From 1ad06ff9a7e38a93e91167f00761f056784cfa3c Mon Sep 17 00:00:00 2001 From: Bryan English Date: Tue, 28 Apr 2026 05:10:39 -0400 Subject: [PATCH 001/168] ffi: add shared-buffer fast path for numeric and pointer signatures Adds an ArrayBuffer-based invocation path for FFI functions whose signatures are composed entirely of numeric types (i8..i64, u8..u64, f32, f64, bool, char) and/or pointer types. The JS wrapper packs arguments directly into a per-function AB via primordial DataView setters and the C++ invoker (`InvokeFunctionSB`) reads them without going through V8's `FunctionCallbackInfo`. Results are returned the same way. Pointer arguments use runtime dispatch: BigInt, null, and undefined take the fast path, while Buffer, ArrayBuffer, ArrayBufferView, and String fall back transparently to the classic `InvokeFunction` path via a stashed `_invokeSlow` function. Signatures containing non-numeric/non-pointer types also bypass the fast path. The fast path is disabled on big-endian platforms. Callers do not opt in, and the fast path is transparent in every way users should rely on. One observable change: function wrappers returned by `library.getFunction`, `library.getFunctions`, and `library.functions` now have `.length` equal to the declared parameter count rather than `0`. Code that relied on the previous value will need to be updated. Adds microbenchmarks covering the common FFI call shapes so future changes to the invoker can be evaluated: - add-i32.js: 2-arg integer - add-f64.js: 2-arg float - many-args.js: 6-arg integer - pointer-bigint.js: 1-arg pointer (BigInt) - sum-buffer.js: pointer + length (Buffer) A `common.js` helper resolves the fixture-library path from `test/ffi/fixture_library` without pulling in the test harness, and throws a clear message if the fixture hasn't been built yet. Also adds `sum_6_i32` to the fixture library for the many-args case. Signed-off-by: Bryan English PR-URL: https://github.com/nodejs/node/pull/62918 Reviewed-By: Anna Henningsen Reviewed-By: Stephen Belanger Reviewed-By: Paolo Insogna --- benchmark/ffi/add-f64.js | 28 + benchmark/ffi/add-i32.js | 28 + benchmark/ffi/common.js | 24 + benchmark/ffi/many-args.js | 28 + benchmark/ffi/pointer-bigint.js | 28 + benchmark/ffi/sum-buffer.js | 33 + lib/ffi.js | 2 + lib/internal/ffi-shared-buffer.js | 635 +++++++++++++++ src/env_properties.h | 4 + src/ffi/types.cc | 128 +++- src/ffi/types.h | 27 + src/node_builtins.cc | 5 +- src/node_ffi.cc | 238 +++++- src/node_ffi.h | 4 + test/ffi/fixture_library/ffi_test_library.c | 65 ++ test/ffi/test-ffi-dynamic-library.js | 6 +- test/ffi/test-ffi-shared-buffer.js | 806 ++++++++++++++++++++ 17 files changed, 2060 insertions(+), 29 deletions(-) create mode 100644 benchmark/ffi/add-f64.js create mode 100644 benchmark/ffi/add-i32.js create mode 100644 benchmark/ffi/common.js create mode 100644 benchmark/ffi/many-args.js create mode 100644 benchmark/ffi/pointer-bigint.js create mode 100644 benchmark/ffi/sum-buffer.js create mode 100644 lib/internal/ffi-shared-buffer.js create mode 100644 test/ffi/test-ffi-shared-buffer.js diff --git a/benchmark/ffi/add-f64.js b/benchmark/ffi/add-f64.js new file mode 100644 index 00000000000000..fab6457e33a09d --- /dev/null +++ b/benchmark/ffi/add-f64.js @@ -0,0 +1,28 @@ +'use strict'; + +const common = require('../common.js'); +const ffi = require('node:ffi'); +const { libraryPath, ensureFixtureLibrary } = require('./common.js'); + +const bench = common.createBenchmark(main, { + n: [1e7], +}, { + flags: ['--experimental-ffi'], +}); + +ensureFixtureLibrary(); + +const { lib, functions } = ffi.dlopen(libraryPath, { + add_f64: { result: 'f64', parameters: ['f64', 'f64'] }, +}); + +const add = functions.add_f64; + +function main({ n }) { + bench.start(); + for (let i = 0; i < n; ++i) + add(1.5, 2.5); + bench.end(n); + + lib.close(); +} diff --git a/benchmark/ffi/add-i32.js b/benchmark/ffi/add-i32.js new file mode 100644 index 00000000000000..bc8e2c4138080e --- /dev/null +++ b/benchmark/ffi/add-i32.js @@ -0,0 +1,28 @@ +'use strict'; + +const common = require('../common.js'); +const ffi = require('node:ffi'); +const { libraryPath, ensureFixtureLibrary } = require('./common.js'); + +const bench = common.createBenchmark(main, { + n: [1e7], +}, { + flags: ['--experimental-ffi'], +}); + +ensureFixtureLibrary(); + +const { lib, functions } = ffi.dlopen(libraryPath, { + add_i32: { result: 'i32', parameters: ['i32', 'i32'] }, +}); + +const add = functions.add_i32; + +function main({ n }) { + bench.start(); + for (let i = 0; i < n; ++i) + add(20, 22); + bench.end(n); + + lib.close(); +} diff --git a/benchmark/ffi/common.js b/benchmark/ffi/common.js new file mode 100644 index 00000000000000..6b1ed29cc4ef56 --- /dev/null +++ b/benchmark/ffi/common.js @@ -0,0 +1,24 @@ +'use strict'; + +const common = require('../common.js'); +const fs = require('node:fs'); +const path = require('node:path'); + +// Cannot use test/ffi/ffi-test-common.js because it requires test/common +// (the test harness module). Construct the path directly. +const libraryPath = path.join(__dirname, '..', '..', 'test', 'ffi', + 'fixture_library', 'build', common.buildType, + process.platform === 'win32' ? 'ffi_test_library.dll' : + process.platform === 'darwin' ? 'ffi_test_library.dylib' : + 'ffi_test_library.so'); + +function ensureFixtureLibrary() { + if (!fs.existsSync(libraryPath)) { + throw new Error( + `Missing FFI fixture library: ${libraryPath}. ` + + 'Build it with `tools/test.py test/ffi/test-ffi-calls.js` first.', + ); + } +} + +module.exports = { libraryPath, ensureFixtureLibrary }; diff --git a/benchmark/ffi/many-args.js b/benchmark/ffi/many-args.js new file mode 100644 index 00000000000000..bacd873df52d1b --- /dev/null +++ b/benchmark/ffi/many-args.js @@ -0,0 +1,28 @@ +'use strict'; + +const common = require('../common.js'); +const ffi = require('node:ffi'); +const { libraryPath, ensureFixtureLibrary } = require('./common.js'); + +const bench = common.createBenchmark(main, { + n: [1e7], +}, { + flags: ['--experimental-ffi'], +}); + +ensureFixtureLibrary(); + +const { lib, functions } = ffi.dlopen(libraryPath, { + sum_6_i32: { result: 'i32', parameters: ['i32', 'i32', 'i32', 'i32', 'i32', 'i32'] }, +}); + +const fn = functions.sum_6_i32; + +function main({ n }) { + bench.start(); + for (let i = 0; i < n; ++i) + fn(1, 2, 3, 4, 5, 6); + bench.end(n); + + lib.close(); +} diff --git a/benchmark/ffi/pointer-bigint.js b/benchmark/ffi/pointer-bigint.js new file mode 100644 index 00000000000000..c44ef7f1656a0c --- /dev/null +++ b/benchmark/ffi/pointer-bigint.js @@ -0,0 +1,28 @@ +'use strict'; + +const common = require('../common.js'); +const ffi = require('node:ffi'); +const { libraryPath, ensureFixtureLibrary } = require('./common.js'); + +const bench = common.createBenchmark(main, { + n: [1e7], +}, { + flags: ['--experimental-ffi'], +}); + +ensureFixtureLibrary(); + +const { lib, functions } = ffi.dlopen(libraryPath, { + pointer_to_usize: { result: 'u64', parameters: ['pointer'] }, +}); + +const fn = functions.pointer_to_usize; + +function main({ n }) { + bench.start(); + for (let i = 0; i < n; ++i) + fn(0xdeadbeefn); + bench.end(n); + + lib.close(); +} diff --git a/benchmark/ffi/sum-buffer.js b/benchmark/ffi/sum-buffer.js new file mode 100644 index 00000000000000..3117f61aaedabf --- /dev/null +++ b/benchmark/ffi/sum-buffer.js @@ -0,0 +1,33 @@ +'use strict'; + +const common = require('../common.js'); +const ffi = require('node:ffi'); +const { libraryPath, ensureFixtureLibrary } = require('./common.js'); + +const bench = common.createBenchmark(main, { + size: [64, 1024, 16384], + n: [1e6], +}, { + flags: ['--experimental-ffi'], +}); + +ensureFixtureLibrary(); + +const { lib, functions } = ffi.dlopen(libraryPath, { + sum_buffer: { result: 'u64', parameters: ['pointer', 'u64'] }, +}); + +function main({ n, size }) { + const buf = Buffer.alloc(size, 0x42); + const ptr = ffi.getRawPointer(buf); + const len = BigInt(size); + + const sum = functions.sum_buffer; + + bench.start(); + for (let i = 0; i < n; ++i) + sum(ptr, len); + bench.end(n); + + lib.close(); +} diff --git a/lib/ffi.js b/lib/ffi.js index b276f4b29dfcdc..44aff307ad0f32 100644 --- a/lib/ffi.js +++ b/lib/ffi.js @@ -53,6 +53,8 @@ const { toArrayBuffer, } = internalBinding('ffi'); +require('internal/ffi-shared-buffer'); + function checkFFIPermission() { if (!permission.isEnabled() || permission.has('ffi')) { return; diff --git a/lib/internal/ffi-shared-buffer.js b/lib/internal/ffi-shared-buffer.js new file mode 100644 index 00000000000000..bce51fd79959dd --- /dev/null +++ b/lib/internal/ffi-shared-buffer.js @@ -0,0 +1,635 @@ +'use strict'; + +const { + DataView, + DataViewPrototypeGetBigInt64, + DataViewPrototypeGetBigUint64, + DataViewPrototypeGetFloat32, + DataViewPrototypeGetFloat64, + DataViewPrototypeGetInt16, + DataViewPrototypeGetInt32, + DataViewPrototypeGetInt8, + DataViewPrototypeGetUint16, + DataViewPrototypeGetUint32, + DataViewPrototypeGetUint8, + DataViewPrototypeSetBigInt64, + DataViewPrototypeSetBigUint64, + DataViewPrototypeSetFloat32, + DataViewPrototypeSetFloat64, + DataViewPrototypeSetInt16, + DataViewPrototypeSetInt32, + DataViewPrototypeSetInt8, + DataViewPrototypeSetUint16, + DataViewPrototypeSetUint32, + DataViewPrototypeSetUint8, + FunctionPrototypeCall, + NumberIsInteger, + ObjectDefineProperty, + ObjectGetOwnPropertyDescriptor, + ObjectKeys, + ReflectApply, + TypeError, +} = primordials; + +const { + codes: { + ERR_INTERNAL_ASSERTION, + }, +} = require('internal/errors'); + +const { + DynamicLibrary, + charIsSigned, + kSbInvokeSlow, + kSbParams, + kSbResult, + kSbSharedBuffer, + uintptrMax, +} = internalBinding('ffi'); + +// Validator fields (`min`, `max`, `label`) must mirror `ToFFIArgument` in +// `src/ffi/types.cc` so the fast and slow paths produce identical errors. +const sI8 = DataViewPrototypeSetInt8; +const gI8 = DataViewPrototypeGetInt8; +const sU8 = DataViewPrototypeSetUint8; +const gU8 = DataViewPrototypeGetUint8; +const sI16 = DataViewPrototypeSetInt16; +const gI16 = DataViewPrototypeGetInt16; +const sU16 = DataViewPrototypeSetUint16; +const gU16 = DataViewPrototypeGetUint16; +const sI32 = DataViewPrototypeSetInt32; +const gI32 = DataViewPrototypeGetInt32; +const sU32 = DataViewPrototypeSetUint32; +const gU32 = DataViewPrototypeGetUint32; +const sI64 = DataViewPrototypeSetBigInt64; +const gI64 = DataViewPrototypeGetBigInt64; +const sU64 = DataViewPrototypeSetBigUint64; +const gU64 = DataViewPrototypeGetBigUint64; +const sF32 = DataViewPrototypeSetFloat32; +const gF32 = DataViewPrototypeGetFloat32; +const sF64 = DataViewPrototypeSetFloat64; +const gF64 = DataViewPrototypeGetFloat64; + +const sbTypeInfo = { + __proto__: null, + i8: { set: sI8, get: gI8, kind: 'int', min: -128, max: 127, label: 'an int8' }, + int8: { set: sI8, get: gI8, kind: 'int', min: -128, max: 127, label: 'an int8' }, + char: charIsSigned ? + { set: sI8, get: gI8, kind: 'int', min: -128, max: 127, label: 'an int8' } : + { set: sU8, get: gU8, kind: 'int', min: 0, max: 255, label: 'a uint8' }, + u8: { set: sU8, get: gU8, kind: 'int', min: 0, max: 255, label: 'a uint8' }, + uint8: { set: sU8, get: gU8, kind: 'int', min: 0, max: 255, label: 'a uint8' }, + bool: { set: sU8, get: gU8, kind: 'int', min: 0, max: 255, label: 'a uint8' }, + i16: { set: sI16, get: gI16, kind: 'int', min: -32768, max: 32767, label: 'an int16' }, + int16: { set: sI16, get: gI16, kind: 'int', min: -32768, max: 32767, label: 'an int16' }, + u16: { set: sU16, get: gU16, kind: 'int', min: 0, max: 65535, label: 'a uint16' }, + uint16: { set: sU16, get: gU16, kind: 'int', min: 0, max: 65535, label: 'a uint16' }, + i32: { set: sI32, get: gI32, kind: 'int', min: -2147483648, max: 2147483647, label: 'an int32' }, + int32: { set: sI32, get: gI32, kind: 'int', min: -2147483648, max: 2147483647, label: 'an int32' }, + u32: { set: sU32, get: gU32, kind: 'int', min: 0, max: 4294967295, label: 'a uint32' }, + uint32: { set: sU32, get: gU32, kind: 'int', min: 0, max: 4294967295, label: 'a uint32' }, + i64: { set: sI64, get: gI64, kind: 'i64', label: 'an int64' }, + int64: { set: sI64, get: gI64, kind: 'i64', label: 'an int64' }, + u64: { set: sU64, get: gU64, kind: 'u64', label: 'a uint64' }, + uint64: { set: sU64, get: gU64, kind: 'u64', label: 'a uint64' }, + f32: { set: sF32, get: gF32, kind: 'float', label: 'a float' }, + float: { set: sF32, get: gF32, kind: 'float', label: 'a float' }, + float32: { set: sF32, get: gF32, kind: 'float', label: 'a float' }, + f64: { set: sF64, get: gF64, kind: 'float', label: 'a double' }, + double: { set: sF64, get: gF64, kind: 'float', label: 'a double' }, + float64: { set: sF64, get: gF64, kind: 'float', label: 'a double' }, + pointer: { set: sU64, get: gU64, kind: 'pointer' }, + ptr: { set: sU64, get: gU64, kind: 'pointer' }, + function: { set: sU64, get: gU64, kind: 'pointer' }, + buffer: { set: sU64, get: gU64, kind: 'pointer' }, + arraybuffer: { set: sU64, get: gU64, kind: 'pointer' }, + string: { set: sU64, get: gU64, kind: 'pointer' }, + str: { set: sU64, get: gU64, kind: 'pointer' }, +}; + +const U64_MAX = 0xFFFFFFFFFFFFFFFFn; +const I64_MAX = 0x7FFFFFFFFFFFFFFFn; +const I64_MIN = -0x8000000000000000n; + +// Builds the exact error shape the non-SB implementation (the native FFI +// invoker) produces. +function throwFFIArgError(msg) { + // eslint-disable-next-line no-restricted-syntax + const err = new TypeError(msg); + err.code = 'ERR_INVALID_ARG_VALUE'; + throw err; +} + +function throwFFIArgCountError(expected, actual) { + throwFFIArgError( + `Invalid argument count: expected ${expected}, got ${actual}`); +} + +// Validation and error messages must mirror `ToFFIArgument` in +// `src/ffi/types.cc`. +function writeNumericArg(view, info, offset, arg, index) { + const kind = info.kind; + if (kind === 'int') { + if (typeof arg !== 'number' || !NumberIsInteger(arg) || + arg < info.min || arg > info.max) { + throwFFIArgError(`Argument ${index} must be ${info.label}`); + } + info.set(view, offset, arg, true); + return; + } + if (kind === 'i64') { + if (typeof arg !== 'bigint' || arg < I64_MIN || arg > I64_MAX) { + throwFFIArgError(`Argument ${index} must be ${info.label}`); + } + sI64(view, offset, arg, true); + return; + } + if (kind === 'u64') { + if (typeof arg !== 'bigint' || arg < 0n || arg > U64_MAX) { + throwFFIArgError(`Argument ${index} must be ${info.label}`); + } + sU64(view, offset, arg, true); + return; + } + if (kind === 'float') { + if (typeof arg !== 'number') { + throwFFIArgError(`Argument ${index} must be ${info.label}`); + } + info.set(view, offset, arg, true); + return; + } + + /* c8 ignore start */ + // Unreachable: caller filters out non-numeric kinds. + throw new ERR_INTERNAL_ASSERTION( + `FFI: writeNumericArg reached with unexpected kind="${kind}"`); + /* c8 ignore stop */ +} + +// Returns true on fast-path success, false when the caller must fall back +// to the slow path (strings, Buffers, ArrayBuffers, ArrayBufferViews). +function writePointerArg(view, offset, arg, index) { + if (typeof arg === 'bigint') { + // Bound by `uintptrMax` (not `U64_MAX`) to mirror the slow path: on + // 32-bit platforms a BigInt that doesn't fit in `uintptr_t` would be + // silently truncated by `ReadFFIArgFromBuffer`'s + // `memcpy(..., type->size, ...)`. + if (arg < 0n || arg > uintptrMax) { + throwFFIArgError( + `Argument ${index} must be a non-negative pointer bigint`); + } + sU64(view, offset, arg, true); + return true; + } + if (arg === null || arg === undefined) { + sU64(view, offset, 0n, true); + return true; + } + return false; +} + +// The `pointer` descriptor mirrors the raw function's so user code that +// reassigns `.pointer` keeps working through the wrapper. +function inheritMetadata(wrapper, rawFn, nargs) { + ObjectDefineProperty(wrapper, 'name', { + __proto__: null, value: rawFn.name, configurable: true, + }); + ObjectDefineProperty(wrapper, 'length', { + __proto__: null, value: nargs, configurable: true, + }); + ObjectDefineProperty(wrapper, 'pointer', { + __proto__: null, value: rawFn.pointer, + writable: true, configurable: true, enumerable: true, + }); + return wrapper; +} + +// Reentrancy: the ArrayBuffer is per-function, but `InvokeFunctionSB` copies +// arguments out of it into invocation-local storage before `ffi_call` and +// reads the return value back only after, so nested/reentrant calls into +// the same function are safe. +function wrapWithSharedBuffer(rawFn, parameters, resultType) { + if (rawFn === undefined || rawFn === null) return rawFn; + const buffer = rawFn[kSbSharedBuffer]; + if (buffer === undefined) return rawFn; + + // Callers without explicit signature info (the `functions` accessor + // patch below) rely on the `kSbParams` / `kSbResult` metadata attached + // by the native `CreateFunction`. + if (parameters === undefined) parameters = rawFn[kSbParams]; + if (resultType === undefined) resultType = rawFn[kSbResult]; + // `CreateFunction` always attaches these for SB-eligible functions. + // Missing here means the native side and this wrapper are out of sync. + /* c8 ignore start */ + if (parameters === undefined || resultType === undefined) { + throw new ERR_INTERNAL_ASSERTION( + 'FFI: shared-buffer raw function is missing kSbParams or kSbResult'); + } + /* c8 ignore stop */ + + const slowInvoke = rawFn[kSbInvokeSlow]; + const view = new DataView(buffer); + let retGetter = null; + if (resultType !== 'void') { + const retInfo = sbTypeInfo[resultType]; + /* c8 ignore start */ + if (retInfo === undefined) { + throw new ERR_INTERNAL_ASSERTION( + `FFI: shared-buffer type table missing entry for result type "${resultType}"`); + } + /* c8 ignore stop */ + retGetter = retInfo.get; + } + + const nargs = parameters.length; + const argInfos = []; + const argOffsets = []; + let anyPointer = false; + for (let i = 0; i < nargs; i++) { + const info = sbTypeInfo[parameters[i]]; + /* c8 ignore start */ + if (info === undefined) { + throw new ERR_INTERNAL_ASSERTION( + `FFI: shared-buffer type table missing entry for parameter type "${parameters[i]}"`); + } + /* c8 ignore stop */ + // Push the `sbTypeInfo` entry directly (entries with the same `kind` + // share a shape, keeping `writeNumericArg`'s call sites + // low-polymorphism) and store offsets in a parallel array to avoid + // per-arg object cloning. + argInfos.push(info); + argOffsets.push(8 * (i + 1)); + if (info.kind === 'pointer') anyPointer = true; + } + + let wrapper; + if (anyPointer) { + // Pointer signatures need a per-arg runtime type check and fall back + // to the native slow-path invoker for non-BigInt pointer arguments, + // so arity specialization wouldn't buy much here. + /* c8 ignore start */ + if (slowInvoke === undefined) { + throw new ERR_INTERNAL_ASSERTION( + 'FFI: shared-buffer raw function with pointer arguments is ' + + 'missing kSbInvokeSlow'); + } + /* c8 ignore stop */ + wrapper = function(...args) { + if (args.length !== nargs) { + throwFFIArgCountError(nargs, args.length); + } + for (let i = 0; i < nargs; i++) { + const info = argInfos[i]; + const offset = argOffsets[i]; + if (info.kind === 'pointer') { + if (!writePointerArg(view, offset, args[i], i)) { + return ReflectApply(slowInvoke, undefined, args); + } + } else { + writeNumericArg(view, info, offset, args[i], i); + } + } + rawFn(); + return retGetter === null ? undefined : retGetter(view, 0, true); + }; + } else { + // Arity specialization avoids the per-call `Array` allocation of + // `...args`; the void/non-void split removes a per-call branch on + // `retGetter`. + wrapper = buildNumericWrapper( + rawFn, view, argInfos, argOffsets, nargs, retGetter); + } + return inheritMetadata(wrapper, rawFn, nargs); +} + +// Specialized for nargs 0..6 with a generic rest-params fallback for 7+. +// Per-arg type info and offsets are captured into closure locals so the +// hot path reads a single variable per arg. This is admittedly pretty weird +// but it's the result of lots of perf-hunting. +function buildNumericWrapper( + rawFn, view, argInfos, argOffsets, nargs, retGetter) { + // `IsSBEligibleSignature` on the native side rejects 0-arg signatures, + // so this branch is unreachable today. It's kept as defense-in-depth + // for when that filter changes or for programmatic callers that hand a + // 0-arg signature through `wrapWithSharedBuffer` directly. + /* c8 ignore start */ + if (nargs === 0) { + if (retGetter === null) { + return function() { + if (arguments.length !== 0) { + throwFFIArgCountError(0, arguments.length); + } + rawFn(); + }; + } + return function() { + if (arguments.length !== 0) { + throwFFIArgCountError(0, arguments.length); + } + rawFn(); + return retGetter(view, 0, true); + }; + } + /* c8 ignore stop */ + if (nargs === 1) { + const i0 = argInfos[0]; + const o0 = argOffsets[0]; + if (retGetter === null) { + return function(a0) { + if (arguments.length !== 1) { + throwFFIArgCountError(1, arguments.length); + } + writeNumericArg(view, i0, o0, a0, 0); + rawFn(); + }; + } + return function(a0) { + if (arguments.length !== 1) { + throwFFIArgCountError(1, arguments.length); + } + writeNumericArg(view, i0, o0, a0, 0); + rawFn(); + return retGetter(view, 0, true); + }; + } + if (nargs === 2) { + const i0 = argInfos[0]; + const i1 = argInfos[1]; + const o0 = argOffsets[0]; + const o1 = argOffsets[1]; + if (retGetter === null) { + return function(a0, a1) { + if (arguments.length !== 2) { + throwFFIArgCountError(2, arguments.length); + } + writeNumericArg(view, i0, o0, a0, 0); + writeNumericArg(view, i1, o1, a1, 1); + rawFn(); + }; + } + return function(a0, a1) { + if (arguments.length !== 2) { + throwFFIArgCountError(2, arguments.length); + } + writeNumericArg(view, i0, o0, a0, 0); + writeNumericArg(view, i1, o1, a1, 1); + rawFn(); + return retGetter(view, 0, true); + }; + } + if (nargs === 3) { + const i0 = argInfos[0]; + const i1 = argInfos[1]; + const i2 = argInfos[2]; + const o0 = argOffsets[0]; + const o1 = argOffsets[1]; + const o2 = argOffsets[2]; + if (retGetter === null) { + return function(a0, a1, a2) { + if (arguments.length !== 3) { + throwFFIArgCountError(3, arguments.length); + } + writeNumericArg(view, i0, o0, a0, 0); + writeNumericArg(view, i1, o1, a1, 1); + writeNumericArg(view, i2, o2, a2, 2); + rawFn(); + }; + } + return function(a0, a1, a2) { + if (arguments.length !== 3) { + throwFFIArgCountError(3, arguments.length); + } + writeNumericArg(view, i0, o0, a0, 0); + writeNumericArg(view, i1, o1, a1, 1); + writeNumericArg(view, i2, o2, a2, 2); + rawFn(); + return retGetter(view, 0, true); + }; + } + if (nargs === 4) { + const i0 = argInfos[0]; + const i1 = argInfos[1]; + const i2 = argInfos[2]; + const i3 = argInfos[3]; + const o0 = argOffsets[0]; + const o1 = argOffsets[1]; + const o2 = argOffsets[2]; + const o3 = argOffsets[3]; + if (retGetter === null) { + return function(a0, a1, a2, a3) { + if (arguments.length !== 4) { + throwFFIArgCountError(4, arguments.length); + } + writeNumericArg(view, i0, o0, a0, 0); + writeNumericArg(view, i1, o1, a1, 1); + writeNumericArg(view, i2, o2, a2, 2); + writeNumericArg(view, i3, o3, a3, 3); + rawFn(); + }; + } + return function(a0, a1, a2, a3) { + if (arguments.length !== 4) { + throwFFIArgCountError(4, arguments.length); + } + writeNumericArg(view, i0, o0, a0, 0); + writeNumericArg(view, i1, o1, a1, 1); + writeNumericArg(view, i2, o2, a2, 2); + writeNumericArg(view, i3, o3, a3, 3); + rawFn(); + return retGetter(view, 0, true); + }; + } + if (nargs === 5) { + const i0 = argInfos[0]; + const i1 = argInfos[1]; + const i2 = argInfos[2]; + const i3 = argInfos[3]; + const i4 = argInfos[4]; + const o0 = argOffsets[0]; + const o1 = argOffsets[1]; + const o2 = argOffsets[2]; + const o3 = argOffsets[3]; + const o4 = argOffsets[4]; + if (retGetter === null) { + return function(a0, a1, a2, a3, a4) { + if (arguments.length !== 5) { + throwFFIArgCountError(5, arguments.length); + } + writeNumericArg(view, i0, o0, a0, 0); + writeNumericArg(view, i1, o1, a1, 1); + writeNumericArg(view, i2, o2, a2, 2); + writeNumericArg(view, i3, o3, a3, 3); + writeNumericArg(view, i4, o4, a4, 4); + rawFn(); + }; + } + return function(a0, a1, a2, a3, a4) { + if (arguments.length !== 5) { + throwFFIArgCountError(5, arguments.length); + } + writeNumericArg(view, i0, o0, a0, 0); + writeNumericArg(view, i1, o1, a1, 1); + writeNumericArg(view, i2, o2, a2, 2); + writeNumericArg(view, i3, o3, a3, 3); + writeNumericArg(view, i4, o4, a4, 4); + rawFn(); + return retGetter(view, 0, true); + }; + } + if (nargs === 6) { + const i0 = argInfos[0]; + const i1 = argInfos[1]; + const i2 = argInfos[2]; + const i3 = argInfos[3]; + const i4 = argInfos[4]; + const i5 = argInfos[5]; + const o0 = argOffsets[0]; + const o1 = argOffsets[1]; + const o2 = argOffsets[2]; + const o3 = argOffsets[3]; + const o4 = argOffsets[4]; + const o5 = argOffsets[5]; + if (retGetter === null) { + return function(a0, a1, a2, a3, a4, a5) { + if (arguments.length !== 6) { + throwFFIArgCountError(6, arguments.length); + } + writeNumericArg(view, i0, o0, a0, 0); + writeNumericArg(view, i1, o1, a1, 1); + writeNumericArg(view, i2, o2, a2, 2); + writeNumericArg(view, i3, o3, a3, 3); + writeNumericArg(view, i4, o4, a4, 4); + writeNumericArg(view, i5, o5, a5, 5); + rawFn(); + }; + } + return function(a0, a1, a2, a3, a4, a5) { + if (arguments.length !== 6) { + throwFFIArgCountError(6, arguments.length); + } + writeNumericArg(view, i0, o0, a0, 0); + writeNumericArg(view, i1, o1, a1, 1); + writeNumericArg(view, i2, o2, a2, 2); + writeNumericArg(view, i3, o3, a3, 3); + writeNumericArg(view, i4, o4, a4, 4); + writeNumericArg(view, i5, o5, a5, 5); + rawFn(); + return retGetter(view, 0, true); + }; + } + // 7+ args: further specialization is diminishing returns and bloats + // this builder. + if (retGetter === null) { + return function(...args) { + if (args.length !== nargs) { + throwFFIArgCountError(nargs, args.length); + } + for (let i = 0; i < nargs; i++) { + writeNumericArg(view, argInfos[i], argOffsets[i], args[i], i); + } + rawFn(); + }; + } + return function(...args) { + if (args.length !== nargs) { + throwFFIArgCountError(nargs, args.length); + } + for (let i = 0; i < nargs; i++) { + writeNumericArg(view, argInfos[i], argOffsets[i], args[i], i); + } + rawFn(); + return retGetter(view, 0, true); + }; +} + +// Accept-set mirrors the native `ParseFunctionSignature` in +// `src/ffi/types.cc`. `ParseFunctionSignature` additionally throws when +// multiple aliases are set at once. The wrapper runs before the native +// call, so those conflicts still surface from the native side regardless +// of which alias we happen to read here. +function sigParams(sig) { + return sig.parameters ?? sig.arguments ?? []; +} + +function sigResult(sig) { + return sig.result ?? sig.return ?? sig.returns ?? 'void'; +} + +// The native invoker for SB-eligible symbols is `InvokeFunctionSB`, which +// reads arguments from the shared buffer populated by +// `wrapWithSharedBuffer`. These patches make sure every path that surfaces +// a raw SB-eligible function to user code (`getFunction`, `getFunctions`, +// and the `functions` accessor) returns the wrapper instead. +const rawGetFunction = DynamicLibrary.prototype.getFunction; +const rawGetFunctions = DynamicLibrary.prototype.getFunctions; + +DynamicLibrary.prototype.getFunction = function getFunction(name, sig) { + // Native `DynamicLibrary::GetFunction` validates `sig`, so by the time + // we have `raw` we know `sig` is a valid object. + const raw = FunctionPrototypeCall(rawGetFunction, this, name, sig); + return wrapWithSharedBuffer(raw, sigParams(sig), sigResult(sig)); +}; + +DynamicLibrary.prototype.getFunctions = function getFunctions(definitions) { + // Native `GetFunctions` switches on `args.Length() > 0`. Zero args + // returns every cached function, one arg requires an object. Forwarding + // `undefined` would fail the object check, so drop it when omitted. + const raw = definitions === undefined ? + FunctionPrototypeCall(rawGetFunctions, this) : + FunctionPrototypeCall(rawGetFunctions, this, definitions); + if (raw === undefined || raw === null) return raw; + const keys = ObjectKeys(raw); + const out = { __proto__: null }; + for (let i = 0; i < keys.length; i++) { + const name = keys[i]; + // No `definitions`: native side returned every cached function, so we + // wrap using each function's own `kSbParams` / `kSbResult` metadata + // (same fallback as the `functions` accessor). + if (definitions === undefined) { + out[name] = wrapWithSharedBuffer(raw[name]); + } else { + const sig = definitions[name]; + out[name] = wrapWithSharedBuffer(raw[name], sigParams(sig), sigResult(sig)); + } + } + return out; +}; + +{ + // The native side installs `functions` as an accessor returning raw + // functions. Rewrap each access so `lib.functions.foo(...)` goes through + // the SB wrapper instead of invoking the fast path against an + // uninitialized buffer. + const functionsDescriptor = + ObjectGetOwnPropertyDescriptor(DynamicLibrary.prototype, 'functions'); + /* c8 ignore start */ + if (functionsDescriptor === undefined || !functionsDescriptor.get) { + // Missing getter means the native and JS sides are out of sync; silently + // skipping the patch would expose the fast-path-against-uninitialized-buffer + // footgun this whole block exists to prevent. + throw new ERR_INTERNAL_ASSERTION( + 'FFI: DynamicLibrary.prototype.functions accessor not found or has no getter'); + } + /* c8 ignore stop */ + const origGetter = functionsDescriptor.get; + ObjectDefineProperty(DynamicLibrary.prototype, 'functions', { + __proto__: null, + configurable: true, + enumerable: functionsDescriptor.enumerable, + get() { + const raw = FunctionPrototypeCall(origGetter, this); + if (raw === undefined || raw === null) return raw; + const wrapped = { __proto__: null }; + const keys = ObjectKeys(raw); + for (let i = 0; i < keys.length; i++) { + const name = keys[i]; + wrapped[name] = wrapWithSharedBuffer(raw[name]); + } + return wrapped; + }, + }); +} + +module.exports = { + wrapWithSharedBuffer, +}; diff --git a/src/env_properties.h b/src/env_properties.h index b95bdfa65e4d39..0fc7b2b66179e4 100644 --- a/src/env_properties.h +++ b/src/env_properties.h @@ -46,6 +46,10 @@ #define PER_ISOLATE_SYMBOL_PROPERTIES(V) \ V(fs_use_promises_symbol, "fs_use_promises_symbol") \ V(async_id_symbol, "async_id_symbol") \ + V(ffi_sb_shared_buffer_symbol, "ffi_sb_shared_buffer_symbol") \ + V(ffi_sb_invoke_slow_symbol, "ffi_sb_invoke_slow_symbol") \ + V(ffi_sb_params_symbol, "ffi_sb_params_symbol") \ + V(ffi_sb_result_symbol, "ffi_sb_result_symbol") \ V(constructor_key_symbol, "constructor_key_symbol") \ V(handle_onclose_symbol, "handle_onclose") \ V(no_message_symbol, "no_message_symbol") \ diff --git a/src/ffi/types.cc b/src/ffi/types.cc index 83e4987ca69279..4d5062cdf832fb 100644 --- a/src/ffi/types.cc +++ b/src/ffi/types.cc @@ -95,9 +95,6 @@ Maybe ParseFunctionSignature(Environment* env, bool has_parameters; bool has_arguments; - ffi_type* return_type; - std::vector args; - if (!signature->Has(context, returns_key).To(&has_returns) || !signature->Has(context, return_key).To(&has_return) || !signature->Has(context, result_key).To(&has_result) || @@ -125,7 +122,10 @@ Maybe ParseFunctionSignature(Environment* env, return {}; } - return_type = &ffi_type_void; + ffi_type* return_type = &ffi_type_void; + std::vector args; + std::string return_type_name = "void"; + std::vector arg_type_names; Isolate* isolate = env->isolate(); if (has_returns || has_return || has_result) { @@ -159,6 +159,7 @@ Maybe ParseFunctionSignature(Environment* env, if (!ToFFIType(env, return_type_str.ToStringView()).To(&return_type)) { return {}; } + return_type_name = return_type_str.ToString(); } if (has_arguments || has_parameters) { @@ -203,10 +204,14 @@ Maybe ParseFunctionSignature(Environment* env, } args.push_back(arg_type); + arg_type_names.emplace_back(arg_str.ToString()); } } - return Just(FunctionSignature{return_type, std::move(args)}); + return Just(FunctionSignature{return_type, + std::move(args), + std::move(return_type_name), + std::move(arg_type_names)}); } bool SignaturesMatch(const FFIFunction& fn, @@ -225,6 +230,102 @@ bool SignaturesMatch(const FFIFunction& fn, return true; } +bool IsSBEligibleFFIType(ffi_type* type) { + return type == &ffi_type_void || type == &ffi_type_sint8 || + type == &ffi_type_uint8 || type == &ffi_type_sint16 || + type == &ffi_type_uint16 || type == &ffi_type_sint32 || + type == &ffi_type_uint32 || type == &ffi_type_sint64 || + type == &ffi_type_uint64 || type == &ffi_type_float || + type == &ffi_type_double || type == &ffi_type_pointer; +} + +bool IsSBEligibleSignature(const FFIFunction& fn) { + // The JS wrapper writes and reads the shared buffer little-endian while + // the C++ side uses memcpy in host order. On big-endian hosts these + // disagree, so the fast path is disabled there. + if constexpr (IsBigEndian()) { + return false; + } + // Zero-argument functions gain nothing from the shared-buffer path + // (no argument packing to skip) and measurably lose on tight native + // calls like `uv_os_getpid` due to the wrapper's fixed overhead. + if (fn.args.empty()) return false; + if (!IsSBEligibleFFIType(fn.return_type)) return false; + for (ffi_type* arg : fn.args) { + if (!IsSBEligibleFFIType(arg)) return false; + } + return true; +} + +bool SignatureHasPointerArgs(const FFIFunction& fn) { + for (ffi_type* arg : fn.args) { + if (arg == &ffi_type_pointer) return true; + } + return false; +} + +void ReadFFIArgFromBuffer(ffi_type* type, + const uint8_t* buffer, + size_t offset, + void* out) { + CHECK(IsSBEligibleFFIType(type)); + CHECK_LE(type->size, sizeof(uint64_t)); + // memcpy avoids the strict-aliasing violation that a direct typed load + // from the raw uint8_t buffer would incur. + const uint8_t* src = buffer + offset; + std::memcpy(out, src, type->size); +} + +void WriteFFIReturnToBuffer(ffi_type* type, + const void* result, + uint8_t* buffer, + size_t offset) { + CHECK(IsSBEligibleFFIType(type)); + uint8_t* dst = buffer + offset; + std::memset(dst, 0, 8); + + if (type == &ffi_type_void) { + return; + } + + // libffi promotes small integer return values to ffi_arg size, so these + // branches read as ffi_arg or ffi_sarg and then truncate back down. + if (type == &ffi_type_sint8) { + int8_t tmp = static_cast(*static_cast(result)); + std::memcpy(dst, &tmp, sizeof(tmp)); + return; + } + if (type == &ffi_type_uint8) { + uint8_t tmp = static_cast(*static_cast(result)); + std::memcpy(dst, &tmp, sizeof(tmp)); + return; + } + if (type == &ffi_type_sint16) { + int16_t tmp = static_cast(*static_cast(result)); + std::memcpy(dst, &tmp, sizeof(tmp)); + return; + } + if (type == &ffi_type_uint16) { + uint16_t tmp = static_cast(*static_cast(result)); + std::memcpy(dst, &tmp, sizeof(tmp)); + return; + } + if (type == &ffi_type_sint32) { + int32_t tmp = static_cast(*static_cast(result)); + std::memcpy(dst, &tmp, sizeof(tmp)); + return; + } + if (type == &ffi_type_uint32) { + uint32_t tmp = static_cast(*static_cast(result)); + std::memcpy(dst, &tmp, sizeof(tmp)); + return; + } + + // Remaining SB-eligible types (sint64, uint64, float, double, pointer) + // are not promoted by libffi and can be copied as-is. + std::memcpy(dst, result, type->size); +} + v8::Maybe ToFFIType(Environment* env, std::string_view type_str) { if (type_str == "void") { return Just(&ffi_type_void); @@ -263,6 +364,10 @@ v8::Maybe ToFFIType(Environment* env, std::string_view type_str) { } } +// The JS fast path in lib/internal/ffi-shared-buffer.js mirrors the +// validation below. `writeNumericArg` matches the numeric branches and +// `writePointerArg` matches the pointer-BigInt branch. Error codes and +// messages must stay identical across all three sites. Maybe ToFFIArgument(Environment* env, unsigned int index, ffi_type* type, @@ -363,8 +468,8 @@ Maybe ToFFIArgument(Environment* env, if (arg->IsNullOrUndefined()) { *static_cast(ret) = reinterpret_cast(nullptr); } else if (arg->IsString()) { - // This will handled in Invoke so that we can free the copied string after - // the call + // String arguments are handled in Invoke so the UTF-8 copy can be + // freed after the call. return Just(FFIArgumentCategory::String); } else if (arg->IsArrayBufferView()) { // Pointer-like ArrayBufferView arguments borrow backing-store memory @@ -453,12 +558,11 @@ Local ToJSArgument(Isolate* isolate, ffi_type* type, void* data) { } else if (type == &ffi_type_double) { ret = Number::New(isolate, *static_cast(data)); } else if (type == &ffi_type_pointer) { - // All others are treated as pointer (and thus bigint), the user will use - // other helpers to convert + // Pointers surface as BigInt. Callers decode them further with the + // ffi helpers. ret = BigInt::NewFromUnsigned( isolate, reinterpret_cast(*static_cast(data))); } else { - // For anything else, return undefined to avoid problems ret = Undefined(isolate); } @@ -621,7 +725,9 @@ bool ToFFIReturnValue(Local result, ffi_type* type, void* ret) { *static_cast(ret) = pointer; } else { - // Note that strings, buffer or ArrayBuffer are ignored + // Strings, Buffers, and ArrayBuffers are not accepted as pointer + // return values from a JS callback. The slot is zeroed before the + // false return so the caller sees a defined null pointer. *static_cast(ret) = reinterpret_cast(nullptr); return false; } diff --git a/src/ffi/types.h b/src/ffi/types.h index 1b7802e5b52480..14f474a465aa4a 100644 --- a/src/ffi/types.h +++ b/src/ffi/types.h @@ -20,6 +20,8 @@ bool ThrowIfContainsNullBytes(Environment* env, struct FunctionSignature { ffi_type* return_type; std::vector args; + std::string return_type_name; + std::vector arg_type_names; }; v8::Maybe ParseFunctionSignature( Environment* env, std::string_view name, v8::Local signature); @@ -51,6 +53,31 @@ bool SignaturesMatch(const FFIFunction& fn, ffi_type* return_type, const std::vector& args); +// True if the FFI type can be read from / written to a raw byte buffer +// without needing V8 operations (conversion, allocation, etc.). +bool IsSBEligibleFFIType(ffi_type* type); + +// True if the signature's return type and all argument types are SB-eligible. +bool IsSBEligibleSignature(const FFIFunction& fn); + +// True if any argument is pointer-typed. For these, the JS wrapper must +// do a runtime type check to decide fast vs. slow path per call. +bool SignatureHasPointerArgs(const FFIFunction& fn); + +// Read a value of the given FFI type from buffer at the given byte offset +// into the output pointer (sized as uint64_t to hold any numeric type). +void ReadFFIArgFromBuffer(ffi_type* type, + const uint8_t* buffer, + size_t offset, + void* out); + +// Write a return value of the given FFI type from the ffi_call result +// into the buffer at the given byte offset. +void WriteFFIReturnToBuffer(ffi_type* type, + const void* result, + uint8_t* buffer, + size_t offset); + } // namespace node::ffi #endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS diff --git a/src/node_builtins.cc b/src/node_builtins.cc index 39b027ed24f06a..b098a41cca9ea4 100644 --- a/src/node_builtins.cc +++ b/src/node_builtins.cc @@ -139,7 +139,10 @@ BuiltinLoader::BuiltinCategories BuiltinLoader::GetBuiltinCategories() const { #ifndef OPENSSL_NO_QUIC "internal/quic/quic", "internal/quic/symbols", "internal/quic/stats", "internal/quic/state", -#endif // !OPENSSL_NO_QUIC +#endif // !OPENSSL_NO_QUIC +#if !HAVE_FFI + "internal/ffi-shared-buffer", +#endif // !HAVE_FFI "ffi", // Experimental. "quic", // Experimental. "sqlite", // Experimental. diff --git a/src/node_ffi.cc b/src/node_ffi.cc index b1a8b54d38050f..89018c8e6e4b32 100644 --- a/src/node_ffi.cc +++ b/src/node_ffi.cc @@ -1,7 +1,10 @@ #if HAVE_FFI #include "node_ffi.h" +#include #include +#include +#include #include "base_object-inl.h" #include "env-inl.h" #include "ffi/data.h" @@ -11,9 +14,12 @@ namespace node { using v8::Array; +using v8::ArrayBuffer; using v8::BigInt; +using v8::Boolean; using v8::Context; using v8::DontDelete; +using v8::DontEnum; using v8::External; using v8::Function; using v8::FunctionCallbackInfo; @@ -59,6 +65,10 @@ void DynamicLibrary::MemoryInfo(MemoryTracker* tracker) const { tracker->TrackFieldWithSize( "symbols", symbols_size, "std::unordered_map"); + + // FFIFunctionInfo instances and their sb_backing ArrayBuffers are + // owned by V8 function wrappers and reachable only via weak references, + // so they are deliberately not counted here. } void DynamicLibrary::Close() { @@ -115,7 +125,8 @@ Maybe DynamicLibrary::PrepareFunction( if (!ParseFunctionSignature(env, name, signature).To(&parsed)) { return {}; } - auto [return_type, args] = parsed; + auto [return_type, args, return_type_name, arg_type_names] = + std::move(parsed); bool should_cache_symbol = false; bool should_cache_function = false; @@ -129,11 +140,14 @@ Maybe DynamicLibrary::PrepareFunction( should_cache_symbol = symbols_.find(name) == symbols_.end(); - fn = std::make_shared(FFIFunction{.closed = false, - .ptr = ptr, - .cif = {}, - .args = args, - .return_type = return_type}); + fn = std::make_shared( + FFIFunction{.closed = false, + .ptr = ptr, + .cif = {}, + .args = args, + .return_type = return_type, + .arg_type_names = std::move(arg_type_names), + .return_type_name = std::move(return_type_name)}); ffi_status status = ffi_prep_cif(&fn->cif, FFI_DEFAULT_ABI, @@ -188,13 +202,26 @@ MaybeLocal DynamicLibrary::CreateFunction( const std::string& name, const std::shared_ptr& fn) { Isolate* isolate = env->isolate(); + Local context = env->context(); - FFIFunctionInfo* info = new FFIFunctionInfo(); + // The info is held in a unique_ptr so early-return paths free it. Ownership + // moves to the weak callback via `release()` once `SetWeak` succeeds. + auto info = std::make_unique(); info->fn = fn; + + DCHECK_EQ(fn->args.size(), fn->arg_type_names.size()); + + bool use_sb = IsSBEligibleSignature(*fn); + bool has_ptr_args = use_sb && SignatureHasPointerArgs(*fn); + Local data = - External::New(isolate, info, v8::kExternalPointerTypeTagDefault); + External::New(isolate, info.get(), v8::kExternalPointerTypeTagDefault); + MaybeLocal maybe_ret = - Function::New(env->context(), DynamicLibrary::InvokeFunction, data); + Function::New(context, + use_sb ? DynamicLibrary::InvokeFunctionSB + : DynamicLibrary::InvokeFunction, + data); Local ret; if (!maybe_ret.ToLocal(&ret)) { return MaybeLocal(); @@ -204,13 +231,10 @@ MaybeLocal DynamicLibrary::CreateFunction( if (!ToV8Value(env->context(), name, isolate).ToLocal(&name_str)) { return MaybeLocal(); } - - info->self.Reset(isolate, ret); - info->self.SetWeak( - info, DynamicLibrary::CleanupFunctionInfo, WeakCallbackType::kParameter); ret->SetName(name_str.As()); + if (!ret->Set( - env->context(), + context, env->pointer_string(), BigInt::NewFromUnsigned( isolate, @@ -219,6 +243,80 @@ MaybeLocal DynamicLibrary::CreateFunction( return MaybeLocal(); } + // Internal properties are keyed by per-isolate Symbols (see + // `env_properties.h`) to keep them out of string-key reflection, and the + // `ReadOnly | DontEnum | DontDelete` attribute set blocks user code from + // reading, modifying, or deleting them. + PropertyAttribute internal_attrs = + static_cast(ReadOnly | DontEnum | DontDelete); + + if (use_sb) { + size_t sb_size = 8 * (fn->args.size() + 1); + Local ab = ArrayBuffer::New(isolate, sb_size); + // The shared_ptr to the backing store keeps the memory alive while + // FFIFunctionInfo still references it. + info->sb_backing = ab->GetBackingStore(); + + if (!ret->DefineOwnProperty( + context, env->ffi_sb_shared_buffer_symbol(), ab, internal_attrs) + .FromMaybe(false)) { + return MaybeLocal(); + } + + // Signatures with pointer args also expose a slow-path invoker bound + // to the same FFIFunctionInfo. The JS wrapper routes through it when a + // pointer argument is anything other than a BigInt, null, or undefined + // (strings, Buffers, ArrayBuffers, and ArrayBufferViews). + if (has_ptr_args) { + Local slow_fn; + if (!Function::New(context, DynamicLibrary::InvokeFunction, data) + .ToLocal(&slow_fn)) { + return MaybeLocal(); + } + if (!ret->DefineOwnProperty(context, + env->ffi_sb_invoke_slow_symbol(), + slow_fn, + internal_attrs) + .FromMaybe(false)) { + return MaybeLocal(); + } + } + + // Attach the original signature type names so the JS wrapper can + // rebuild the signature from a raw function when the caller did not + // pass parameters and result explicitly. The `lib.functions` accessor + // path relies on this. + Local params_arr; + if (!ToV8Value(context, fn->arg_type_names, isolate).ToLocal(¶ms_arr)) { + return MaybeLocal(); + } + if (!ret->DefineOwnProperty(context, + env->ffi_sb_params_symbol(), + params_arr, + internal_attrs) + .FromMaybe(false)) { + return MaybeLocal(); + } + + Local result_name; + if (!ToV8Value(context, fn->return_type_name, isolate) + .ToLocal(&result_name)) { + return MaybeLocal(); + } + if (!ret->DefineOwnProperty(context, + env->ffi_sb_result_symbol(), + result_name, + internal_attrs) + .FromMaybe(false)) { + return MaybeLocal(); + } + } + + info->self.Reset(isolate, ret); + info->self.SetWeak(info.release(), + DynamicLibrary::CleanupFunctionInfo, + WeakCallbackType::kParameter); + return ret; } @@ -342,6 +440,65 @@ void DynamicLibrary::InvokeFunction(const FunctionCallbackInfo& args) { free(result); } +void DynamicLibrary::InvokeFunctionSB(const FunctionCallbackInfo& args) { + Environment* env = Environment::GetCurrent(args); + FFIFunctionInfo* info = + static_cast(args.Data().As()->Value()); + FFIFunction* fn = info->fn.get(); + + if (fn == nullptr || fn->closed || fn->ptr == nullptr) { + THROW_ERR_FFI_LIBRARY_CLOSED(env); + return; + } + + // Arguments reach the native invoker through the shared buffer, not + // through V8. The JS wrapper always calls the raw function as `rawFn()` + // so any non-zero argument count indicates that user code reached the + // raw SB function directly and is about to read stale buffer contents. + if (args.Length() != 0) { + THROW_ERR_INVALID_ARG_VALUE( + env, + "SB-invoked FFI functions receive arguments through the shared " + "buffer, not as JavaScript arguments"); + return; + } + + // A failure of either CHECK means the SB invoker ran against a function + // that `CreateFunction` did not set up for the fast path, which is a + // contract violation. They stay enabled in Release because each FFI call + // is already dominated by `ffi_call` itself. + CHECK(info->sb_backing); + CHECK_EQ(info->sb_backing->ByteLength(), 8u * (info->fn->args.size() + 1)); + + uint8_t* buffer = static_cast(info->sb_backing->Data()); + unsigned int nargs = fn->args.size(); + + // Layout is 8 bytes per slot. The return value lives at offset 0 and + // argument i lives at offset 8*(i+1). + std::vector values(nargs, 0); + std::vector ffi_args(nargs, nullptr); + + for (unsigned int i = 0; i < nargs; i++) { + ReadFFIArgFromBuffer(fn->args[i], buffer, 8 * (i + 1), &values[i]); + ffi_args[i] = &values[i]; + } + + // The storage must cover both the ffi_arg width that libffi uses for + // promoted small integer returns and the 8 bytes needed for non-promoted + // SB-eligible returns like f64, i64, and u64. `sizeof(ffi_arg)` is only + // 4 on 32-bit ARM, so take the max. + constexpr size_t kSBResultStorageSize = + sizeof(ffi_arg) > 8 ? sizeof(ffi_arg) : 8; + alignas(8) uint8_t result_storage[kSBResultStorageSize] = {0}; + void* result = (fn->return_type != &ffi_type_void) ? result_storage : nullptr; + + ffi_call(&fn->cif, FFI_FN(fn->ptr), result, ffi_args.data()); + + if (result != nullptr) { + WriteFFIReturnToBuffer(fn->return_type, result, buffer, 0); + } +} + // This is the function that will be called by libffi when a callback // is invoked from a dlopen library. It converts the arguments to JavaScript // values and calls the original JavaScript callback function. @@ -914,11 +1071,15 @@ Local DynamicLibrary::GetConstructorTemplate( Local(), attributes); - tmpl->InstanceTemplate()->SetAccessorProperty( + // `functions` lives on the prototype template rather than the instance + // template so `lib/ffi.js` can replace it via `Object.defineProperty` + // on the prototype. The attribute set omits `DontDelete` for the same + // reason. + tmpl->PrototypeTemplate()->SetAccessorProperty( FIXED_ONE_BYTE_STRING(isolate, "functions"), FunctionTemplate::New(env->isolate(), DynamicLibrary::GetFunctions), Local(), - attributes); + static_cast(ReadOnly)); SetProtoMethod(isolate, tmpl, "close", DynamicLibrary::Close); SetProtoMethod(isolate, tmpl, "getFunction", DynamicLibrary::GetFunction); @@ -978,6 +1139,51 @@ static void Initialize(Local target, SetMethod(context, target, "setUint64", SetUint64); SetMethod(context, target, "setFloat32", SetFloat32); SetMethod(context, target, "setFloat64", SetFloat64); + + // ToFFIType maps `char` to sint8 or uint8 based on `CHAR_MIN < 0` at C++ + // build time. Exposing the same decision to JS lets the shared-buffer + // wrapper's range check match `ToFFIArgument` on every platform. + Isolate* isolate = env->isolate(); + target + ->Set(context, + FIXED_ONE_BYTE_STRING(isolate, "charIsSigned"), + Boolean::New(isolate, CHAR_MIN < 0)) + .Check(); + + // The shared-buffer fast path uses `uintptrMax` to reject pointer BigInts + // that would otherwise be silently truncated by `ReadFFIArgFromBuffer`'s + // `memcpy(..., type->size, ...)` on 32-bit platforms. The slow path + // rejects the same values through `ToFFIArgument`. + target + ->Set(context, + FIXED_ONE_BYTE_STRING(isolate, "uintptrMax"), + v8::BigInt::NewFromUnsigned( + isolate, + static_cast(std::numeric_limits::max()))) + .Check(); + + // Per-isolate Symbols used by `lib/internal/ffi-shared-buffer.js` to key + // shared-buffer internal state on raw FFI functions. + target + ->Set(context, + FIXED_ONE_BYTE_STRING(isolate, "kSbSharedBuffer"), + env->ffi_sb_shared_buffer_symbol()) + .Check(); + target + ->Set(context, + FIXED_ONE_BYTE_STRING(isolate, "kSbInvokeSlow"), + env->ffi_sb_invoke_slow_symbol()) + .Check(); + target + ->Set(context, + FIXED_ONE_BYTE_STRING(isolate, "kSbParams"), + env->ffi_sb_params_symbol()) + .Check(); + target + ->Set(context, + FIXED_ONE_BYTE_STRING(isolate, "kSbResult"), + env->ffi_sb_result_symbol()) + .Check(); } } // namespace ffi diff --git a/src/node_ffi.h b/src/node_ffi.h index 6482a31ae386a6..14362963f288ce 100644 --- a/src/node_ffi.h +++ b/src/node_ffi.h @@ -25,11 +25,14 @@ struct FFIFunction { ffi_cif cif; std::vector args; ffi_type* return_type; + std::vector arg_type_names; + std::string return_type_name; }; struct FFIFunctionInfo { std::shared_ptr fn; v8::Global self; + std::shared_ptr sb_backing; }; struct FFICallback { @@ -75,6 +78,7 @@ class DynamicLibrary : public BaseObject { static void New(const v8::FunctionCallbackInfo& args); static void Close(const v8::FunctionCallbackInfo& args); static void InvokeFunction(const v8::FunctionCallbackInfo& args); + static void InvokeFunctionSB(const v8::FunctionCallbackInfo& args); static void InvokeCallback(ffi_cif* cif, void* ret, void** args, diff --git a/test/ffi/fixture_library/ffi_test_library.c b/test/ffi/fixture_library/ffi_test_library.c index 8ac19c1a6d1ae2..4a57b9c9970a9a 100644 --- a/test/ffi/fixture_library/ffi_test_library.c +++ b/test/ffi/fixture_library/ffi_test_library.c @@ -215,6 +215,7 @@ FFI_EXPORT int32_t logical_not(int32_t a) { // Void operations (side effects). static int32_t global_counter = 0; +static int32_t global_scratch = 0; FFI_EXPORT void increment_counter(void) { global_counter++; @@ -228,6 +229,47 @@ FFI_EXPORT void reset_counter(void) { global_counter = 0; } +FFI_EXPORT void store_sum_2_i32(int32_t a, int32_t b) { + global_scratch = a + b; +} + +FFI_EXPORT void store_i32(int32_t a) { + global_scratch = a; +} + +FFI_EXPORT void store_sum_3_i32(int32_t a, int32_t b, int32_t c) { + global_scratch = a + b + c; +} + +FFI_EXPORT void store_sum_4_i32(int32_t a, int32_t b, int32_t c, int32_t d) { + global_scratch = a + b + c + d; +} + +FFI_EXPORT void store_sum_5_i32( + int32_t a, int32_t b, int32_t c, int32_t d, int32_t e) { + global_scratch = a + b + c + d + e; +} + +FFI_EXPORT void store_sum_6_i32( + int32_t a, int32_t b, int32_t c, int32_t d, int32_t e, int32_t f) { + global_scratch = a + b + c + d + e + f; +} + +FFI_EXPORT void store_sum_8_i32(int32_t a, + int32_t b, + int32_t c, + int32_t d, + int32_t e, + int32_t f, + int32_t g, + int32_t h) { + global_scratch = a + b + c + d + e + f + g + h; +} + +FFI_EXPORT int32_t get_scratch(void) { + return global_scratch; +} + // Callback operations. typedef int32_t (*IntCallback)(int32_t); @@ -331,6 +373,29 @@ FFI_EXPORT double sum_five_f64( return a + b + c + d + e; } +FFI_EXPORT int32_t sum_3_i32(int32_t a, int32_t b, int32_t c) { + return a + b + c; +} + +FFI_EXPORT int32_t sum_4_i32(int32_t a, int32_t b, int32_t c, int32_t d) { + return a + b + c + d; +} + +FFI_EXPORT int32_t +sum_6_i32(int32_t a, int32_t b, int32_t c, int32_t d, int32_t e, int32_t f) { + return a + b + c + d + e + f; +} + +FFI_EXPORT int32_t sum_7_i32(int32_t a, + int32_t b, + int32_t c, + int32_t d, + int32_t e, + int32_t f, + int32_t g) { + return a + b + c + d + e + f + g; +} + // Mixed parameter types. FFI_EXPORT double mixed_operation(int32_t i, float f, double d, uint32_t u) { diff --git a/test/ffi/test-ffi-dynamic-library.js b/test/ffi/test-ffi-dynamic-library.js index 8ff2e9de816317..ec67e4f34c40be 100644 --- a/test/ffi/test-ffi-dynamic-library.js +++ b/test/ffi/test-ffi-dynamic-library.js @@ -50,7 +50,11 @@ test('dlopen resolves functions from definitions', () => { assert.strictEqual(functions.add_f32(1.25, 2.75), 4); assert.strictEqual(functions.add_u64(20n, 22n), 42n); assert.strictEqual(functions.add_i32.name, 'add_i32'); - assert.strictEqual(functions.add_i32.length, 0); + // Shared-buffer wrapper sets `length` to the FFI signature's arity + // (see `inheritMetadata` in lib/internal/ffi-shared-buffer.js). The raw + // native function has length 0, but the wrapper exposes the parameter + // count so `fn.length` is useful for introspection. + assert.strictEqual(functions.add_i32.length, 2); assert.strictEqual(typeof functions.add_i32.pointer, 'bigint'); assert.strictEqual(Object.getPrototypeOf(functions), null); } finally { diff --git a/test/ffi/test-ffi-shared-buffer.js b/test/ffi/test-ffi-shared-buffer.js new file mode 100644 index 00000000000000..43d76a4da18315 --- /dev/null +++ b/test/ffi/test-ffi-shared-buffer.js @@ -0,0 +1,806 @@ +// Flags: --experimental-ffi --expose-internals +'use strict'; +const common = require('../common'); +common.skipIfFFIMissing(); + +const assert = require('node:assert'); +const { test } = require('node:test'); + +// Capture the unpatched DynamicLibrary.prototype.getFunction BEFORE loading +// `node:ffi`, which patches it. The SB-metadata test below uses the raw +// method to inspect Symbol-keyed internals that `inheritMetadata` +// deliberately does not forward onto the wrapper. +const { internalBinding } = require('internal/test/binding'); +const ffiBinding = internalBinding('ffi'); +const { + kSbInvokeSlow, + kSbParams, + kSbResult, + kSbSharedBuffer, +} = ffiBinding; +const rawGetFunctionUnpatched = ffiBinding.DynamicLibrary.prototype.getFunction; + +const ffi = require('node:ffi'); +const { libraryPath } = require('./ffi-test-common'); + +test('numeric-only i32 function uses SB path', () => { + const { lib, functions } = ffi.dlopen(libraryPath, { + add_i32: { result: 'i32', parameters: ['i32', 'i32'] }, + }); + try { + assert.strictEqual(functions.add_i32(20, 22), 42); + assert.strictEqual(functions.add_i32(-10, 10), 0); + assert.strictEqual(functions.add_i32(0, 0), 0); + assert.strictEqual(functions.add_i32(2147483647, 0), 2147483647); + } finally { + lib.close(); + } +}); + +test('i8/u8/i16/u16 round-trip', () => { + const { lib, functions } = ffi.dlopen(libraryPath, { + add_i8: { result: 'i8', parameters: ['i8', 'i8'] }, + add_u8: { result: 'u8', parameters: ['u8', 'u8'] }, + add_i16: { result: 'i16', parameters: ['i16', 'i16'] }, + add_u16: { result: 'u16', parameters: ['u16', 'u16'] }, + }); + try { + assert.strictEqual(functions.add_i8(10, 20), 30); + assert.strictEqual(functions.add_u8(100, 155), 255); + assert.strictEqual(functions.add_i16(1000, 2000), 3000); + assert.strictEqual(functions.add_u16(30000, 35535), 65535); + } finally { + lib.close(); + } +}); + +test('f32/f64 round-trip', () => { + const { lib, functions } = ffi.dlopen(libraryPath, { + add_f32: { result: 'f32', parameters: ['f32', 'f32'] }, + add_f64: { result: 'f64', parameters: ['f64', 'f64'] }, + }); + try { + // 1.25 and 2.75 are exactly representable in float32, so the sum is exact. + assert.strictEqual(functions.add_f32(1.25, 2.75), 4.0); + assert.strictEqual(functions.add_f64(1.5, 2.5), 4.0); + } finally { + lib.close(); + } +}); + +test('i64/u64 BigInt round-trip', () => { + const { lib, functions } = ffi.dlopen(libraryPath, { + add_i64: { result: 'i64', parameters: ['i64', 'i64'] }, + add_u64: { result: 'u64', parameters: ['u64', 'u64'] }, + }); + try { + assert.strictEqual(functions.add_i64(10n, 20n), 30n); + assert.strictEqual(functions.add_u64(10n, 20n), 30n); + } finally { + lib.close(); + } +}); + +test('zero-arg function', () => { + const { lib, functions } = ffi.dlopen(libraryPath, { + char_is_signed: { result: 'i32', parameters: [] }, + }); + try { + const result = functions.char_is_signed(); + assert.strictEqual(typeof result, 'number'); + assert.ok(result === 0 || result === 1); + } finally { + lib.close(); + } +}); + +test('6-arg numeric function', () => { + const { lib, functions } = ffi.dlopen(libraryPath, { + sum_6_i32: { result: 'i32', parameters: ['i32', 'i32', 'i32', 'i32', 'i32', 'i32'] }, + }); + try { + assert.strictEqual(functions.sum_6_i32(1, 2, 3, 4, 5, 6), 21); + } finally { + lib.close(); + } +}); + +test('pointer args: fast path (BigInt/null) and slow-path fallback (Buffer/ArrayBuffer)', () => { + const { lib, functions } = ffi.dlopen(libraryPath, { + identity_pointer: { result: 'pointer', parameters: ['pointer'] }, + pointer_to_usize: { result: 'u64', parameters: ['pointer'] }, + }); + try { + assert.strictEqual(functions.identity_pointer(0n), 0n); + assert.strictEqual(functions.identity_pointer(0x1234n), 0x1234n); + assert.strictEqual(functions.identity_pointer(null), 0n); + assert.strictEqual(functions.identity_pointer(undefined), 0n); + assert.strictEqual(functions.pointer_to_usize(0x42n), 0x42n); + + const buf = Buffer.from('hello'); + const bufPtr = functions.identity_pointer(buf); + assert.strictEqual(typeof bufPtr, 'bigint'); + assert.strictEqual(bufPtr, ffi.getRawPointer(buf)); + + const abPtr = functions.identity_pointer(new ArrayBuffer(16)); + assert.strictEqual(typeof abPtr, 'bigint'); + assert.ok(abPtr !== 0n); + } finally { + lib.close(); + } +}); + +test('string pointer uses slow-path fallback', () => { + const { lib, functions } = ffi.dlopen(libraryPath, { + string_length: { result: 'u64', parameters: ['pointer'] }, + }); + try { + assert.strictEqual(functions.string_length('hello'), 5n); + // strlen(NULL) is UB, so use a NUL-terminated Buffer for the fast path. + assert.strictEqual(functions.string_length(Buffer.from('world\0')), 5n); + } finally { + lib.close(); + } +}); + +test('non-SB-eligible signature falls back to raw function', () => { + const { lib, functions } = ffi.dlopen(libraryPath, { + string_duplicate: { result: 'pointer', parameters: ['pointer'] }, + free_string: { result: 'void', parameters: ['pointer'] }, + }); + try { + const dup = functions.string_duplicate('round-trip'); + assert.strictEqual(typeof dup, 'bigint'); + assert.ok(dup !== 0n); + functions.free_string(dup); + } finally { + lib.close(); + } +}); + +test('reentrancy across two FFI symbols', () => { + // A JS callback invoked by one FFI function reenters a different FFI + // function. Each has its own ArrayBuffer; neither may clobber the other. + const { lib, functions } = ffi.dlopen(libraryPath, { + call_int_callback: { result: 'i32', parameters: ['pointer', 'i32'] }, + add_i32: { result: 'i32', parameters: ['i32', 'i32'] }, + }); + + let callDepth = 0; + let innerResult = -1; + const callback = lib.registerCallback( + { result: 'i32', parameters: ['i32'] }, + (x) => { + callDepth++; + if (callDepth === 1) innerResult = functions.add_i32(x, 100); + return x * 2; + }, + ); + + try { + const outer = functions.call_int_callback(callback, 7); + assert.strictEqual(innerResult, 107); + assert.strictEqual(outer, 14); + } finally { + lib.unregisterCallback(callback); + lib.close(); + } +}); + +test('arity mismatch throws ERR_INVALID_ARG_VALUE', () => { + const { lib, functions } = ffi.dlopen(libraryPath, { + add_i32: { result: 'i32', parameters: ['i32', 'i32'] }, + }); + try { + assert.throws(() => functions.add_i32(1), { + code: 'ERR_INVALID_ARG_VALUE', + message: /Invalid argument count: expected 2, got 1/, + }); + assert.throws(() => functions.add_i32(1, 2, 3), { + code: 'ERR_INVALID_ARG_VALUE', + message: /Invalid argument count: expected 2, got 3/, + }); + } finally { + lib.close(); + } +}); + +test('arity 7+ uses the generic rest-params branch', () => { + const { lib, functions } = ffi.dlopen(libraryPath, { + sum_7_i32: { + result: 'i32', + parameters: ['i32', 'i32', 'i32', 'i32', 'i32', 'i32', 'i32'], + }, + }); + try { + assert.strictEqual(functions.sum_7_i32(1, 2, 3, 4, 5, 6, 7), 28); + assert.throws( + () => functions.sum_7_i32(1, 2, 3, 4, 5, 6), + { code: 'ERR_INVALID_ARG_VALUE', message: /expected 7, got 6/ }, + ); + } finally { + lib.close(); + } +}); + +test('wrappers preserve name/length/pointer and the functions accessor returns wrappers', () => { + const { lib, functions } = ffi.dlopen(libraryPath, { + add_i32: { result: 'i32', parameters: ['i32', 'i32'] }, + identity_pointer: { result: 'pointer', parameters: ['pointer'] }, + }); + try { + assert.strictEqual(functions.add_i32.name, 'add_i32'); + assert.strictEqual(typeof functions.add_i32.pointer, 'bigint'); + assert.ok(functions.add_i32.pointer !== 0n); + + assert.strictEqual(functions.identity_pointer.name, 'identity_pointer'); + assert.strictEqual(typeof functions.identity_pointer.pointer, 'bigint'); + assert.ok(functions.identity_pointer.pointer !== 0n); + + // `lib.functions.*` must also go through the SB wrapper. + assert.strictEqual(typeof lib.functions.add_i32, 'function'); + assert.strictEqual(lib.functions.add_i32(20, 22), 42); + assert.strictEqual(lib.functions.identity_pointer(0x1234n), 0x1234n); + } finally { + lib.close(); + } +}); + +test('integer boundaries for i8/u8/i16/u16/i32/u32', () => { + const { lib, functions } = ffi.dlopen(libraryPath, { + add_i8: { result: 'i8', parameters: ['i8', 'i8'] }, + add_u8: { result: 'u8', parameters: ['u8', 'u8'] }, + add_i16: { result: 'i16', parameters: ['i16', 'i16'] }, + add_u16: { result: 'u16', parameters: ['u16', 'u16'] }, + add_i32: { result: 'i32', parameters: ['i32', 'i32'] }, + add_u32: { result: 'u32', parameters: ['u32', 'u32'] }, + }); + + try { + assert.strictEqual(functions.add_i8(127, 0), 127); + assert.strictEqual(functions.add_i8(-128, 0), -128); + assert.strictEqual(functions.add_u8(255, 0), 255); + assert.strictEqual(functions.add_u8(0, 0), 0); + assert.strictEqual(functions.add_i16(32767, 0), 32767); + assert.strictEqual(functions.add_i16(-32768, 0), -32768); + assert.strictEqual(functions.add_u16(65535, 0), 65535); + assert.strictEqual(functions.add_i32(2147483647, 0), 2147483647); + assert.strictEqual(functions.add_i32(-2147483648, 0), -2147483648); + assert.strictEqual(functions.add_u32(4294967295, 0), 4294967295); + assert.strictEqual(functions.add_u32(0, 0), 0); + + const expect = { code: 'ERR_INVALID_ARG_VALUE' }; + assert.throws(() => functions.add_i8(128, 0), expect); + assert.throws(() => functions.add_i8(-129, 0), expect); + assert.throws(() => functions.add_u8(256, 0), expect); + assert.throws(() => functions.add_u8(-1, 0), expect); + assert.throws(() => functions.add_i16(32768, 0), expect); + assert.throws(() => functions.add_i16(-32769, 0), expect); + assert.throws(() => functions.add_u16(65536, 0), expect); + assert.throws(() => functions.add_u16(-1, 0), expect); + assert.throws(() => functions.add_i32(2147483648, 0), expect); + assert.throws(() => functions.add_i32(-2147483649, 0), expect); + assert.throws(() => functions.add_u32(4294967296, 0), expect); + assert.throws(() => functions.add_u32(-1, 0), expect); + + assert.throws(() => functions.add_i32(1.5, 0), expect); + assert.throws(() => functions.add_i32(NaN, 0), expect); + assert.throws(() => functions.add_i32(Infinity, 0), expect); + assert.throws(() => functions.add_i32('1', 0), expect); + } finally { + lib.close(); + } +}); + +test('i64/u64 BigInt boundaries and Number/BigInt type mismatches', () => { + const { lib, functions } = ffi.dlopen(libraryPath, { + add_i64: { result: 'i64', parameters: ['i64', 'i64'] }, + add_u64: { result: 'u64', parameters: ['u64', 'u64'] }, + }); + + try { + const I64_MAX = (1n << 63n) - 1n; + const I64_MIN = -(1n << 63n); + const U64_MAX = (1n << 64n) - 1n; + + assert.strictEqual(functions.add_i64(I64_MAX, 0n), I64_MAX); + assert.strictEqual(functions.add_i64(I64_MIN, 0n), I64_MIN); + assert.strictEqual(functions.add_u64(U64_MAX, 0n), U64_MAX); + assert.strictEqual(functions.add_u64(0n, 0n), 0n); + + const expect = { code: 'ERR_INVALID_ARG_VALUE' }; + assert.throws(() => functions.add_i64(I64_MAX + 1n, 0n), expect); + assert.throws(() => functions.add_i64(I64_MIN - 1n, 0n), expect); + assert.throws(() => functions.add_u64(U64_MAX + 1n, 0n), expect); + assert.throws(() => functions.add_u64(-1n, 0n), expect); + + assert.throws(() => functions.add_i64(1, 2n), expect); + assert.throws(() => functions.add_i64(1n, '2'), expect); + } finally { + lib.close(); + } +}); + +test('char type picks signed/unsigned range based on host ABI', () => { + const { lib, functions } = ffi.dlopen(libraryPath, { + char_is_signed: { result: 'i32', parameters: [] }, + identity_char: { result: 'char', parameters: ['char'] }, + }); + + try { + const isSigned = functions.char_is_signed() !== 0; + const expect = { code: 'ERR_INVALID_ARG_VALUE' }; + + assert.strictEqual(functions.identity_char(65), 65); + + if (isSigned) { + assert.strictEqual(functions.identity_char(-128), -128); + assert.strictEqual(functions.identity_char(127), 127); + assert.throws(() => functions.identity_char(128), expect); + assert.throws(() => functions.identity_char(-129), expect); + } else { + assert.strictEqual(functions.identity_char(255), 255); + assert.strictEqual(functions.identity_char(0), 0); + assert.throws(() => functions.identity_char(256), expect); + assert.throws(() => functions.identity_char(-1), expect); + } + } finally { + lib.close(); + } +}); + +test('SB metadata is Symbol-keyed, attribute-hardened, and not leaked onto the wrapper', () => { + const rawLib = new ffiBinding.DynamicLibrary(libraryPath); + try { + const rawFn = rawGetFunctionUnpatched.call( + rawLib, 'add_i32', { result: 'i32', parameters: ['i32', 'i32'] }); + + for (const [name, sym] of [ + ['kSbSharedBuffer', kSbSharedBuffer], + ['kSbInvokeSlow', kSbInvokeSlow], + ['kSbParams', kSbParams], + ['kSbResult', kSbResult], + ]) { + assert.strictEqual(typeof sym, 'symbol', `${name} must be a Symbol`); + } + + // Numeric-only signature: kSbInvokeSlow absent; the rest present and hardened. + for (const [name, sym] of [ + ['kSbSharedBuffer', kSbSharedBuffer], + ['kSbParams', kSbParams], + ['kSbResult', kSbResult], + ]) { + const desc = Object.getOwnPropertyDescriptor(rawFn, sym); + assert.ok(desc !== undefined, `${name} missing on pure-numeric SB function`); + assert.strictEqual(desc.enumerable, false); + assert.strictEqual(desc.configurable, false); + assert.strictEqual(desc.writable, false); + } + assert.strictEqual( + Object.getOwnPropertyDescriptor(rawFn, kSbInvokeSlow), undefined); + + // Pointer signature: kSbInvokeSlow must exist (and be hardened). + const rawPtrFn = rawGetFunctionUnpatched.call( + rawLib, 'identity_pointer', { result: 'pointer', parameters: ['pointer'] }); + const slowDesc = Object.getOwnPropertyDescriptor(rawPtrFn, kSbInvokeSlow); + assert.ok(slowDesc !== undefined); + assert.strictEqual(slowDesc.enumerable, false); + assert.strictEqual(slowDesc.configurable, false); + assert.strictEqual(slowDesc.writable, false); + + assert.deepStrictEqual(Object.keys(rawFn), ['pointer']); + const ownSyms = Object.getOwnPropertySymbols(rawFn); + assert.ok(ownSyms.includes(kSbSharedBuffer)); + assert.ok(ownSyms.includes(kSbParams)); + assert.ok(ownSyms.includes(kSbResult)); + + // Internals must not be forwarded by `inheritMetadata`. + const { lib, functions } = ffi.dlopen(libraryPath, { + add_i32: { result: 'i32', parameters: ['i32', 'i32'] }, + }); + try { + assert.strictEqual(functions.add_i32[kSbSharedBuffer], undefined); + assert.strictEqual(functions.add_i32[kSbInvokeSlow], undefined); + assert.strictEqual(functions.add_i32[kSbParams], undefined); + assert.strictEqual(functions.add_i32[kSbResult], undefined); + } finally { + lib.close(); + } + } finally { + rawLib.close(); + } +}); + +test('pointer fast-path range check: [0, 2^64 - 1]', () => { + const { lib, functions } = ffi.dlopen(libraryPath, { + identity_pointer: { result: 'pointer', parameters: ['pointer'] }, + }); + try { + assert.strictEqual(functions.identity_pointer(0n), 0n); + assert.strictEqual(functions.identity_pointer((1n << 64n) - 1n), (1n << 64n) - 1n); + + const expect = { code: 'ERR_INVALID_ARG_VALUE' }; + assert.throws(() => functions.identity_pointer(-1n), expect); + assert.throws(() => functions.identity_pointer(1n << 64n), expect); + } finally { + lib.close(); + } +}); + +test('self-recursive reentrancy: a single function\'s ArrayBuffer survives a nested call', () => { + // Stricter invariant than the two-symbol case: `InvokeFunctionSB` must + // copy args out of the ArrayBuffer to stack before `ffi_call` so a recursive + // call can reuse the same buffer without clobbering the outer frame. + const { lib, functions } = ffi.dlopen(libraryPath, { + call_binary_int_callback: { + result: 'i32', + parameters: ['function', 'i32', 'i32'], + }, + }); + + try { + let depth = 0; + const callback = lib.registerCallback( + { result: 'i32', parameters: ['i32', 'i32'] }, + common.mustCall((a, b) => { + depth++; + if (depth === 1) { + const inner = functions.call_binary_int_callback(callback, 100, 200); + assert.strictEqual(inner, 300); + } + return a + b; + }, 2), + ); + + try { + assert.strictEqual(functions.call_binary_int_callback(callback, 10, 20), 30); + } finally { + lib.unregisterCallback(callback); + } + } finally { + lib.close(); + } +}); + +test('void-return 0-arg wrapper branch', () => { + const { lib, functions } = ffi.dlopen(libraryPath, { + reset_counter: { result: 'void', parameters: [] }, + increment_counter: { result: 'void', parameters: [] }, + get_counter: { result: 'i32', parameters: [] }, + }); + try { + assert.strictEqual(functions.reset_counter(), undefined); + assert.strictEqual(functions.get_counter(), 0); + + functions.increment_counter(); + functions.increment_counter(); + functions.increment_counter(); + assert.strictEqual(functions.get_counter(), 3); + + assert.strictEqual(functions.reset_counter(), undefined); + assert.strictEqual(functions.get_counter(), 0); + } finally { + lib.close(); + } +}); + +test('void-return wrapper at every specialized arity observes side effects', () => { + // The arity ladder has a separate void-return closure for each arity. + // A wiring bug in a mid-arity void specialization would not be caught + // by the 0-arg void test above, so exercise the side effects directly + // at every arity the ladder specializes (1..6) plus the 7+ rest-params + // fallback. + const { lib, functions } = ffi.dlopen(libraryPath, { + store_i32: { result: 'void', parameters: ['i32'] }, + store_sum_2_i32: { result: 'void', parameters: ['i32', 'i32'] }, + store_sum_3_i32: { result: 'void', parameters: ['i32', 'i32', 'i32'] }, + store_sum_4_i32: { + result: 'void', + parameters: ['i32', 'i32', 'i32', 'i32'], + }, + store_sum_5_i32: { + result: 'void', + parameters: ['i32', 'i32', 'i32', 'i32', 'i32'], + }, + store_sum_6_i32: { + result: 'void', + parameters: ['i32', 'i32', 'i32', 'i32', 'i32', 'i32'], + }, + store_sum_8_i32: { + result: 'void', + parameters: ['i32', 'i32', 'i32', 'i32', 'i32', 'i32', 'i32', 'i32'], + }, + get_scratch: { result: 'i32', parameters: [] }, + }); + try { + // Powers-of-two summands detect a dropped or duplicated slot at each + // arity. + assert.strictEqual(functions.store_i32(7), undefined); + assert.strictEqual(functions.get_scratch(), 7); + + assert.strictEqual(functions.store_sum_2_i32(10, 32), undefined); + assert.strictEqual(functions.get_scratch(), 42); + + assert.strictEqual(functions.store_sum_3_i32(1, 2, 4), undefined); + assert.strictEqual(functions.get_scratch(), 7); + + assert.strictEqual(functions.store_sum_4_i32(1, 2, 4, 8), undefined); + assert.strictEqual(functions.get_scratch(), 15); + + assert.strictEqual(functions.store_sum_5_i32(1, 2, 4, 8, 16), undefined); + assert.strictEqual(functions.get_scratch(), 31); + + assert.strictEqual( + functions.store_sum_6_i32(1, 2, 4, 8, 16, 32), undefined); + assert.strictEqual(functions.get_scratch(), 63); + + // 7+ args takes the generic rest-params void branch rather than a + // per-arity specialization. + assert.strictEqual( + functions.store_sum_8_i32(1, 2, 4, 8, 16, 32, 64, 128), undefined); + assert.strictEqual(functions.get_scratch(), 255); + + // Validation still runs on every void-return branch, including the + // rest-params fallback. + assert.throws( + () => functions.store_i32(1.5), + { code: 'ERR_INVALID_ARG_VALUE' }); + assert.throws( + () => functions.store_sum_2_i32(1.5, 2), + { code: 'ERR_INVALID_ARG_VALUE' }); + assert.throws( + () => functions.store_sum_3_i32(1, 1.5, 3), + { code: 'ERR_INVALID_ARG_VALUE' }); + assert.throws( + () => functions.store_sum_4_i32(1, 2, 1.5, 4), + { code: 'ERR_INVALID_ARG_VALUE' }); + assert.throws( + () => functions.store_sum_5_i32(1, 2, 3, 1.5, 5), + { code: 'ERR_INVALID_ARG_VALUE' }); + assert.throws( + () => functions.store_sum_6_i32(1, 2, 3, 4, 5), + { code: 'ERR_INVALID_ARG_VALUE' }); + assert.throws( + () => functions.store_sum_8_i32(1, 2, 3, 4, 5, 6, 7, 1.5), + { code: 'ERR_INVALID_ARG_VALUE' }); + + // Wrong arity hits the `throwFFIArgCountError` branch inside each + // specialization (1..6 and the 7+ rest-params fallback). + for (const [name, expected, badArgs] of [ + ['store_i32', 1, []], + ['store_sum_2_i32', 2, [1]], + ['store_sum_3_i32', 3, [1, 2]], + ['store_sum_4_i32', 4, [1, 2, 3]], + ['store_sum_5_i32', 5, [1, 2, 3, 4]], + ['store_sum_6_i32', 6, [1, 2, 3, 4, 5]], + ['store_sum_8_i32', 8, [1, 2, 3, 4, 5, 6, 7]], + ]) { + assert.throws( + () => functions[name](...badArgs), + { + code: 'ERR_INVALID_ARG_VALUE', + message: new RegExp(`expected ${expected}, got ${badArgs.length}`), + }); + } + } finally { + lib.close(); + } +}); + +test('value-return wrapper arity mismatch hits every specialized branch', () => { + // `sum_7_i32` already exercises the 7+ rest-params branch elsewhere; + // this test targets the per-arity `throwFFIArgCountError` call in the + // value-return closures for arities 1..6 so each specialization's + // argument-count guard runs at least once. + const { lib, functions } = ffi.dlopen(libraryPath, { + logical_not: { result: 'i32', parameters: ['i32'] }, + add_i32: { result: 'i32', parameters: ['i32', 'i32'] }, + sum_3_i32: { result: 'i32', parameters: ['i32', 'i32', 'i32'] }, + sum_4_i32: { result: 'i32', parameters: ['i32', 'i32', 'i32', 'i32'] }, + sum_five_i32: { + result: 'i32', + parameters: ['i32', 'i32', 'i32', 'i32', 'i32'], + }, + sum_6_i32: { + result: 'i32', + parameters: ['i32', 'i32', 'i32', 'i32', 'i32', 'i32'], + }, + }); + try { + for (const [name, expected, badArgs] of [ + ['logical_not', 1, []], + ['add_i32', 2, [1]], + ['sum_3_i32', 3, [1, 2]], + ['sum_4_i32', 4, [1, 2, 3]], + ['sum_five_i32', 5, [1, 2, 3, 4]], + ['sum_6_i32', 6, [1, 2, 3, 4, 5]], + ]) { + assert.throws( + () => functions[name](...badArgs), + { + code: 'ERR_INVALID_ARG_VALUE', + message: new RegExp(`expected ${expected}, got ${badArgs.length}`), + }); + } + + // Sanity-check that a correct call still returns a value at each + // arity — a bug that swallowed the return on the value-return path + // would be caught here. + assert.strictEqual(functions.logical_not(0), 1); + assert.strictEqual(functions.add_i32(1, 2), 3); + assert.strictEqual(functions.sum_3_i32(1, 2, 4), 7); + assert.strictEqual(functions.sum_4_i32(1, 2, 4, 8), 15); + assert.strictEqual(functions.sum_five_i32(1, 2, 4, 8, 16), 31); + assert.strictEqual(functions.sum_6_i32(1, 2, 4, 8, 16, 32), 63); + } finally { + lib.close(); + } +}); + +test('pointer-dispatch wrapper rejects wrong-arity calls', () => { + // Pointer signatures share a single rest-params wrapper rather than the + // per-arity ladder, but it still has its own `throwFFIArgCountError` + // branch that needs to be exercised. + const { lib, functions } = ffi.dlopen(libraryPath, { + identity_pointer: { result: 'pointer', parameters: ['pointer'] }, + }); + try { + assert.throws( + () => functions.identity_pointer(), + { + code: 'ERR_INVALID_ARG_VALUE', + message: /expected 1, got 0/, + }); + assert.throws( + () => functions.identity_pointer(0n, 0n), + { + code: 'ERR_INVALID_ARG_VALUE', + message: /expected 1, got 2/, + }); + } finally { + lib.close(); + } +}); + +test('mid-arity wrappers (1, 3, 4, 5)', () => { + const { lib, functions } = ffi.dlopen(libraryPath, { + logical_not: { result: 'i32', parameters: ['i32'] }, + sum_3_i32: { result: 'i32', parameters: ['i32', 'i32', 'i32'] }, + sum_4_i32: { result: 'i32', parameters: ['i32', 'i32', 'i32', 'i32'] }, + sum_five_i32: { result: 'i32', parameters: ['i32', 'i32', 'i32', 'i32', 'i32'] }, + }); + try { + assert.strictEqual(functions.logical_not(0), 1); + assert.strictEqual(functions.logical_not(42), 0); + + // Powers-of-two summands: a dropped or duplicated slot would change the total. + assert.strictEqual(functions.sum_3_i32(1, 2, 4), 7); + assert.strictEqual(functions.sum_4_i32(1, 2, 4, 8), 15); + assert.strictEqual(functions.sum_five_i32(1, 2, 4, 8, 16), 31); + } finally { + lib.close(); + } +}); + +test('float specials: NaN, ±Infinity, -0 round-trip bit-exact', () => { + const { lib, functions } = ffi.dlopen(libraryPath, { + add_f64: { result: 'f64', parameters: ['f64', 'f64'] }, + multiply_f64: { result: 'f64', parameters: ['f64', 'f64'] }, + }); + try { + assert.ok(Number.isNaN(functions.add_f64(NaN, 1.0))); + assert.strictEqual(functions.add_f64(Infinity, 1.0), Infinity); + assert.strictEqual(functions.add_f64(-Infinity, 1.0), -Infinity); + assert.ok(Object.is(functions.multiply_f64(-0, 1.0), -0)); + } finally { + lib.close(); + } +}); + +test('arity-7+ branch still runs per-arg validation', () => { + const { lib, functions } = ffi.dlopen(libraryPath, { + sum_7_i32: { result: 'i32', parameters: ['i32', 'i32', 'i32', 'i32', 'i32', 'i32', 'i32'] }, + }); + try { + assert.throws( + () => functions.sum_7_i32(1, 2, 3, 1.5, 5, 6, 7), + { code: 'ERR_INVALID_ARG_VALUE' }, + ); + } finally { + lib.close(); + } +}); + +test('mixed-kind signature (i32, f32, f64, u32) dispatches the right writer per slot', () => { + // Four distinct `sbTypeInfo.kind` values (int, float, float, int) — a + // wiring bug that reused one writer across slots would surface here. + const { lib, functions } = ffi.dlopen(libraryPath, { + mixed_operation: { parameters: ['i32', 'f32', 'f64', 'u32'], result: 'f64' }, + }); + + try { + assert.strictEqual(functions.mixed_operation(10, 2.5, 3.5, 4), 20); + assert.strictEqual(functions.mixed_operation(-1, 0.25, 0.75, 0), 0); + + const expect = { code: 'ERR_INVALID_ARG_VALUE' }; + // -1 on u32 slot: distinguishes u32 writer from i32 (i32 accepts -1). + assert.throws(() => functions.mixed_operation(0, 0.0, 0.0, -1), expect); + // 2^31 on i32 slot: distinguishes i32 writer from u32 (u32 accepts it). + assert.throws(() => functions.mixed_operation(2147483648, 0.0, 0.0, 0), expect); + // Float slots reject BigInt / string (the int/float writers both gate on `typeof`). + assert.throws(() => functions.mixed_operation(0, 1n, 0.0, 0), expect); + assert.throws(() => functions.mixed_operation(0, 0.0, 'x', 0), expect); + } finally { + lib.close(); + } +}); + +test('lib.getFunctions() with no arguments wraps every cached function', () => { + // Regression: the no-args branch previously returned raw native functions + // whose shared buffer was uninitialized, producing garbage numeric results. + // Mix SB-eligible signatures with one that is not (`string_length` takes a + // string, which bypasses the fast path) so the no-args branch has to walk + // the early-return path in `wrapWithSharedBuffer` alongside the wrapped + // branch. + const { lib } = ffi.dlopen(libraryPath, { + add_i32: { result: 'i32', parameters: ['i32', 'i32'] }, + add_f64: { result: 'f64', parameters: ['f64', 'f64'] }, + mixed_operation: { parameters: ['i32', 'f32', 'f64', 'u32'], result: 'f64' }, + identity_pointer: { result: 'pointer', parameters: ['pointer'] }, + string_length: { result: 'u64', parameters: ['string'] }, + }); + + try { + const all = lib.getFunctions(); + assert.strictEqual(Object.getPrototypeOf(all), null); + + // SB-eligible entries go through the shared-buffer wrapper. + assert.strictEqual(all.add_i32(20, 22), 42); + assert.strictEqual(all.add_f64(1.5, 2.5), 4.0); + assert.strictEqual(all.identity_pointer(0x42n), 0x42n); + + // Non-eligible entry returns its raw native wrapper unchanged; it still + // has to be callable from the object returned by `getFunctions()`. + assert.strictEqual(all.string_length('hello'), 5n); + + assert.deepStrictEqual( + Object.keys(all).sort(), + ['add_f64', 'add_i32', 'identity_pointer', + 'mixed_operation', 'string_length']); + + assert.throws(() => all.add_i32(1), { code: 'ERR_INVALID_ARG_VALUE' }); + assert.throws(() => all.add_i32(1.5, 0), { code: 'ERR_INVALID_ARG_VALUE' }); + + assert.strictEqual(typeof all.add_i32.pointer, 'bigint'); + assert.ok(all.add_i32.pointer !== 0n); + + // The wrapper object is no longer frozen; nothing in the SB design + // requires it. + assert.ok(!Object.isFrozen(all)); + } finally { + lib.close(); + } +}); + +test('mixed pointer + numeric signature uses the pointer-dispatch wrapper', () => { + const { lib, functions } = ffi.dlopen(libraryPath, { + call_int_callback: { result: 'i32', parameters: ['pointer', 'i32'] }, + }); + + try { + const cb = lib.registerCallback( + { result: 'i32', parameters: ['i32'] }, + (x) => x * 2, + ); + try { + assert.strictEqual(functions.call_int_callback(cb, 7), 14); + // Negative i32 must land in the numeric writer (not the pointer writer, + // which would reject a negative BigInt). + assert.strictEqual(functions.call_int_callback(cb, -5), -10); + } finally { + lib.unregisterCallback(cb); + } + } finally { + lib.close(); + } +}); From 746624951f48e2850f683642ba2f9b918cca4ab5 Mon Sep 17 00:00:00 2001 From: SudhansuBandha <63417376+SudhansuBandha@users.noreply.github.com> Date: Tue, 28 Apr 2026 13:31:52 +0000 Subject: [PATCH 002/168] watch: track worker entry files in watch mode Currently, --watch mode only tracks dependencies from the main module graph (require/import). Worker thread entry points created via new Worker() are not included, so changes to worker files do not trigger restarts. This change hooks into Worker initialization and registers the worker entry file with watch mode, ensuring restarts when worker files change. Fixes: https://github.com/nodejs/node/issues/62275 Signed-off-by: SudhansuBandha PR-URL: https://github.com/nodejs/node/pull/62368 Reviewed-By: Moshe Atlow --- lib/internal/modules/cjs/loader.js | 24 ++ lib/internal/modules/esm/loader.js | 10 + lib/internal/worker.js | 22 +- test/sequential/test-watch-mode-worker.mjs | 281 +++++++++++++++++++++ 4 files changed, 336 insertions(+), 1 deletion(-) create mode 100644 test/sequential/test-watch-mode-worker.mjs diff --git a/lib/internal/modules/cjs/loader.js b/lib/internal/modules/cjs/loader.js index d7df00b3fdc96b..0b59d7e7a0f911 100644 --- a/lib/internal/modules/cjs/loader.js +++ b/lib/internal/modules/cjs/loader.js @@ -329,6 +329,28 @@ function reportModuleNotFoundToWatchMode(basePath, extensions) { } } +/** + * Tell the watch mode that a module was required, from within a worker thread. + * @param {string} filename Absolute path of the module + * @returns {void} + */ +function reportModuleToWatchModeFromWorker(filename) { + if (!shouldReportRequiredModules()) { + return; + } + const { isMainThread } = internalBinding('worker'); + if (isMainThread) { + return; + } + // Lazy require to avoid circular dependency: worker_threads is loaded after + // the CJS loader is fully set up. + const { parentPort } = require('worker_threads'); + if (!parentPort) { + return; + } + parentPort.postMessage({ 'watch:require': [filename] }); +} + /** * Create a new module instance. * @param {string} id @@ -1245,6 +1267,7 @@ Module._load = function(request, parent, isMain, internalResolveOptions = kEmpty relResolveCacheIdentifier = `${parent.path}\x00${request}`; const filename = relativeResolveCache[relResolveCacheIdentifier]; reportModuleToWatchMode(filename); + reportModuleToWatchModeFromWorker(filename); if (filename !== undefined) { const cachedModule = Module._cache[filename]; if (cachedModule !== undefined) { @@ -1335,6 +1358,7 @@ Module._load = function(request, parent, isMain, internalResolveOptions = kEmpty } reportModuleToWatchMode(filename); + reportModuleToWatchModeFromWorker(filename); Module._cache[filename] = module; module[kIsCachedByESMLoader] = false; // If there are resolve hooks, carry the context information into the diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js index 876ea6535f2187..e12cb7f01baa7d 100644 --- a/lib/internal/modules/esm/loader.js +++ b/lib/internal/modules/esm/loader.js @@ -518,6 +518,16 @@ class ModuleLoader { const type = requestType === kRequireInImportedCJS ? 'require' : 'import'; process.send({ [`watch:${type}`]: [url] }); } + // Relay Events from worker to main thread + if (process.env.WATCH_REPORT_DEPENDENCIES && !process.send) { + const { isMainThread } = internalBinding('worker'); + if (!isMainThread) { + const { parentPort } = require('worker_threads'); + if (parentPort) { + parentPort.postMessage({ 'watch:import': [url] }); + } + } + } // TODO(joyeecheung): update the module requests to use importAttributes as property names. const importAttributes = resolveResult.importAttributes ?? request.attributes; diff --git a/lib/internal/worker.js b/lib/internal/worker.js index 9c0dd03cac6726..3afd2180d705f6 100644 --- a/lib/internal/worker.js +++ b/lib/internal/worker.js @@ -1,6 +1,7 @@ 'use strict'; const { + ArrayIsArray, ArrayPrototypeForEach, ArrayPrototypeMap, ArrayPrototypePush, @@ -337,9 +338,28 @@ class Worker extends EventEmitter { this[kPublicPort] = publicPortToParent; ArrayPrototypeForEach(['message', 'messageerror'], (event) => { - this[kPublicPort].on(event, (message) => this.emit(event, message)); + this[kPublicPort].on(event, (message) => { + // Extract watch messages first if needed and relay events from worker thread to watcher + if ( + event === 'message' && + process.env.WATCH_REPORT_DEPENDENCIES && + process.send + ) { + const { isMainThread } = internalBinding('worker'); + if (isMainThread) { + if (ArrayIsArray(message?.['watch:require'])) { + process.send({ 'watch:require': message['watch:require'] }); + } + if (ArrayIsArray(message?.['watch:import'])) { + process.send({ 'watch:import': message['watch:import'] }); + } + } + } + this.emit(event, message); + }); }); setupPortReferencing(this[kPublicPort], this, 'message'); + this[kPort].postMessage({ argv, type: messageTypes.LOAD_SCRIPT, diff --git a/test/sequential/test-watch-mode-worker.mjs b/test/sequential/test-watch-mode-worker.mjs new file mode 100644 index 00000000000000..b7bc1a94a87ba4 --- /dev/null +++ b/test/sequential/test-watch-mode-worker.mjs @@ -0,0 +1,281 @@ +import * as common from '../common/index.mjs'; +import tmpdir from '../common/tmpdir.js'; +import assert from 'node:assert'; +import path from 'node:path'; +import { execPath } from 'node:process'; +import { describe, it } from 'node:test'; +import { spawn } from 'node:child_process'; +import { writeFileSync, readFileSync } from 'node:fs'; +import { inspect } from 'node:util'; +import { pathToFileURL } from 'node:url'; +import { createInterface } from 'node:readline'; + +if (common.isIBMi) + common.skip('IBMi does not support `fs.watch()`'); + +function restart(file, content = readFileSync(file)) { + writeFileSync(file, content); + const timer = setInterval(() => writeFileSync(file, content), common.platformTimeout(250)); + return () => clearInterval(timer); +} + +let tmpFiles = 0; +function createTmpFile(content = 'console.log(\'running\');', ext = '.js', basename = tmpdir.path) { + const file = path.join(basename, `${tmpFiles++}${ext}`); + writeFileSync(file, content); + return file; +} + +async function runWriteSucceed({ + file, + watchedFile, + watchFlag = '--watch', + args = [file], + completed = 'Completed running', + restarts = 2, + options = {}, + shouldFail = false, +}) { + args.unshift('--no-warnings'); + if (watchFlag !== null) args.unshift(watchFlag); + + const child = spawn(execPath, args, { encoding: 'utf8', stdio: 'pipe', ...options }); + + let completes = 0; + let cancelRestarts = () => {}; + let stderr = ''; + const stdout = []; + + child.stderr.on('data', (data) => { + stderr += data; + }); + + try { + for await (const data of createInterface({ input: child.stdout })) { + if (!data.startsWith('Waiting for graceful termination') && + !data.startsWith('Gracefully restarted')) { + stdout.push(data); + } + + if (data.startsWith(completed)) { + completes++; + + if (completes === restarts) break; + + if (completes === 1) { + cancelRestarts = restart(watchedFile); + } + } + + if (!shouldFail && data.startsWith('Failed running')) break; + } + } finally { + child.kill(); + cancelRestarts(); + } + + return { stdout, stderr, pid: child.pid }; +} + +tmpdir.refresh(); +const dir = tmpdir.path; + +describe('watch mode', { concurrency: !process.env.TEST_PARALLEL, timeout: 60_000 }, () => { + it('should watch changes to worker - cjs', async () => { + const worker = path.join(dir, 'worker.js'); + + writeFileSync(worker, ` +console.log('worker running'); +`); + + const file = createTmpFile(` +const { Worker } = require('node:worker_threads'); +const w = new Worker(${JSON.stringify(worker)}); +`, '.js', dir); + + const { stderr, stdout } = await runWriteSucceed({ + file, + watchedFile: worker, + }); + + assert.strictEqual(stderr, ''); + assert.deepStrictEqual(stdout, [ + 'worker running', + `Completed running ${inspect(file)}. Waiting for file changes before restarting...`, + `Restarting ${inspect(file)}`, + 'worker running', + `Completed running ${inspect(file)}. Waiting for file changes before restarting...`, + ]); + }); + + it('should watch changes to worker dependencies - cjs', async () => { + const dep = path.join(dir, 'dep.js'); + const worker = path.join(dir, 'worker.js'); + + writeFileSync(dep, ` +module.exports = 'dep v1'; +`); + + writeFileSync(worker, ` +const dep = require('./dep.js'); +console.log(dep); +`); + + const file = createTmpFile(` +const { Worker } = require('node:worker_threads'); +const w = new Worker(${JSON.stringify(worker)}); +`, '.js', dir); + + const { stderr, stdout } = await runWriteSucceed({ + file, + watchedFile: dep, + }); + + assert.strictEqual(stderr, ''); + assert.deepStrictEqual(stdout, [ + 'dep v1', + `Completed running ${inspect(file)}. Waiting for file changes before restarting...`, + `Restarting ${inspect(file)}`, + 'dep v1', + `Completed running ${inspect(file)}. Waiting for file changes before restarting...`, + ]); + }); + + it('should watch changes to nested worker dependencies - cjs', async () => { + const subDep = path.join(dir, 'sub-dep.js'); + const dep = path.join(dir, 'dep.js'); + const worker = path.join(dir, 'worker.js'); + + writeFileSync(subDep, ` +module.exports = 'sub-dep v1'; +`); + + writeFileSync(dep, ` +const subDep = require('./sub-dep.js'); +console.log(subDep); +module.exports = 'dep v1'; +`); + + writeFileSync(worker, ` +const dep = require('./dep.js'); +`); + + const file = createTmpFile(` +const { Worker } = require('node:worker_threads'); +const w = new Worker(${JSON.stringify(worker)}); +`, '.js', dir); + + const { stderr, stdout } = await runWriteSucceed({ + file, + watchedFile: subDep, + }); + + assert.strictEqual(stderr, ''); + assert.deepStrictEqual(stdout, [ + 'sub-dep v1', + `Completed running ${inspect(file)}. Waiting for file changes before restarting...`, + `Restarting ${inspect(file)}`, + 'sub-dep v1', + `Completed running ${inspect(file)}. Waiting for file changes before restarting...`, + ]); + }); + + it('should watch changes to worker - esm', async () => { + const worker = path.join(dir, 'worker.mjs'); + + writeFileSync(worker, ` +console.log('worker running'); +`); + + const file = createTmpFile(` +import { Worker } from 'node:worker_threads'; +new Worker(new URL(${JSON.stringify(pathToFileURL(worker))})); +`, '.mjs', dir); + + const { stderr, stdout } = await runWriteSucceed({ + file, + watchedFile: worker, + }); + + assert.strictEqual(stderr, ''); + assert.deepStrictEqual(stdout, [ + 'worker running', + `Completed running ${inspect(file)}. Waiting for file changes before restarting...`, + `Restarting ${inspect(file)}`, + 'worker running', + `Completed running ${inspect(file)}. Waiting for file changes before restarting...`, + ]); + }); + + it('should watch changes to worker dependencies - esm', async () => { + const dep = path.join(dir, 'dep.mjs'); + const worker = path.join(dir, 'worker.mjs'); + + writeFileSync(dep, ` +export default 'dep v1'; +`); + + writeFileSync(worker, ` +import dep from ${JSON.stringify(pathToFileURL(dep))}; +console.log(dep); +`); + + const file = createTmpFile(` +import { Worker } from 'node:worker_threads'; +new Worker(new URL(${JSON.stringify(pathToFileURL(worker))})); +`, '.mjs', dir); + + const { stderr, stdout } = await runWriteSucceed({ + file, + watchedFile: dep, + }); + + assert.strictEqual(stderr, ''); + assert.deepStrictEqual(stdout, [ + 'dep v1', + `Completed running ${inspect(file)}. Waiting for file changes before restarting...`, + `Restarting ${inspect(file)}`, + 'dep v1', + `Completed running ${inspect(file)}. Waiting for file changes before restarting...`, + ]); + }); + + it('should watch changes to nested worker dependencies - esm', async () => { + const subDep = path.join(dir, 'sub-dep.mjs'); + const dep = path.join(dir, 'dep.mjs'); + const worker = path.join(dir, 'worker.mjs'); + + writeFileSync(subDep, ` +export default 'sub-dep v1'; +`); + + writeFileSync(dep, ` +import subDep from ${JSON.stringify(pathToFileURL(subDep))}; +console.log(subDep); +export default 'dep v1'; +`); + + writeFileSync(worker, ` +import dep from ${JSON.stringify(pathToFileURL(dep))}; +`); + + const file = createTmpFile(` +import { Worker } from 'node:worker_threads'; +new Worker(new URL(${JSON.stringify(pathToFileURL(worker))})); +`, '.mjs', dir); + + const { stderr, stdout } = await runWriteSucceed({ + file, + watchedFile: subDep, + }); + + assert.strictEqual(stderr, ''); + assert.deepStrictEqual(stdout, [ + 'sub-dep v1', + `Completed running ${inspect(file)}. Waiting for file changes before restarting...`, + `Restarting ${inspect(file)}`, + 'sub-dep v1', + `Completed running ${inspect(file)}. Waiting for file changes before restarting...`, + ]); + }); +}); From 8385efc01343a835e3a0efe05611f44272cbb413 Mon Sep 17 00:00:00 2001 From: ishabi Date: Tue, 10 Mar 2026 09:38:50 +0100 Subject: [PATCH 003/168] deps: V8: cherry-pick 0f024d4e66e0 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Original commit message: [heap profiler] Add is_live field to AllocationProfile::Sample When using kSamplingIncludeObjectsCollectedByMajorGC/MinorGC flag, samples for collected objects are retained but callers had no way to distinguish live from dead objects. Add is_live to expose this information. Change-Id: I2e930644348ff942caa4b192a127c5baa05bbfef Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/7603535 Reviewed-by: Dominik Inführ Commit-Queue: Dominik Inführ Reviewed-by: Michael Lippautz Cr-Commit-Position: refs/heads/main@{#105698} Refs: https://github.com/v8/v8/commit/0f024d4e66e0edcb4a1370e47e2ba44686a28ac4 Signed-off-by: ishabi PR-URL: https://github.com/nodejs/node/pull/62408 Reviewed-By: Stephen Belanger Reviewed-By: Richard Lau Reviewed-By: Ruben Bridgewater --- common.gypi | 2 +- deps/v8/AUTHORS | 1 + deps/v8/include/v8-profiler.h | 6 ++ .../v8/src/profiler/sampling-heap-profiler.cc | 3 +- deps/v8/test/cctest/test-heap-profiler.cc | 76 +++++++++++++++++++ 5 files changed, 86 insertions(+), 2 deletions(-) diff --git a/common.gypi b/common.gypi index de828a0f74cc12..dbd6bf9df814f8 100644 --- a/common.gypi +++ b/common.gypi @@ -40,7 +40,7 @@ # Reset this number to 0 on major V8 upgrades. # Increment by one for each non-official patch applied to deps/v8. - 'v8_embedder_string': '-node.18', + 'v8_embedder_string': '-node.19', ##### V8 defaults for Node.js ##### diff --git a/deps/v8/AUTHORS b/deps/v8/AUTHORS index c5ed884e128c21..9329e34ae252be 100644 --- a/deps/v8/AUTHORS +++ b/deps/v8/AUTHORS @@ -155,6 +155,7 @@ Huáng Jùnliàng HyeockJin Kim Iain Ireland Ilya Gavrilin +Ilyas Shabi Ingvar Stepanyan Ioseb Dzmanashvili Isiah Meadows diff --git a/deps/v8/include/v8-profiler.h b/deps/v8/include/v8-profiler.h index 7e2d0933e92e68..927fa12e319026 100644 --- a/deps/v8/include/v8-profiler.h +++ b/deps/v8/include/v8-profiler.h @@ -830,6 +830,12 @@ class V8_EXPORT AllocationProfile { * what samples were added or removed between two snapshots. */ uint64_t sample_id; + + /** + * Indicates whether the sampled allocation is still live or has already + * been collected by GC. + */ + bool is_live; }; /** diff --git a/deps/v8/src/profiler/sampling-heap-profiler.cc b/deps/v8/src/profiler/sampling-heap-profiler.cc index 07b198ea534c77..228234c02258af 100644 --- a/deps/v8/src/profiler/sampling-heap-profiler.cc +++ b/deps/v8/src/profiler/sampling-heap-profiler.cc @@ -312,9 +312,10 @@ SamplingHeapProfiler::BuildSamples() const { samples.reserve(samples_.size()); for (const auto& it : samples_) { const Sample* sample = it.second.get(); + const bool is_live = !sample->global.IsEmpty(); samples.emplace_back(v8::AllocationProfile::Sample{ sample->owner->id_, sample->size, ScaleSample(sample->size, 1).count, - sample->sample_id}); + sample->sample_id, is_live}); } return samples; } diff --git a/deps/v8/test/cctest/test-heap-profiler.cc b/deps/v8/test/cctest/test-heap-profiler.cc index 4e584da6a728b3..427ad5ce91c0d8 100644 --- a/deps/v8/test/cctest/test-heap-profiler.cc +++ b/deps/v8/test/cctest/test-heap-profiler.cc @@ -4442,6 +4442,82 @@ TEST(SamplingHeapProfilerLargeInterval) { heap_profiler->StopSamplingHeapProfiler(); } +TEST(SamplingHeapProfilerSampleWithoutGCFlags) { + v8::HandleScope scope(CcTest::isolate()); + LocalContext env; + v8::HeapProfiler* heap_profiler = env.isolate()->GetHeapProfiler(); + + // Suppress randomness to avoid flakiness in tests. + i::v8_flags.sampling_heap_profiler_suppress_randomness = true; + + heap_profiler->StartSamplingHeapProfiler(1024); + + // Allocate objects that will be retained + CompileRun( + "var retained = [];\n" + "for (var i = 0; i < 500; i++) retained.push(new Array(10));\n"); + + CompileRun("for (var i = 0; i < 500; i++) new Array(10);\n"); + + std::unique_ptr profile( + heap_profiler->GetAllocationProfile()); + CHECK(profile); + + const auto& samples = profile->GetSamples(); + CHECK(!samples.empty()); + + for (const auto& sample : samples) { + CHECK(sample.is_live); + } + + heap_profiler->StopSamplingHeapProfiler(); +} + +TEST(SamplingHeapProfilerSampleIsLive) { + v8::HandleScope scope(CcTest::isolate()); + LocalContext env; + v8::HeapProfiler* heap_profiler = env.isolate()->GetHeapProfiler(); + + // Suppress randomness to avoid flakiness in tests. + i::v8_flags.sampling_heap_profiler_suppress_randomness = true; + + heap_profiler->StartSamplingHeapProfiler( + 64, 16, + static_cast( + v8::HeapProfiler::kSamplingForceGC | + v8::HeapProfiler::kSamplingIncludeObjectsCollectedByMajorGC)); + + // Allocate objects that will be retained + CompileRun( + "var retained = [];\n" + "for (var i = 0; i < 500; i++) retained.push(new Array(10));\n"); + + CompileRun("for (var i = 0; i < 500; i++) new Array(10);\n"); + + std::unique_ptr profile( + heap_profiler->GetAllocationProfile()); + CHECK(profile); + + const auto& samples = profile->GetSamples(); + CHECK(!samples.empty()); + + int live_samples = 0; + int dead_samples = 0; + for (const auto& sample : samples) { + if (sample.is_live) { + ++live_samples; + } else { + ++dead_samples; + } + } + + // We expect both retained and collected allocations in this profile. + CHECK_GT(live_samples, 0); + CHECK_GT(dead_samples, 0); + + heap_profiler->StopSamplingHeapProfiler(); +} + TEST(HeapSnapshotPrototypeNotJSReceiver) { LocalContext env; v8::HandleScope scope(env.isolate()); From 3ee30d93ee3acf07399e3e6d49174502152262cd Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Tue, 28 Apr 2026 17:15:22 +0200 Subject: [PATCH 004/168] crypto: reject unintended raw key format string input MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Filip Skokan PR-URL: https://github.com/nodejs/node/pull/62974 Reviewed-By: Сковорода Никита Андреевич Reviewed-By: Tobias Nießen Reviewed-By: Luigi Pinca --- lib/internal/crypto/keys.js | 2 +- test/parallel/test-crypto-key-objects-raw.js | 44 ++++++++++++++++++++ 2 files changed, 45 insertions(+), 1 deletion(-) diff --git a/lib/internal/crypto/keys.js b/lib/internal/crypto/keys.js index 595b9c2b1e849a..0e39e9a1640eaa 100644 --- a/lib/internal/crypto/keys.js +++ b/lib/internal/crypto/keys.js @@ -659,7 +659,7 @@ function prepareAsymmetricKey(key, ctx, name = 'key') { return { data, format: kKeyFormatJWK }; } else if (format === 'raw-public' || format === 'raw-private' || format === 'raw-seed') { - if (!isStringOrBuffer(data)) { + if (!isArrayBufferView(data) && !isAnyArrayBuffer(data)) { throw new ERR_INVALID_ARG_TYPE( `${name}.key`, ['ArrayBuffer', 'Buffer', 'TypedArray', 'DataView'], diff --git a/test/parallel/test-crypto-key-objects-raw.js b/test/parallel/test-crypto-key-objects-raw.js index f301cc1942fd9a..5658be6825823f 100644 --- a/test/parallel/test-crypto-key-objects-raw.js +++ b/test/parallel/test-crypto-key-objects-raw.js @@ -32,6 +32,50 @@ const { hasOpenSSL } = require('../common/crypto'); } } +// Raw key imports do not support strings. +{ + const pubKeyObj = crypto.createPublicKey( + fixtures.readKey('ed25519_public.pem', 'ascii')); + const privKeyObj = crypto.createPrivateKey( + fixtures.readKey('ed25519_private.pem', 'ascii')); + + const rawPub = pubKeyObj.export({ format: 'raw-public' }); + const rawPriv = privKeyObj.export({ format: 'raw-private' }); + + for (const encoding of ['hex', 'base64', 'utf8', 'latin1', 'ascii']) { + assert.throws(() => crypto.createPublicKey({ + key: rawPub.toString(encoding), + encoding, + format: 'raw-public', + asymmetricKeyType: 'ed25519', + }), { code: 'ERR_INVALID_ARG_TYPE' }); + + assert.throws(() => crypto.createPrivateKey({ + key: rawPriv.toString(encoding), + encoding, + format: 'raw-private', + asymmetricKeyType: 'ed25519', + }), { code: 'ERR_INVALID_ARG_TYPE' }); + } +} + +// Raw seed imports do not support strings. +if (hasOpenSSL(3, 5)) { + const privKeyObj = crypto.createPrivateKey( + fixtures.readKey('ml_dsa_44_private.pem', 'ascii')); + + const rawSeed = privKeyObj.export({ format: 'raw-seed' }); + + for (const encoding of ['hex', 'base64']) { + assert.throws(() => crypto.createPrivateKey({ + key: rawSeed.toString(encoding), + encoding, + format: 'raw-seed', + asymmetricKeyType: 'ml-dsa-44', + }), { code: 'ERR_INVALID_ARG_TYPE' }); + } +} + // Key types that don't support raw-* formats { for (const [type, pub, priv] of [ From 3d6584005cf0cdaf71bcb6ebb5521e69f558e59d Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 28 Apr 2026 16:05:11 +0000 Subject: [PATCH 005/168] meta: bump cachix/install-nix-action from 31.10.3 to 31.10.5 Bumps [cachix/install-nix-action](https://github.com/cachix/install-nix-action) from 31.10.3 to 31.10.5. - [Release notes](https://github.com/cachix/install-nix-action/releases) - [Changelog](https://github.com/cachix/install-nix-action/blob/master/RELEASE.md) - [Commits](https://github.com/cachix/install-nix-action/compare/96951a368ba55167b55f1c916f7d416bac6505fe...ab739621df7a23f52766f9ccc97f38da6b7af14f) --- updated-dependencies: - dependency-name: cachix/install-nix-action dependency-version: 31.10.4 dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] PR-URL: https://github.com/nodejs/node/pull/62846 Reviewed-By: Antoine du Hamel --- .github/workflows/linters.yml | 2 +- .github/workflows/test-shared.yml | 2 +- .github/workflows/tools.yml | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/linters.yml b/.github/workflows/linters.yml index 1ff1eb21002771..352bfd1e23bbea 100644 --- a/.github/workflows/linters.yml +++ b/.github/workflows/linters.yml @@ -149,7 +149,7 @@ jobs: persist-credentials: false sparse-checkout: '*.nix' sparse-checkout-cone-mode: false - - uses: cachix/install-nix-action@96951a368ba55167b55f1c916f7d416bac6505fe # v31.10.3 + - uses: cachix/install-nix-action@ab739621df7a23f52766f9ccc97f38da6b7af14f # v31.10.5 - name: Lint Nix files run: | nix-shell -I nixpkgs=./tools/nix/pkgs.nix -p 'nixfmt-tree' --run ' diff --git a/.github/workflows/test-shared.yml b/.github/workflows/test-shared.yml index bc5140cc90eaeb..b5732d00423c46 100644 --- a/.github/workflows/test-shared.yml +++ b/.github/workflows/test-shared.yml @@ -189,7 +189,7 @@ jobs: tar xzf tarballs/*.tar.gz -C "$RUNNER_TEMP" echo "TAR_DIR=$RUNNER_TEMP/$(basename tarballs/*.tar.gz .tar.gz)" >> "$GITHUB_ENV" - - uses: cachix/install-nix-action@96951a368ba55167b55f1c916f7d416bac6505fe # v31.10.3 + - uses: cachix/install-nix-action@ab739621df7a23f52766f9ccc97f38da6b7af14f # v31.10.5 if: ${{ steps.cachix-check.outputs.IS_AVAILABLE == 'true' }} with: extra_nix_config: sandbox = true diff --git a/.github/workflows/tools.yml b/.github/workflows/tools.yml index ad244c41eddb93..c81865bcde2b71 100644 --- a/.github/workflows/tools.yml +++ b/.github/workflows/tools.yml @@ -321,7 +321,7 @@ jobs: allow-prereleases: true - name: Set up Nix if: matrix.id == 'nixpkgs-unstable' && (github.event_name == 'schedule' || inputs.id == 'all' || inputs.id == matrix.id) - uses: cachix/install-nix-action@96951a368ba55167b55f1c916f7d416bac6505fe # v31.10.3 + uses: cachix/install-nix-action@ab739621df7a23f52766f9ccc97f38da6b7af14f # v31.10.5 - run: ${{ matrix.run }} if: github.event_name == 'schedule' || inputs.id == 'all' || inputs.id == matrix.id env: From 4247cd305b4f6d79912caaaf105faad324d3bc83 Mon Sep 17 00:00:00 2001 From: semimikoh <123785695+semimikoh@users.noreply.github.com> Date: Wed, 29 Apr 2026 01:49:29 +0900 Subject: [PATCH 006/168] src: fix crash in GetErrorSource() for invalid using syntax MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: semimikoh PR-URL: https://github.com/nodejs/node/pull/62770 Fixes: https://github.com/nodejs/node/issues/62767 Refs: https://github.com/tc39/test262 Reviewed-By: René Reviewed-By: Daeyeon Jeong Reviewed-By: Chengzhong Wu --- src/node_errors.cc | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/src/node_errors.cc b/src/node_errors.cc index a2ece94b938c21..74326496132773 100644 --- a/src/node_errors.cc +++ b/src/node_errors.cc @@ -150,8 +150,7 @@ static std::string GetErrorSource(Isolate* isolate, : 0; int start = message->GetStartColumn(); int end = message->GetEndColumn(); - if (start >= script_start) { - CHECK_GE(end, start); + if (start >= script_start && end >= script_start) { start -= script_start; end -= script_start; } @@ -161,8 +160,7 @@ static std::string GetErrorSource(Isolate* isolate, CHECK_GT(buf.size(), 0); *added_exception_line = true; - if (start > end || - start < 0 || + if (start > end || start < 0 || end < 0 || static_cast(end) > sourceline.size()) { return buf; } From 186995e81760874968c193fb793acd2edf2377b6 Mon Sep 17 00:00:00 2001 From: Paolo Insogna Date: Tue, 28 Apr 2026 20:48:27 +0200 Subject: [PATCH 007/168] deps: fix libffi macos build Signed-off-by: Paolo Insogna PR-URL: https://github.com/nodejs/node/pull/63006 Reviewed-By: Matteo Collina Reviewed-By: Bryan English Reviewed-By: Richard Lau Reviewed-By: Filip Skokan --- deps/libffi/libffi.gyp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/deps/libffi/libffi.gyp b/deps/libffi/libffi.gyp index a6ca819188ef6f..cc83695f45b6ab 100644 --- a/deps/libffi/libffi.gyp +++ b/deps/libffi/libffi.gyp @@ -133,6 +133,10 @@ 'generate-headers.py', '--output-dir', '<(SHARED_INTERMEDIATE_DIR)/libffi', + '--target-arch', + '<(target_arch)', + '--os', + '<(OS)', ], }, ], From 2a601eb4ea846d11c56a80b4ab670b4907492cb3 Mon Sep 17 00:00:00 2001 From: Jamie Magee Date: Tue, 28 Apr 2026 12:21:05 -0700 Subject: [PATCH 008/168] test: export isRiscv64 from common module isRiscv64 is defined and used internally for the timeout multiplier but was not exported. Export it alongside the other platform booleans (isLinux, isFreeBSD, isPi, etc.) so tests can use common.isRiscv64 instead of inlining process.arch checks. Refs: https://github.com/nodejs/build/issues/4099 Signed-off-by: Jamie Magee PR-URL: https://github.com/nodejs/node/pull/62609 Reviewed-By: Colin Ihrig Reviewed-By: Luigi Pinca Reviewed-By: Richard Lau --- test/common/index.js | 1 + test/common/index.mjs | 2 ++ 2 files changed, 3 insertions(+) diff --git a/test/common/index.js b/test/common/index.js index 75af09c1fdaac3..c50057e3c5c8e7 100755 --- a/test/common/index.js +++ b/test/common/index.js @@ -996,6 +996,7 @@ const common = { isOpenBSD, isMacOS, isPi, + isRiscv64, isSunOS, isWindows, localIPv6Hosts, diff --git a/test/common/index.mjs b/test/common/index.mjs index 54eafb60ec50e3..1a2844f8604917 100644 --- a/test/common/index.mjs +++ b/test/common/index.mjs @@ -31,6 +31,7 @@ const { isLinux, isOpenBSD, isMacOS, + isRiscv64, isSunOS, isWindows, localIPv6Hosts, @@ -86,6 +87,7 @@ export { isLinux, isOpenBSD, isMacOS, + isRiscv64, isSunOS, isWindows, localIPv6Hosts, From 81732512c1dff743cb0cda2bb3b08f3c7e8e5a8d Mon Sep 17 00:00:00 2001 From: "Node.js GitHub Bot" Date: Tue, 28 Apr 2026 18:14:19 -0400 Subject: [PATCH 009/168] deps: update corepack to 0.34.7 PR-URL: https://github.com/nodejs/node/pull/62810 Reviewed-By: Antoine du Hamel --- deps/corepack/CHANGELOG.md | 7 + deps/corepack/dist/lib/corepack.cjs | 1145 ++++++++++++++------------- deps/corepack/package.json | 8 +- 3 files changed, 614 insertions(+), 546 deletions(-) diff --git a/deps/corepack/CHANGELOG.md b/deps/corepack/CHANGELOG.md index dfc1dddd7b6a32..16553bd776ffa4 100644 --- a/deps/corepack/CHANGELOG.md +++ b/deps/corepack/CHANGELOG.md @@ -1,5 +1,12 @@ # Changelog +## [0.34.7](https://github.com/nodejs/corepack/compare/v0.34.6...v0.34.7) (2026-04-17) + + +### Bug Fixes + +* update package manager versions ([#790](https://github.com/nodejs/corepack/issues/790)) ([e8961d6](https://github.com/nodejs/corepack/commit/e8961d6bdc14b8141fbda008febdd3649022862c)) + ## [0.34.6](https://github.com/nodejs/corepack/compare/v0.34.5...v0.34.6) (2026-01-23) diff --git a/deps/corepack/dist/lib/corepack.cjs b/deps/corepack/dist/lib/corepack.cjs index 2d570f7b70233c..232645cab47b0c 100644 --- a/deps/corepack/dist/lib/corepack.cjs +++ b/deps/corepack/dist/lib/corepack.cjs @@ -1750,7 +1750,7 @@ var require_cmp = __commonJS({ var require_comparator = __commonJS({ ".yarn/cache/semver-npm-7.7.3-9cf7b3b46c-4afe5c9865.zip/node_modules/semver/classes/comparator.js"(exports2, module2) { "use strict"; - var ANY = Symbol("SemVer ANY"); + var ANY = /* @__PURE__ */ Symbol("SemVer ANY"); var Comparator = class _Comparator { static get ANY() { return ANY; @@ -3119,11 +3119,11 @@ var require_proxy_from_env = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/core/errors.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/errors.js var require_errors = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/core/errors.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/errors.js"(exports2, module2) { "use strict"; - var kUndiciError = Symbol.for("undici.error.UND_ERR"); + var kUndiciError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR"); var UndiciError = class extends Error { constructor(message) { super(message); @@ -3135,7 +3135,7 @@ var require_errors = __commonJS({ } [kUndiciError] = true; }; - var kConnectTimeoutError = Symbol.for("undici.error.UND_ERR_CONNECT_TIMEOUT"); + var kConnectTimeoutError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_CONNECT_TIMEOUT"); var ConnectTimeoutError = class extends UndiciError { constructor(message) { super(message); @@ -3148,7 +3148,7 @@ var require_errors = __commonJS({ } [kConnectTimeoutError] = true; }; - var kHeadersTimeoutError = Symbol.for("undici.error.UND_ERR_HEADERS_TIMEOUT"); + var kHeadersTimeoutError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_HEADERS_TIMEOUT"); var HeadersTimeoutError = class extends UndiciError { constructor(message) { super(message); @@ -3161,7 +3161,7 @@ var require_errors = __commonJS({ } [kHeadersTimeoutError] = true; }; - var kHeadersOverflowError = Symbol.for("undici.error.UND_ERR_HEADERS_OVERFLOW"); + var kHeadersOverflowError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_HEADERS_OVERFLOW"); var HeadersOverflowError = class extends UndiciError { constructor(message) { super(message); @@ -3174,7 +3174,7 @@ var require_errors = __commonJS({ } [kHeadersOverflowError] = true; }; - var kBodyTimeoutError = Symbol.for("undici.error.UND_ERR_BODY_TIMEOUT"); + var kBodyTimeoutError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_BODY_TIMEOUT"); var BodyTimeoutError = class extends UndiciError { constructor(message) { super(message); @@ -3187,7 +3187,7 @@ var require_errors = __commonJS({ } [kBodyTimeoutError] = true; }; - var kResponseStatusCodeError = Symbol.for("undici.error.UND_ERR_RESPONSE_STATUS_CODE"); + var kResponseStatusCodeError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_RESPONSE_STATUS_CODE"); var ResponseStatusCodeError = class extends UndiciError { constructor(message, statusCode, headers, body) { super(message); @@ -3204,7 +3204,7 @@ var require_errors = __commonJS({ } [kResponseStatusCodeError] = true; }; - var kInvalidArgumentError = Symbol.for("undici.error.UND_ERR_INVALID_ARG"); + var kInvalidArgumentError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_INVALID_ARG"); var InvalidArgumentError = class extends UndiciError { constructor(message) { super(message); @@ -3217,7 +3217,7 @@ var require_errors = __commonJS({ } [kInvalidArgumentError] = true; }; - var kInvalidReturnValueError = Symbol.for("undici.error.UND_ERR_INVALID_RETURN_VALUE"); + var kInvalidReturnValueError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_INVALID_RETURN_VALUE"); var InvalidReturnValueError = class extends UndiciError { constructor(message) { super(message); @@ -3230,7 +3230,7 @@ var require_errors = __commonJS({ } [kInvalidReturnValueError] = true; }; - var kAbortError = Symbol.for("undici.error.UND_ERR_ABORT"); + var kAbortError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_ABORT"); var AbortError = class extends UndiciError { constructor(message) { super(message); @@ -3243,7 +3243,7 @@ var require_errors = __commonJS({ } [kAbortError] = true; }; - var kRequestAbortedError = Symbol.for("undici.error.UND_ERR_ABORTED"); + var kRequestAbortedError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_ABORTED"); var RequestAbortedError = class extends AbortError { constructor(message) { super(message); @@ -3256,7 +3256,7 @@ var require_errors = __commonJS({ } [kRequestAbortedError] = true; }; - var kInformationalError = Symbol.for("undici.error.UND_ERR_INFO"); + var kInformationalError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_INFO"); var InformationalError = class extends UndiciError { constructor(message) { super(message); @@ -3269,7 +3269,7 @@ var require_errors = __commonJS({ } [kInformationalError] = true; }; - var kRequestContentLengthMismatchError = Symbol.for("undici.error.UND_ERR_REQ_CONTENT_LENGTH_MISMATCH"); + var kRequestContentLengthMismatchError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_REQ_CONTENT_LENGTH_MISMATCH"); var RequestContentLengthMismatchError = class extends UndiciError { constructor(message) { super(message); @@ -3282,7 +3282,7 @@ var require_errors = __commonJS({ } [kRequestContentLengthMismatchError] = true; }; - var kResponseContentLengthMismatchError = Symbol.for("undici.error.UND_ERR_RES_CONTENT_LENGTH_MISMATCH"); + var kResponseContentLengthMismatchError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_RES_CONTENT_LENGTH_MISMATCH"); var ResponseContentLengthMismatchError = class extends UndiciError { constructor(message) { super(message); @@ -3295,7 +3295,7 @@ var require_errors = __commonJS({ } [kResponseContentLengthMismatchError] = true; }; - var kClientDestroyedError = Symbol.for("undici.error.UND_ERR_DESTROYED"); + var kClientDestroyedError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_DESTROYED"); var ClientDestroyedError = class extends UndiciError { constructor(message) { super(message); @@ -3308,7 +3308,7 @@ var require_errors = __commonJS({ } [kClientDestroyedError] = true; }; - var kClientClosedError = Symbol.for("undici.error.UND_ERR_CLOSED"); + var kClientClosedError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_CLOSED"); var ClientClosedError = class extends UndiciError { constructor(message) { super(message); @@ -3321,7 +3321,7 @@ var require_errors = __commonJS({ } [kClientClosedError] = true; }; - var kSocketError = Symbol.for("undici.error.UND_ERR_SOCKET"); + var kSocketError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_SOCKET"); var SocketError = class extends UndiciError { constructor(message, socket) { super(message); @@ -3335,7 +3335,7 @@ var require_errors = __commonJS({ } [kSocketError] = true; }; - var kNotSupportedError = Symbol.for("undici.error.UND_ERR_NOT_SUPPORTED"); + var kNotSupportedError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_NOT_SUPPORTED"); var NotSupportedError = class extends UndiciError { constructor(message) { super(message); @@ -3348,7 +3348,7 @@ var require_errors = __commonJS({ } [kNotSupportedError] = true; }; - var kBalancedPoolMissingUpstreamError = Symbol.for("undici.error.UND_ERR_BPL_MISSING_UPSTREAM"); + var kBalancedPoolMissingUpstreamError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_BPL_MISSING_UPSTREAM"); var BalancedPoolMissingUpstreamError = class extends UndiciError { constructor(message) { super(message); @@ -3361,7 +3361,7 @@ var require_errors = __commonJS({ } [kBalancedPoolMissingUpstreamError] = true; }; - var kHTTPParserError = Symbol.for("undici.error.UND_ERR_HTTP_PARSER"); + var kHTTPParserError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_HTTP_PARSER"); var HTTPParserError = class extends Error { constructor(message, code2, data) { super(message); @@ -3374,7 +3374,7 @@ var require_errors = __commonJS({ } [kHTTPParserError] = true; }; - var kResponseExceededMaxSizeError = Symbol.for("undici.error.UND_ERR_RES_EXCEEDED_MAX_SIZE"); + var kResponseExceededMaxSizeError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_RES_EXCEEDED_MAX_SIZE"); var ResponseExceededMaxSizeError = class extends UndiciError { constructor(message) { super(message); @@ -3387,7 +3387,7 @@ var require_errors = __commonJS({ } [kResponseExceededMaxSizeError] = true; }; - var kRequestRetryError = Symbol.for("undici.error.UND_ERR_REQ_RETRY"); + var kRequestRetryError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_REQ_RETRY"); var RequestRetryError = class extends UndiciError { constructor(message, code2, { headers, data }) { super(message); @@ -3403,7 +3403,7 @@ var require_errors = __commonJS({ } [kRequestRetryError] = true; }; - var kResponseError = Symbol.for("undici.error.UND_ERR_RESPONSE"); + var kResponseError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_RESPONSE"); var ResponseError = class extends UndiciError { constructor(message, code2, { headers, data }) { super(message); @@ -3419,7 +3419,7 @@ var require_errors = __commonJS({ } [kResponseError] = true; }; - var kSecureProxyConnectionError = Symbol.for("undici.error.UND_ERR_PRX_TLS"); + var kSecureProxyConnectionError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_PRX_TLS"); var SecureProxyConnectionError = class extends UndiciError { constructor(cause, message, options) { super(message, { cause, ...options ?? {} }); @@ -3433,6 +3433,21 @@ var require_errors = __commonJS({ } [kSecureProxyConnectionError] = true; }; + var kMessageSizeExceededError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_WS_MESSAGE_SIZE_EXCEEDED"); + var MessageSizeExceededError = class extends UndiciError { + constructor(message) { + super(message); + this.name = "MessageSizeExceededError"; + this.message = message || "Max decompressed message size exceeded"; + this.code = "UND_ERR_WS_MESSAGE_SIZE_EXCEEDED"; + } + static [Symbol.hasInstance](instance) { + return instance && instance[kMessageSizeExceededError] === true; + } + get [kMessageSizeExceededError]() { + return true; + } + }; module2.exports = { AbortError, HTTPParserError, @@ -3456,87 +3471,88 @@ var require_errors = __commonJS({ ResponseExceededMaxSizeError, RequestRetryError, ResponseError, - SecureProxyConnectionError + SecureProxyConnectionError, + MessageSizeExceededError }; } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/core/symbols.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/symbols.js var require_symbols = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/core/symbols.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/symbols.js"(exports2, module2) { module2.exports = { - kClose: Symbol("close"), - kDestroy: Symbol("destroy"), - kDispatch: Symbol("dispatch"), - kUrl: Symbol("url"), - kWriting: Symbol("writing"), - kResuming: Symbol("resuming"), - kQueue: Symbol("queue"), - kConnect: Symbol("connect"), - kConnecting: Symbol("connecting"), - kKeepAliveDefaultTimeout: Symbol("default keep alive timeout"), - kKeepAliveMaxTimeout: Symbol("max keep alive timeout"), - kKeepAliveTimeoutThreshold: Symbol("keep alive timeout threshold"), - kKeepAliveTimeoutValue: Symbol("keep alive timeout"), - kKeepAlive: Symbol("keep alive"), - kHeadersTimeout: Symbol("headers timeout"), - kBodyTimeout: Symbol("body timeout"), - kServerName: Symbol("server name"), - kLocalAddress: Symbol("local address"), - kHost: Symbol("host"), - kNoRef: Symbol("no ref"), - kBodyUsed: Symbol("used"), - kBody: Symbol("abstracted request body"), - kRunning: Symbol("running"), - kBlocking: Symbol("blocking"), - kPending: Symbol("pending"), - kSize: Symbol("size"), - kBusy: Symbol("busy"), - kQueued: Symbol("queued"), - kFree: Symbol("free"), - kConnected: Symbol("connected"), - kClosed: Symbol("closed"), - kNeedDrain: Symbol("need drain"), - kReset: Symbol("reset"), - kDestroyed: Symbol.for("nodejs.stream.destroyed"), - kResume: Symbol("resume"), - kOnError: Symbol("on error"), - kMaxHeadersSize: Symbol("max headers size"), - kRunningIdx: Symbol("running index"), - kPendingIdx: Symbol("pending index"), - kError: Symbol("error"), - kClients: Symbol("clients"), - kClient: Symbol("client"), - kParser: Symbol("parser"), - kOnDestroyed: Symbol("destroy callbacks"), - kPipelining: Symbol("pipelining"), - kSocket: Symbol("socket"), - kHostHeader: Symbol("host header"), - kConnector: Symbol("connector"), - kStrictContentLength: Symbol("strict content length"), - kMaxRedirections: Symbol("maxRedirections"), - kMaxRequests: Symbol("maxRequestsPerClient"), - kProxy: Symbol("proxy agent options"), - kCounter: Symbol("socket request counter"), - kInterceptors: Symbol("dispatch interceptors"), - kMaxResponseSize: Symbol("max response size"), - kHTTP2Session: Symbol("http2Session"), - kHTTP2SessionState: Symbol("http2Session state"), - kRetryHandlerDefaultRetry: Symbol("retry agent default retry"), - kConstruct: Symbol("constructable"), - kListeners: Symbol("listeners"), - kHTTPContext: Symbol("http context"), - kMaxConcurrentStreams: Symbol("max concurrent streams"), - kNoProxyAgent: Symbol("no proxy agent"), - kHttpProxyAgent: Symbol("http proxy agent"), - kHttpsProxyAgent: Symbol("https proxy agent") + kClose: /* @__PURE__ */ Symbol("close"), + kDestroy: /* @__PURE__ */ Symbol("destroy"), + kDispatch: /* @__PURE__ */ Symbol("dispatch"), + kUrl: /* @__PURE__ */ Symbol("url"), + kWriting: /* @__PURE__ */ Symbol("writing"), + kResuming: /* @__PURE__ */ Symbol("resuming"), + kQueue: /* @__PURE__ */ Symbol("queue"), + kConnect: /* @__PURE__ */ Symbol("connect"), + kConnecting: /* @__PURE__ */ Symbol("connecting"), + kKeepAliveDefaultTimeout: /* @__PURE__ */ Symbol("default keep alive timeout"), + kKeepAliveMaxTimeout: /* @__PURE__ */ Symbol("max keep alive timeout"), + kKeepAliveTimeoutThreshold: /* @__PURE__ */ Symbol("keep alive timeout threshold"), + kKeepAliveTimeoutValue: /* @__PURE__ */ Symbol("keep alive timeout"), + kKeepAlive: /* @__PURE__ */ Symbol("keep alive"), + kHeadersTimeout: /* @__PURE__ */ Symbol("headers timeout"), + kBodyTimeout: /* @__PURE__ */ Symbol("body timeout"), + kServerName: /* @__PURE__ */ Symbol("server name"), + kLocalAddress: /* @__PURE__ */ Symbol("local address"), + kHost: /* @__PURE__ */ Symbol("host"), + kNoRef: /* @__PURE__ */ Symbol("no ref"), + kBodyUsed: /* @__PURE__ */ Symbol("used"), + kBody: /* @__PURE__ */ Symbol("abstracted request body"), + kRunning: /* @__PURE__ */ Symbol("running"), + kBlocking: /* @__PURE__ */ Symbol("blocking"), + kPending: /* @__PURE__ */ Symbol("pending"), + kSize: /* @__PURE__ */ Symbol("size"), + kBusy: /* @__PURE__ */ Symbol("busy"), + kQueued: /* @__PURE__ */ Symbol("queued"), + kFree: /* @__PURE__ */ Symbol("free"), + kConnected: /* @__PURE__ */ Symbol("connected"), + kClosed: /* @__PURE__ */ Symbol("closed"), + kNeedDrain: /* @__PURE__ */ Symbol("need drain"), + kReset: /* @__PURE__ */ Symbol("reset"), + kDestroyed: /* @__PURE__ */ Symbol.for("nodejs.stream.destroyed"), + kResume: /* @__PURE__ */ Symbol("resume"), + kOnError: /* @__PURE__ */ Symbol("on error"), + kMaxHeadersSize: /* @__PURE__ */ Symbol("max headers size"), + kRunningIdx: /* @__PURE__ */ Symbol("running index"), + kPendingIdx: /* @__PURE__ */ Symbol("pending index"), + kError: /* @__PURE__ */ Symbol("error"), + kClients: /* @__PURE__ */ Symbol("clients"), + kClient: /* @__PURE__ */ Symbol("client"), + kParser: /* @__PURE__ */ Symbol("parser"), + kOnDestroyed: /* @__PURE__ */ Symbol("destroy callbacks"), + kPipelining: /* @__PURE__ */ Symbol("pipelining"), + kSocket: /* @__PURE__ */ Symbol("socket"), + kHostHeader: /* @__PURE__ */ Symbol("host header"), + kConnector: /* @__PURE__ */ Symbol("connector"), + kStrictContentLength: /* @__PURE__ */ Symbol("strict content length"), + kMaxRedirections: /* @__PURE__ */ Symbol("maxRedirections"), + kMaxRequests: /* @__PURE__ */ Symbol("maxRequestsPerClient"), + kProxy: /* @__PURE__ */ Symbol("proxy agent options"), + kCounter: /* @__PURE__ */ Symbol("socket request counter"), + kInterceptors: /* @__PURE__ */ Symbol("dispatch interceptors"), + kMaxResponseSize: /* @__PURE__ */ Symbol("max response size"), + kHTTP2Session: /* @__PURE__ */ Symbol("http2Session"), + kHTTP2SessionState: /* @__PURE__ */ Symbol("http2Session state"), + kRetryHandlerDefaultRetry: /* @__PURE__ */ Symbol("retry agent default retry"), + kConstruct: /* @__PURE__ */ Symbol("constructable"), + kListeners: /* @__PURE__ */ Symbol("listeners"), + kHTTPContext: /* @__PURE__ */ Symbol("http context"), + kMaxConcurrentStreams: /* @__PURE__ */ Symbol("max concurrent streams"), + kNoProxyAgent: /* @__PURE__ */ Symbol("no proxy agent"), + kHttpProxyAgent: /* @__PURE__ */ Symbol("http proxy agent"), + kHttpsProxyAgent: /* @__PURE__ */ Symbol("https proxy agent") }; } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/core/constants.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/constants.js var require_constants2 = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/core/constants.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/constants.js"(exports2, module2) { "use strict"; var headerNameLowerCasedRecord = {}; var wellknownHeaderNames = [ @@ -3649,9 +3665,9 @@ var require_constants2 = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/core/tree.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/tree.js var require_tree = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/core/tree.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/tree.js"(exports2, module2) { "use strict"; var { wellknownHeaderNames, @@ -3789,9 +3805,9 @@ var require_tree = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/core/util.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/util.js var require_util = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/core/util.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/util.js"(exports2, module2) { "use strict"; var assert5 = require("node:assert"); var { kDestroyed, kBodyUsed, kListeners, kBody } = require_symbols(); @@ -4295,21 +4311,21 @@ var require_util = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/api/readable.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/readable.js var require_readable = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/api/readable.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/readable.js"(exports2, module2) { "use strict"; var assert5 = require("node:assert"); var { Readable: Readable2 } = require("node:stream"); var { RequestAbortedError, NotSupportedError, InvalidArgumentError, AbortError } = require_errors(); var util = require_util(); var { ReadableStreamFrom } = require_util(); - var kConsume = Symbol("kConsume"); - var kReading = Symbol("kReading"); - var kBody = Symbol("kBody"); - var kAbort = Symbol("kAbort"); - var kContentType = Symbol("kContentType"); - var kContentLength = Symbol("kContentLength"); + var kConsume = /* @__PURE__ */ Symbol("kConsume"); + var kReading = /* @__PURE__ */ Symbol("kReading"); + var kBody = /* @__PURE__ */ Symbol("kBody"); + var kAbort = /* @__PURE__ */ Symbol("kAbort"); + var kContentType = /* @__PURE__ */ Symbol("kContentType"); + var kContentLength = /* @__PURE__ */ Symbol("kContentLength"); var noop3 = () => { }; var BodyReadable = class extends Readable2 { @@ -4588,9 +4604,9 @@ var require_readable = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/api/util.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/util.js var require_util2 = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/api/util.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/util.js"(exports2, module2) { var assert5 = require("node:assert"); var { ResponseStatusCodeError @@ -4649,9 +4665,9 @@ var require_util2 = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/api/api-request.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/api-request.js var require_api_request = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/api/api-request.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/api-request.js"(exports2, module2) { "use strict"; var assert5 = require("node:assert"); var { Readable: Readable2 } = require_readable(); @@ -4835,13 +4851,13 @@ var require_api_request = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/api/abort-signal.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/abort-signal.js var require_abort_signal = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/api/abort-signal.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/abort-signal.js"(exports2, module2) { var { addAbortListener } = require_util(); var { RequestAbortedError } = require_errors(); - var kListener = Symbol("kListener"); - var kSignal = Symbol("kSignal"); + var kListener = /* @__PURE__ */ Symbol("kListener"); + var kSignal = /* @__PURE__ */ Symbol("kSignal"); function abort(self2) { if (self2.abort) { self2.abort(self2[kSignal]?.reason); @@ -4886,9 +4902,9 @@ var require_abort_signal = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/api/api-stream.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/api-stream.js var require_api_stream = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/api/api-stream.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/api-stream.js"(exports2, module2) { "use strict"; var assert5 = require("node:assert"); var { finished, PassThrough } = require("node:stream"); @@ -5059,9 +5075,9 @@ var require_api_stream = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/api/api-pipeline.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/api-pipeline.js var require_api_pipeline = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/api/api-pipeline.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/api-pipeline.js"(exports2, module2) { "use strict"; var { Readable: Readable2, @@ -5077,7 +5093,7 @@ var require_api_pipeline = __commonJS({ var { AsyncResource } = require("node:async_hooks"); var { addSignal, removeSignal } = require_abort_signal(); var assert5 = require("node:assert"); - var kResume = Symbol("resume"); + var kResume = /* @__PURE__ */ Symbol("resume"); var PipelineRequest = class extends Readable2 { constructor() { super({ autoDestroy: true }); @@ -5259,9 +5275,9 @@ var require_api_pipeline = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/api/api-upgrade.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/api-upgrade.js var require_api_upgrade = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/api/api-upgrade.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/api-upgrade.js"(exports2, module2) { "use strict"; var { InvalidArgumentError, SocketError } = require_errors(); var { AsyncResource } = require("node:async_hooks"); @@ -5351,9 +5367,9 @@ var require_api_upgrade = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/api/api-connect.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/api-connect.js var require_api_connect = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/api/api-connect.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/api-connect.js"(exports2, module2) { "use strict"; var assert5 = require("node:assert"); var { AsyncResource } = require("node:async_hooks"); @@ -5441,9 +5457,9 @@ var require_api_connect = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/api/index.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/index.js var require_api = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/api/index.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/api/index.js"(exports2, module2) { "use strict"; module2.exports.request = require_api_request(); module2.exports.stream = require_api_stream(); @@ -5453,9 +5469,9 @@ var require_api = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/dispatcher/dispatcher.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/dispatcher.js var require_dispatcher = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/dispatcher/dispatcher.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/dispatcher.js"(exports2, module2) { "use strict"; var EventEmitter2 = require("node:events"); var Dispatcher = class extends EventEmitter2 { @@ -5508,9 +5524,9 @@ var require_dispatcher = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/dispatcher/dispatcher-base.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/dispatcher-base.js var require_dispatcher_base = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/dispatcher/dispatcher-base.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/dispatcher-base.js"(exports2, module2) { "use strict"; var Dispatcher = require_dispatcher(); var { @@ -5519,16 +5535,23 @@ var require_dispatcher_base = __commonJS({ InvalidArgumentError } = require_errors(); var { kDestroy, kClose, kClosed, kDestroyed, kDispatch, kInterceptors } = require_symbols(); - var kOnDestroyed = Symbol("onDestroyed"); - var kOnClosed = Symbol("onClosed"); - var kInterceptedDispatch = Symbol("Intercepted Dispatch"); + var kOnDestroyed = /* @__PURE__ */ Symbol("onDestroyed"); + var kOnClosed = /* @__PURE__ */ Symbol("onClosed"); + var kInterceptedDispatch = /* @__PURE__ */ Symbol("Intercepted Dispatch"); + var kWebSocketOptions = /* @__PURE__ */ Symbol("webSocketOptions"); var DispatcherBase = class extends Dispatcher { - constructor() { + constructor(opts) { super(); this[kDestroyed] = false; this[kOnDestroyed] = null; this[kClosed] = false; this[kOnClosed] = []; + this[kWebSocketOptions] = opts?.webSocket ?? {}; + } + get webSocketOptions() { + return { + maxPayloadSize: this[kWebSocketOptions].maxPayloadSize ?? 128 * 1024 * 1024 + }; } get destroyed() { return this[kDestroyed]; @@ -5669,9 +5692,9 @@ var require_dispatcher_base = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/dispatcher/fixed-queue.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/fixed-queue.js var require_fixed_queue = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/dispatcher/fixed-queue.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/fixed-queue.js"(exports2, module2) { "use strict"; var kSize = 2048; var kMask = kSize - 1; @@ -5726,11 +5749,11 @@ var require_fixed_queue = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/dispatcher/pool-stats.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/pool-stats.js var require_pool_stats = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/dispatcher/pool-stats.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/pool-stats.js"(exports2, module2) { var { kFree, kConnected, kPending, kQueued, kRunning, kSize } = require_symbols(); - var kPool = Symbol("pool"); + var kPool = /* @__PURE__ */ Symbol("pool"); var PoolStats = class { constructor(pool) { this[kPool] = pool; @@ -5758,29 +5781,29 @@ var require_pool_stats = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/dispatcher/pool-base.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/pool-base.js var require_pool_base = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/dispatcher/pool-base.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/pool-base.js"(exports2, module2) { "use strict"; var DispatcherBase = require_dispatcher_base(); var FixedQueue = require_fixed_queue(); var { kConnected, kSize, kRunning, kPending, kQueued, kBusy, kFree, kUrl, kClose, kDestroy, kDispatch } = require_symbols(); var PoolStats = require_pool_stats(); - var kClients = Symbol("clients"); - var kNeedDrain = Symbol("needDrain"); - var kQueue = Symbol("queue"); - var kClosedResolve = Symbol("closed resolve"); - var kOnDrain = Symbol("onDrain"); - var kOnConnect = Symbol("onConnect"); - var kOnDisconnect = Symbol("onDisconnect"); - var kOnConnectionError = Symbol("onConnectionError"); - var kGetDispatcher = Symbol("get dispatcher"); - var kAddClient = Symbol("add client"); - var kRemoveClient = Symbol("remove client"); - var kStats = Symbol("stats"); + var kClients = /* @__PURE__ */ Symbol("clients"); + var kNeedDrain = /* @__PURE__ */ Symbol("needDrain"); + var kQueue = /* @__PURE__ */ Symbol("queue"); + var kClosedResolve = /* @__PURE__ */ Symbol("closed resolve"); + var kOnDrain = /* @__PURE__ */ Symbol("onDrain"); + var kOnConnect = /* @__PURE__ */ Symbol("onConnect"); + var kOnDisconnect = /* @__PURE__ */ Symbol("onDisconnect"); + var kOnConnectionError = /* @__PURE__ */ Symbol("onConnectionError"); + var kGetDispatcher = /* @__PURE__ */ Symbol("get dispatcher"); + var kAddClient = /* @__PURE__ */ Symbol("add client"); + var kRemoveClient = /* @__PURE__ */ Symbol("remove client"); + var kStats = /* @__PURE__ */ Symbol("stats"); var PoolBase = class extends DispatcherBase { - constructor() { - super(); + constructor(opts) { + super(opts); this[kQueue] = new FixedQueue(); this[kClients] = []; this[kQueued] = 0; @@ -5913,9 +5936,9 @@ var require_pool_base = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/core/diagnostics.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/diagnostics.js var require_diagnostics = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/core/diagnostics.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/diagnostics.js"(exports2, module2) { "use strict"; var diagnosticsChannel = require("node:diagnostics_channel"); var util = require("node:util"); @@ -6098,9 +6121,9 @@ var require_diagnostics = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/core/request.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/request.js var require_request = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/core/request.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/request.js"(exports2, module2) { "use strict"; var { InvalidArgumentError, @@ -6124,7 +6147,7 @@ var require_request = __commonJS({ var { channels } = require_diagnostics(); var { headerNameLowerCasedRecord } = require_constants2(); var invalidPathRegex = /[^\u0021-\u00ff]/; - var kHandler = Symbol("handler"); + var kHandler = /* @__PURE__ */ Symbol("handler"); var Request = class { constructor(origin, { path: path16, @@ -6157,6 +6180,9 @@ var require_request = __commonJS({ if (upgrade && typeof upgrade !== "string") { throw new InvalidArgumentError("upgrade must be a string"); } + if (upgrade && !isValidHeaderValue(upgrade)) { + throw new InvalidArgumentError("invalid upgrade header"); + } if (headersTimeout != null && (!Number.isFinite(headersTimeout) || headersTimeout < 0)) { throw new InvalidArgumentError("invalid headersTimeout"); } @@ -6389,12 +6415,18 @@ var require_request = __commonJS({ } else { val = `${val}`; } - if (request.host === null && headerName === "host") { + if (headerName === "host") { + if (request.host !== null) { + throw new InvalidArgumentError("duplicate host header"); + } if (typeof val !== "string") { throw new InvalidArgumentError("invalid host header"); } request.host = val; - } else if (request.contentLength === null && headerName === "content-length") { + } else if (headerName === "content-length") { + if (request.contentLength !== null) { + throw new InvalidArgumentError("duplicate content-length header"); + } request.contentLength = parseInt(val, 10); if (!Number.isFinite(request.contentLength)) { throw new InvalidArgumentError("invalid content-length header"); @@ -6422,15 +6454,15 @@ var require_request = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/util/timers.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/util/timers.js var require_timers = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/util/timers.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/util/timers.js"(exports2, module2) { "use strict"; var fastNow = 0; var RESOLUTION_MS = 1e3; var TICK_MS = (RESOLUTION_MS >> 1) - 1; var fastNowTimeout; - var kFastTimer = Symbol("kFastTimer"); + var kFastTimer = /* @__PURE__ */ Symbol("kFastTimer"); var fastTimers = []; var NOT_IN_LIST = -2; var TO_BE_CLEARED = -1; @@ -6653,9 +6685,9 @@ var require_timers = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/core/connect.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/connect.js var require_connect = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/core/connect.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/core/connect.js"(exports2, module2) { "use strict"; var net = require("node:net"); var assert5 = require("node:assert"); @@ -6833,9 +6865,9 @@ var require_connect = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/llhttp/utils.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/llhttp/utils.js var require_utils = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/llhttp/utils.js"(exports2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/llhttp/utils.js"(exports2) { "use strict"; Object.defineProperty(exports2, "__esModule", { value: true }); exports2.enumToMap = void 0; @@ -6853,9 +6885,9 @@ var require_utils = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/llhttp/constants.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/llhttp/constants.js var require_constants3 = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/llhttp/constants.js"(exports2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/llhttp/constants.js"(exports2) { "use strict"; Object.defineProperty(exports2, "__esModule", { value: true }); exports2.SPECIAL_HEADERS = exports2.HEADER_STATE = exports2.MINOR = exports2.MAJOR = exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS = exports2.TOKEN = exports2.STRICT_TOKEN = exports2.HEX = exports2.URL_CHAR = exports2.STRICT_URL_CHAR = exports2.USERINFO_CHARS = exports2.MARK = exports2.ALPHANUM = exports2.NUM = exports2.HEX_MAP = exports2.NUM_MAP = exports2.ALPHA = exports2.FINISH = exports2.H_METHOD_MAP = exports2.METHOD_MAP = exports2.METHODS_RTSP = exports2.METHODS_ICE = exports2.METHODS_HTTP = exports2.METHODS = exports2.LENIENT_FLAGS = exports2.FLAGS = exports2.TYPE = exports2.ERROR = void 0; @@ -7174,27 +7206,27 @@ var require_constants3 = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/llhttp/llhttp-wasm.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/llhttp/llhttp-wasm.js var require_llhttp_wasm = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/llhttp/llhttp-wasm.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/llhttp/llhttp-wasm.js"(exports2, module2) { "use strict"; var { Buffer: Buffer3 } = require("node:buffer"); module2.exports = Buffer3.from("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", "base64"); } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/llhttp/llhttp_simd-wasm.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/llhttp/llhttp_simd-wasm.js var require_llhttp_simd_wasm = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/llhttp/llhttp_simd-wasm.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/llhttp/llhttp_simd-wasm.js"(exports2, module2) { "use strict"; var { Buffer: Buffer3 } = require("node:buffer"); module2.exports = Buffer3.from("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", "base64"); } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/web/fetch/constants.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/constants.js var require_constants4 = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/web/fetch/constants.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/constants.js"(exports2, module2) { "use strict"; var corsSafeListedMethods = ( /** @type {const} */ @@ -7410,11 +7442,11 @@ var require_constants4 = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/web/fetch/global.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/global.js var require_global = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/web/fetch/global.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/global.js"(exports2, module2) { "use strict"; - var globalOrigin = Symbol.for("undici.globalOrigin.1"); + var globalOrigin = /* @__PURE__ */ Symbol.for("undici.globalOrigin.1"); function getGlobalOrigin() { return globalThis[globalOrigin]; } @@ -7446,9 +7478,9 @@ var require_global = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/web/fetch/data-url.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/data-url.js var require_data_url = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/web/fetch/data-url.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/data-url.js"(exports2, module2) { "use strict"; var assert5 = require("node:assert"); var encoder = new TextEncoder(); @@ -7798,9 +7830,9 @@ var require_data_url = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/web/fetch/webidl.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/webidl.js var require_webidl = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/web/fetch/webidl.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/webidl.js"(exports2, module2) { "use strict"; var { types, inspect } = require("node:util"); var { markAsUncloneable } = require("node:worker_threads"); @@ -8217,9 +8249,9 @@ var require_webidl = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/web/fetch/util.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/util.js var require_util3 = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/web/fetch/util.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/util.js"(exports2, module2) { "use strict"; var { Transform } = require("node:stream"); var zlib = require("node:zlib"); @@ -9087,23 +9119,23 @@ var require_util3 = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/web/fetch/symbols.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/symbols.js var require_symbols2 = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/web/fetch/symbols.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/symbols.js"(exports2, module2) { "use strict"; module2.exports = { - kUrl: Symbol("url"), - kHeaders: Symbol("headers"), - kSignal: Symbol("signal"), - kState: Symbol("state"), - kDispatcher: Symbol("dispatcher") + kUrl: /* @__PURE__ */ Symbol("url"), + kHeaders: /* @__PURE__ */ Symbol("headers"), + kSignal: /* @__PURE__ */ Symbol("signal"), + kState: /* @__PURE__ */ Symbol("state"), + kDispatcher: /* @__PURE__ */ Symbol("dispatcher") }; } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/web/fetch/file.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/file.js var require_file = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/web/fetch/file.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/file.js"(exports2, module2) { "use strict"; var { Blob: Blob2, File } = require("node:buffer"); var { kState } = require_symbols2(); @@ -9164,9 +9196,9 @@ var require_file = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/web/fetch/formdata.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/formdata.js var require_formdata = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/web/fetch/formdata.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/formdata.js"(exports2, module2) { "use strict"; var { isBlobLike, iteratorMixin } = require_util3(); var { kState } = require_symbols2(); @@ -9311,9 +9343,9 @@ var require_formdata = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/web/fetch/formdata-parser.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/formdata-parser.js var require_formdata_parser = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/web/fetch/formdata-parser.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/formdata-parser.js"(exports2, module2) { "use strict"; var { isUSVString, bufferToLowerCasedHeaderName } = require_util(); var { utf8DecodeBytes } = require_util3(); @@ -9562,9 +9594,9 @@ var require_formdata_parser = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/web/fetch/body.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/body.js var require_body = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/web/fetch/body.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/web/fetch/body.js"(exports2, module2) { "use strict"; var util = require_util(); var { @@ -9876,9 +9908,9 @@ Content-Type: ${value.type || "application/octet-stream"}\r } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/dispatcher/client-h1.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/client-h1.js var require_client_h1 = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/dispatcher/client-h1.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/client-h1.js"(exports2, module2) { "use strict"; var assert5 = require("node:assert"); var util = require_util(); @@ -10896,9 +10928,9 @@ ${len.toString(16)}\r } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/dispatcher/client-h2.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/client-h2.js var require_client_h2 = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/dispatcher/client-h2.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/client-h2.js"(exports2, module2) { "use strict"; var assert5 = require("node:assert"); var { pipeline } = require("node:stream"); @@ -10928,7 +10960,7 @@ var require_client_h2 = __commonJS({ kSize, kHTTPContext } = require_symbols(); - var kOpenStreams = Symbol("open streams"); + var kOpenStreams = /* @__PURE__ */ Symbol("open streams"); var extractBody; var h2ExperimentalWarned = false; var http2; @@ -11437,9 +11469,9 @@ var require_client_h2 = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/handler/redirect-handler.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/handler/redirect-handler.js var require_redirect_handler = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/handler/redirect-handler.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/handler/redirect-handler.js"(exports2, module2) { "use strict"; var util = require_util(); var { kBodyUsed } = require_symbols(); @@ -11447,7 +11479,7 @@ var require_redirect_handler = __commonJS({ var { InvalidArgumentError } = require_errors(); var EE3 = require("node:events"); var redirectableStatusCodes = [300, 301, 302, 303, 307, 308]; - var kBody = Symbol("body"); + var kBody = /* @__PURE__ */ Symbol("body"); var BodyAsyncIterable = class { constructor(body) { this[kBody] = body; @@ -11596,9 +11628,9 @@ var require_redirect_handler = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/interceptor/redirect-interceptor.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/interceptor/redirect-interceptor.js var require_redirect_interceptor = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/interceptor/redirect-interceptor.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/interceptor/redirect-interceptor.js"(exports2, module2) { "use strict"; var RedirectHandler = require_redirect_handler(); function createRedirectInterceptor({ maxRedirections: defaultMaxRedirections }) { @@ -11618,9 +11650,9 @@ var require_redirect_interceptor = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/dispatcher/client.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/client.js var require_client = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/dispatcher/client.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/client.js"(exports2, module2) { "use strict"; var assert5 = require("node:assert"); var net = require("node:net"); @@ -11680,7 +11712,7 @@ var require_client = __commonJS({ var connectH1 = require_client_h1(); var connectH2 = require_client_h2(); var deprecatedInterceptorWarned = false; - var kClosedResolve = Symbol("kClosedResolve"); + var kClosedResolve = /* @__PURE__ */ Symbol("kClosedResolve"); var noop3 = () => { }; function getPipelining(client) { @@ -11720,9 +11752,10 @@ var require_client = __commonJS({ autoSelectFamilyAttemptTimeout, // h2 maxConcurrentStreams, - allowH2 + allowH2, + webSocket } = {}) { - super(); + super({ webSocket }); if (keepAlive !== void 0) { throw new InvalidArgumentError("unsupported keepAlive, use pipelining=0 instead"); } @@ -12118,9 +12151,9 @@ var require_client = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/dispatcher/pool.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/pool.js var require_pool = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/dispatcher/pool.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/pool.js"(exports2, module2) { "use strict"; var { PoolBase, @@ -12136,9 +12169,9 @@ var require_pool = __commonJS({ var util = require_util(); var { kUrl, kInterceptors } = require_symbols(); var buildConnector = require_connect(); - var kOptions = Symbol("options"); - var kConnections = Symbol("connections"); - var kFactory = Symbol("factory"); + var kOptions = /* @__PURE__ */ Symbol("options"); + var kConnections = /* @__PURE__ */ Symbol("connections"); + var kFactory = /* @__PURE__ */ Symbol("factory"); function defaultFactory(origin, opts) { return new Client(origin, opts); } @@ -12156,7 +12189,6 @@ var require_pool = __commonJS({ allowH2, ...options } = {}) { - super(); if (connections != null && (!Number.isFinite(connections) || connections < 0)) { throw new InvalidArgumentError("invalid connections"); } @@ -12177,6 +12209,7 @@ var require_pool = __commonJS({ ...connect }); } + super(options); this[kInterceptors] = options.interceptors?.Pool && Array.isArray(options.interceptors.Pool) ? options.interceptors.Pool : []; this[kConnections] = connections || null; this[kUrl] = util.parseOrigin(origin); @@ -12209,9 +12242,9 @@ var require_pool = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/dispatcher/agent.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/agent.js var require_agent = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/dispatcher/agent.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/agent.js"(exports2, module2) { "use strict"; var { InvalidArgumentError } = require_errors(); var { kClients, kRunning, kClose, kDestroy, kDispatch, kInterceptors } = require_symbols(); @@ -12220,19 +12253,18 @@ var require_agent = __commonJS({ var Client = require_client(); var util = require_util(); var createRedirectInterceptor = require_redirect_interceptor(); - var kOnConnect = Symbol("onConnect"); - var kOnDisconnect = Symbol("onDisconnect"); - var kOnConnectionError = Symbol("onConnectionError"); - var kMaxRedirections = Symbol("maxRedirections"); - var kOnDrain = Symbol("onDrain"); - var kFactory = Symbol("factory"); - var kOptions = Symbol("options"); + var kOnConnect = /* @__PURE__ */ Symbol("onConnect"); + var kOnDisconnect = /* @__PURE__ */ Symbol("onDisconnect"); + var kOnConnectionError = /* @__PURE__ */ Symbol("onConnectionError"); + var kMaxRedirections = /* @__PURE__ */ Symbol("maxRedirections"); + var kOnDrain = /* @__PURE__ */ Symbol("onDrain"); + var kFactory = /* @__PURE__ */ Symbol("factory"); + var kOptions = /* @__PURE__ */ Symbol("options"); function defaultFactory(origin, opts) { return opts && opts.connections === 1 ? new Client(origin, opts) : new Pool(origin, opts); } var Agent = class extends DispatcherBase { constructor({ factory = defaultFactory, maxRedirections = 0, connect, ...options } = {}) { - super(); if (typeof factory !== "function") { throw new InvalidArgumentError("factory must be a function."); } @@ -12242,6 +12274,7 @@ var require_agent = __commonJS({ if (!Number.isInteger(maxRedirections) || maxRedirections < 0) { throw new InvalidArgumentError("maxRedirections must be a positive number"); } + super(options); if (connect && typeof connect !== "function") { connect = { ...connect }; } @@ -12306,9 +12339,9 @@ var require_agent = __commonJS({ } }); -// .yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/dispatcher/proxy-agent.js +// .yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/proxy-agent.js var require_proxy_agent = __commonJS({ - ".yarn/cache/undici-npm-6.22.0-4664dd0314-47903c489d.zip/node_modules/undici/lib/dispatcher/proxy-agent.js"(exports2, module2) { + ".yarn/cache/undici-npm-6.25.0-6002e70879-2597cc6689.zip/node_modules/undici/lib/dispatcher/proxy-agent.js"(exports2, module2) { "use strict"; var { kProxy, kClose, kDestroy, kDispatch, kInterceptors } = require_symbols(); var { URL: URL2 } = require("node:url"); @@ -12318,13 +12351,13 @@ var require_proxy_agent = __commonJS({ var { InvalidArgumentError, RequestAbortedError, SecureProxyConnectionError } = require_errors(); var buildConnector = require_connect(); var Client = require_client(); - var kAgent = Symbol("proxy agent"); - var kClient = Symbol("proxy client"); - var kProxyHeaders = Symbol("proxy headers"); - var kRequestTls = Symbol("request tls settings"); - var kProxyTls = Symbol("proxy tls settings"); - var kConnectEndpoint = Symbol("connect endpoint function"); - var kTunnelProxy = Symbol("tunnel proxy"); + var kAgent = /* @__PURE__ */ Symbol("proxy agent"); + var kClient = /* @__PURE__ */ Symbol("proxy client"); + var kProxyHeaders = /* @__PURE__ */ Symbol("proxy headers"); + var kRequestTls = /* @__PURE__ */ Symbol("request tls settings"); + var kProxyTls = /* @__PURE__ */ Symbol("proxy tls settings"); + var kConnectEndpoint = /* @__PURE__ */ Symbol("connect endpoint function"); + var kTunnelProxy = /* @__PURE__ */ Symbol("tunnel proxy"); function defaultProtocolPort(protocol) { return protocol === "https:" ? 443 : 80; } @@ -12544,37 +12577,37 @@ var init_esm = __esm({ isReadable = (s) => !!s && typeof s === "object" && s instanceof import_node_events.EventEmitter && typeof s.pipe === "function" && // node core Writable streams have a pipe() method, but it throws s.pipe !== import_node_stream.default.Writable.prototype.pipe; isWritable = (s) => !!s && typeof s === "object" && s instanceof import_node_events.EventEmitter && typeof s.write === "function" && typeof s.end === "function"; - EOF = Symbol("EOF"); - MAYBE_EMIT_END = Symbol("maybeEmitEnd"); - EMITTED_END = Symbol("emittedEnd"); - EMITTING_END = Symbol("emittingEnd"); - EMITTED_ERROR = Symbol("emittedError"); - CLOSED = Symbol("closed"); - READ = Symbol("read"); - FLUSH = Symbol("flush"); - FLUSHCHUNK = Symbol("flushChunk"); - ENCODING = Symbol("encoding"); - DECODER = Symbol("decoder"); - FLOWING = Symbol("flowing"); - PAUSED = Symbol("paused"); - RESUME = Symbol("resume"); - BUFFER = Symbol("buffer"); - PIPES = Symbol("pipes"); - BUFFERLENGTH = Symbol("bufferLength"); - BUFFERPUSH = Symbol("bufferPush"); - BUFFERSHIFT = Symbol("bufferShift"); - OBJECTMODE = Symbol("objectMode"); - DESTROYED = Symbol("destroyed"); - ERROR = Symbol("error"); - EMITDATA = Symbol("emitData"); - EMITEND = Symbol("emitEnd"); - EMITEND2 = Symbol("emitEnd2"); - ASYNC = Symbol("async"); - ABORT = Symbol("abort"); - ABORTED = Symbol("aborted"); - SIGNAL = Symbol("signal"); - DATALISTENERS = Symbol("dataListeners"); - DISCARDED = Symbol("discarded"); + EOF = /* @__PURE__ */ Symbol("EOF"); + MAYBE_EMIT_END = /* @__PURE__ */ Symbol("maybeEmitEnd"); + EMITTED_END = /* @__PURE__ */ Symbol("emittedEnd"); + EMITTING_END = /* @__PURE__ */ Symbol("emittingEnd"); + EMITTED_ERROR = /* @__PURE__ */ Symbol("emittedError"); + CLOSED = /* @__PURE__ */ Symbol("closed"); + READ = /* @__PURE__ */ Symbol("read"); + FLUSH = /* @__PURE__ */ Symbol("flush"); + FLUSHCHUNK = /* @__PURE__ */ Symbol("flushChunk"); + ENCODING = /* @__PURE__ */ Symbol("encoding"); + DECODER = /* @__PURE__ */ Symbol("decoder"); + FLOWING = /* @__PURE__ */ Symbol("flowing"); + PAUSED = /* @__PURE__ */ Symbol("paused"); + RESUME = /* @__PURE__ */ Symbol("resume"); + BUFFER = /* @__PURE__ */ Symbol("buffer"); + PIPES = /* @__PURE__ */ Symbol("pipes"); + BUFFERLENGTH = /* @__PURE__ */ Symbol("bufferLength"); + BUFFERPUSH = /* @__PURE__ */ Symbol("bufferPush"); + BUFFERSHIFT = /* @__PURE__ */ Symbol("bufferShift"); + OBJECTMODE = /* @__PURE__ */ Symbol("objectMode"); + DESTROYED = /* @__PURE__ */ Symbol("destroyed"); + ERROR = /* @__PURE__ */ Symbol("error"); + EMITDATA = /* @__PURE__ */ Symbol("emitData"); + EMITEND = /* @__PURE__ */ Symbol("emitEnd"); + EMITEND2 = /* @__PURE__ */ Symbol("emitEnd2"); + ASYNC = /* @__PURE__ */ Symbol("async"); + ABORT = /* @__PURE__ */ Symbol("abort"); + ABORTED = /* @__PURE__ */ Symbol("aborted"); + SIGNAL = /* @__PURE__ */ Symbol("signal"); + DATALISTENERS = /* @__PURE__ */ Symbol("dataListeners"); + DISCARDED = /* @__PURE__ */ Symbol("discarded"); defer = (fn2) => Promise.resolve().then(fn2); nodefer = (fn2) => fn2(); isEndish = (ev) => ev === "end" || ev === "finish" || ev === "prefinish"; @@ -13420,34 +13453,34 @@ var init_esm2 = __esm({ import_fs2 = __toESM(require("fs"), 1); init_esm(); writev = import_fs2.default.writev; - _autoClose = Symbol("_autoClose"); - _close = Symbol("_close"); - _ended = Symbol("_ended"); - _fd = Symbol("_fd"); - _finished = Symbol("_finished"); - _flags = Symbol("_flags"); - _flush = Symbol("_flush"); - _handleChunk = Symbol("_handleChunk"); - _makeBuf = Symbol("_makeBuf"); - _mode = Symbol("_mode"); - _needDrain = Symbol("_needDrain"); - _onerror = Symbol("_onerror"); - _onopen = Symbol("_onopen"); - _onread = Symbol("_onread"); - _onwrite = Symbol("_onwrite"); - _open = Symbol("_open"); - _path = Symbol("_path"); - _pos = Symbol("_pos"); - _queue = Symbol("_queue"); - _read = Symbol("_read"); - _readSize = Symbol("_readSize"); - _reading = Symbol("_reading"); - _remain = Symbol("_remain"); - _size = Symbol("_size"); - _write = Symbol("_write"); - _writing = Symbol("_writing"); - _defaultFlag = Symbol("_defaultFlag"); - _errored = Symbol("_errored"); + _autoClose = /* @__PURE__ */ Symbol("_autoClose"); + _close = /* @__PURE__ */ Symbol("_close"); + _ended = /* @__PURE__ */ Symbol("_ended"); + _fd = /* @__PURE__ */ Symbol("_fd"); + _finished = /* @__PURE__ */ Symbol("_finished"); + _flags = /* @__PURE__ */ Symbol("_flags"); + _flush = /* @__PURE__ */ Symbol("_flush"); + _handleChunk = /* @__PURE__ */ Symbol("_handleChunk"); + _makeBuf = /* @__PURE__ */ Symbol("_makeBuf"); + _mode = /* @__PURE__ */ Symbol("_mode"); + _needDrain = /* @__PURE__ */ Symbol("_needDrain"); + _onerror = /* @__PURE__ */ Symbol("_onerror"); + _onopen = /* @__PURE__ */ Symbol("_onopen"); + _onread = /* @__PURE__ */ Symbol("_onread"); + _onwrite = /* @__PURE__ */ Symbol("_onwrite"); + _open = /* @__PURE__ */ Symbol("_open"); + _path = /* @__PURE__ */ Symbol("_path"); + _pos = /* @__PURE__ */ Symbol("_pos"); + _queue = /* @__PURE__ */ Symbol("_queue"); + _read = /* @__PURE__ */ Symbol("_read"); + _readSize = /* @__PURE__ */ Symbol("_readSize"); + _reading = /* @__PURE__ */ Symbol("_reading"); + _remain = /* @__PURE__ */ Symbol("_remain"); + _size = /* @__PURE__ */ Symbol("_size"); + _write = /* @__PURE__ */ Symbol("_write"); + _writing = /* @__PURE__ */ Symbol("_writing"); + _defaultFlag = /* @__PURE__ */ Symbol("_defaultFlag"); + _errored = /* @__PURE__ */ Symbol("_errored"); ReadStream = class extends Minipass { [_errored] = false; [_fd]; @@ -13800,10 +13833,10 @@ var init_esm2 = __esm({ } }); -// .yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/options.js +// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/options.js var argmap, isSyncFile, isAsyncFile, isSyncNoFile, isAsyncNoFile, dealiasKey, dealias; var init_options = __esm({ - ".yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/options.js"() { + ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/options.js"() { argmap = /* @__PURE__ */ new Map([ ["C", "cwd"], ["f", "file"], @@ -13853,10 +13886,10 @@ var init_options = __esm({ } }); -// .yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/make-command.js +// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/make-command.js var makeCommand; var init_make_command = __esm({ - ".yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/make-command.js"() { + ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/make-command.js"() { init_options(); makeCommand = (syncFile, asyncFile, syncNoFile, asyncNoFile, validate) => { return Object.assign((opt_ = [], entries, cb) => { @@ -13868,11 +13901,7 @@ var init_make_command = __esm({ cb = entries; entries = void 0; } - if (!entries) { - entries = []; - } else { - entries = Array.from(entries); - } + entries = !entries ? [] : Array.from(entries); const opt = dealias(opt_); validate?.(opt, entries); if (isSyncFile(opt)) { @@ -13882,8 +13911,7 @@ var init_make_command = __esm({ return syncFile(opt, entries); } else if (isAsyncFile(opt)) { const p = asyncFile(opt, entries); - const c = cb ? cb : void 0; - return c ? p.then(() => c(), c) : p; + return cb ? p.then(() => cb(), cb) : p; } else if (isSyncNoFile(opt)) { if (typeof cb === "function") { throw new TypeError("callback not supported for sync tar functions"); @@ -13894,9 +13922,8 @@ var init_make_command = __esm({ throw new TypeError("callback only supported with file option"); } return asyncNoFile(opt, entries); - } else { - throw new Error("impossible options??"); } + throw new Error("impossible options??"); }, { syncFile, asyncFile, @@ -14042,7 +14069,7 @@ var init_esm3 = __esm({ import_buffer.Buffer.concat = makeNoOp ? noop : OriginalBufferConcat; } : (_) => { }; - _superWrite = Symbol("_superWrite"); + _superWrite = /* @__PURE__ */ Symbol("_superWrite"); ZlibError = class extends Error { code; errno; @@ -14059,7 +14086,7 @@ var init_esm3 = __esm({ return "ZlibError"; } }; - _flushFlag = Symbol("flushFlag"); + _flushFlag = /* @__PURE__ */ Symbol("flushFlag"); ZlibBase = class extends Minipass { #sawError = false; #ended = false; @@ -14307,10 +14334,10 @@ var init_esm3 = __esm({ } }); -// .yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/large-numbers.js +// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/large-numbers.js var encode, encodePositive, encodeNegative, parse, twos, pos, onesComp, twosComp; var init_large_numbers = __esm({ - ".yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/large-numbers.js"() { + ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/large-numbers.js"() { encode = (num, buf) => { if (!Number.isSafeInteger(num)) { throw Error("cannot encode number outside of javascript safe integer range"); @@ -14393,10 +14420,10 @@ var init_large_numbers = __esm({ } }); -// .yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/types.js +// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/types.js var isCode, name, code; var init_types = __esm({ - ".yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/types.js"() { + ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/types.js"() { isCode = (c) => name.has(c); name = /* @__PURE__ */ new Map([ ["0", "File"], @@ -14441,10 +14468,10 @@ var init_types = __esm({ } }); -// .yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/header.js +// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/header.js var import_node_path, Header, splitPrefix, decString, decDate, numToDate, decNumber, nanUndef, decSmallNumber, MAXNUM, encNumber, encSmallNumber, octalString, padOctal, encDate, NULLS, encString; var init_header = __esm({ - ".yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/header.js"() { + ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/header.js"() { import_node_path = require("node:path"); init_large_numbers(); init_types(); @@ -14561,7 +14588,7 @@ var init_header = __esm({ this.needPax = encNumber(buf, off + 116, 8, this.gid) || this.needPax; this.needPax = encNumber(buf, off + 124, 12, this.size) || this.needPax; this.needPax = encDate(buf, off + 136, 12, this.mtime) || this.needPax; - buf[off + 156] = this.#type.charCodeAt(0); + buf[off + 156] = Number(this.#type.codePointAt(0)); this.needPax = encString(buf, off + 157, 100, this.linkpath) || this.needPax; buf.write("ustar\x0000", off + 257, 8); this.needPax = encString(buf, off + 265, 32, this.uname) || this.needPax; @@ -14652,10 +14679,10 @@ var init_header = __esm({ } }); -// .yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/pax.js +// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/pax.js var import_node_path2, Pax, merge, parseKV, parseKVLine; var init_pax = __esm({ - ".yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/pax.js"() { + ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/pax.js"() { import_node_path2 = require("node:path"); init_header(); Pax = class _Pax { @@ -14775,19 +14802,19 @@ var init_pax = __esm({ } }); -// .yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/normalize-windows-path.js +// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/normalize-windows-path.js var platform, normalizeWindowsPath; var init_normalize_windows_path = __esm({ - ".yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/normalize-windows-path.js"() { + ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/normalize-windows-path.js"() { platform = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform; - normalizeWindowsPath = platform !== "win32" ? (p) => p : (p) => p && p.replace(/\\/g, "/"); + normalizeWindowsPath = platform !== "win32" ? (p) => p : (p) => p && p.replaceAll(/\\/g, "/"); } }); -// .yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/read-entry.js +// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/read-entry.js var ReadEntry; var init_read_entry = __esm({ - ".yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/read-entry.js"() { + ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/read-entry.js"() { init_esm(); init_normalize_windows_path(); ReadEntry = class extends Minipass { @@ -14908,10 +14935,10 @@ var init_read_entry = __esm({ } }); -// .yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/warn-method.js +// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/warn-method.js var warnMethod; var init_warn_method = __esm({ - ".yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/warn-method.js"() { + ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/warn-method.js"() { warnMethod = (self2, code2, message, data = {}) => { if (self2.file) { data.file = self2.file; @@ -14936,10 +14963,10 @@ var init_warn_method = __esm({ } }); -// .yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/parse.js +// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/parse.js var import_events3, maxMetaEntrySize, gzipHeader, zstdHeader, ZIP_HEADER_LEN, STATE, WRITEENTRY, READENTRY, NEXTENTRY, PROCESSENTRY, EX, GEX, META, EMITMETA, BUFFER2, QUEUE, ENDED, EMITTEDEND, EMIT, UNZIP, CONSUMECHUNK, CONSUMECHUNKSUB, CONSUMEBODY, CONSUMEMETA, CONSUMEHEADER, CONSUMING, BUFFERCONCAT, MAYBEEND, WRITING, ABORTED2, DONE, SAW_VALID_ENTRY, SAW_NULL_BLOCK, SAW_EOF, CLOSESTREAM, noop2, Parser; var init_parse = __esm({ - ".yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/parse.js"() { + ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/parse.js"() { import_events3 = require("events"); init_esm3(); init_header(); @@ -14950,36 +14977,36 @@ var init_parse = __esm({ gzipHeader = Buffer.from([31, 139]); zstdHeader = Buffer.from([40, 181, 47, 253]); ZIP_HEADER_LEN = Math.max(gzipHeader.length, zstdHeader.length); - STATE = Symbol("state"); - WRITEENTRY = Symbol("writeEntry"); - READENTRY = Symbol("readEntry"); - NEXTENTRY = Symbol("nextEntry"); - PROCESSENTRY = Symbol("processEntry"); - EX = Symbol("extendedHeader"); - GEX = Symbol("globalExtendedHeader"); - META = Symbol("meta"); - EMITMETA = Symbol("emitMeta"); - BUFFER2 = Symbol("buffer"); - QUEUE = Symbol("queue"); - ENDED = Symbol("ended"); - EMITTEDEND = Symbol("emittedEnd"); - EMIT = Symbol("emit"); - UNZIP = Symbol("unzip"); - CONSUMECHUNK = Symbol("consumeChunk"); - CONSUMECHUNKSUB = Symbol("consumeChunkSub"); - CONSUMEBODY = Symbol("consumeBody"); - CONSUMEMETA = Symbol("consumeMeta"); - CONSUMEHEADER = Symbol("consumeHeader"); - CONSUMING = Symbol("consuming"); - BUFFERCONCAT = Symbol("bufferConcat"); - MAYBEEND = Symbol("maybeEnd"); - WRITING = Symbol("writing"); - ABORTED2 = Symbol("aborted"); - DONE = Symbol("onDone"); - SAW_VALID_ENTRY = Symbol("sawValidEntry"); - SAW_NULL_BLOCK = Symbol("sawNullBlock"); - SAW_EOF = Symbol("sawEOF"); - CLOSESTREAM = Symbol("closeStream"); + STATE = /* @__PURE__ */ Symbol("state"); + WRITEENTRY = /* @__PURE__ */ Symbol("writeEntry"); + READENTRY = /* @__PURE__ */ Symbol("readEntry"); + NEXTENTRY = /* @__PURE__ */ Symbol("nextEntry"); + PROCESSENTRY = /* @__PURE__ */ Symbol("processEntry"); + EX = /* @__PURE__ */ Symbol("extendedHeader"); + GEX = /* @__PURE__ */ Symbol("globalExtendedHeader"); + META = /* @__PURE__ */ Symbol("meta"); + EMITMETA = /* @__PURE__ */ Symbol("emitMeta"); + BUFFER2 = /* @__PURE__ */ Symbol("buffer"); + QUEUE = /* @__PURE__ */ Symbol("queue"); + ENDED = /* @__PURE__ */ Symbol("ended"); + EMITTEDEND = /* @__PURE__ */ Symbol("emittedEnd"); + EMIT = /* @__PURE__ */ Symbol("emit"); + UNZIP = /* @__PURE__ */ Symbol("unzip"); + CONSUMECHUNK = /* @__PURE__ */ Symbol("consumeChunk"); + CONSUMECHUNKSUB = /* @__PURE__ */ Symbol("consumeChunkSub"); + CONSUMEBODY = /* @__PURE__ */ Symbol("consumeBody"); + CONSUMEMETA = /* @__PURE__ */ Symbol("consumeMeta"); + CONSUMEHEADER = /* @__PURE__ */ Symbol("consumeHeader"); + CONSUMING = /* @__PURE__ */ Symbol("consuming"); + BUFFERCONCAT = /* @__PURE__ */ Symbol("bufferConcat"); + MAYBEEND = /* @__PURE__ */ Symbol("maybeEnd"); + WRITING = /* @__PURE__ */ Symbol("writing"); + ABORTED2 = /* @__PURE__ */ Symbol("aborted"); + DONE = /* @__PURE__ */ Symbol("onDone"); + SAW_VALID_ENTRY = /* @__PURE__ */ Symbol("sawValidEntry"); + SAW_NULL_BLOCK = /* @__PURE__ */ Symbol("sawNullBlock"); + SAW_EOF = /* @__PURE__ */ Symbol("sawEOF"); + CLOSESTREAM = /* @__PURE__ */ Symbol("closeStream"); noop2 = () => true; Parser = class extends import_events3.EventEmitter { file; @@ -15154,7 +15181,7 @@ var init_parse = __esm({ [NEXTENTRY]() { do { } while (this[PROCESSENTRY](this[QUEUE].shift())); - if (!this[QUEUE].length) { + if (this[QUEUE].length === 0) { const re = this[READENTRY]; const drainNow = !re || re.flowing || re.size === re.remain; if (drainNow) { @@ -15190,7 +15217,7 @@ var init_parse = __esm({ return ret; } [EMIT](ev, data, extra) { - if (!this[QUEUE].length && !this[READENTRY]) { + if (this[QUEUE].length === 0 && !this[READENTRY]) { this.emit(ev, data, extra); } else { this[QUEUE].push([ev, data, extra]); @@ -15314,8 +15341,8 @@ var init_parse = __esm({ this[CONSUMECHUNK](chunk); } this[WRITING] = false; - const ret = this[QUEUE].length ? false : this[READENTRY] ? this[READENTRY].flowing : true; - if (!ret && !this[QUEUE].length) { + const ret = this[QUEUE].length > 0 ? false : this[READENTRY] ? this[READENTRY].flowing : true; + if (!ret && this[QUEUE].length === 0) { this[READENTRY]?.once("drain", () => this.emit("drain")); } cb?.(); @@ -15390,14 +15417,7 @@ var init_parse = __esm({ } } if (position < length) { - if (this[BUFFER2]) { - this[BUFFER2] = Buffer.concat([ - chunk.subarray(position), - this[BUFFER2] - ]); - } else { - this[BUFFER2] = chunk.subarray(position); - } + this[BUFFER2] = this[BUFFER2] ? Buffer.concat([chunk.subarray(position), this[BUFFER2]]) : chunk.subarray(position); } } end(chunk, encoding, cb) { @@ -15435,10 +15455,10 @@ var init_parse = __esm({ } }); -// .yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/strip-trailing-slashes.js +// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/strip-trailing-slashes.js var stripTrailingSlashes; var init_strip_trailing_slashes = __esm({ - ".yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/strip-trailing-slashes.js"() { + ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/strip-trailing-slashes.js"() { stripTrailingSlashes = (str) => { let i = str.length - 1; let slashesStart = -1; @@ -15451,7 +15471,7 @@ var init_strip_trailing_slashes = __esm({ } }); -// .yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/list.js +// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/list.js var list_exports = {}; __export(list_exports, { filesFilter: () => filesFilter, @@ -15459,7 +15479,7 @@ __export(list_exports, { }); var import_node_fs, import_path2, onReadEntryFunction, filesFilter, listFileSync, listFile, list; var init_list = __esm({ - ".yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/list.js"() { + ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/list.js"() { init_esm2(); import_node_fs = __toESM(require("node:fs"), 1); import_path2 = require("path"); @@ -15483,11 +15503,7 @@ var init_list = __esm({ ret = false; else { const m = map.get(file); - if (m !== void 0) { - ret = m; - } else { - ret = mapHas((0, import_path2.dirname)(file), root); - } + ret = m !== void 0 ? m : mapHas((0, import_path2.dirname)(file), root); } map.set(file, ret); return ret; @@ -15522,7 +15538,7 @@ var init_list = __esm({ if (typeof fd === "number") { try { import_node_fs.default.closeSync(fd); - } catch (er) { + } catch { } } } @@ -15558,19 +15574,20 @@ var init_list = __esm({ } }); -// .yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/get-write-flag.js -var import_fs3, platform2, isWindows, O_CREAT, O_TRUNC, O_WRONLY, UV_FS_O_FILEMAP, fMapEnabled, fMapLimit, fMapFlag, getWriteFlag; +// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/get-write-flag.js +var import_fs3, platform2, isWindows, O_CREAT, O_NOFOLLOW, O_TRUNC, O_WRONLY, UV_FS_O_FILEMAP, fMapEnabled, fMapLimit, fMapFlag, noFollowFlag, getWriteFlag; var init_get_write_flag = __esm({ - ".yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/get-write-flag.js"() { + ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/get-write-flag.js"() { import_fs3 = __toESM(require("fs"), 1); platform2 = process.env.__FAKE_PLATFORM__ || process.platform; isWindows = platform2 === "win32"; - ({ O_CREAT, O_TRUNC, O_WRONLY } = import_fs3.default.constants); + ({ O_CREAT, O_NOFOLLOW, O_TRUNC, O_WRONLY } = import_fs3.default.constants); UV_FS_O_FILEMAP = Number(process.env.__FAKE_FS_O_FILENAME__) || import_fs3.default.constants.UV_FS_O_FILEMAP || 0; fMapEnabled = isWindows && !!UV_FS_O_FILEMAP; fMapLimit = 512 * 1024; fMapFlag = UV_FS_O_FILEMAP | O_TRUNC | O_CREAT | O_WRONLY; - getWriteFlag = !fMapEnabled ? () => "w" : (size) => size < fMapLimit ? fMapFlag : "w"; + noFollowFlag = !isWindows && typeof O_NOFOLLOW === "number" ? O_NOFOLLOW | O_TRUNC | O_CREAT | O_WRONLY : null; + getWriteFlag = noFollowFlag !== null ? () => noFollowFlag : !fMapEnabled ? () => "w" : (size) => size < fMapLimit ? fMapFlag : "w"; } }); @@ -15657,10 +15674,10 @@ var init_esm4 = __esm({ } }); -// .yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/cwd-error.js +// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/cwd-error.js var CwdError; var init_cwd_error = __esm({ - ".yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/cwd-error.js"() { + ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/cwd-error.js"() { CwdError = class extends Error { path; code; @@ -15677,10 +15694,10 @@ var init_cwd_error = __esm({ } }); -// .yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/symlink-error.js +// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/symlink-error.js var SymlinkError; var init_symlink_error = __esm({ - ".yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/symlink-error.js"() { + ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/symlink-error.js"() { SymlinkError = class extends Error { path; symlink; @@ -15698,10 +15715,10 @@ var init_symlink_error = __esm({ } }); -// .yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/mkdir.js +// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/mkdir.js var import_node_fs3, import_promises, import_node_path4, checkCwd, mkdir, mkdir_, onmkdir, checkCwdSync, mkdirSync2; var init_mkdir = __esm({ - ".yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/mkdir.js"() { + ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/mkdir.js"() { init_esm4(); import_node_fs3 = __toESM(require("node:fs"), 1); import_promises = __toESM(require("node:fs/promises"), 1); @@ -15719,9 +15736,9 @@ var init_mkdir = __esm({ }; mkdir = (dir, opt, cb) => { dir = normalizeWindowsPath(dir); - const umask = opt.umask ?? 18; + const umask2 = opt.umask ?? 18; const mode = opt.mode | 448; - const needChmod = (mode & umask) !== 0; + const needChmod = (mode & umask2) !== 0; const uid = opt.uid; const gid = opt.gid; const doChown = typeof uid === "number" && typeof gid === "number" && (uid !== opt.processUid || gid !== opt.processGid); @@ -15756,7 +15773,7 @@ var init_mkdir = __esm({ mkdir_(cwd, parts, mode, unlink, cwd, void 0, done); }; mkdir_ = (base, parts, mode, unlink, cwd, created, cb) => { - if (!parts.length) { + if (parts.length === 0) { return cb(null, created); } const p = parts.shift(); @@ -15791,7 +15808,7 @@ var init_mkdir = __esm({ }; checkCwdSync = (dir) => { let ok = false; - let code2 = void 0; + let code2; try { ok = import_node_fs3.default.statSync(dir).isDirectory(); } catch (er) { @@ -15804,9 +15821,9 @@ var init_mkdir = __esm({ }; mkdirSync2 = (dir, opt) => { dir = normalizeWindowsPath(dir); - const umask = opt.umask ?? 18; + const umask2 = opt.umask ?? 18; const mode = opt.mode | 448; - const needChmod = (mode & umask) !== 0; + const needChmod = (mode & umask2) !== 0; const uid = opt.uid; const gid = opt.gid; const doChown = typeof uid === "number" && typeof gid === "number" && (uid !== opt.processUid || gid !== opt.processGid); @@ -15830,13 +15847,13 @@ var init_mkdir = __esm({ } const sub = normalizeWindowsPath(import_node_path4.default.relative(cwd, dir)); const parts = sub.split("/"); - let created = void 0; + let created; for (let p = parts.shift(), part = cwd; p && (part += "/" + p); p = parts.shift()) { part = normalizeWindowsPath(import_node_path4.default.resolve(part)); try { import_node_fs3.default.mkdirSync(part, mode); created = created || part; - } catch (er) { + } catch { const st = import_node_fs3.default.lstatSync(part); if (st.isDirectory()) { continue; @@ -15855,10 +15872,10 @@ var init_mkdir = __esm({ } }); -// .yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/strip-absolute-path.js +// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/strip-absolute-path.js var import_node_path5, isAbsolute, parse3, stripAbsolutePath; var init_strip_absolute_path = __esm({ - ".yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/strip-absolute-path.js"() { + ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/strip-absolute-path.js"() { import_node_path5 = require("node:path"); ({ isAbsolute, parse: parse3 } = import_node_path5.win32); stripAbsolutePath = (path16) => { @@ -15875,12 +15892,12 @@ var init_strip_absolute_path = __esm({ } }); -// .yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/winchars.js +// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/winchars.js var raw, win, toWin, toRaw, encode2, decode; var init_winchars = __esm({ - ".yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/winchars.js"() { + ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/winchars.js"() { raw = ["|", "<", ">", "?", ":"]; - win = raw.map((char) => String.fromCharCode(61440 + char.charCodeAt(0))); + win = raw.map((char) => String.fromCodePoint(61440 + Number(char.codePointAt(0)))); toWin = new Map(raw.map((char, i) => [char, win[i]])); toRaw = new Map(win.map((char, i) => [char, raw[i]])); encode2 = (s) => raw.reduce((s2, c) => s2.split(c).join(toWin.get(c)), s); @@ -15888,10 +15905,10 @@ var init_winchars = __esm({ } }); -// .yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/normalize-unicode.js +// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/normalize-unicode.js var normalizeCache, MAX, cache, normalizeUnicode; var init_normalize_unicode = __esm({ - ".yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/normalize-unicode.js"() { + ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/normalize-unicode.js"() { normalizeCache = /* @__PURE__ */ Object.create(null); MAX = 1e4; cache = /* @__PURE__ */ new Set(); @@ -15917,10 +15934,10 @@ var init_normalize_unicode = __esm({ } }); -// .yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/path-reservations.js +// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/path-reservations.js var import_node_path6, platform3, isWindows2, getDirs, PathReservations; var init_path_reservations = __esm({ - ".yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/path-reservations.js"() { + ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/path-reservations.js"() { import_node_path6 = require("node:path"); init_normalize_unicode(); init_strip_trailing_slashes(); @@ -15928,7 +15945,7 @@ var init_path_reservations = __esm({ isWindows2 = platform3 === "win32"; getDirs = (path16) => { const dirs = path16.split("/").slice(0, -1).reduce((set, path17) => { - const s = set[set.length - 1]; + const s = set.at(-1); if (s !== void 0) { path17 = (0, import_node_path6.join)(s, path17); } @@ -15965,7 +15982,7 @@ var init_path_reservations = __esm({ if (!q) { this.#queues.set(dir, [/* @__PURE__ */ new Set([fn2])]); } else { - const l = q[q.length - 1]; + const l = q.at(-1); if (l instanceof Set) { l.add(fn2); } else { @@ -16057,10 +16074,18 @@ var init_path_reservations = __esm({ } }); -// .yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/unpack.js -var import_node_assert, import_node_crypto, import_node_fs4, import_node_path7, ONENTRY, CHECKFS, CHECKFS2, ISREUSABLE, MAKEFS, FILE, DIRECTORY, LINK, SYMLINK, HARDLINK, UNSUPPORTED, CHECKPATH, STRIPABSOLUTEPATH, MKDIR, ONERROR, PENDING, PEND, UNPEND, ENDED2, MAYBECLOSE, SKIP, DOCHOWN, UID, GID, CHECKED_CWD, platform4, isWindows3, DEFAULT_MAX_DEPTH, unlinkFile, unlinkFileSync, uint32, Unpack, callSync, UnpackSync; +// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/process-umask.js +var umask; +var init_process_umask = __esm({ + ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/process-umask.js"() { + umask = () => process.umask(); + } +}); + +// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/unpack.js +var import_node_assert, import_node_crypto, import_node_fs4, import_node_path7, ONENTRY, CHECKFS, CHECKFS2, ISREUSABLE, MAKEFS, FILE, DIRECTORY, LINK, SYMLINK, HARDLINK, ENSURE_NO_SYMLINK, UNSUPPORTED, CHECKPATH, STRIPABSOLUTEPATH, MKDIR, ONERROR, PENDING, PEND, UNPEND, ENDED2, MAYBECLOSE, SKIP, DOCHOWN, UID, GID, CHECKED_CWD, platform4, isWindows3, DEFAULT_MAX_DEPTH, unlinkFile, unlinkFileSync, uint32, Unpack, callSync, UnpackSync; var init_unpack = __esm({ - ".yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/unpack.js"() { + ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/unpack.js"() { init_esm2(); import_node_assert = __toESM(require("node:assert"), 1); import_node_crypto = require("node:crypto"); @@ -16073,31 +16098,34 @@ var init_unpack = __esm({ init_strip_absolute_path(); init_winchars(); init_path_reservations(); - ONENTRY = Symbol("onEntry"); - CHECKFS = Symbol("checkFs"); - CHECKFS2 = Symbol("checkFs2"); - ISREUSABLE = Symbol("isReusable"); - MAKEFS = Symbol("makeFs"); - FILE = Symbol("file"); - DIRECTORY = Symbol("directory"); - LINK = Symbol("link"); - SYMLINK = Symbol("symlink"); - HARDLINK = Symbol("hardlink"); - UNSUPPORTED = Symbol("unsupported"); - CHECKPATH = Symbol("checkPath"); - STRIPABSOLUTEPATH = Symbol("stripAbsolutePath"); - MKDIR = Symbol("mkdir"); - ONERROR = Symbol("onError"); - PENDING = Symbol("pending"); - PEND = Symbol("pend"); - UNPEND = Symbol("unpend"); - ENDED2 = Symbol("ended"); - MAYBECLOSE = Symbol("maybeClose"); - SKIP = Symbol("skip"); - DOCHOWN = Symbol("doChown"); - UID = Symbol("uid"); - GID = Symbol("gid"); - CHECKED_CWD = Symbol("checkedCwd"); + init_symlink_error(); + init_process_umask(); + ONENTRY = /* @__PURE__ */ Symbol("onEntry"); + CHECKFS = /* @__PURE__ */ Symbol("checkFs"); + CHECKFS2 = /* @__PURE__ */ Symbol("checkFs2"); + ISREUSABLE = /* @__PURE__ */ Symbol("isReusable"); + MAKEFS = /* @__PURE__ */ Symbol("makeFs"); + FILE = /* @__PURE__ */ Symbol("file"); + DIRECTORY = /* @__PURE__ */ Symbol("directory"); + LINK = /* @__PURE__ */ Symbol("link"); + SYMLINK = /* @__PURE__ */ Symbol("symlink"); + HARDLINK = /* @__PURE__ */ Symbol("hardlink"); + ENSURE_NO_SYMLINK = /* @__PURE__ */ Symbol("ensureNoSymlink"); + UNSUPPORTED = /* @__PURE__ */ Symbol("unsupported"); + CHECKPATH = /* @__PURE__ */ Symbol("checkPath"); + STRIPABSOLUTEPATH = /* @__PURE__ */ Symbol("stripAbsolutePath"); + MKDIR = /* @__PURE__ */ Symbol("mkdir"); + ONERROR = /* @__PURE__ */ Symbol("onError"); + PENDING = /* @__PURE__ */ Symbol("pending"); + PEND = /* @__PURE__ */ Symbol("pend"); + UNPEND = /* @__PURE__ */ Symbol("unpend"); + ENDED2 = /* @__PURE__ */ Symbol("ended"); + MAYBECLOSE = /* @__PURE__ */ Symbol("maybeClose"); + SKIP = /* @__PURE__ */ Symbol("skip"); + DOCHOWN = /* @__PURE__ */ Symbol("doChown"); + UID = /* @__PURE__ */ Symbol("uid"); + GID = /* @__PURE__ */ Symbol("gid"); + CHECKED_CWD = /* @__PURE__ */ Symbol("checkedCwd"); platform4 = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform; isWindows3 = platform4 === "win32"; DEFAULT_MAX_DEPTH = 1024; @@ -16174,11 +16202,7 @@ var init_unpack = __esm({ this.gid = void 0; this.setOwner = false; } - if (opt.preserveOwner === void 0 && typeof opt.uid !== "number") { - this.preserveOwner = !!(process.getuid && process.getuid() === 0); - } else { - this.preserveOwner = !!opt.preserveOwner; - } + this.preserveOwner = opt.preserveOwner === void 0 && typeof opt.uid !== "number" ? !!(process.getuid && process.getuid() === 0) : !!opt.preserveOwner; this.processUid = (this.preserveOwner || this.setOwner) && process.getuid ? process.getuid() : void 0; this.processGid = (this.preserveOwner || this.setOwner) && process.getgid ? process.getgid() : void 0; this.maxDepth = typeof opt.maxDepth === "number" ? opt.maxDepth : DEFAULT_MAX_DEPTH; @@ -16191,7 +16215,7 @@ var init_unpack = __esm({ this.unlink = !!opt.unlink; this.cwd = normalizeWindowsPath(import_node_path7.default.resolve(opt.cwd || process.cwd())); this.strip = Number(opt.strip) || 0; - this.processUmask = !this.chmod ? 0 : typeof opt.processUmask === "number" ? opt.processUmask : process.umask(); + this.processUmask = !this.chmod ? 0 : typeof opt.processUmask === "number" ? opt.processUmask : umask(); this.umask = typeof opt.umask === "number" ? opt.umask : this.processUmask; this.dmode = opt.dmode || 511 & ~this.umask; this.fmode = opt.fmode || 438 & ~this.umask; @@ -16217,30 +16241,30 @@ var init_unpack = __esm({ // return true if the field was successfully sanitized [STRIPABSOLUTEPATH](entry, field) { const p = entry[field]; + const { type } = entry; if (!p || this.preservePaths) return true; - const parts = p.split("/"); + const [root, stripped] = stripAbsolutePath(p); + const parts = stripped.replaceAll(/\\/g, "/").split("/"); if (parts.includes("..") || /* c8 ignore next */ isWindows3 && /^[a-z]:\.\.$/i.test(parts[0] ?? "")) { - if (field === "path") { + if (field === "path" || type === "Link") { this.warn("TAR_ENTRY_ERROR", `${field} contains '..'`, { entry, [field]: p }); return false; - } else { - const entryDir = import_node_path7.default.posix.dirname(entry.path); - const resolved = import_node_path7.default.posix.normalize(import_node_path7.default.posix.join(entryDir, p)); - if (resolved.startsWith("../") || resolved === "..") { - this.warn("TAR_ENTRY_ERROR", `${field} escapes extraction directory`, { - entry, - [field]: p - }); - return false; - } + } + const entryDir = import_node_path7.default.posix.dirname(entry.path); + const resolved = import_node_path7.default.posix.normalize(import_node_path7.default.posix.join(entryDir, parts.join("/"))); + if (resolved.startsWith("../") || resolved === "..") { + this.warn("TAR_ENTRY_ERROR", `${field} escapes extraction directory`, { + entry, + [field]: p + }); + return false; } } - const [root, stripped] = stripAbsolutePath(p); if (root) { entry[field] = String(stripped); this.warn("TAR_ENTRY_INFO", `stripping ${root} from absolute ${field}`, { @@ -16250,6 +16274,7 @@ var init_unpack = __esm({ } return true; } + // no IO, just string checking for absolute indicators [CHECKPATH](entry) { const p = normalizeWindowsPath(entry.path); const parts = p.split("/"); @@ -16280,11 +16305,7 @@ var init_unpack = __esm({ if (!this[STRIPABSOLUTEPATH](entry, "path") || !this[STRIPABSOLUTEPATH](entry, "linkpath")) { return false; } - if (import_node_path7.default.isAbsolute(entry.path)) { - entry.absolute = normalizeWindowsPath(import_node_path7.default.resolve(entry.path)); - } else { - entry.absolute = normalizeWindowsPath(import_node_path7.default.resolve(this.cwd, entry.path)); - } + entry.absolute = import_node_path7.default.isAbsolute(entry.path) ? normalizeWindowsPath(import_node_path7.default.resolve(entry.path)) : normalizeWindowsPath(import_node_path7.default.resolve(this.cwd, entry.path)); if (!this.preservePaths && typeof entry.absolute === "string" && entry.absolute.indexOf(this.cwd + "/") !== 0 && entry.absolute !== this.cwd) { this.warn("TAR_ENTRY_ERROR", "path escaped extraction target", { entry, @@ -16464,11 +16485,33 @@ var init_unpack = __esm({ entry.resume(); } [SYMLINK](entry, done) { - this[LINK](entry, String(entry.linkpath), "symlink", done); + const parts = normalizeWindowsPath(import_node_path7.default.relative(this.cwd, import_node_path7.default.resolve(import_node_path7.default.dirname(String(entry.absolute)), String(entry.linkpath)))).split("/"); + this[ENSURE_NO_SYMLINK](entry, this.cwd, parts, () => this[LINK](entry, String(entry.linkpath), "symlink", done), (er) => { + this[ONERROR](er, entry); + done(); + }); } [HARDLINK](entry, done) { const linkpath = normalizeWindowsPath(import_node_path7.default.resolve(this.cwd, String(entry.linkpath))); - this[LINK](entry, linkpath, "link", done); + const parts = normalizeWindowsPath(String(entry.linkpath)).split("/"); + this[ENSURE_NO_SYMLINK](entry, this.cwd, parts, () => this[LINK](entry, linkpath, "link", done), (er) => { + this[ONERROR](er, entry); + done(); + }); + } + [ENSURE_NO_SYMLINK](entry, cwd, parts, done, onError) { + const p = parts.shift(); + if (this.preservePaths || p === void 0) + return done(); + const t = import_node_path7.default.resolve(cwd, p); + import_node_fs4.default.lstat(t, (er, st) => { + if (er) + return done(); + if (st?.isSymbolicLink()) { + return onError(new SymlinkError(t, import_node_path7.default.resolve(t, parts.join("/")))); + } + this[ENSURE_NO_SYMLINK](entry, t, parts, done, onError); + }); } [PEND]() { this[PENDING]++; @@ -16689,7 +16732,7 @@ var init_unpack = __esm({ } catch (futimeser) { try { import_node_fs4.default.utimesSync(String(entry.absolute), atime, mtime); - } catch (utimeser) { + } catch { er = futimeser; } } @@ -16702,7 +16745,7 @@ var init_unpack = __esm({ } catch (fchowner) { try { import_node_fs4.default.chownSync(String(entry.absolute), Number(uid), Number(gid)); - } catch (chowner) { + } catch { er = er || fchowner; } } @@ -16721,13 +16764,13 @@ var init_unpack = __esm({ if (entry.mtime && !this.noMtime) { try { import_node_fs4.default.utimesSync(String(entry.absolute), entry.atime || /* @__PURE__ */ new Date(), entry.mtime); - } catch (er2) { + } catch { } } if (this[DOCHOWN](entry)) { try { import_node_fs4.default.chownSync(String(entry.absolute), Number(this[UID](entry)), Number(this[GID](entry))); - } catch (er2) { + } catch { } } done(); @@ -16750,10 +16793,25 @@ var init_unpack = __esm({ return er; } } + [ENSURE_NO_SYMLINK](_entry, cwd, parts, done, onError) { + if (this.preservePaths || parts.length === 0) + return done(); + let t = cwd; + for (const p of parts) { + t = import_node_path7.default.resolve(t, p); + const [er, st] = callSync(() => import_node_fs4.default.lstatSync(t)); + if (er) + return done(); + if (st.isSymbolicLink()) { + return onError(new SymlinkError(t, import_node_path7.default.resolve(cwd, parts.join("/")))); + } + } + done(); + } [LINK](entry, linkpath, link, done) { - const ls = `${link}Sync`; + const linkSync = `${link}Sync`; try { - import_node_fs4.default[ls](linkpath, String(entry.absolute)); + import_node_fs4.default[linkSync](linkpath, String(entry.absolute)); done(); entry.resume(); } catch (er) { @@ -16764,14 +16822,14 @@ var init_unpack = __esm({ } }); -// .yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/extract.js +// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/extract.js var extract_exports = {}; __export(extract_exports, { extract: () => extract }); var import_node_fs5, extractFileSync, extractFile, extract; var init_extract = __esm({ - ".yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/extract.js"() { + ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/extract.js"() { init_esm2(); import_node_fs5 = __toESM(require("node:fs"), 1); init_list(); @@ -17814,8 +17872,8 @@ var require_graceful_fs = __commonJS({ var gracefulQueue; var previousSymbol; if (typeof Symbol === "function" && typeof Symbol.for === "function") { - gracefulQueue = Symbol.for("graceful-fs.queue"); - previousSymbol = Symbol.for("graceful-fs.previous"); + gracefulQueue = /* @__PURE__ */ Symbol.for("graceful-fs.queue"); + previousSymbol = /* @__PURE__ */ Symbol.for("graceful-fs.previous"); } else { gracefulQueue = "___graceful-fs.queue"; previousSymbol = "___graceful-fs.previous"; @@ -18517,10 +18575,10 @@ ${nodePath ? "$env:NODE_PATH=$env_node_path\n" : ""}${prependPath ? "$env:PATH=$ } }); -// .yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/mode-fix.js +// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/mode-fix.js var modeFix; var init_mode_fix = __esm({ - ".yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/mode-fix.js"() { + ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/mode-fix.js"() { modeFix = (mode, isDir, portable) => { mode &= 4095; if (portable) { @@ -18542,10 +18600,10 @@ var init_mode_fix = __esm({ } }); -// .yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/write-entry.js +// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/write-entry.js var import_fs11, import_path9, prefixPath, maxReadSize, PROCESS, FILE2, DIRECTORY2, SYMLINK2, HARDLINK2, HEADER, READ2, LSTAT, ONLSTAT, ONREAD, ONREADLINK, OPENFILE, ONOPENFILE, CLOSE, MODE, AWAITDRAIN, ONDRAIN, PREFIX, WriteEntry, WriteEntrySync, WriteEntryTar, getType; var init_write_entry = __esm({ - ".yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/write-entry.js"() { + ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/write-entry.js"() { import_fs11 = __toESM(require("fs"), 1); init_esm(); import_path9 = __toESM(require("path"), 1); @@ -18566,24 +18624,24 @@ var init_write_entry = __esm({ return stripTrailingSlashes(prefix) + "/" + path16; }; maxReadSize = 16 * 1024 * 1024; - PROCESS = Symbol("process"); - FILE2 = Symbol("file"); - DIRECTORY2 = Symbol("directory"); - SYMLINK2 = Symbol("symlink"); - HARDLINK2 = Symbol("hardlink"); - HEADER = Symbol("header"); - READ2 = Symbol("read"); - LSTAT = Symbol("lstat"); - ONLSTAT = Symbol("onlstat"); - ONREAD = Symbol("onread"); - ONREADLINK = Symbol("onreadlink"); - OPENFILE = Symbol("openfile"); - ONOPENFILE = Symbol("onopenfile"); - CLOSE = Symbol("close"); - MODE = Symbol("mode"); - AWAITDRAIN = Symbol("awaitDrain"); - ONDRAIN = Symbol("ondrain"); - PREFIX = Symbol("prefix"); + PROCESS = /* @__PURE__ */ Symbol("process"); + FILE2 = /* @__PURE__ */ Symbol("file"); + DIRECTORY2 = /* @__PURE__ */ Symbol("directory"); + SYMLINK2 = /* @__PURE__ */ Symbol("symlink"); + HARDLINK2 = /* @__PURE__ */ Symbol("hardlink"); + HEADER = /* @__PURE__ */ Symbol("header"); + READ2 = /* @__PURE__ */ Symbol("read"); + LSTAT = /* @__PURE__ */ Symbol("lstat"); + ONLSTAT = /* @__PURE__ */ Symbol("onlstat"); + ONREAD = /* @__PURE__ */ Symbol("onread"); + ONREADLINK = /* @__PURE__ */ Symbol("onreadlink"); + OPENFILE = /* @__PURE__ */ Symbol("openfile"); + ONOPENFILE = /* @__PURE__ */ Symbol("onopenfile"); + CLOSE = /* @__PURE__ */ Symbol("close"); + MODE = /* @__PURE__ */ Symbol("mode"); + AWAITDRAIN = /* @__PURE__ */ Symbol("awaitDrain"); + ONDRAIN = /* @__PURE__ */ Symbol("ondrain"); + PREFIX = /* @__PURE__ */ Symbol("prefix"); WriteEntry = class extends Minipass { path; portable; @@ -18645,8 +18703,8 @@ var init_write_entry = __esm({ } this.win32 = !!opt.win32 || process.platform === "win32"; if (this.win32) { - this.path = decode(this.path.replace(/\\/g, "/")); - p = p.replace(/\\/g, "/"); + this.path = decode(this.path.replaceAll(/\\/g, "/")); + p = p.replaceAll(/\\/g, "/"); } this.absolute = normalizeWindowsPath(opt.absolute || import_path9.default.resolve(this.cwd, p)); if (this.path === "") { @@ -18956,7 +19014,7 @@ var init_write_entry = __esm({ try { this[CLOSE](() => { }); - } catch (er) { + } catch { } } } @@ -19129,7 +19187,10 @@ var init_write_entry = __esm({ } if (cb) this.once("finish", cb); - chunk ? super.end(chunk, cb) : super.end(cb); + if (chunk) + super.end(chunk, cb); + else + super.end(cb); return this; } }; @@ -19511,10 +19572,10 @@ var init_esm5 = __esm({ } }); -// .yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/pack.js +// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/pack.js var import_fs12, import_path10, PackJob, EOF2, ONSTAT, ENDED3, QUEUE2, CURRENT, PROCESS2, PROCESSING, PROCESSJOB, JOBS, JOBDONE, ADDFSENTRY, ADDTARENTRY, STAT, READDIR, ONREADDIR, PIPE, ENTRY, ENTRYOPT, WRITEENTRYCLASS, WRITE, ONDRAIN2, Pack, PackSync; var init_pack = __esm({ - ".yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/pack.js"() { + ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/pack.js"() { import_fs12 = __toESM(require("fs"), 1); init_write_entry(); init_esm(); @@ -19539,26 +19600,26 @@ var init_pack = __esm({ } }; EOF2 = Buffer.alloc(1024); - ONSTAT = Symbol("onStat"); - ENDED3 = Symbol("ended"); - QUEUE2 = Symbol("queue"); - CURRENT = Symbol("current"); - PROCESS2 = Symbol("process"); - PROCESSING = Symbol("processing"); - PROCESSJOB = Symbol("processJob"); - JOBS = Symbol("jobs"); - JOBDONE = Symbol("jobDone"); - ADDFSENTRY = Symbol("addFSEntry"); - ADDTARENTRY = Symbol("addTarEntry"); - STAT = Symbol("stat"); - READDIR = Symbol("readdir"); - ONREADDIR = Symbol("onreaddir"); - PIPE = Symbol("pipe"); - ENTRY = Symbol("entry"); - ENTRYOPT = Symbol("entryOpt"); - WRITEENTRYCLASS = Symbol("writeEntryClass"); - WRITE = Symbol("write"); - ONDRAIN2 = Symbol("ondrain"); + ONSTAT = /* @__PURE__ */ Symbol("onStat"); + ENDED3 = /* @__PURE__ */ Symbol("ended"); + QUEUE2 = /* @__PURE__ */ Symbol("queue"); + CURRENT = /* @__PURE__ */ Symbol("current"); + PROCESS2 = /* @__PURE__ */ Symbol("process"); + PROCESSING = /* @__PURE__ */ Symbol("processing"); + PROCESSJOB = /* @__PURE__ */ Symbol("processJob"); + JOBS = /* @__PURE__ */ Symbol("jobs"); + JOBDONE = /* @__PURE__ */ Symbol("jobDone"); + ADDFSENTRY = /* @__PURE__ */ Symbol("addFSEntry"); + ADDTARENTRY = /* @__PURE__ */ Symbol("addTarEntry"); + STAT = /* @__PURE__ */ Symbol("stat"); + READDIR = /* @__PURE__ */ Symbol("readdir"); + ONREADDIR = /* @__PURE__ */ Symbol("onreaddir"); + PIPE = /* @__PURE__ */ Symbol("pipe"); + ENTRY = /* @__PURE__ */ Symbol("entry"); + ENTRYOPT = /* @__PURE__ */ Symbol("entryOpt"); + WRITEENTRYCLASS = /* @__PURE__ */ Symbol("writeEntryClass"); + WRITE = /* @__PURE__ */ Symbol("write"); + ONDRAIN2 = /* @__PURE__ */ Symbol("ondrain"); Pack = class extends Minipass { sync = false; opt; @@ -19769,7 +19830,7 @@ var init_pack = __esm({ } } this[PROCESSING] = false; - if (this[ENDED3] && !this[QUEUE2].length && this[JOBS] === 0) { + if (this[ENDED3] && this[QUEUE2].length === 0 && this[JOBS] === 0) { if (this.zip) { this.zip.end(EOF2); } else { @@ -19945,14 +20006,14 @@ var init_pack = __esm({ } }); -// .yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/create.js +// .yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/create.js var create_exports = {}; __export(create_exports, { create: () => create }); var import_node_path8, createFileSync, createFile, addFilesSync, addFilesAsync, createSync, createAsync, create; var init_create = __esm({ - ".yarn/cache/tar-npm-7.5.6-955ec951c2-08af380703.zip/node_modules/tar/dist/esm/create.js"() { + ".yarn/cache/tar-npm-7.5.13-3c09e37d51-5c65b80847.zip/node_modules/tar/dist/esm/create.js"() { init_esm2(); import_node_path8 = __toESM(require("node:path"), 1); init_list(); @@ -19977,7 +20038,7 @@ var init_create = __esm({ stream.on("close", res); p.on("error", rej); }); - addFilesAsync(p, files); + addFilesAsync(p, files).catch((er) => p.emit("error", er)); return promise; }; addFilesSync = (p, files) => { @@ -19996,8 +20057,7 @@ var init_create = __esm({ p.end(); }; addFilesAsync = async (p, files) => { - for (let i = 0; i < files.length; i++) { - const file = String(files[i]); + for (const file of files) { if (file.charAt(0) === "@") { await list({ file: import_node_path8.default.resolve(String(p.cwd), file.slice(1)), @@ -20019,7 +20079,7 @@ var init_create = __esm({ }; createAsync = (opt, files) => { const p = new Pack(opt); - addFilesAsync(p, files); + addFilesAsync(p, files).catch((er) => p.emit("error", er)); return p; }; create = makeCommand(createFileSync, createFile, createSync, createAsync, (_opt, files) => { @@ -20189,7 +20249,7 @@ function formatMarkdownish(text, { format, paragraphs }) { } // .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/options/utils.mjs -var isOptionSymbol = Symbol(`clipanion/isOption`); +var isOptionSymbol = /* @__PURE__ */ Symbol(`clipanion/isOption`); function makeCommandOption(spec) { return { ...spec, [isOptionSymbol]: true }; } @@ -20785,7 +20845,7 @@ var reducers = { return { ...state, errorMessage: `Not enough arguments to option ${lastOption.name}.` }; } }; -var NoLimits = Symbol(); +var NoLimits = /* @__PURE__ */ Symbol(); var CommandBuilder = class { constructor(cliIndex, cliOpts) { this.allOptionNames = []; @@ -21089,7 +21149,7 @@ var HelpCommand = class _HelpCommand extends Command { }; // .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/Cli.mjs -var errorCommandSymbol = Symbol(`clipanion/errorCommand`); +var errorCommandSymbol = /* @__PURE__ */ Symbol(`clipanion/errorCommand`); var Cli = class _Cli { constructor({ binaryLabel, binaryName: binaryNameOpt = `...`, binaryVersion, enableCapture = false, enableColors } = {}) { this.registrations = /* @__PURE__ */ new Map(); @@ -21703,7 +21763,7 @@ function String2(descriptor, ...args) { } // package.json -var version = "0.34.6"; +var version = "0.34.7"; // sources/Engine.ts var import_fs6 = __toESM(require("fs")); @@ -21717,7 +21777,7 @@ var import_valid4 = __toESM(require_valid2()); var config_default = { definitions: { npm: { - default: "11.8.0+sha1.d1bc924deb3b4d412055b1755098a70bf8a4713b", + default: "11.12.1+sha1.432da55a9f0ca53c982740fabe2b081a38019fb1", fetchLatestFrom: { type: "npm", package: "npm" @@ -21754,7 +21814,7 @@ var config_default = { } }, pnpm: { - default: "10.28.1+sha1.20817ab95fb7f61154ba5ff3bcb61f27defb6142", + default: "10.33.0+sha1.46a0bef28aad690765997ab6da6d5475bdd4148e", fetchLatestFrom: { type: "npm", package: "pnpm" @@ -21835,7 +21895,7 @@ var config_default = { package: "yarn" }, transparent: { - default: "4.12.0+sha224.877304a94a6946ab1d58a358df5ff8af2f7c9d86ea506f05f5c9df05", + default: "4.14.1+sha224.88b7a7244bbd9040380c417f7eb556d85c67640b651f113cb4c72113", commands: [ [ "yarn", @@ -22811,6 +22871,7 @@ var Engine = class { constructor(config = config_default) { this.config = config; } + config; getPackageManagerFor(binaryName) { for (const packageManager of SupportedPackageManagerSet) { for (const rangeDefinition of Object.values(this.config.definitions[packageManager].ranges)) { diff --git a/deps/corepack/package.json b/deps/corepack/package.json index ab39b1d2dd8e20..d800198cb7df0f 100644 --- a/deps/corepack/package.json +++ b/deps/corepack/package.json @@ -1,6 +1,6 @@ { "name": "corepack", - "version": "0.34.6", + "version": "0.34.7", "homepage": "https://github.com/nodejs/corepack#readme", "bugs": { "url": "https://github.com/nodejs/corepack/issues" @@ -29,15 +29,15 @@ "better-sqlite3": "^11.7.2", "clipanion": "patch:clipanion@npm%3A3.2.1#~/.yarn/patches/clipanion-npm-3.2.1-fc9187f56c.patch", "debug": "^4.1.1", - "esbuild": "^0.25.0", + "esbuild": "^0.27.0", "eslint": "^9.22.0", "proxy-from-env": "^1.1.0", "semver": "^7.6.3", "supports-color": "^10.0.0", - "tar": "^7.5.4", + "tar": "^7.5.11", "tsx": "^4.16.2", "typescript": "^5.7.3", - "undici": "^6.21.2", + "undici": "^6.24.0", "v8-compile-cache": "^2.3.0", "vitest": "^3.0.5", "which": "^5.0.0" From 1f9636ad7b11ef48c690be8b866e2cc4e645a626 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Wed, 29 Apr 2026 09:00:30 +0000 Subject: [PATCH 010/168] tools: bump the eslint group in /tools/eslint with 4 updates Bumps the eslint group in /tools/eslint with 4 updates: [@eslint/markdown](https://github.com/eslint/markdown), [eslint](https://github.com/eslint/eslint), [eslint-plugin-jsdoc](https://github.com/gajus/eslint-plugin-jsdoc) and [globals](https://github.com/sindresorhus/globals). Updates `@eslint/markdown` from 8.0.0 to 8.0.1 - [Release notes](https://github.com/eslint/markdown/releases) - [Changelog](https://github.com/eslint/markdown/blob/main/CHANGELOG.md) - [Commits](https://github.com/eslint/markdown/compare/v8.0.0...v8.0.1) Updates `eslint` from 10.1.0 to 10.2.0 - [Release notes](https://github.com/eslint/eslint/releases) - [Commits](https://github.com/eslint/eslint/compare/v10.1.0...v10.2.0) Updates `eslint-plugin-jsdoc` from 62.8.1 to 62.9.0 - [Release notes](https://github.com/gajus/eslint-plugin-jsdoc/releases) - [Commits](https://github.com/gajus/eslint-plugin-jsdoc/compare/v62.8.1...v62.9.0) Updates `globals` from 17.4.0 to 17.5.0 - [Release notes](https://github.com/sindresorhus/globals/releases) - [Commits](https://github.com/sindresorhus/globals/compare/v17.4.0...v17.5.0) --- updated-dependencies: - dependency-name: "@eslint/markdown" dependency-version: 8.0.1 dependency-type: direct:production update-type: version-update:semver-patch dependency-group: eslint - dependency-name: eslint dependency-version: 10.2.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: eslint - dependency-name: eslint-plugin-jsdoc dependency-version: 62.9.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: eslint - dependency-name: globals dependency-version: 17.5.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: eslint ... Signed-off-by: dependabot[bot] PR-URL: https://github.com/nodejs/node/pull/62848 Reviewed-By: Antoine du Hamel --- tools/eslint/package-lock.json | 131 ++++++++++++++++++--------------- tools/eslint/package.json | 8 +- 2 files changed, 76 insertions(+), 63 deletions(-) diff --git a/tools/eslint/package-lock.json b/tools/eslint/package-lock.json index 7455b3b9e3c3fe..773eb74fd03f80 100644 --- a/tools/eslint/package-lock.json +++ b/tools/eslint/package-lock.json @@ -12,13 +12,13 @@ "@babel/eslint-parser": "^8.0.0-rc.3", "@babel/plugin-syntax-import-source": "^8.0.0-rc.3", "@eslint/js": "^10.0.1", - "@eslint/markdown": "^8.0.0", + "@eslint/markdown": "^8.0.1", "@stylistic/eslint-plugin": "^5.10.0", - "eslint": "^10.1.0", + "eslint": "^10.2.0", "eslint-formatter-tap": "^9.0.1", - "eslint-plugin-jsdoc": "^62.8.1", + "eslint-plugin-jsdoc": "^62.9.0", "eslint-plugin-regexp": "^3.1.0", - "globals": "^17.4.0" + "globals": "^17.5.0" } }, "node_modules/@babel/code-frame": { @@ -270,16 +270,16 @@ } }, "node_modules/@es-joy/jsdoccomment": { - "version": "0.84.0", - "resolved": "https://registry.npmjs.org/@es-joy/jsdoccomment/-/jsdoccomment-0.84.0.tgz", - "integrity": "sha512-0xew1CxOam0gV5OMjh2KjFQZsKL2bByX1+q4j3E73MpYIdyUxcZb/xQct9ccUb+ve5KGUYbCUxyPnYB7RbuP+w==", + "version": "0.86.0", + "resolved": "https://registry.npmjs.org/@es-joy/jsdoccomment/-/jsdoccomment-0.86.0.tgz", + "integrity": "sha512-ukZmRQ81WiTpDWO6D/cTBM7XbrNtutHKvAVnZN/8pldAwLoJArGOvkNyxPTBGsPjsoaQBJxlH+tE2TNA/92Qgw==", "license": "MIT", "dependencies": { "@types/estree": "^1.0.8", - "@typescript-eslint/types": "^8.54.0", - "comment-parser": "1.4.5", + "@typescript-eslint/types": "^8.58.0", + "comment-parser": "1.4.6", "esquery": "^1.7.0", - "jsdoc-type-pratt-parser": "~7.1.1" + "jsdoc-type-pratt-parser": "~7.2.0" }, "engines": { "node": "^20.19.0 || ^22.13.0 || >=24" @@ -334,12 +334,12 @@ } }, "node_modules/@eslint/config-array": { - "version": "0.23.3", - "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.23.3.tgz", - "integrity": "sha512-j+eEWmB6YYLwcNOdlwQ6L2OsptI/LO6lNBuLIqe5R7RetD658HLoF+Mn7LzYmAWWNNzdC6cqP+L6r8ujeYXWLw==", + "version": "0.23.5", + "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.23.5.tgz", + "integrity": "sha512-Y3kKLvC1dvTOT+oGlqNQ1XLqK6D1HU2YXPc52NmAlJZbMMWDzGYXMiPRJ8TYD39muD/OTjlZmNJ4ib7dvSrMBA==", "license": "Apache-2.0", "dependencies": { - "@eslint/object-schema": "^3.0.3", + "@eslint/object-schema": "^3.0.5", "debug": "^4.3.1", "minimatch": "^10.2.4" }, @@ -348,21 +348,21 @@ } }, "node_modules/@eslint/config-helpers": { - "version": "0.5.3", - "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.5.3.tgz", - "integrity": "sha512-lzGN0onllOZCGroKJmRwY6QcEHxbjBw1gwB8SgRSqK8YbbtEXMvKynsXc3553ckIEBxsbMBU7oOZXKIPGZNeZw==", + "version": "0.5.5", + "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.5.5.tgz", + "integrity": "sha512-eIJYKTCECbP/nsKaaruF6LW967mtbQbsw4JTtSVkUQc9MneSkbrgPJAbKl9nWr0ZeowV8BfsarBmPpBzGelA2w==", "license": "Apache-2.0", "dependencies": { - "@eslint/core": "^1.1.1" + "@eslint/core": "^1.2.1" }, "engines": { "node": "^20.19.0 || ^22.13.0 || >=24" } }, "node_modules/@eslint/core": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/@eslint/core/-/core-1.1.1.tgz", - "integrity": "sha512-QUPblTtE51/7/Zhfv8BDwO0qkkzQL7P/aWWbqcf4xWLEYn1oKjdO0gglQBB4GAsu7u6wjijbCmzsUTy6mnk6oQ==", + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/@eslint/core/-/core-1.2.1.tgz", + "integrity": "sha512-MwcE1P+AZ4C6DWlpin/OmOA54mmIZ/+xZuJiQd4SyB29oAJjN30UW9wkKNptW2ctp4cEsvhlLY/CsQ1uoHDloQ==", "license": "Apache-2.0", "dependencies": { "@types/json-schema": "^7.0.15" @@ -392,9 +392,9 @@ } }, "node_modules/@eslint/markdown": { - "version": "8.0.0", - "resolved": "https://registry.npmjs.org/@eslint/markdown/-/markdown-8.0.0.tgz", - "integrity": "sha512-Rh3+76uHdnkk/ocLMZfWHXoPA/MK+GOqqjCAioiyNk2eYBC8UniRHdTMbM+2XZqTLWAcQo/SuU1CsXtdIOTX1g==", + "version": "8.0.1", + "resolved": "https://registry.npmjs.org/@eslint/markdown/-/markdown-8.0.1.tgz", + "integrity": "sha512-WWKmld/EyNdEB8GMq7JMPX1SDWgyJAM1uhtCi5ySrqYQM4HQjmg11EX/q3ZpnpRXHfdccFtli3NBvvGaYjWyQw==", "license": "MIT", "workspaces": [ "examples/*" @@ -417,9 +417,9 @@ } }, "node_modules/@eslint/object-schema": { - "version": "3.0.3", - "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-3.0.3.tgz", - "integrity": "sha512-iM869Pugn9Nsxbh/YHRqYiqd23AmIbxJOcpUMOuWCVNdoQJ5ZtwL6h3t0bcZzJUlC3Dq9jCFCESBZnX0GTv7iQ==", + "version": "3.0.5", + "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-3.0.5.tgz", + "integrity": "sha512-vqTaUEgxzm+YDSdElad6PiRoX4t8VGDjCtt05zn4nU810UIx/uNEV7/lZJ6KwFThKZOzOxzXy48da+No7HZaMw==", "license": "Apache-2.0", "engines": { "node": "^20.19.0 || ^22.13.0 || >=24" @@ -651,9 +651,9 @@ "license": "MIT" }, "node_modules/@typescript-eslint/types": { - "version": "8.56.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.56.0.tgz", - "integrity": "sha512-DBsLPs3GsWhX5HylbP9HNG15U0bnwut55Lx12bHB9MpXxQ+R5GC8MwQe+N1UFXxAeQDvEsEDY6ZYwX03K7Z6HQ==", + "version": "8.59.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.59.0.tgz", + "integrity": "sha512-nLzdsT1gdOgFxxxwrlNVUBzSNBEEHJ86bblmk4QAS6stfig7rcJzWKqCyxFy3YRRHXDWEkb2NralA1nOYkkm/A==", "license": "MIT", "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" @@ -831,9 +831,9 @@ } }, "node_modules/comment-parser": { - "version": "1.4.5", - "resolved": "https://registry.npmjs.org/comment-parser/-/comment-parser-1.4.5.tgz", - "integrity": "sha512-aRDkn3uyIlCFfk5NUA+VdwMmMsh8JGhc4hapfV4yxymHGQ3BVskMQfoXGpCo5IoBuQ9tS5iiVKhCpTcB4pW4qw==", + "version": "1.4.6", + "resolved": "https://registry.npmjs.org/comment-parser/-/comment-parser-1.4.6.tgz", + "integrity": "sha512-ObxuY6vnbWTN6Od72xfwN9DbzC7Y2vv8u1Soi9ahRKL37gb6y1qk6/dgjs+3JWuXJHWvsg3BXIwzd/rkmAwavg==", "license": "MIT", "engines": { "node": ">= 12.0.0" @@ -945,17 +945,17 @@ } }, "node_modules/eslint": { - "version": "10.1.0", - "resolved": "https://registry.npmjs.org/eslint/-/eslint-10.1.0.tgz", - "integrity": "sha512-S9jlY/ELKEUwwQnqWDO+f+m6sercqOPSqXM5Go94l7DOmxHVDgmSFGWEzeE/gwgTAr0W103BWt0QLe/7mabIvA==", + "version": "10.2.0", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-10.2.0.tgz", + "integrity": "sha512-+L0vBFYGIpSNIt/KWTpFonPrqYvgKw1eUI5Vn7mEogrQcWtWYtNQ7dNqC+px/J0idT3BAkiWrhfS7k+Tum8TUA==", "license": "MIT", "dependencies": { "@eslint-community/eslint-utils": "^4.8.0", "@eslint-community/regexpp": "^4.12.2", - "@eslint/config-array": "^0.23.3", - "@eslint/config-helpers": "^0.5.3", - "@eslint/core": "^1.1.1", - "@eslint/plugin-kit": "^0.6.1", + "@eslint/config-array": "^0.23.4", + "@eslint/config-helpers": "^0.5.4", + "@eslint/core": "^1.2.0", + "@eslint/plugin-kit": "^0.7.0", "@humanfs/node": "^0.16.6", "@humanwhocodes/module-importer": "^1.0.1", "@humanwhocodes/retry": "^0.4.2", @@ -1012,18 +1012,18 @@ } }, "node_modules/eslint-plugin-jsdoc": { - "version": "62.8.1", - "resolved": "https://registry.npmjs.org/eslint-plugin-jsdoc/-/eslint-plugin-jsdoc-62.8.1.tgz", - "integrity": "sha512-e9358PdHgvcMF98foNd3L7hVCw70Lt+YcSL7JzlJebB8eT5oRJtW6bHMQKoAwJtw6q0q0w/fRIr2kwnHdFDI6A==", + "version": "62.9.0", + "resolved": "https://registry.npmjs.org/eslint-plugin-jsdoc/-/eslint-plugin-jsdoc-62.9.0.tgz", + "integrity": "sha512-PY7/X4jrVgoIDncUmITlUqK546Ltmx/Pd4Hdsu4CvSjryQZJI2mEV4vrdMufyTetMiZ5taNSqvK//BTgVUlNkA==", "license": "BSD-3-Clause", "dependencies": { - "@es-joy/jsdoccomment": "~0.84.0", + "@es-joy/jsdoccomment": "~0.86.0", "@es-joy/resolve.exports": "1.2.0", "are-docs-informative": "^0.0.2", - "comment-parser": "1.4.5", + "comment-parser": "1.4.6", "debug": "^4.4.3", "escape-string-regexp": "^4.0.0", - "espree": "^11.1.0", + "espree": "^11.2.0", "esquery": "^1.7.0", "html-entities": "^2.6.0", "object-deep-merge": "^2.0.0", @@ -1040,9 +1040,9 @@ } }, "node_modules/eslint-plugin-jsdoc/node_modules/espree": { - "version": "11.1.1", - "resolved": "https://registry.npmjs.org/espree/-/espree-11.1.1.tgz", - "integrity": "sha512-AVHPqQoZYc+RUM4/3Ly5udlZY/U4LS8pIG05jEjWM2lQMU/oaZ7qshzAl2YP1tfNmXfftH3ohurfwNAug+MnsQ==", + "version": "11.2.0", + "resolved": "https://registry.npmjs.org/espree/-/espree-11.2.0.tgz", + "integrity": "sha512-7p3DrVEIopW1B1avAGLuCSh1jubc01H2JHc8B4qqGblmg5gI9yumBgACjWo4JlIc04ufug4xJ3SQI8HkS/Rgzw==", "license": "BSD-2-Clause", "dependencies": { "acorn": "^8.16.0", @@ -1107,6 +1107,19 @@ "url": "https://opencollective.com/eslint" } }, + "node_modules/eslint/node_modules/@eslint/plugin-kit": { + "version": "0.7.1", + "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.7.1.tgz", + "integrity": "sha512-rZAP3aVgB9ds9KOeUSL+zZ21hPmo8dh6fnIFwRQj5EAZl9gzR7wxYbYXYysAM8CTqGmUGyp2S4kUdV17MnGuWQ==", + "license": "Apache-2.0", + "dependencies": { + "@eslint/core": "^1.2.1", + "levn": "^0.4.1" + }, + "engines": { + "node": "^20.19.0 || ^22.13.0 || >=24" + } + }, "node_modules/eslint/node_modules/espree": { "version": "11.2.0", "resolved": "https://registry.npmjs.org/espree/-/espree-11.2.0.tgz", @@ -1309,9 +1322,9 @@ } }, "node_modules/globals": { - "version": "17.4.0", - "resolved": "https://registry.npmjs.org/globals/-/globals-17.4.0.tgz", - "integrity": "sha512-hjrNztw/VajQwOLsMNT1cbJiH2muO3OROCHnbehc8eY5JyD2gqz4AcMHPqgaOR59DjgUjYAYLeH699g/eWi2jw==", + "version": "17.5.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-17.5.0.tgz", + "integrity": "sha512-qoV+HK2yFl/366t2/Cb3+xxPUo5BuMynomoDmiaZBIdbs+0pYbjfZU+twLhGKp4uCZ/+NbtpVepH5bGCxRyy2g==", "license": "MIT", "engines": { "node": ">=18" @@ -1410,9 +1423,9 @@ } }, "node_modules/jsdoc-type-pratt-parser": { - "version": "7.1.1", - "resolved": "https://registry.npmjs.org/jsdoc-type-pratt-parser/-/jsdoc-type-pratt-parser-7.1.1.tgz", - "integrity": "sha512-/2uqY7x6bsrpi3i9LVU6J89352C0rpMk0as8trXxCtvd4kPk1ke/Eyif6wqfSLvoNJqcDG9Vk4UsXgygzCt2xA==", + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/jsdoc-type-pratt-parser/-/jsdoc-type-pratt-parser-7.2.0.tgz", + "integrity": "sha512-dh140MMgjyg3JhJZY/+iEzW+NO5xR2gpbDFKHqotCmexElVntw7GjWjt511+C/Ef02RU5TKYrJo/Xlzk+OLaTw==", "license": "MIT", "engines": { "node": ">=20.0.0" @@ -2391,12 +2404,12 @@ "license": "MIT" }, "node_modules/minimatch": { - "version": "10.2.4", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.4.tgz", - "integrity": "sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==", + "version": "10.2.5", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.5.tgz", + "integrity": "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==", "license": "BlueOak-1.0.0", "dependencies": { - "brace-expansion": "^5.0.2" + "brace-expansion": "^5.0.5" }, "engines": { "node": "18 || 20 || >=22" diff --git a/tools/eslint/package.json b/tools/eslint/package.json index 216fdef8415a1d..a6cb40841b6d67 100644 --- a/tools/eslint/package.json +++ b/tools/eslint/package.json @@ -7,12 +7,12 @@ "@babel/eslint-parser": "^8.0.0-rc.3", "@babel/plugin-syntax-import-source": "^8.0.0-rc.3", "@eslint/js": "^10.0.1", - "@eslint/markdown": "^8.0.0", + "@eslint/markdown": "^8.0.1", "@stylistic/eslint-plugin": "^5.10.0", - "eslint": "^10.1.0", + "eslint": "^10.2.0", "eslint-formatter-tap": "^9.0.1", - "eslint-plugin-jsdoc": "^62.8.1", + "eslint-plugin-jsdoc": "^62.9.0", "eslint-plugin-regexp": "^3.1.0", - "globals": "^17.4.0" + "globals": "^17.5.0" } } From 61db2609e3c45affbe6170b8b3b6014002c8fca1 Mon Sep 17 00:00:00 2001 From: Matteo Collina Date: Wed, 29 Apr 2026 13:13:47 +0200 Subject: [PATCH 011/168] ffi: support Symbol.dispose on DynamicLibrary Install [Symbol.dispose]() on DynamicLibrary.prototype (calling close()) and on the object returned from ffi.dlopen(), so both can be used with the `using` declaration for automatic cleanup. Signed-off-by: Matteo Collina PR-URL: https://github.com/nodejs/node/pull/62925 Reviewed-By: Bryan English Reviewed-By: Paolo Insogna Reviewed-By: Anna Henningsen --- doc/api/ffi.md | 41 +++++++++++++++++++ lib/ffi.js | 11 +++++- test/ffi/test-ffi-dynamic-library.js | 59 ++++++++++++++++++++++++++++ 3 files changed, 110 insertions(+), 1 deletion(-) diff --git a/doc/api/ffi.md b/doc/api/ffi.md index 28ca2f9dd1427d..930ad70afc0155 100644 --- a/doc/api/ffi.md +++ b/doc/api/ffi.md @@ -182,6 +182,21 @@ The returned object contains: * `lib` {DynamicLibrary} The loaded library handle. * `functions` {Object} Callable wrappers for the requested symbols. +The returned object also implements the explicit resource management protocol, +so it can be used with the [`using`][] declaration. Disposing the returned +object closes the library handle. + +```mjs +import { dlopen } from 'node:ffi'; + +{ + using handle = dlopen('./mylib.so', { + add_i32: { parameters: ['i32', 'i32'], result: 'i32' }, + }); + console.log(handle.functions.add_i32(20, 22)); +} // handle.lib.close() is invoked automatically here. +``` + ```mjs import { dlopen } from 'node:ffi'; @@ -275,6 +290,21 @@ An object containing previously resolved symbol addresses as `bigint` values. Closes the library handle. +`DynamicLibrary` implements the explicit resource management protocol, so a +library instance can be managed with the [`using`][] declaration. Leaving the +enclosing scope invokes `library.close()` automatically. + +```mjs +import { DynamicLibrary } from 'node:ffi'; + +{ + using lib = new DynamicLibrary('./mylib.so'); + // Use `lib` here; `lib.close()` is called when the block exits. +} +``` + +Calling `library.close()` (or disposing the library) more than once is a no-op. + After a library has been closed: * Resolved function wrappers become invalid. @@ -295,6 +325,16 @@ Calling `library.close()` from one of the library's active callbacks is unsupported and dangerous. The callback must return before the library is closed. +### `library[Symbol.dispose]()` + + + +Calls `library.close()`. This allows `DynamicLibrary` instances to be used with +the [`using`][] declaration for automatic cleanup when the enclosing scope +exits. It is a no-op on a library that has already been closed. + ### `library.getFunction(name, signature)` * `name` {string} @@ -684,3 +724,4 @@ and keep callback and pointer lifetimes explicit on the native side. [Permission Model]: permissions.md#permission-model [`--allow-ffi`]: cli.md#--allow-ffi [`ffi.toBuffer(pointer, length, copy)`]: #ffitobufferpointer-length-copy +[`using`]: https://tc39.es/proposal-explicit-resource-management/#sec-using-declarations diff --git a/lib/ffi.js b/lib/ffi.js index 44aff307ad0f32..98af095e0cb01c 100644 --- a/lib/ffi.js +++ b/lib/ffi.js @@ -3,6 +3,7 @@ const { ObjectFreeze, ObjectPrototypeToString, + SymbolDispose, } = primordials; const { Buffer } = require('buffer'); const { emitExperimentalWarning } = require('internal/util'); @@ -55,6 +56,10 @@ const { require('internal/ffi-shared-buffer'); +DynamicLibrary.prototype[SymbolDispose] = function() { + this.close(); +}; + function checkFFIPermission() { if (!permission.isEnabled() || permission.has('ffi')) { return; @@ -71,7 +76,11 @@ function dlopen(path, definitions) { const lib = new DynamicLibrary(path); try { const functions = definitions === undefined ? ObjectFreeze({ __proto__: null }) : lib.getFunctions(definitions); - return { lib, functions }; + return { + lib, + functions, + [SymbolDispose]() { lib.close(); }, + }; } catch (error) { lib.close(); throw error; diff --git a/test/ffi/test-ffi-dynamic-library.js b/test/ffi/test-ffi-dynamic-library.js index ec67e4f34c40be..a80fe5286afab9 100644 --- a/test/ffi/test-ffi-dynamic-library.js +++ b/test/ffi/test-ffi-dynamic-library.js @@ -129,6 +129,65 @@ test('closed libraries reject subsequent operations', () => { assert.throws(() => lib.getSymbol('add_i32'), /Library is closed/); }); +test('DynamicLibrary supports Symbol.dispose', () => { + const lib = new ffi.DynamicLibrary(libraryPath); + const addI32 = lib.getFunction('add_i32', fixtureSymbols.add_i32); + + assert.strictEqual(typeof lib[Symbol.dispose], 'function'); + assert.strictEqual(addI32(20, 22), 42); + + lib[Symbol.dispose](); + + assert.throws(() => addI32(1, 2), /Library is closed/); + assert.throws(() => lib.getSymbol('add_i32'), /Library is closed/); + + // Disposing twice is a no-op. + lib[Symbol.dispose](); + lib.close(); +}); + +test('using declaration closes DynamicLibrary on scope exit', () => { + let captured; + { + using lib = new ffi.DynamicLibrary(libraryPath); + captured = lib.getFunction('add_i32', fixtureSymbols.add_i32); + assert.strictEqual(captured(20, 22), 42); + } + + assert.throws(() => captured(1, 2), /Library is closed/); +}); + +test('dlopen return value is disposable', () => { + let capturedLib; + let capturedFn; + { + using handle = ffi.dlopen(libraryPath, { + add_i32: fixtureSymbols.add_i32, + }); + assert.strictEqual(typeof handle[Symbol.dispose], 'function'); + capturedLib = handle.lib; + capturedFn = handle.functions.add_i32; + assert.strictEqual(capturedFn(20, 22), 42); + } + + assert.throws(() => capturedFn(1, 2), /Library is closed/); + assert.throws(() => capturedLib.getSymbol('add_i32'), /Library is closed/); +}); + +test('using still disposes DynamicLibrary when block throws', () => { + const sentinel = new Error('boom'); + let captured; + + assert.throws(() => { + using lib = new ffi.DynamicLibrary(libraryPath); + captured = lib.getFunction('add_i32', fixtureSymbols.add_i32); + assert.strictEqual(captured(20, 22), 42); + throw sentinel; + }, sentinel); + + assert.throws(() => captured(1, 2), /Library is closed/); +}); + test('dynamic library APIs validate failures and bad signatures', () => { assert.throws(() => { ffi.dlopen('missing-library-for-ffi-tests.so'); From 5320a1b96f4820e53c33dccb3019c14cf7260af3 Mon Sep 17 00:00:00 2001 From: "Node.js GitHub Bot" Date: Sun, 26 Apr 2026 01:03:53 +0000 Subject: [PATCH 012/168] deps: update nghttp2 to 1.69.0 PR-URL: https://github.com/nodejs/node/pull/62891 Reviewed-By: Luigi Pinca Reviewed-By: Stephen Belanger Reviewed-By: Antoine du Hamel --- deps/nghttp2/lib/CMakeLists.txt | 2 +- deps/nghttp2/lib/includes/nghttp2/nghttp2.h | 2 +- .../nghttp2/lib/includes/nghttp2/nghttp2ver.h | 4 +- deps/nghttp2/lib/nghttp2_alpn.c | 4 +- deps/nghttp2/lib/nghttp2_frame.c | 10 + deps/nghttp2/lib/nghttp2_frame.h | 3 - deps/nghttp2/lib/nghttp2_hd.c | 17 +- deps/nghttp2/lib/nghttp2_hd_huffman.c | 23 +- deps/nghttp2/lib/nghttp2_hd_huffman.h | 14 +- deps/nghttp2/lib/nghttp2_hd_huffman_data.c | 8224 ++++++++--------- deps/nghttp2/lib/nghttp2_helper.h | 10 +- deps/nghttp2/lib/nghttp2_http.c | 3 +- deps/nghttp2/lib/nghttp2_int.h | 7 +- deps/nghttp2/lib/nghttp2_map.c | 267 +- deps/nghttp2/lib/nghttp2_map.h | 17 +- deps/nghttp2/lib/nghttp2_outbound_item.c | 12 + deps/nghttp2/lib/nghttp2_outbound_item.h | 16 +- deps/nghttp2/lib/nghttp2_session.c | 236 +- deps/nghttp2/lib/nghttp2_session.h | 4 +- deps/nghttp2/lib/nghttp2_submit.c | 6 +- 20 files changed, 4558 insertions(+), 4323 deletions(-) diff --git a/deps/nghttp2/lib/CMakeLists.txt b/deps/nghttp2/lib/CMakeLists.txt index 98e3dbe7682fb0..3b6a4400305b31 100644 --- a/deps/nghttp2/lib/CMakeLists.txt +++ b/deps/nghttp2/lib/CMakeLists.txt @@ -51,7 +51,7 @@ set(NGHTTP2_GENERATED_DIR "${CMAKE_CURRENT_BINARY_DIR}/generated") set(NGHTTP2_VERSION_CONFIG "${NGHTTP2_GENERATED_DIR}/${PROJECT_NAME}ConfigVersion.cmake") set(NGHTTP2_PROJECT_CONFIG "${NGHTTP2_GENERATED_DIR}/${PROJECT_NAME}Config.cmake") set(NGHTTP2_TARGETS_EXPORT_NAME "${PROJECT_NAME}Targets") -set(NGHTTP2_CONFIG_INSTALL_DIR "lib/cmake/${PROJECT_NAME}") +set(NGHTTP2_CONFIG_INSTALL_DIR "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}") set(NGHTTP2_NAMESPACE "${PROJECT_NAME}::") set(NGHTTP2_VERSION ${PROJECT_VERSION}) diff --git a/deps/nghttp2/lib/includes/nghttp2/nghttp2.h b/deps/nghttp2/lib/includes/nghttp2/nghttp2.h index 19c1874f23a3ca..55baba71bdaf26 100644 --- a/deps/nghttp2/lib/includes/nghttp2/nghttp2.h +++ b/deps/nghttp2/lib/includes/nghttp2/nghttp2.h @@ -3252,7 +3252,7 @@ NGHTTP2_EXTERN void nghttp2_option_set_max_continuations(nghttp2_option *option, * regenerated per second. When a suspicious activity is detected, * some amount of tokens are consumed. If there is no token * available, GOAWAY is sent to tear down the connection. |burst| and - * |rate| default to 1000 and 33 respectively. + * |rate| default to 10000 and 330 respectively. */ NGHTTP2_EXTERN void nghttp2_option_set_glitch_rate_limit(nghttp2_option *option, uint64_t burst, diff --git a/deps/nghttp2/lib/includes/nghttp2/nghttp2ver.h b/deps/nghttp2/lib/includes/nghttp2/nghttp2ver.h index 8dfe536dec9ade..83fabdeeb95d6e 100644 --- a/deps/nghttp2/lib/includes/nghttp2/nghttp2ver.h +++ b/deps/nghttp2/lib/includes/nghttp2/nghttp2ver.h @@ -29,7 +29,7 @@ * @macro * Version number of the nghttp2 library release */ -#define NGHTTP2_VERSION "1.68.0" +#define NGHTTP2_VERSION "1.69.0" /** * @macro @@ -37,6 +37,6 @@ * release. This is a 24 bit number with 8 bits for major number, 8 bits * for minor and 8 bits for patch. Version 1.2.3 becomes 0x010203. */ -#define NGHTTP2_VERSION_NUM 0x014400 +#define NGHTTP2_VERSION_NUM 0x014500 #endif /* NGHTTP2VER_H */ diff --git a/deps/nghttp2/lib/nghttp2_alpn.c b/deps/nghttp2/lib/nghttp2_alpn.c index 33c5885f8d889f..025bd346594c65 100644 --- a/deps/nghttp2/lib/nghttp2_alpn.c +++ b/deps/nghttp2/lib/nghttp2_alpn.c @@ -26,6 +26,8 @@ #include +#include "nghttp2_helper.h" + static int select_alpn(const unsigned char **out, unsigned char *outlen, const unsigned char *in, unsigned int inlen, const char *key, unsigned int keylen) { @@ -41,7 +43,7 @@ static int select_alpn(const unsigned char **out, unsigned char *outlen, } #define NGHTTP2_HTTP_1_1_ALPN "\x8http/1.1" -#define NGHTTP2_HTTP_1_1_ALPN_LEN (sizeof(NGHTTP2_HTTP_1_1_ALPN) - 1) +#define NGHTTP2_HTTP_1_1_ALPN_LEN nghttp2_strlen_lit(NGHTTP2_HTTP_1_1_ALPN) int nghttp2_select_next_protocol(unsigned char **out, unsigned char *outlen, const unsigned char *in, unsigned int inlen) { diff --git a/deps/nghttp2/lib/nghttp2_frame.c b/deps/nghttp2/lib/nghttp2_frame.c index edc2aaaae9ed75..264ae9d38e0260 100644 --- a/deps/nghttp2/lib/nghttp2_frame.c +++ b/deps/nghttp2/lib/nghttp2_frame.c @@ -750,6 +750,16 @@ void nghttp2_frame_unpack_altsvc_payload(nghttp2_extension *frame, uint8_t *p; altsvc = frame->payload; + + if (payloadlen == 0) { + altsvc->origin = NULL; + altsvc->origin_len = 0; + altsvc->field_value = NULL; + altsvc->field_value_len = 0; + + return; + } + p = payload; altsvc->origin = p; diff --git a/deps/nghttp2/lib/nghttp2_frame.h b/deps/nghttp2/lib/nghttp2_frame.h index ed4ab2c6842e71..c0917c0df4cc9f 100644 --- a/deps/nghttp2/lib/nghttp2_frame.h +++ b/deps/nghttp2/lib/nghttp2_frame.h @@ -34,10 +34,7 @@ #include "nghttp2_buf.h" #define NGHTTP2_STREAM_ID_MASK ((1u << 31) - 1) -#define NGHTTP2_PRI_GROUP_ID_MASK ((1u << 31) - 1) -#define NGHTTP2_PRIORITY_MASK ((1u << 31) - 1) #define NGHTTP2_WINDOW_SIZE_INCREMENT_MASK ((1u << 31) - 1) -#define NGHTTP2_SETTINGS_ID_MASK ((1 << 24) - 1) /* The number of bytes of frame header. */ #define NGHTTP2_FRAME_HDLEN 9 diff --git a/deps/nghttp2/lib/nghttp2_hd.c b/deps/nghttp2/lib/nghttp2_hd.c index ad85eed1e13e7b..5ac77dbc0ea554 100644 --- a/deps/nghttp2/lib/nghttp2_hd.c +++ b/deps/nghttp2/lib/nghttp2_hd.c @@ -35,9 +35,10 @@ /* Make scalar initialization form of nghttp2_hd_entry */ #define MAKE_STATIC_ENT(N, V, T, H) \ { \ - {NULL, NULL, (uint8_t *)(N), sizeof((N)) - 1, -1}, \ - {NULL, NULL, (uint8_t *)(V), sizeof((V)) - 1, -1}, \ - {(uint8_t *)(N), (uint8_t *)(V), sizeof((N)) - 1, sizeof((V)) - 1, 0}, \ + {NULL, NULL, (uint8_t *)(N), nghttp2_strlen_lit((N)), -1}, \ + {NULL, NULL, (uint8_t *)(V), nghttp2_strlen_lit((V)), -1}, \ + {(uint8_t *)(N), (uint8_t *)(V), nghttp2_strlen_lit((N)), \ + nghttp2_strlen_lit((V)), 0}, \ T, \ H, \ } @@ -2058,8 +2059,9 @@ nghttp2_ssize nghttp2_hd_inflate_hd_nv(nghttp2_hd_inflater *inflater, inflater->state = NGHTTP2_HD_STATE_NEWNAME_READ_NAMEHUFF; - rv = - nghttp2_rcbuf_new(&inflater->namercbuf, inflater->left * 2 + 1, mem); + rv = nghttp2_rcbuf_new( + &inflater->namercbuf, + nghttp2_huff_estimate_decode_length(inflater->left) + 1, mem); } else { inflater->state = NGHTTP2_HD_STATE_NEWNAME_READ_NAME; rv = nghttp2_rcbuf_new(&inflater->namercbuf, inflater->left + 1, mem); @@ -2143,8 +2145,9 @@ nghttp2_ssize nghttp2_hd_inflate_hd_nv(nghttp2_hd_inflater *inflater, inflater->state = NGHTTP2_HD_STATE_READ_VALUEHUFF; - rv = - nghttp2_rcbuf_new(&inflater->valuercbuf, inflater->left * 2 + 1, mem); + rv = nghttp2_rcbuf_new( + &inflater->valuercbuf, + nghttp2_huff_estimate_decode_length(inflater->left) + 1, mem); } else { inflater->state = NGHTTP2_HD_STATE_READ_VALUE; diff --git a/deps/nghttp2/lib/nghttp2_hd_huffman.c b/deps/nghttp2/lib/nghttp2_hd_huffman.c index de2620076a6e0d..45672655f08762 100644 --- a/deps/nghttp2/lib/nghttp2_hd_huffman.c +++ b/deps/nghttp2/lib/nghttp2_hd_huffman.c @@ -104,15 +104,15 @@ int nghttp2_hd_huff_encode(nghttp2_bufs *bufs, const uint8_t *src, } void nghttp2_hd_huff_decode_context_init(nghttp2_hd_huff_decode_context *ctx) { - ctx->fstate = NGHTTP2_HUFF_ACCEPTED; + ctx->fstate = 0; + ctx->flags = NGHTTP2_HUFF_ACCEPTED; } nghttp2_ssize nghttp2_hd_huff_decode(nghttp2_hd_huff_decode_context *ctx, nghttp2_buf *buf, const uint8_t *src, size_t srclen, int final) { const uint8_t *end = src + srclen; - nghttp2_huff_decode node = {ctx->fstate, 0}; - const nghttp2_huff_decode *t = &node; + nghttp2_huff_decode t = {ctx->fstate, ctx->flags, 0}; uint8_t c; /* We use the decoding algorithm described in @@ -121,20 +121,21 @@ nghttp2_ssize nghttp2_hd_huff_decode(nghttp2_hd_huff_decode_context *ctx, - https://github.com/nghttp2/nghttp2/files/15141264/Prefix.pdf */ for (; src != end;) { c = *src++; - t = &huff_decode_table[t->fstate & 0x1ff][c >> 4]; - if (t->fstate & NGHTTP2_HUFF_SYM) { - *buf->last++ = t->sym; + t = huff_decode_table[t.fstate][c >> 4]; + if (t.flags & NGHTTP2_HUFF_SYM) { + *buf->last++ = t.sym; } - t = &huff_decode_table[t->fstate & 0x1ff][c & 0xf]; - if (t->fstate & NGHTTP2_HUFF_SYM) { - *buf->last++ = t->sym; + t = huff_decode_table[t.fstate][c & 0xf]; + if (t.flags & NGHTTP2_HUFF_SYM) { + *buf->last++ = t.sym; } } - ctx->fstate = t->fstate; + ctx->fstate = t.fstate; + ctx->flags = t.flags; - if (final && !(ctx->fstate & NGHTTP2_HUFF_ACCEPTED)) { + if (final && !(ctx->flags & NGHTTP2_HUFF_ACCEPTED)) { return NGHTTP2_ERR_HEADER_COMP; } diff --git a/deps/nghttp2/lib/nghttp2_hd_huffman.h b/deps/nghttp2/lib/nghttp2_hd_huffman.h index df037a8b20efc3..f898c1779c01c6 100644 --- a/deps/nghttp2/lib/nghttp2_hd_huffman.h +++ b/deps/nghttp2/lib/nghttp2_hd_huffman.h @@ -34,9 +34,9 @@ typedef enum { /* FSA accepts this state as the end of huffman encoding sequence. */ - NGHTTP2_HUFF_ACCEPTED = 1 << 14, + NGHTTP2_HUFF_ACCEPTED = 1, /* This state emits symbol */ - NGHTTP2_HUFF_SYM = 1 << 15, + NGHTTP2_HUFF_SYM = 1 << 1, } nghttp2_huff_decode_flag; typedef struct { @@ -48,6 +48,7 @@ typedef struct { a special node and it is a terminal state that means decoding failed. */ uint16_t fstate; + uint8_t flags; /* symbol if NGHTTP2_HUFF_SYM flag set */ uint8_t sym; } nghttp2_huff_decode; @@ -57,6 +58,7 @@ typedef nghttp2_huff_decode huff_decode_table_type[16]; typedef struct { /* fstate is the current huffman decoding state. */ uint16_t fstate; + uint8_t flags; } nghttp2_hd_huff_decode_context; typedef struct { @@ -69,4 +71,12 @@ typedef struct { extern const nghttp2_huff_sym huff_sym_table[]; extern const nghttp2_huff_decode huff_decode_table[][16]; +/* + * nghttp2_huff_estimate_decode_length returns the estimated decoded + * length of the huffman encoded string of length |len|. + */ +static inline size_t nghttp2_huff_estimate_decode_length(size_t len) { + return len * 8 / 5; +} + #endif /* !defined(NGHTTP2_HD_HUFFMAN_H) */ diff --git a/deps/nghttp2/lib/nghttp2_hd_huffman_data.c b/deps/nghttp2/lib/nghttp2_hd_huffman_data.c index c8f4a6fa266708..252cae0c18d971 100644 --- a/deps/nghttp2/lib/nghttp2_hd_huffman_data.c +++ b/deps/nghttp2/lib/nghttp2_hd_huffman_data.c @@ -96,4885 +96,4885 @@ const nghttp2_huff_sym huff_sym_table[] = { const nghttp2_huff_decode huff_decode_table[][16] = { /* 0 */ { - {0x04, 0}, - {0x05, 0}, - {0x07, 0}, - {0x08, 0}, - {0x0b, 0}, - {0x0c, 0}, - {0x10, 0}, - {0x13, 0}, - {0x19, 0}, - {0x1c, 0}, - {0x20, 0}, - {0x23, 0}, - {0x2a, 0}, - {0x31, 0}, - {0x39, 0}, - {0x4040, 0}, + {0x04, 0, 0}, + {0x05, 0, 0}, + {0x07, 0, 0}, + {0x08, 0, 0}, + {0x0b, 0, 0}, + {0x0c, 0, 0}, + {0x10, 0, 0}, + {0x13, 0, 0}, + {0x19, 0, 0}, + {0x1c, 0, 0}, + {0x20, 0, 0}, + {0x23, 0, 0}, + {0x2a, 0, 0}, + {0x31, 0, 0}, + {0x39, 0, 0}, + {0x40, 1, 0}, }, /* 1 */ { - {0xc000, 48}, - {0xc000, 49}, - {0xc000, 50}, - {0xc000, 97}, - {0xc000, 99}, - {0xc000, 101}, - {0xc000, 105}, - {0xc000, 111}, - {0xc000, 115}, - {0xc000, 116}, - {0x0d, 0}, - {0x0e, 0}, - {0x11, 0}, - {0x12, 0}, - {0x14, 0}, - {0x15, 0}, + {0x00, 3, 48}, + {0x00, 3, 49}, + {0x00, 3, 50}, + {0x00, 3, 97}, + {0x00, 3, 99}, + {0x00, 3, 101}, + {0x00, 3, 105}, + {0x00, 3, 111}, + {0x00, 3, 115}, + {0x00, 3, 116}, + {0x0d, 0, 0}, + {0x0e, 0, 0}, + {0x11, 0, 0}, + {0x12, 0, 0}, + {0x14, 0, 0}, + {0x15, 0, 0}, }, /* 2 */ { - {0x8001, 48}, - {0xc016, 48}, - {0x8001, 49}, - {0xc016, 49}, - {0x8001, 50}, - {0xc016, 50}, - {0x8001, 97}, - {0xc016, 97}, - {0x8001, 99}, - {0xc016, 99}, - {0x8001, 101}, - {0xc016, 101}, - {0x8001, 105}, - {0xc016, 105}, - {0x8001, 111}, - {0xc016, 111}, + {0x01, 2, 48}, + {0x16, 3, 48}, + {0x01, 2, 49}, + {0x16, 3, 49}, + {0x01, 2, 50}, + {0x16, 3, 50}, + {0x01, 2, 97}, + {0x16, 3, 97}, + {0x01, 2, 99}, + {0x16, 3, 99}, + {0x01, 2, 101}, + {0x16, 3, 101}, + {0x01, 2, 105}, + {0x16, 3, 105}, + {0x01, 2, 111}, + {0x16, 3, 111}, }, /* 3 */ { - {0x8002, 48}, - {0x8009, 48}, - {0x8017, 48}, - {0xc028, 48}, - {0x8002, 49}, - {0x8009, 49}, - {0x8017, 49}, - {0xc028, 49}, - {0x8002, 50}, - {0x8009, 50}, - {0x8017, 50}, - {0xc028, 50}, - {0x8002, 97}, - {0x8009, 97}, - {0x8017, 97}, - {0xc028, 97}, + {0x02, 2, 48}, + {0x09, 2, 48}, + {0x17, 2, 48}, + {0x28, 3, 48}, + {0x02, 2, 49}, + {0x09, 2, 49}, + {0x17, 2, 49}, + {0x28, 3, 49}, + {0x02, 2, 50}, + {0x09, 2, 50}, + {0x17, 2, 50}, + {0x28, 3, 50}, + {0x02, 2, 97}, + {0x09, 2, 97}, + {0x17, 2, 97}, + {0x28, 3, 97}, }, /* 4 */ { - {0x8003, 48}, - {0x8006, 48}, - {0x800a, 48}, - {0x800f, 48}, - {0x8018, 48}, - {0x801f, 48}, - {0x8029, 48}, - {0xc038, 48}, - {0x8003, 49}, - {0x8006, 49}, - {0x800a, 49}, - {0x800f, 49}, - {0x8018, 49}, - {0x801f, 49}, - {0x8029, 49}, - {0xc038, 49}, + {0x03, 2, 48}, + {0x06, 2, 48}, + {0x0a, 2, 48}, + {0x0f, 2, 48}, + {0x18, 2, 48}, + {0x1f, 2, 48}, + {0x29, 2, 48}, + {0x38, 3, 48}, + {0x03, 2, 49}, + {0x06, 2, 49}, + {0x0a, 2, 49}, + {0x0f, 2, 49}, + {0x18, 2, 49}, + {0x1f, 2, 49}, + {0x29, 2, 49}, + {0x38, 3, 49}, }, /* 5 */ { - {0x8003, 50}, - {0x8006, 50}, - {0x800a, 50}, - {0x800f, 50}, - {0x8018, 50}, - {0x801f, 50}, - {0x8029, 50}, - {0xc038, 50}, - {0x8003, 97}, - {0x8006, 97}, - {0x800a, 97}, - {0x800f, 97}, - {0x8018, 97}, - {0x801f, 97}, - {0x8029, 97}, - {0xc038, 97}, + {0x03, 2, 50}, + {0x06, 2, 50}, + {0x0a, 2, 50}, + {0x0f, 2, 50}, + {0x18, 2, 50}, + {0x1f, 2, 50}, + {0x29, 2, 50}, + {0x38, 3, 50}, + {0x03, 2, 97}, + {0x06, 2, 97}, + {0x0a, 2, 97}, + {0x0f, 2, 97}, + {0x18, 2, 97}, + {0x1f, 2, 97}, + {0x29, 2, 97}, + {0x38, 3, 97}, }, /* 6 */ { - {0x8002, 99}, - {0x8009, 99}, - {0x8017, 99}, - {0xc028, 99}, - {0x8002, 101}, - {0x8009, 101}, - {0x8017, 101}, - {0xc028, 101}, - {0x8002, 105}, - {0x8009, 105}, - {0x8017, 105}, - {0xc028, 105}, - {0x8002, 111}, - {0x8009, 111}, - {0x8017, 111}, - {0xc028, 111}, + {0x02, 2, 99}, + {0x09, 2, 99}, + {0x17, 2, 99}, + {0x28, 3, 99}, + {0x02, 2, 101}, + {0x09, 2, 101}, + {0x17, 2, 101}, + {0x28, 3, 101}, + {0x02, 2, 105}, + {0x09, 2, 105}, + {0x17, 2, 105}, + {0x28, 3, 105}, + {0x02, 2, 111}, + {0x09, 2, 111}, + {0x17, 2, 111}, + {0x28, 3, 111}, }, /* 7 */ { - {0x8003, 99}, - {0x8006, 99}, - {0x800a, 99}, - {0x800f, 99}, - {0x8018, 99}, - {0x801f, 99}, - {0x8029, 99}, - {0xc038, 99}, - {0x8003, 101}, - {0x8006, 101}, - {0x800a, 101}, - {0x800f, 101}, - {0x8018, 101}, - {0x801f, 101}, - {0x8029, 101}, - {0xc038, 101}, + {0x03, 2, 99}, + {0x06, 2, 99}, + {0x0a, 2, 99}, + {0x0f, 2, 99}, + {0x18, 2, 99}, + {0x1f, 2, 99}, + {0x29, 2, 99}, + {0x38, 3, 99}, + {0x03, 2, 101}, + {0x06, 2, 101}, + {0x0a, 2, 101}, + {0x0f, 2, 101}, + {0x18, 2, 101}, + {0x1f, 2, 101}, + {0x29, 2, 101}, + {0x38, 3, 101}, }, /* 8 */ { - {0x8003, 105}, - {0x8006, 105}, - {0x800a, 105}, - {0x800f, 105}, - {0x8018, 105}, - {0x801f, 105}, - {0x8029, 105}, - {0xc038, 105}, - {0x8003, 111}, - {0x8006, 111}, - {0x800a, 111}, - {0x800f, 111}, - {0x8018, 111}, - {0x801f, 111}, - {0x8029, 111}, - {0xc038, 111}, + {0x03, 2, 105}, + {0x06, 2, 105}, + {0x0a, 2, 105}, + {0x0f, 2, 105}, + {0x18, 2, 105}, + {0x1f, 2, 105}, + {0x29, 2, 105}, + {0x38, 3, 105}, + {0x03, 2, 111}, + {0x06, 2, 111}, + {0x0a, 2, 111}, + {0x0f, 2, 111}, + {0x18, 2, 111}, + {0x1f, 2, 111}, + {0x29, 2, 111}, + {0x38, 3, 111}, }, /* 9 */ { - {0x8001, 115}, - {0xc016, 115}, - {0x8001, 116}, - {0xc016, 116}, - {0xc000, 32}, - {0xc000, 37}, - {0xc000, 45}, - {0xc000, 46}, - {0xc000, 47}, - {0xc000, 51}, - {0xc000, 52}, - {0xc000, 53}, - {0xc000, 54}, - {0xc000, 55}, - {0xc000, 56}, - {0xc000, 57}, + {0x01, 2, 115}, + {0x16, 3, 115}, + {0x01, 2, 116}, + {0x16, 3, 116}, + {0x00, 3, 32}, + {0x00, 3, 37}, + {0x00, 3, 45}, + {0x00, 3, 46}, + {0x00, 3, 47}, + {0x00, 3, 51}, + {0x00, 3, 52}, + {0x00, 3, 53}, + {0x00, 3, 54}, + {0x00, 3, 55}, + {0x00, 3, 56}, + {0x00, 3, 57}, }, /* 10 */ { - {0x8002, 115}, - {0x8009, 115}, - {0x8017, 115}, - {0xc028, 115}, - {0x8002, 116}, - {0x8009, 116}, - {0x8017, 116}, - {0xc028, 116}, - {0x8001, 32}, - {0xc016, 32}, - {0x8001, 37}, - {0xc016, 37}, - {0x8001, 45}, - {0xc016, 45}, - {0x8001, 46}, - {0xc016, 46}, + {0x02, 2, 115}, + {0x09, 2, 115}, + {0x17, 2, 115}, + {0x28, 3, 115}, + {0x02, 2, 116}, + {0x09, 2, 116}, + {0x17, 2, 116}, + {0x28, 3, 116}, + {0x01, 2, 32}, + {0x16, 3, 32}, + {0x01, 2, 37}, + {0x16, 3, 37}, + {0x01, 2, 45}, + {0x16, 3, 45}, + {0x01, 2, 46}, + {0x16, 3, 46}, }, /* 11 */ { - {0x8003, 115}, - {0x8006, 115}, - {0x800a, 115}, - {0x800f, 115}, - {0x8018, 115}, - {0x801f, 115}, - {0x8029, 115}, - {0xc038, 115}, - {0x8003, 116}, - {0x8006, 116}, - {0x800a, 116}, - {0x800f, 116}, - {0x8018, 116}, - {0x801f, 116}, - {0x8029, 116}, - {0xc038, 116}, + {0x03, 2, 115}, + {0x06, 2, 115}, + {0x0a, 2, 115}, + {0x0f, 2, 115}, + {0x18, 2, 115}, + {0x1f, 2, 115}, + {0x29, 2, 115}, + {0x38, 3, 115}, + {0x03, 2, 116}, + {0x06, 2, 116}, + {0x0a, 2, 116}, + {0x0f, 2, 116}, + {0x18, 2, 116}, + {0x1f, 2, 116}, + {0x29, 2, 116}, + {0x38, 3, 116}, }, /* 12 */ { - {0x8002, 32}, - {0x8009, 32}, - {0x8017, 32}, - {0xc028, 32}, - {0x8002, 37}, - {0x8009, 37}, - {0x8017, 37}, - {0xc028, 37}, - {0x8002, 45}, - {0x8009, 45}, - {0x8017, 45}, - {0xc028, 45}, - {0x8002, 46}, - {0x8009, 46}, - {0x8017, 46}, - {0xc028, 46}, + {0x02, 2, 32}, + {0x09, 2, 32}, + {0x17, 2, 32}, + {0x28, 3, 32}, + {0x02, 2, 37}, + {0x09, 2, 37}, + {0x17, 2, 37}, + {0x28, 3, 37}, + {0x02, 2, 45}, + {0x09, 2, 45}, + {0x17, 2, 45}, + {0x28, 3, 45}, + {0x02, 2, 46}, + {0x09, 2, 46}, + {0x17, 2, 46}, + {0x28, 3, 46}, }, /* 13 */ { - {0x8003, 32}, - {0x8006, 32}, - {0x800a, 32}, - {0x800f, 32}, - {0x8018, 32}, - {0x801f, 32}, - {0x8029, 32}, - {0xc038, 32}, - {0x8003, 37}, - {0x8006, 37}, - {0x800a, 37}, - {0x800f, 37}, - {0x8018, 37}, - {0x801f, 37}, - {0x8029, 37}, - {0xc038, 37}, + {0x03, 2, 32}, + {0x06, 2, 32}, + {0x0a, 2, 32}, + {0x0f, 2, 32}, + {0x18, 2, 32}, + {0x1f, 2, 32}, + {0x29, 2, 32}, + {0x38, 3, 32}, + {0x03, 2, 37}, + {0x06, 2, 37}, + {0x0a, 2, 37}, + {0x0f, 2, 37}, + {0x18, 2, 37}, + {0x1f, 2, 37}, + {0x29, 2, 37}, + {0x38, 3, 37}, }, /* 14 */ { - {0x8003, 45}, - {0x8006, 45}, - {0x800a, 45}, - {0x800f, 45}, - {0x8018, 45}, - {0x801f, 45}, - {0x8029, 45}, - {0xc038, 45}, - {0x8003, 46}, - {0x8006, 46}, - {0x800a, 46}, - {0x800f, 46}, - {0x8018, 46}, - {0x801f, 46}, - {0x8029, 46}, - {0xc038, 46}, + {0x03, 2, 45}, + {0x06, 2, 45}, + {0x0a, 2, 45}, + {0x0f, 2, 45}, + {0x18, 2, 45}, + {0x1f, 2, 45}, + {0x29, 2, 45}, + {0x38, 3, 45}, + {0x03, 2, 46}, + {0x06, 2, 46}, + {0x0a, 2, 46}, + {0x0f, 2, 46}, + {0x18, 2, 46}, + {0x1f, 2, 46}, + {0x29, 2, 46}, + {0x38, 3, 46}, }, /* 15 */ { - {0x8001, 47}, - {0xc016, 47}, - {0x8001, 51}, - {0xc016, 51}, - {0x8001, 52}, - {0xc016, 52}, - {0x8001, 53}, - {0xc016, 53}, - {0x8001, 54}, - {0xc016, 54}, - {0x8001, 55}, - {0xc016, 55}, - {0x8001, 56}, - {0xc016, 56}, - {0x8001, 57}, - {0xc016, 57}, + {0x01, 2, 47}, + {0x16, 3, 47}, + {0x01, 2, 51}, + {0x16, 3, 51}, + {0x01, 2, 52}, + {0x16, 3, 52}, + {0x01, 2, 53}, + {0x16, 3, 53}, + {0x01, 2, 54}, + {0x16, 3, 54}, + {0x01, 2, 55}, + {0x16, 3, 55}, + {0x01, 2, 56}, + {0x16, 3, 56}, + {0x01, 2, 57}, + {0x16, 3, 57}, }, /* 16 */ { - {0x8002, 47}, - {0x8009, 47}, - {0x8017, 47}, - {0xc028, 47}, - {0x8002, 51}, - {0x8009, 51}, - {0x8017, 51}, - {0xc028, 51}, - {0x8002, 52}, - {0x8009, 52}, - {0x8017, 52}, - {0xc028, 52}, - {0x8002, 53}, - {0x8009, 53}, - {0x8017, 53}, - {0xc028, 53}, + {0x02, 2, 47}, + {0x09, 2, 47}, + {0x17, 2, 47}, + {0x28, 3, 47}, + {0x02, 2, 51}, + {0x09, 2, 51}, + {0x17, 2, 51}, + {0x28, 3, 51}, + {0x02, 2, 52}, + {0x09, 2, 52}, + {0x17, 2, 52}, + {0x28, 3, 52}, + {0x02, 2, 53}, + {0x09, 2, 53}, + {0x17, 2, 53}, + {0x28, 3, 53}, }, /* 17 */ { - {0x8003, 47}, - {0x8006, 47}, - {0x800a, 47}, - {0x800f, 47}, - {0x8018, 47}, - {0x801f, 47}, - {0x8029, 47}, - {0xc038, 47}, - {0x8003, 51}, - {0x8006, 51}, - {0x800a, 51}, - {0x800f, 51}, - {0x8018, 51}, - {0x801f, 51}, - {0x8029, 51}, - {0xc038, 51}, + {0x03, 2, 47}, + {0x06, 2, 47}, + {0x0a, 2, 47}, + {0x0f, 2, 47}, + {0x18, 2, 47}, + {0x1f, 2, 47}, + {0x29, 2, 47}, + {0x38, 3, 47}, + {0x03, 2, 51}, + {0x06, 2, 51}, + {0x0a, 2, 51}, + {0x0f, 2, 51}, + {0x18, 2, 51}, + {0x1f, 2, 51}, + {0x29, 2, 51}, + {0x38, 3, 51}, }, /* 18 */ { - {0x8003, 52}, - {0x8006, 52}, - {0x800a, 52}, - {0x800f, 52}, - {0x8018, 52}, - {0x801f, 52}, - {0x8029, 52}, - {0xc038, 52}, - {0x8003, 53}, - {0x8006, 53}, - {0x800a, 53}, - {0x800f, 53}, - {0x8018, 53}, - {0x801f, 53}, - {0x8029, 53}, - {0xc038, 53}, + {0x03, 2, 52}, + {0x06, 2, 52}, + {0x0a, 2, 52}, + {0x0f, 2, 52}, + {0x18, 2, 52}, + {0x1f, 2, 52}, + {0x29, 2, 52}, + {0x38, 3, 52}, + {0x03, 2, 53}, + {0x06, 2, 53}, + {0x0a, 2, 53}, + {0x0f, 2, 53}, + {0x18, 2, 53}, + {0x1f, 2, 53}, + {0x29, 2, 53}, + {0x38, 3, 53}, }, /* 19 */ { - {0x8002, 54}, - {0x8009, 54}, - {0x8017, 54}, - {0xc028, 54}, - {0x8002, 55}, - {0x8009, 55}, - {0x8017, 55}, - {0xc028, 55}, - {0x8002, 56}, - {0x8009, 56}, - {0x8017, 56}, - {0xc028, 56}, - {0x8002, 57}, - {0x8009, 57}, - {0x8017, 57}, - {0xc028, 57}, + {0x02, 2, 54}, + {0x09, 2, 54}, + {0x17, 2, 54}, + {0x28, 3, 54}, + {0x02, 2, 55}, + {0x09, 2, 55}, + {0x17, 2, 55}, + {0x28, 3, 55}, + {0x02, 2, 56}, + {0x09, 2, 56}, + {0x17, 2, 56}, + {0x28, 3, 56}, + {0x02, 2, 57}, + {0x09, 2, 57}, + {0x17, 2, 57}, + {0x28, 3, 57}, }, /* 20 */ { - {0x8003, 54}, - {0x8006, 54}, - {0x800a, 54}, - {0x800f, 54}, - {0x8018, 54}, - {0x801f, 54}, - {0x8029, 54}, - {0xc038, 54}, - {0x8003, 55}, - {0x8006, 55}, - {0x800a, 55}, - {0x800f, 55}, - {0x8018, 55}, - {0x801f, 55}, - {0x8029, 55}, - {0xc038, 55}, + {0x03, 2, 54}, + {0x06, 2, 54}, + {0x0a, 2, 54}, + {0x0f, 2, 54}, + {0x18, 2, 54}, + {0x1f, 2, 54}, + {0x29, 2, 54}, + {0x38, 3, 54}, + {0x03, 2, 55}, + {0x06, 2, 55}, + {0x0a, 2, 55}, + {0x0f, 2, 55}, + {0x18, 2, 55}, + {0x1f, 2, 55}, + {0x29, 2, 55}, + {0x38, 3, 55}, }, /* 21 */ { - {0x8003, 56}, - {0x8006, 56}, - {0x800a, 56}, - {0x800f, 56}, - {0x8018, 56}, - {0x801f, 56}, - {0x8029, 56}, - {0xc038, 56}, - {0x8003, 57}, - {0x8006, 57}, - {0x800a, 57}, - {0x800f, 57}, - {0x8018, 57}, - {0x801f, 57}, - {0x8029, 57}, - {0xc038, 57}, + {0x03, 2, 56}, + {0x06, 2, 56}, + {0x0a, 2, 56}, + {0x0f, 2, 56}, + {0x18, 2, 56}, + {0x1f, 2, 56}, + {0x29, 2, 56}, + {0x38, 3, 56}, + {0x03, 2, 57}, + {0x06, 2, 57}, + {0x0a, 2, 57}, + {0x0f, 2, 57}, + {0x18, 2, 57}, + {0x1f, 2, 57}, + {0x29, 2, 57}, + {0x38, 3, 57}, }, /* 22 */ { - {0x1a, 0}, - {0x1b, 0}, - {0x1d, 0}, - {0x1e, 0}, - {0x21, 0}, - {0x22, 0}, - {0x24, 0}, - {0x25, 0}, - {0x2b, 0}, - {0x2e, 0}, - {0x32, 0}, - {0x35, 0}, - {0x3a, 0}, - {0x3d, 0}, - {0x41, 0}, - {0x4044, 0}, + {0x1a, 0, 0}, + {0x1b, 0, 0}, + {0x1d, 0, 0}, + {0x1e, 0, 0}, + {0x21, 0, 0}, + {0x22, 0, 0}, + {0x24, 0, 0}, + {0x25, 0, 0}, + {0x2b, 0, 0}, + {0x2e, 0, 0}, + {0x32, 0, 0}, + {0x35, 0, 0}, + {0x3a, 0, 0}, + {0x3d, 0, 0}, + {0x41, 0, 0}, + {0x44, 1, 0}, }, /* 23 */ { - {0xc000, 61}, - {0xc000, 65}, - {0xc000, 95}, - {0xc000, 98}, - {0xc000, 100}, - {0xc000, 102}, - {0xc000, 103}, - {0xc000, 104}, - {0xc000, 108}, - {0xc000, 109}, - {0xc000, 110}, - {0xc000, 112}, - {0xc000, 114}, - {0xc000, 117}, - {0x26, 0}, - {0x27, 0}, + {0x00, 3, 61}, + {0x00, 3, 65}, + {0x00, 3, 95}, + {0x00, 3, 98}, + {0x00, 3, 100}, + {0x00, 3, 102}, + {0x00, 3, 103}, + {0x00, 3, 104}, + {0x00, 3, 108}, + {0x00, 3, 109}, + {0x00, 3, 110}, + {0x00, 3, 112}, + {0x00, 3, 114}, + {0x00, 3, 117}, + {0x26, 0, 0}, + {0x27, 0, 0}, }, /* 24 */ { - {0x8001, 61}, - {0xc016, 61}, - {0x8001, 65}, - {0xc016, 65}, - {0x8001, 95}, - {0xc016, 95}, - {0x8001, 98}, - {0xc016, 98}, - {0x8001, 100}, - {0xc016, 100}, - {0x8001, 102}, - {0xc016, 102}, - {0x8001, 103}, - {0xc016, 103}, - {0x8001, 104}, - {0xc016, 104}, + {0x01, 2, 61}, + {0x16, 3, 61}, + {0x01, 2, 65}, + {0x16, 3, 65}, + {0x01, 2, 95}, + {0x16, 3, 95}, + {0x01, 2, 98}, + {0x16, 3, 98}, + {0x01, 2, 100}, + {0x16, 3, 100}, + {0x01, 2, 102}, + {0x16, 3, 102}, + {0x01, 2, 103}, + {0x16, 3, 103}, + {0x01, 2, 104}, + {0x16, 3, 104}, }, /* 25 */ { - {0x8002, 61}, - {0x8009, 61}, - {0x8017, 61}, - {0xc028, 61}, - {0x8002, 65}, - {0x8009, 65}, - {0x8017, 65}, - {0xc028, 65}, - {0x8002, 95}, - {0x8009, 95}, - {0x8017, 95}, - {0xc028, 95}, - {0x8002, 98}, - {0x8009, 98}, - {0x8017, 98}, - {0xc028, 98}, + {0x02, 2, 61}, + {0x09, 2, 61}, + {0x17, 2, 61}, + {0x28, 3, 61}, + {0x02, 2, 65}, + {0x09, 2, 65}, + {0x17, 2, 65}, + {0x28, 3, 65}, + {0x02, 2, 95}, + {0x09, 2, 95}, + {0x17, 2, 95}, + {0x28, 3, 95}, + {0x02, 2, 98}, + {0x09, 2, 98}, + {0x17, 2, 98}, + {0x28, 3, 98}, }, /* 26 */ { - {0x8003, 61}, - {0x8006, 61}, - {0x800a, 61}, - {0x800f, 61}, - {0x8018, 61}, - {0x801f, 61}, - {0x8029, 61}, - {0xc038, 61}, - {0x8003, 65}, - {0x8006, 65}, - {0x800a, 65}, - {0x800f, 65}, - {0x8018, 65}, - {0x801f, 65}, - {0x8029, 65}, - {0xc038, 65}, + {0x03, 2, 61}, + {0x06, 2, 61}, + {0x0a, 2, 61}, + {0x0f, 2, 61}, + {0x18, 2, 61}, + {0x1f, 2, 61}, + {0x29, 2, 61}, + {0x38, 3, 61}, + {0x03, 2, 65}, + {0x06, 2, 65}, + {0x0a, 2, 65}, + {0x0f, 2, 65}, + {0x18, 2, 65}, + {0x1f, 2, 65}, + {0x29, 2, 65}, + {0x38, 3, 65}, }, /* 27 */ { - {0x8003, 95}, - {0x8006, 95}, - {0x800a, 95}, - {0x800f, 95}, - {0x8018, 95}, - {0x801f, 95}, - {0x8029, 95}, - {0xc038, 95}, - {0x8003, 98}, - {0x8006, 98}, - {0x800a, 98}, - {0x800f, 98}, - {0x8018, 98}, - {0x801f, 98}, - {0x8029, 98}, - {0xc038, 98}, + {0x03, 2, 95}, + {0x06, 2, 95}, + {0x0a, 2, 95}, + {0x0f, 2, 95}, + {0x18, 2, 95}, + {0x1f, 2, 95}, + {0x29, 2, 95}, + {0x38, 3, 95}, + {0x03, 2, 98}, + {0x06, 2, 98}, + {0x0a, 2, 98}, + {0x0f, 2, 98}, + {0x18, 2, 98}, + {0x1f, 2, 98}, + {0x29, 2, 98}, + {0x38, 3, 98}, }, /* 28 */ { - {0x8002, 100}, - {0x8009, 100}, - {0x8017, 100}, - {0xc028, 100}, - {0x8002, 102}, - {0x8009, 102}, - {0x8017, 102}, - {0xc028, 102}, - {0x8002, 103}, - {0x8009, 103}, - {0x8017, 103}, - {0xc028, 103}, - {0x8002, 104}, - {0x8009, 104}, - {0x8017, 104}, - {0xc028, 104}, + {0x02, 2, 100}, + {0x09, 2, 100}, + {0x17, 2, 100}, + {0x28, 3, 100}, + {0x02, 2, 102}, + {0x09, 2, 102}, + {0x17, 2, 102}, + {0x28, 3, 102}, + {0x02, 2, 103}, + {0x09, 2, 103}, + {0x17, 2, 103}, + {0x28, 3, 103}, + {0x02, 2, 104}, + {0x09, 2, 104}, + {0x17, 2, 104}, + {0x28, 3, 104}, }, /* 29 */ { - {0x8003, 100}, - {0x8006, 100}, - {0x800a, 100}, - {0x800f, 100}, - {0x8018, 100}, - {0x801f, 100}, - {0x8029, 100}, - {0xc038, 100}, - {0x8003, 102}, - {0x8006, 102}, - {0x800a, 102}, - {0x800f, 102}, - {0x8018, 102}, - {0x801f, 102}, - {0x8029, 102}, - {0xc038, 102}, + {0x03, 2, 100}, + {0x06, 2, 100}, + {0x0a, 2, 100}, + {0x0f, 2, 100}, + {0x18, 2, 100}, + {0x1f, 2, 100}, + {0x29, 2, 100}, + {0x38, 3, 100}, + {0x03, 2, 102}, + {0x06, 2, 102}, + {0x0a, 2, 102}, + {0x0f, 2, 102}, + {0x18, 2, 102}, + {0x1f, 2, 102}, + {0x29, 2, 102}, + {0x38, 3, 102}, }, /* 30 */ { - {0x8003, 103}, - {0x8006, 103}, - {0x800a, 103}, - {0x800f, 103}, - {0x8018, 103}, - {0x801f, 103}, - {0x8029, 103}, - {0xc038, 103}, - {0x8003, 104}, - {0x8006, 104}, - {0x800a, 104}, - {0x800f, 104}, - {0x8018, 104}, - {0x801f, 104}, - {0x8029, 104}, - {0xc038, 104}, + {0x03, 2, 103}, + {0x06, 2, 103}, + {0x0a, 2, 103}, + {0x0f, 2, 103}, + {0x18, 2, 103}, + {0x1f, 2, 103}, + {0x29, 2, 103}, + {0x38, 3, 103}, + {0x03, 2, 104}, + {0x06, 2, 104}, + {0x0a, 2, 104}, + {0x0f, 2, 104}, + {0x18, 2, 104}, + {0x1f, 2, 104}, + {0x29, 2, 104}, + {0x38, 3, 104}, }, /* 31 */ { - {0x8001, 108}, - {0xc016, 108}, - {0x8001, 109}, - {0xc016, 109}, - {0x8001, 110}, - {0xc016, 110}, - {0x8001, 112}, - {0xc016, 112}, - {0x8001, 114}, - {0xc016, 114}, - {0x8001, 117}, - {0xc016, 117}, - {0xc000, 58}, - {0xc000, 66}, - {0xc000, 67}, - {0xc000, 68}, + {0x01, 2, 108}, + {0x16, 3, 108}, + {0x01, 2, 109}, + {0x16, 3, 109}, + {0x01, 2, 110}, + {0x16, 3, 110}, + {0x01, 2, 112}, + {0x16, 3, 112}, + {0x01, 2, 114}, + {0x16, 3, 114}, + {0x01, 2, 117}, + {0x16, 3, 117}, + {0x00, 3, 58}, + {0x00, 3, 66}, + {0x00, 3, 67}, + {0x00, 3, 68}, }, /* 32 */ { - {0x8002, 108}, - {0x8009, 108}, - {0x8017, 108}, - {0xc028, 108}, - {0x8002, 109}, - {0x8009, 109}, - {0x8017, 109}, - {0xc028, 109}, - {0x8002, 110}, - {0x8009, 110}, - {0x8017, 110}, - {0xc028, 110}, - {0x8002, 112}, - {0x8009, 112}, - {0x8017, 112}, - {0xc028, 112}, + {0x02, 2, 108}, + {0x09, 2, 108}, + {0x17, 2, 108}, + {0x28, 3, 108}, + {0x02, 2, 109}, + {0x09, 2, 109}, + {0x17, 2, 109}, + {0x28, 3, 109}, + {0x02, 2, 110}, + {0x09, 2, 110}, + {0x17, 2, 110}, + {0x28, 3, 110}, + {0x02, 2, 112}, + {0x09, 2, 112}, + {0x17, 2, 112}, + {0x28, 3, 112}, }, /* 33 */ { - {0x8003, 108}, - {0x8006, 108}, - {0x800a, 108}, - {0x800f, 108}, - {0x8018, 108}, - {0x801f, 108}, - {0x8029, 108}, - {0xc038, 108}, - {0x8003, 109}, - {0x8006, 109}, - {0x800a, 109}, - {0x800f, 109}, - {0x8018, 109}, - {0x801f, 109}, - {0x8029, 109}, - {0xc038, 109}, + {0x03, 2, 108}, + {0x06, 2, 108}, + {0x0a, 2, 108}, + {0x0f, 2, 108}, + {0x18, 2, 108}, + {0x1f, 2, 108}, + {0x29, 2, 108}, + {0x38, 3, 108}, + {0x03, 2, 109}, + {0x06, 2, 109}, + {0x0a, 2, 109}, + {0x0f, 2, 109}, + {0x18, 2, 109}, + {0x1f, 2, 109}, + {0x29, 2, 109}, + {0x38, 3, 109}, }, /* 34 */ { - {0x8003, 110}, - {0x8006, 110}, - {0x800a, 110}, - {0x800f, 110}, - {0x8018, 110}, - {0x801f, 110}, - {0x8029, 110}, - {0xc038, 110}, - {0x8003, 112}, - {0x8006, 112}, - {0x800a, 112}, - {0x800f, 112}, - {0x8018, 112}, - {0x801f, 112}, - {0x8029, 112}, - {0xc038, 112}, + {0x03, 2, 110}, + {0x06, 2, 110}, + {0x0a, 2, 110}, + {0x0f, 2, 110}, + {0x18, 2, 110}, + {0x1f, 2, 110}, + {0x29, 2, 110}, + {0x38, 3, 110}, + {0x03, 2, 112}, + {0x06, 2, 112}, + {0x0a, 2, 112}, + {0x0f, 2, 112}, + {0x18, 2, 112}, + {0x1f, 2, 112}, + {0x29, 2, 112}, + {0x38, 3, 112}, }, /* 35 */ { - {0x8002, 114}, - {0x8009, 114}, - {0x8017, 114}, - {0xc028, 114}, - {0x8002, 117}, - {0x8009, 117}, - {0x8017, 117}, - {0xc028, 117}, - {0x8001, 58}, - {0xc016, 58}, - {0x8001, 66}, - {0xc016, 66}, - {0x8001, 67}, - {0xc016, 67}, - {0x8001, 68}, - {0xc016, 68}, + {0x02, 2, 114}, + {0x09, 2, 114}, + {0x17, 2, 114}, + {0x28, 3, 114}, + {0x02, 2, 117}, + {0x09, 2, 117}, + {0x17, 2, 117}, + {0x28, 3, 117}, + {0x01, 2, 58}, + {0x16, 3, 58}, + {0x01, 2, 66}, + {0x16, 3, 66}, + {0x01, 2, 67}, + {0x16, 3, 67}, + {0x01, 2, 68}, + {0x16, 3, 68}, }, /* 36 */ { - {0x8003, 114}, - {0x8006, 114}, - {0x800a, 114}, - {0x800f, 114}, - {0x8018, 114}, - {0x801f, 114}, - {0x8029, 114}, - {0xc038, 114}, - {0x8003, 117}, - {0x8006, 117}, - {0x800a, 117}, - {0x800f, 117}, - {0x8018, 117}, - {0x801f, 117}, - {0x8029, 117}, - {0xc038, 117}, + {0x03, 2, 114}, + {0x06, 2, 114}, + {0x0a, 2, 114}, + {0x0f, 2, 114}, + {0x18, 2, 114}, + {0x1f, 2, 114}, + {0x29, 2, 114}, + {0x38, 3, 114}, + {0x03, 2, 117}, + {0x06, 2, 117}, + {0x0a, 2, 117}, + {0x0f, 2, 117}, + {0x18, 2, 117}, + {0x1f, 2, 117}, + {0x29, 2, 117}, + {0x38, 3, 117}, }, /* 37 */ { - {0x8002, 58}, - {0x8009, 58}, - {0x8017, 58}, - {0xc028, 58}, - {0x8002, 66}, - {0x8009, 66}, - {0x8017, 66}, - {0xc028, 66}, - {0x8002, 67}, - {0x8009, 67}, - {0x8017, 67}, - {0xc028, 67}, - {0x8002, 68}, - {0x8009, 68}, - {0x8017, 68}, - {0xc028, 68}, + {0x02, 2, 58}, + {0x09, 2, 58}, + {0x17, 2, 58}, + {0x28, 3, 58}, + {0x02, 2, 66}, + {0x09, 2, 66}, + {0x17, 2, 66}, + {0x28, 3, 66}, + {0x02, 2, 67}, + {0x09, 2, 67}, + {0x17, 2, 67}, + {0x28, 3, 67}, + {0x02, 2, 68}, + {0x09, 2, 68}, + {0x17, 2, 68}, + {0x28, 3, 68}, }, /* 38 */ { - {0x8003, 58}, - {0x8006, 58}, - {0x800a, 58}, - {0x800f, 58}, - {0x8018, 58}, - {0x801f, 58}, - {0x8029, 58}, - {0xc038, 58}, - {0x8003, 66}, - {0x8006, 66}, - {0x800a, 66}, - {0x800f, 66}, - {0x8018, 66}, - {0x801f, 66}, - {0x8029, 66}, - {0xc038, 66}, + {0x03, 2, 58}, + {0x06, 2, 58}, + {0x0a, 2, 58}, + {0x0f, 2, 58}, + {0x18, 2, 58}, + {0x1f, 2, 58}, + {0x29, 2, 58}, + {0x38, 3, 58}, + {0x03, 2, 66}, + {0x06, 2, 66}, + {0x0a, 2, 66}, + {0x0f, 2, 66}, + {0x18, 2, 66}, + {0x1f, 2, 66}, + {0x29, 2, 66}, + {0x38, 3, 66}, }, /* 39 */ { - {0x8003, 67}, - {0x8006, 67}, - {0x800a, 67}, - {0x800f, 67}, - {0x8018, 67}, - {0x801f, 67}, - {0x8029, 67}, - {0xc038, 67}, - {0x8003, 68}, - {0x8006, 68}, - {0x800a, 68}, - {0x800f, 68}, - {0x8018, 68}, - {0x801f, 68}, - {0x8029, 68}, - {0xc038, 68}, + {0x03, 2, 67}, + {0x06, 2, 67}, + {0x0a, 2, 67}, + {0x0f, 2, 67}, + {0x18, 2, 67}, + {0x1f, 2, 67}, + {0x29, 2, 67}, + {0x38, 3, 67}, + {0x03, 2, 68}, + {0x06, 2, 68}, + {0x0a, 2, 68}, + {0x0f, 2, 68}, + {0x18, 2, 68}, + {0x1f, 2, 68}, + {0x29, 2, 68}, + {0x38, 3, 68}, }, /* 40 */ { - {0x2c, 0}, - {0x2d, 0}, - {0x2f, 0}, - {0x30, 0}, - {0x33, 0}, - {0x34, 0}, - {0x36, 0}, - {0x37, 0}, - {0x3b, 0}, - {0x3c, 0}, - {0x3e, 0}, - {0x3f, 0}, - {0x42, 0}, - {0x43, 0}, - {0x45, 0}, - {0x4048, 0}, + {0x2c, 0, 0}, + {0x2d, 0, 0}, + {0x2f, 0, 0}, + {0x30, 0, 0}, + {0x33, 0, 0}, + {0x34, 0, 0}, + {0x36, 0, 0}, + {0x37, 0, 0}, + {0x3b, 0, 0}, + {0x3c, 0, 0}, + {0x3e, 0, 0}, + {0x3f, 0, 0}, + {0x42, 0, 0}, + {0x43, 0, 0}, + {0x45, 0, 0}, + {0x48, 1, 0}, }, /* 41 */ { - {0xc000, 69}, - {0xc000, 70}, - {0xc000, 71}, - {0xc000, 72}, - {0xc000, 73}, - {0xc000, 74}, - {0xc000, 75}, - {0xc000, 76}, - {0xc000, 77}, - {0xc000, 78}, - {0xc000, 79}, - {0xc000, 80}, - {0xc000, 81}, - {0xc000, 82}, - {0xc000, 83}, - {0xc000, 84}, + {0x00, 3, 69}, + {0x00, 3, 70}, + {0x00, 3, 71}, + {0x00, 3, 72}, + {0x00, 3, 73}, + {0x00, 3, 74}, + {0x00, 3, 75}, + {0x00, 3, 76}, + {0x00, 3, 77}, + {0x00, 3, 78}, + {0x00, 3, 79}, + {0x00, 3, 80}, + {0x00, 3, 81}, + {0x00, 3, 82}, + {0x00, 3, 83}, + {0x00, 3, 84}, }, /* 42 */ { - {0x8001, 69}, - {0xc016, 69}, - {0x8001, 70}, - {0xc016, 70}, - {0x8001, 71}, - {0xc016, 71}, - {0x8001, 72}, - {0xc016, 72}, - {0x8001, 73}, - {0xc016, 73}, - {0x8001, 74}, - {0xc016, 74}, - {0x8001, 75}, - {0xc016, 75}, - {0x8001, 76}, - {0xc016, 76}, + {0x01, 2, 69}, + {0x16, 3, 69}, + {0x01, 2, 70}, + {0x16, 3, 70}, + {0x01, 2, 71}, + {0x16, 3, 71}, + {0x01, 2, 72}, + {0x16, 3, 72}, + {0x01, 2, 73}, + {0x16, 3, 73}, + {0x01, 2, 74}, + {0x16, 3, 74}, + {0x01, 2, 75}, + {0x16, 3, 75}, + {0x01, 2, 76}, + {0x16, 3, 76}, }, /* 43 */ { - {0x8002, 69}, - {0x8009, 69}, - {0x8017, 69}, - {0xc028, 69}, - {0x8002, 70}, - {0x8009, 70}, - {0x8017, 70}, - {0xc028, 70}, - {0x8002, 71}, - {0x8009, 71}, - {0x8017, 71}, - {0xc028, 71}, - {0x8002, 72}, - {0x8009, 72}, - {0x8017, 72}, - {0xc028, 72}, + {0x02, 2, 69}, + {0x09, 2, 69}, + {0x17, 2, 69}, + {0x28, 3, 69}, + {0x02, 2, 70}, + {0x09, 2, 70}, + {0x17, 2, 70}, + {0x28, 3, 70}, + {0x02, 2, 71}, + {0x09, 2, 71}, + {0x17, 2, 71}, + {0x28, 3, 71}, + {0x02, 2, 72}, + {0x09, 2, 72}, + {0x17, 2, 72}, + {0x28, 3, 72}, }, /* 44 */ { - {0x8003, 69}, - {0x8006, 69}, - {0x800a, 69}, - {0x800f, 69}, - {0x8018, 69}, - {0x801f, 69}, - {0x8029, 69}, - {0xc038, 69}, - {0x8003, 70}, - {0x8006, 70}, - {0x800a, 70}, - {0x800f, 70}, - {0x8018, 70}, - {0x801f, 70}, - {0x8029, 70}, - {0xc038, 70}, + {0x03, 2, 69}, + {0x06, 2, 69}, + {0x0a, 2, 69}, + {0x0f, 2, 69}, + {0x18, 2, 69}, + {0x1f, 2, 69}, + {0x29, 2, 69}, + {0x38, 3, 69}, + {0x03, 2, 70}, + {0x06, 2, 70}, + {0x0a, 2, 70}, + {0x0f, 2, 70}, + {0x18, 2, 70}, + {0x1f, 2, 70}, + {0x29, 2, 70}, + {0x38, 3, 70}, }, /* 45 */ { - {0x8003, 71}, - {0x8006, 71}, - {0x800a, 71}, - {0x800f, 71}, - {0x8018, 71}, - {0x801f, 71}, - {0x8029, 71}, - {0xc038, 71}, - {0x8003, 72}, - {0x8006, 72}, - {0x800a, 72}, - {0x800f, 72}, - {0x8018, 72}, - {0x801f, 72}, - {0x8029, 72}, - {0xc038, 72}, + {0x03, 2, 71}, + {0x06, 2, 71}, + {0x0a, 2, 71}, + {0x0f, 2, 71}, + {0x18, 2, 71}, + {0x1f, 2, 71}, + {0x29, 2, 71}, + {0x38, 3, 71}, + {0x03, 2, 72}, + {0x06, 2, 72}, + {0x0a, 2, 72}, + {0x0f, 2, 72}, + {0x18, 2, 72}, + {0x1f, 2, 72}, + {0x29, 2, 72}, + {0x38, 3, 72}, }, /* 46 */ { - {0x8002, 73}, - {0x8009, 73}, - {0x8017, 73}, - {0xc028, 73}, - {0x8002, 74}, - {0x8009, 74}, - {0x8017, 74}, - {0xc028, 74}, - {0x8002, 75}, - {0x8009, 75}, - {0x8017, 75}, - {0xc028, 75}, - {0x8002, 76}, - {0x8009, 76}, - {0x8017, 76}, - {0xc028, 76}, + {0x02, 2, 73}, + {0x09, 2, 73}, + {0x17, 2, 73}, + {0x28, 3, 73}, + {0x02, 2, 74}, + {0x09, 2, 74}, + {0x17, 2, 74}, + {0x28, 3, 74}, + {0x02, 2, 75}, + {0x09, 2, 75}, + {0x17, 2, 75}, + {0x28, 3, 75}, + {0x02, 2, 76}, + {0x09, 2, 76}, + {0x17, 2, 76}, + {0x28, 3, 76}, }, /* 47 */ { - {0x8003, 73}, - {0x8006, 73}, - {0x800a, 73}, - {0x800f, 73}, - {0x8018, 73}, - {0x801f, 73}, - {0x8029, 73}, - {0xc038, 73}, - {0x8003, 74}, - {0x8006, 74}, - {0x800a, 74}, - {0x800f, 74}, - {0x8018, 74}, - {0x801f, 74}, - {0x8029, 74}, - {0xc038, 74}, + {0x03, 2, 73}, + {0x06, 2, 73}, + {0x0a, 2, 73}, + {0x0f, 2, 73}, + {0x18, 2, 73}, + {0x1f, 2, 73}, + {0x29, 2, 73}, + {0x38, 3, 73}, + {0x03, 2, 74}, + {0x06, 2, 74}, + {0x0a, 2, 74}, + {0x0f, 2, 74}, + {0x18, 2, 74}, + {0x1f, 2, 74}, + {0x29, 2, 74}, + {0x38, 3, 74}, }, /* 48 */ { - {0x8003, 75}, - {0x8006, 75}, - {0x800a, 75}, - {0x800f, 75}, - {0x8018, 75}, - {0x801f, 75}, - {0x8029, 75}, - {0xc038, 75}, - {0x8003, 76}, - {0x8006, 76}, - {0x800a, 76}, - {0x800f, 76}, - {0x8018, 76}, - {0x801f, 76}, - {0x8029, 76}, - {0xc038, 76}, + {0x03, 2, 75}, + {0x06, 2, 75}, + {0x0a, 2, 75}, + {0x0f, 2, 75}, + {0x18, 2, 75}, + {0x1f, 2, 75}, + {0x29, 2, 75}, + {0x38, 3, 75}, + {0x03, 2, 76}, + {0x06, 2, 76}, + {0x0a, 2, 76}, + {0x0f, 2, 76}, + {0x18, 2, 76}, + {0x1f, 2, 76}, + {0x29, 2, 76}, + {0x38, 3, 76}, }, /* 49 */ { - {0x8001, 77}, - {0xc016, 77}, - {0x8001, 78}, - {0xc016, 78}, - {0x8001, 79}, - {0xc016, 79}, - {0x8001, 80}, - {0xc016, 80}, - {0x8001, 81}, - {0xc016, 81}, - {0x8001, 82}, - {0xc016, 82}, - {0x8001, 83}, - {0xc016, 83}, - {0x8001, 84}, - {0xc016, 84}, + {0x01, 2, 77}, + {0x16, 3, 77}, + {0x01, 2, 78}, + {0x16, 3, 78}, + {0x01, 2, 79}, + {0x16, 3, 79}, + {0x01, 2, 80}, + {0x16, 3, 80}, + {0x01, 2, 81}, + {0x16, 3, 81}, + {0x01, 2, 82}, + {0x16, 3, 82}, + {0x01, 2, 83}, + {0x16, 3, 83}, + {0x01, 2, 84}, + {0x16, 3, 84}, }, /* 50 */ { - {0x8002, 77}, - {0x8009, 77}, - {0x8017, 77}, - {0xc028, 77}, - {0x8002, 78}, - {0x8009, 78}, - {0x8017, 78}, - {0xc028, 78}, - {0x8002, 79}, - {0x8009, 79}, - {0x8017, 79}, - {0xc028, 79}, - {0x8002, 80}, - {0x8009, 80}, - {0x8017, 80}, - {0xc028, 80}, + {0x02, 2, 77}, + {0x09, 2, 77}, + {0x17, 2, 77}, + {0x28, 3, 77}, + {0x02, 2, 78}, + {0x09, 2, 78}, + {0x17, 2, 78}, + {0x28, 3, 78}, + {0x02, 2, 79}, + {0x09, 2, 79}, + {0x17, 2, 79}, + {0x28, 3, 79}, + {0x02, 2, 80}, + {0x09, 2, 80}, + {0x17, 2, 80}, + {0x28, 3, 80}, }, /* 51 */ { - {0x8003, 77}, - {0x8006, 77}, - {0x800a, 77}, - {0x800f, 77}, - {0x8018, 77}, - {0x801f, 77}, - {0x8029, 77}, - {0xc038, 77}, - {0x8003, 78}, - {0x8006, 78}, - {0x800a, 78}, - {0x800f, 78}, - {0x8018, 78}, - {0x801f, 78}, - {0x8029, 78}, - {0xc038, 78}, + {0x03, 2, 77}, + {0x06, 2, 77}, + {0x0a, 2, 77}, + {0x0f, 2, 77}, + {0x18, 2, 77}, + {0x1f, 2, 77}, + {0x29, 2, 77}, + {0x38, 3, 77}, + {0x03, 2, 78}, + {0x06, 2, 78}, + {0x0a, 2, 78}, + {0x0f, 2, 78}, + {0x18, 2, 78}, + {0x1f, 2, 78}, + {0x29, 2, 78}, + {0x38, 3, 78}, }, /* 52 */ { - {0x8003, 79}, - {0x8006, 79}, - {0x800a, 79}, - {0x800f, 79}, - {0x8018, 79}, - {0x801f, 79}, - {0x8029, 79}, - {0xc038, 79}, - {0x8003, 80}, - {0x8006, 80}, - {0x800a, 80}, - {0x800f, 80}, - {0x8018, 80}, - {0x801f, 80}, - {0x8029, 80}, - {0xc038, 80}, + {0x03, 2, 79}, + {0x06, 2, 79}, + {0x0a, 2, 79}, + {0x0f, 2, 79}, + {0x18, 2, 79}, + {0x1f, 2, 79}, + {0x29, 2, 79}, + {0x38, 3, 79}, + {0x03, 2, 80}, + {0x06, 2, 80}, + {0x0a, 2, 80}, + {0x0f, 2, 80}, + {0x18, 2, 80}, + {0x1f, 2, 80}, + {0x29, 2, 80}, + {0x38, 3, 80}, }, /* 53 */ { - {0x8002, 81}, - {0x8009, 81}, - {0x8017, 81}, - {0xc028, 81}, - {0x8002, 82}, - {0x8009, 82}, - {0x8017, 82}, - {0xc028, 82}, - {0x8002, 83}, - {0x8009, 83}, - {0x8017, 83}, - {0xc028, 83}, - {0x8002, 84}, - {0x8009, 84}, - {0x8017, 84}, - {0xc028, 84}, + {0x02, 2, 81}, + {0x09, 2, 81}, + {0x17, 2, 81}, + {0x28, 3, 81}, + {0x02, 2, 82}, + {0x09, 2, 82}, + {0x17, 2, 82}, + {0x28, 3, 82}, + {0x02, 2, 83}, + {0x09, 2, 83}, + {0x17, 2, 83}, + {0x28, 3, 83}, + {0x02, 2, 84}, + {0x09, 2, 84}, + {0x17, 2, 84}, + {0x28, 3, 84}, }, /* 54 */ { - {0x8003, 81}, - {0x8006, 81}, - {0x800a, 81}, - {0x800f, 81}, - {0x8018, 81}, - {0x801f, 81}, - {0x8029, 81}, - {0xc038, 81}, - {0x8003, 82}, - {0x8006, 82}, - {0x800a, 82}, - {0x800f, 82}, - {0x8018, 82}, - {0x801f, 82}, - {0x8029, 82}, - {0xc038, 82}, + {0x03, 2, 81}, + {0x06, 2, 81}, + {0x0a, 2, 81}, + {0x0f, 2, 81}, + {0x18, 2, 81}, + {0x1f, 2, 81}, + {0x29, 2, 81}, + {0x38, 3, 81}, + {0x03, 2, 82}, + {0x06, 2, 82}, + {0x0a, 2, 82}, + {0x0f, 2, 82}, + {0x18, 2, 82}, + {0x1f, 2, 82}, + {0x29, 2, 82}, + {0x38, 3, 82}, }, /* 55 */ { - {0x8003, 83}, - {0x8006, 83}, - {0x800a, 83}, - {0x800f, 83}, - {0x8018, 83}, - {0x801f, 83}, - {0x8029, 83}, - {0xc038, 83}, - {0x8003, 84}, - {0x8006, 84}, - {0x800a, 84}, - {0x800f, 84}, - {0x8018, 84}, - {0x801f, 84}, - {0x8029, 84}, - {0xc038, 84}, + {0x03, 2, 83}, + {0x06, 2, 83}, + {0x0a, 2, 83}, + {0x0f, 2, 83}, + {0x18, 2, 83}, + {0x1f, 2, 83}, + {0x29, 2, 83}, + {0x38, 3, 83}, + {0x03, 2, 84}, + {0x06, 2, 84}, + {0x0a, 2, 84}, + {0x0f, 2, 84}, + {0x18, 2, 84}, + {0x1f, 2, 84}, + {0x29, 2, 84}, + {0x38, 3, 84}, }, /* 56 */ { - {0xc000, 85}, - {0xc000, 86}, - {0xc000, 87}, - {0xc000, 89}, - {0xc000, 106}, - {0xc000, 107}, - {0xc000, 113}, - {0xc000, 118}, - {0xc000, 119}, - {0xc000, 120}, - {0xc000, 121}, - {0xc000, 122}, - {0x46, 0}, - {0x47, 0}, - {0x49, 0}, - {0x404a, 0}, + {0x00, 3, 85}, + {0x00, 3, 86}, + {0x00, 3, 87}, + {0x00, 3, 89}, + {0x00, 3, 106}, + {0x00, 3, 107}, + {0x00, 3, 113}, + {0x00, 3, 118}, + {0x00, 3, 119}, + {0x00, 3, 120}, + {0x00, 3, 121}, + {0x00, 3, 122}, + {0x46, 0, 0}, + {0x47, 0, 0}, + {0x49, 0, 0}, + {0x4a, 1, 0}, }, /* 57 */ { - {0x8001, 85}, - {0xc016, 85}, - {0x8001, 86}, - {0xc016, 86}, - {0x8001, 87}, - {0xc016, 87}, - {0x8001, 89}, - {0xc016, 89}, - {0x8001, 106}, - {0xc016, 106}, - {0x8001, 107}, - {0xc016, 107}, - {0x8001, 113}, - {0xc016, 113}, - {0x8001, 118}, - {0xc016, 118}, + {0x01, 2, 85}, + {0x16, 3, 85}, + {0x01, 2, 86}, + {0x16, 3, 86}, + {0x01, 2, 87}, + {0x16, 3, 87}, + {0x01, 2, 89}, + {0x16, 3, 89}, + {0x01, 2, 106}, + {0x16, 3, 106}, + {0x01, 2, 107}, + {0x16, 3, 107}, + {0x01, 2, 113}, + {0x16, 3, 113}, + {0x01, 2, 118}, + {0x16, 3, 118}, }, /* 58 */ { - {0x8002, 85}, - {0x8009, 85}, - {0x8017, 85}, - {0xc028, 85}, - {0x8002, 86}, - {0x8009, 86}, - {0x8017, 86}, - {0xc028, 86}, - {0x8002, 87}, - {0x8009, 87}, - {0x8017, 87}, - {0xc028, 87}, - {0x8002, 89}, - {0x8009, 89}, - {0x8017, 89}, - {0xc028, 89}, + {0x02, 2, 85}, + {0x09, 2, 85}, + {0x17, 2, 85}, + {0x28, 3, 85}, + {0x02, 2, 86}, + {0x09, 2, 86}, + {0x17, 2, 86}, + {0x28, 3, 86}, + {0x02, 2, 87}, + {0x09, 2, 87}, + {0x17, 2, 87}, + {0x28, 3, 87}, + {0x02, 2, 89}, + {0x09, 2, 89}, + {0x17, 2, 89}, + {0x28, 3, 89}, }, /* 59 */ { - {0x8003, 85}, - {0x8006, 85}, - {0x800a, 85}, - {0x800f, 85}, - {0x8018, 85}, - {0x801f, 85}, - {0x8029, 85}, - {0xc038, 85}, - {0x8003, 86}, - {0x8006, 86}, - {0x800a, 86}, - {0x800f, 86}, - {0x8018, 86}, - {0x801f, 86}, - {0x8029, 86}, - {0xc038, 86}, + {0x03, 2, 85}, + {0x06, 2, 85}, + {0x0a, 2, 85}, + {0x0f, 2, 85}, + {0x18, 2, 85}, + {0x1f, 2, 85}, + {0x29, 2, 85}, + {0x38, 3, 85}, + {0x03, 2, 86}, + {0x06, 2, 86}, + {0x0a, 2, 86}, + {0x0f, 2, 86}, + {0x18, 2, 86}, + {0x1f, 2, 86}, + {0x29, 2, 86}, + {0x38, 3, 86}, }, /* 60 */ { - {0x8003, 87}, - {0x8006, 87}, - {0x800a, 87}, - {0x800f, 87}, - {0x8018, 87}, - {0x801f, 87}, - {0x8029, 87}, - {0xc038, 87}, - {0x8003, 89}, - {0x8006, 89}, - {0x800a, 89}, - {0x800f, 89}, - {0x8018, 89}, - {0x801f, 89}, - {0x8029, 89}, - {0xc038, 89}, + {0x03, 2, 87}, + {0x06, 2, 87}, + {0x0a, 2, 87}, + {0x0f, 2, 87}, + {0x18, 2, 87}, + {0x1f, 2, 87}, + {0x29, 2, 87}, + {0x38, 3, 87}, + {0x03, 2, 89}, + {0x06, 2, 89}, + {0x0a, 2, 89}, + {0x0f, 2, 89}, + {0x18, 2, 89}, + {0x1f, 2, 89}, + {0x29, 2, 89}, + {0x38, 3, 89}, }, /* 61 */ { - {0x8002, 106}, - {0x8009, 106}, - {0x8017, 106}, - {0xc028, 106}, - {0x8002, 107}, - {0x8009, 107}, - {0x8017, 107}, - {0xc028, 107}, - {0x8002, 113}, - {0x8009, 113}, - {0x8017, 113}, - {0xc028, 113}, - {0x8002, 118}, - {0x8009, 118}, - {0x8017, 118}, - {0xc028, 118}, + {0x02, 2, 106}, + {0x09, 2, 106}, + {0x17, 2, 106}, + {0x28, 3, 106}, + {0x02, 2, 107}, + {0x09, 2, 107}, + {0x17, 2, 107}, + {0x28, 3, 107}, + {0x02, 2, 113}, + {0x09, 2, 113}, + {0x17, 2, 113}, + {0x28, 3, 113}, + {0x02, 2, 118}, + {0x09, 2, 118}, + {0x17, 2, 118}, + {0x28, 3, 118}, }, /* 62 */ { - {0x8003, 106}, - {0x8006, 106}, - {0x800a, 106}, - {0x800f, 106}, - {0x8018, 106}, - {0x801f, 106}, - {0x8029, 106}, - {0xc038, 106}, - {0x8003, 107}, - {0x8006, 107}, - {0x800a, 107}, - {0x800f, 107}, - {0x8018, 107}, - {0x801f, 107}, - {0x8029, 107}, - {0xc038, 107}, + {0x03, 2, 106}, + {0x06, 2, 106}, + {0x0a, 2, 106}, + {0x0f, 2, 106}, + {0x18, 2, 106}, + {0x1f, 2, 106}, + {0x29, 2, 106}, + {0x38, 3, 106}, + {0x03, 2, 107}, + {0x06, 2, 107}, + {0x0a, 2, 107}, + {0x0f, 2, 107}, + {0x18, 2, 107}, + {0x1f, 2, 107}, + {0x29, 2, 107}, + {0x38, 3, 107}, }, /* 63 */ { - {0x8003, 113}, - {0x8006, 113}, - {0x800a, 113}, - {0x800f, 113}, - {0x8018, 113}, - {0x801f, 113}, - {0x8029, 113}, - {0xc038, 113}, - {0x8003, 118}, - {0x8006, 118}, - {0x800a, 118}, - {0x800f, 118}, - {0x8018, 118}, - {0x801f, 118}, - {0x8029, 118}, - {0xc038, 118}, + {0x03, 2, 113}, + {0x06, 2, 113}, + {0x0a, 2, 113}, + {0x0f, 2, 113}, + {0x18, 2, 113}, + {0x1f, 2, 113}, + {0x29, 2, 113}, + {0x38, 3, 113}, + {0x03, 2, 118}, + {0x06, 2, 118}, + {0x0a, 2, 118}, + {0x0f, 2, 118}, + {0x18, 2, 118}, + {0x1f, 2, 118}, + {0x29, 2, 118}, + {0x38, 3, 118}, }, /* 64 */ { - {0x8001, 119}, - {0xc016, 119}, - {0x8001, 120}, - {0xc016, 120}, - {0x8001, 121}, - {0xc016, 121}, - {0x8001, 122}, - {0xc016, 122}, - {0xc000, 38}, - {0xc000, 42}, - {0xc000, 44}, - {0xc000, 59}, - {0xc000, 88}, - {0xc000, 90}, - {0x4b, 0}, - {0x4e, 0}, + {0x01, 2, 119}, + {0x16, 3, 119}, + {0x01, 2, 120}, + {0x16, 3, 120}, + {0x01, 2, 121}, + {0x16, 3, 121}, + {0x01, 2, 122}, + {0x16, 3, 122}, + {0x00, 3, 38}, + {0x00, 3, 42}, + {0x00, 3, 44}, + {0x00, 3, 59}, + {0x00, 3, 88}, + {0x00, 3, 90}, + {0x4b, 0, 0}, + {0x4e, 0, 0}, }, /* 65 */ { - {0x8002, 119}, - {0x8009, 119}, - {0x8017, 119}, - {0xc028, 119}, - {0x8002, 120}, - {0x8009, 120}, - {0x8017, 120}, - {0xc028, 120}, - {0x8002, 121}, - {0x8009, 121}, - {0x8017, 121}, - {0xc028, 121}, - {0x8002, 122}, - {0x8009, 122}, - {0x8017, 122}, - {0xc028, 122}, + {0x02, 2, 119}, + {0x09, 2, 119}, + {0x17, 2, 119}, + {0x28, 3, 119}, + {0x02, 2, 120}, + {0x09, 2, 120}, + {0x17, 2, 120}, + {0x28, 3, 120}, + {0x02, 2, 121}, + {0x09, 2, 121}, + {0x17, 2, 121}, + {0x28, 3, 121}, + {0x02, 2, 122}, + {0x09, 2, 122}, + {0x17, 2, 122}, + {0x28, 3, 122}, }, /* 66 */ { - {0x8003, 119}, - {0x8006, 119}, - {0x800a, 119}, - {0x800f, 119}, - {0x8018, 119}, - {0x801f, 119}, - {0x8029, 119}, - {0xc038, 119}, - {0x8003, 120}, - {0x8006, 120}, - {0x800a, 120}, - {0x800f, 120}, - {0x8018, 120}, - {0x801f, 120}, - {0x8029, 120}, - {0xc038, 120}, + {0x03, 2, 119}, + {0x06, 2, 119}, + {0x0a, 2, 119}, + {0x0f, 2, 119}, + {0x18, 2, 119}, + {0x1f, 2, 119}, + {0x29, 2, 119}, + {0x38, 3, 119}, + {0x03, 2, 120}, + {0x06, 2, 120}, + {0x0a, 2, 120}, + {0x0f, 2, 120}, + {0x18, 2, 120}, + {0x1f, 2, 120}, + {0x29, 2, 120}, + {0x38, 3, 120}, }, /* 67 */ { - {0x8003, 121}, - {0x8006, 121}, - {0x800a, 121}, - {0x800f, 121}, - {0x8018, 121}, - {0x801f, 121}, - {0x8029, 121}, - {0xc038, 121}, - {0x8003, 122}, - {0x8006, 122}, - {0x800a, 122}, - {0x800f, 122}, - {0x8018, 122}, - {0x801f, 122}, - {0x8029, 122}, - {0xc038, 122}, + {0x03, 2, 121}, + {0x06, 2, 121}, + {0x0a, 2, 121}, + {0x0f, 2, 121}, + {0x18, 2, 121}, + {0x1f, 2, 121}, + {0x29, 2, 121}, + {0x38, 3, 121}, + {0x03, 2, 122}, + {0x06, 2, 122}, + {0x0a, 2, 122}, + {0x0f, 2, 122}, + {0x18, 2, 122}, + {0x1f, 2, 122}, + {0x29, 2, 122}, + {0x38, 3, 122}, }, /* 68 */ { - {0x8001, 38}, - {0xc016, 38}, - {0x8001, 42}, - {0xc016, 42}, - {0x8001, 44}, - {0xc016, 44}, - {0x8001, 59}, - {0xc016, 59}, - {0x8001, 88}, - {0xc016, 88}, - {0x8001, 90}, - {0xc016, 90}, - {0x4c, 0}, - {0x4d, 0}, - {0x4f, 0}, - {0x51, 0}, + {0x01, 2, 38}, + {0x16, 3, 38}, + {0x01, 2, 42}, + {0x16, 3, 42}, + {0x01, 2, 44}, + {0x16, 3, 44}, + {0x01, 2, 59}, + {0x16, 3, 59}, + {0x01, 2, 88}, + {0x16, 3, 88}, + {0x01, 2, 90}, + {0x16, 3, 90}, + {0x4c, 0, 0}, + {0x4d, 0, 0}, + {0x4f, 0, 0}, + {0x51, 0, 0}, }, /* 69 */ { - {0x8002, 38}, - {0x8009, 38}, - {0x8017, 38}, - {0xc028, 38}, - {0x8002, 42}, - {0x8009, 42}, - {0x8017, 42}, - {0xc028, 42}, - {0x8002, 44}, - {0x8009, 44}, - {0x8017, 44}, - {0xc028, 44}, - {0x8002, 59}, - {0x8009, 59}, - {0x8017, 59}, - {0xc028, 59}, + {0x02, 2, 38}, + {0x09, 2, 38}, + {0x17, 2, 38}, + {0x28, 3, 38}, + {0x02, 2, 42}, + {0x09, 2, 42}, + {0x17, 2, 42}, + {0x28, 3, 42}, + {0x02, 2, 44}, + {0x09, 2, 44}, + {0x17, 2, 44}, + {0x28, 3, 44}, + {0x02, 2, 59}, + {0x09, 2, 59}, + {0x17, 2, 59}, + {0x28, 3, 59}, }, /* 70 */ { - {0x8003, 38}, - {0x8006, 38}, - {0x800a, 38}, - {0x800f, 38}, - {0x8018, 38}, - {0x801f, 38}, - {0x8029, 38}, - {0xc038, 38}, - {0x8003, 42}, - {0x8006, 42}, - {0x800a, 42}, - {0x800f, 42}, - {0x8018, 42}, - {0x801f, 42}, - {0x8029, 42}, - {0xc038, 42}, + {0x03, 2, 38}, + {0x06, 2, 38}, + {0x0a, 2, 38}, + {0x0f, 2, 38}, + {0x18, 2, 38}, + {0x1f, 2, 38}, + {0x29, 2, 38}, + {0x38, 3, 38}, + {0x03, 2, 42}, + {0x06, 2, 42}, + {0x0a, 2, 42}, + {0x0f, 2, 42}, + {0x18, 2, 42}, + {0x1f, 2, 42}, + {0x29, 2, 42}, + {0x38, 3, 42}, }, /* 71 */ { - {0x8003, 44}, - {0x8006, 44}, - {0x800a, 44}, - {0x800f, 44}, - {0x8018, 44}, - {0x801f, 44}, - {0x8029, 44}, - {0xc038, 44}, - {0x8003, 59}, - {0x8006, 59}, - {0x800a, 59}, - {0x800f, 59}, - {0x8018, 59}, - {0x801f, 59}, - {0x8029, 59}, - {0xc038, 59}, + {0x03, 2, 44}, + {0x06, 2, 44}, + {0x0a, 2, 44}, + {0x0f, 2, 44}, + {0x18, 2, 44}, + {0x1f, 2, 44}, + {0x29, 2, 44}, + {0x38, 3, 44}, + {0x03, 2, 59}, + {0x06, 2, 59}, + {0x0a, 2, 59}, + {0x0f, 2, 59}, + {0x18, 2, 59}, + {0x1f, 2, 59}, + {0x29, 2, 59}, + {0x38, 3, 59}, }, /* 72 */ { - {0x8002, 88}, - {0x8009, 88}, - {0x8017, 88}, - {0xc028, 88}, - {0x8002, 90}, - {0x8009, 90}, - {0x8017, 90}, - {0xc028, 90}, - {0xc000, 33}, - {0xc000, 34}, - {0xc000, 40}, - {0xc000, 41}, - {0xc000, 63}, - {0x50, 0}, - {0x52, 0}, - {0x54, 0}, + {0x02, 2, 88}, + {0x09, 2, 88}, + {0x17, 2, 88}, + {0x28, 3, 88}, + {0x02, 2, 90}, + {0x09, 2, 90}, + {0x17, 2, 90}, + {0x28, 3, 90}, + {0x00, 3, 33}, + {0x00, 3, 34}, + {0x00, 3, 40}, + {0x00, 3, 41}, + {0x00, 3, 63}, + {0x50, 0, 0}, + {0x52, 0, 0}, + {0x54, 0, 0}, }, /* 73 */ { - {0x8003, 88}, - {0x8006, 88}, - {0x800a, 88}, - {0x800f, 88}, - {0x8018, 88}, - {0x801f, 88}, - {0x8029, 88}, - {0xc038, 88}, - {0x8003, 90}, - {0x8006, 90}, - {0x800a, 90}, - {0x800f, 90}, - {0x8018, 90}, - {0x801f, 90}, - {0x8029, 90}, - {0xc038, 90}, + {0x03, 2, 88}, + {0x06, 2, 88}, + {0x0a, 2, 88}, + {0x0f, 2, 88}, + {0x18, 2, 88}, + {0x1f, 2, 88}, + {0x29, 2, 88}, + {0x38, 3, 88}, + {0x03, 2, 90}, + {0x06, 2, 90}, + {0x0a, 2, 90}, + {0x0f, 2, 90}, + {0x18, 2, 90}, + {0x1f, 2, 90}, + {0x29, 2, 90}, + {0x38, 3, 90}, }, /* 74 */ { - {0x8001, 33}, - {0xc016, 33}, - {0x8001, 34}, - {0xc016, 34}, - {0x8001, 40}, - {0xc016, 40}, - {0x8001, 41}, - {0xc016, 41}, - {0x8001, 63}, - {0xc016, 63}, - {0xc000, 39}, - {0xc000, 43}, - {0xc000, 124}, - {0x53, 0}, - {0x55, 0}, - {0x58, 0}, + {0x01, 2, 33}, + {0x16, 3, 33}, + {0x01, 2, 34}, + {0x16, 3, 34}, + {0x01, 2, 40}, + {0x16, 3, 40}, + {0x01, 2, 41}, + {0x16, 3, 41}, + {0x01, 2, 63}, + {0x16, 3, 63}, + {0x00, 3, 39}, + {0x00, 3, 43}, + {0x00, 3, 124}, + {0x53, 0, 0}, + {0x55, 0, 0}, + {0x58, 0, 0}, }, /* 75 */ { - {0x8002, 33}, - {0x8009, 33}, - {0x8017, 33}, - {0xc028, 33}, - {0x8002, 34}, - {0x8009, 34}, - {0x8017, 34}, - {0xc028, 34}, - {0x8002, 40}, - {0x8009, 40}, - {0x8017, 40}, - {0xc028, 40}, - {0x8002, 41}, - {0x8009, 41}, - {0x8017, 41}, - {0xc028, 41}, + {0x02, 2, 33}, + {0x09, 2, 33}, + {0x17, 2, 33}, + {0x28, 3, 33}, + {0x02, 2, 34}, + {0x09, 2, 34}, + {0x17, 2, 34}, + {0x28, 3, 34}, + {0x02, 2, 40}, + {0x09, 2, 40}, + {0x17, 2, 40}, + {0x28, 3, 40}, + {0x02, 2, 41}, + {0x09, 2, 41}, + {0x17, 2, 41}, + {0x28, 3, 41}, }, /* 76 */ { - {0x8003, 33}, - {0x8006, 33}, - {0x800a, 33}, - {0x800f, 33}, - {0x8018, 33}, - {0x801f, 33}, - {0x8029, 33}, - {0xc038, 33}, - {0x8003, 34}, - {0x8006, 34}, - {0x800a, 34}, - {0x800f, 34}, - {0x8018, 34}, - {0x801f, 34}, - {0x8029, 34}, - {0xc038, 34}, + {0x03, 2, 33}, + {0x06, 2, 33}, + {0x0a, 2, 33}, + {0x0f, 2, 33}, + {0x18, 2, 33}, + {0x1f, 2, 33}, + {0x29, 2, 33}, + {0x38, 3, 33}, + {0x03, 2, 34}, + {0x06, 2, 34}, + {0x0a, 2, 34}, + {0x0f, 2, 34}, + {0x18, 2, 34}, + {0x1f, 2, 34}, + {0x29, 2, 34}, + {0x38, 3, 34}, }, /* 77 */ { - {0x8003, 40}, - {0x8006, 40}, - {0x800a, 40}, - {0x800f, 40}, - {0x8018, 40}, - {0x801f, 40}, - {0x8029, 40}, - {0xc038, 40}, - {0x8003, 41}, - {0x8006, 41}, - {0x800a, 41}, - {0x800f, 41}, - {0x8018, 41}, - {0x801f, 41}, - {0x8029, 41}, - {0xc038, 41}, + {0x03, 2, 40}, + {0x06, 2, 40}, + {0x0a, 2, 40}, + {0x0f, 2, 40}, + {0x18, 2, 40}, + {0x1f, 2, 40}, + {0x29, 2, 40}, + {0x38, 3, 40}, + {0x03, 2, 41}, + {0x06, 2, 41}, + {0x0a, 2, 41}, + {0x0f, 2, 41}, + {0x18, 2, 41}, + {0x1f, 2, 41}, + {0x29, 2, 41}, + {0x38, 3, 41}, }, /* 78 */ { - {0x8002, 63}, - {0x8009, 63}, - {0x8017, 63}, - {0xc028, 63}, - {0x8001, 39}, - {0xc016, 39}, - {0x8001, 43}, - {0xc016, 43}, - {0x8001, 124}, - {0xc016, 124}, - {0xc000, 35}, - {0xc000, 62}, - {0x56, 0}, - {0x57, 0}, - {0x59, 0}, - {0x5a, 0}, + {0x02, 2, 63}, + {0x09, 2, 63}, + {0x17, 2, 63}, + {0x28, 3, 63}, + {0x01, 2, 39}, + {0x16, 3, 39}, + {0x01, 2, 43}, + {0x16, 3, 43}, + {0x01, 2, 124}, + {0x16, 3, 124}, + {0x00, 3, 35}, + {0x00, 3, 62}, + {0x56, 0, 0}, + {0x57, 0, 0}, + {0x59, 0, 0}, + {0x5a, 0, 0}, }, /* 79 */ { - {0x8003, 63}, - {0x8006, 63}, - {0x800a, 63}, - {0x800f, 63}, - {0x8018, 63}, - {0x801f, 63}, - {0x8029, 63}, - {0xc038, 63}, - {0x8002, 39}, - {0x8009, 39}, - {0x8017, 39}, - {0xc028, 39}, - {0x8002, 43}, - {0x8009, 43}, - {0x8017, 43}, - {0xc028, 43}, + {0x03, 2, 63}, + {0x06, 2, 63}, + {0x0a, 2, 63}, + {0x0f, 2, 63}, + {0x18, 2, 63}, + {0x1f, 2, 63}, + {0x29, 2, 63}, + {0x38, 3, 63}, + {0x02, 2, 39}, + {0x09, 2, 39}, + {0x17, 2, 39}, + {0x28, 3, 39}, + {0x02, 2, 43}, + {0x09, 2, 43}, + {0x17, 2, 43}, + {0x28, 3, 43}, }, /* 80 */ { - {0x8003, 39}, - {0x8006, 39}, - {0x800a, 39}, - {0x800f, 39}, - {0x8018, 39}, - {0x801f, 39}, - {0x8029, 39}, - {0xc038, 39}, - {0x8003, 43}, - {0x8006, 43}, - {0x800a, 43}, - {0x800f, 43}, - {0x8018, 43}, - {0x801f, 43}, - {0x8029, 43}, - {0xc038, 43}, + {0x03, 2, 39}, + {0x06, 2, 39}, + {0x0a, 2, 39}, + {0x0f, 2, 39}, + {0x18, 2, 39}, + {0x1f, 2, 39}, + {0x29, 2, 39}, + {0x38, 3, 39}, + {0x03, 2, 43}, + {0x06, 2, 43}, + {0x0a, 2, 43}, + {0x0f, 2, 43}, + {0x18, 2, 43}, + {0x1f, 2, 43}, + {0x29, 2, 43}, + {0x38, 3, 43}, }, /* 81 */ { - {0x8002, 124}, - {0x8009, 124}, - {0x8017, 124}, - {0xc028, 124}, - {0x8001, 35}, - {0xc016, 35}, - {0x8001, 62}, - {0xc016, 62}, - {0xc000, 0}, - {0xc000, 36}, - {0xc000, 64}, - {0xc000, 91}, - {0xc000, 93}, - {0xc000, 126}, - {0x5b, 0}, - {0x5c, 0}, + {0x02, 2, 124}, + {0x09, 2, 124}, + {0x17, 2, 124}, + {0x28, 3, 124}, + {0x01, 2, 35}, + {0x16, 3, 35}, + {0x01, 2, 62}, + {0x16, 3, 62}, + {0x00, 3, 0}, + {0x00, 3, 36}, + {0x00, 3, 64}, + {0x00, 3, 91}, + {0x00, 3, 93}, + {0x00, 3, 126}, + {0x5b, 0, 0}, + {0x5c, 0, 0}, }, /* 82 */ { - {0x8003, 124}, - {0x8006, 124}, - {0x800a, 124}, - {0x800f, 124}, - {0x8018, 124}, - {0x801f, 124}, - {0x8029, 124}, - {0xc038, 124}, - {0x8002, 35}, - {0x8009, 35}, - {0x8017, 35}, - {0xc028, 35}, - {0x8002, 62}, - {0x8009, 62}, - {0x8017, 62}, - {0xc028, 62}, + {0x03, 2, 124}, + {0x06, 2, 124}, + {0x0a, 2, 124}, + {0x0f, 2, 124}, + {0x18, 2, 124}, + {0x1f, 2, 124}, + {0x29, 2, 124}, + {0x38, 3, 124}, + {0x02, 2, 35}, + {0x09, 2, 35}, + {0x17, 2, 35}, + {0x28, 3, 35}, + {0x02, 2, 62}, + {0x09, 2, 62}, + {0x17, 2, 62}, + {0x28, 3, 62}, }, /* 83 */ { - {0x8003, 35}, - {0x8006, 35}, - {0x800a, 35}, - {0x800f, 35}, - {0x8018, 35}, - {0x801f, 35}, - {0x8029, 35}, - {0xc038, 35}, - {0x8003, 62}, - {0x8006, 62}, - {0x800a, 62}, - {0x800f, 62}, - {0x8018, 62}, - {0x801f, 62}, - {0x8029, 62}, - {0xc038, 62}, + {0x03, 2, 35}, + {0x06, 2, 35}, + {0x0a, 2, 35}, + {0x0f, 2, 35}, + {0x18, 2, 35}, + {0x1f, 2, 35}, + {0x29, 2, 35}, + {0x38, 3, 35}, + {0x03, 2, 62}, + {0x06, 2, 62}, + {0x0a, 2, 62}, + {0x0f, 2, 62}, + {0x18, 2, 62}, + {0x1f, 2, 62}, + {0x29, 2, 62}, + {0x38, 3, 62}, }, /* 84 */ { - {0x8001, 0}, - {0xc016, 0}, - {0x8001, 36}, - {0xc016, 36}, - {0x8001, 64}, - {0xc016, 64}, - {0x8001, 91}, - {0xc016, 91}, - {0x8001, 93}, - {0xc016, 93}, - {0x8001, 126}, - {0xc016, 126}, - {0xc000, 94}, - {0xc000, 125}, - {0x5d, 0}, - {0x5e, 0}, + {0x01, 2, 0}, + {0x16, 3, 0}, + {0x01, 2, 36}, + {0x16, 3, 36}, + {0x01, 2, 64}, + {0x16, 3, 64}, + {0x01, 2, 91}, + {0x16, 3, 91}, + {0x01, 2, 93}, + {0x16, 3, 93}, + {0x01, 2, 126}, + {0x16, 3, 126}, + {0x00, 3, 94}, + {0x00, 3, 125}, + {0x5d, 0, 0}, + {0x5e, 0, 0}, }, /* 85 */ { - {0x8002, 0}, - {0x8009, 0}, - {0x8017, 0}, - {0xc028, 0}, - {0x8002, 36}, - {0x8009, 36}, - {0x8017, 36}, - {0xc028, 36}, - {0x8002, 64}, - {0x8009, 64}, - {0x8017, 64}, - {0xc028, 64}, - {0x8002, 91}, - {0x8009, 91}, - {0x8017, 91}, - {0xc028, 91}, + {0x02, 2, 0}, + {0x09, 2, 0}, + {0x17, 2, 0}, + {0x28, 3, 0}, + {0x02, 2, 36}, + {0x09, 2, 36}, + {0x17, 2, 36}, + {0x28, 3, 36}, + {0x02, 2, 64}, + {0x09, 2, 64}, + {0x17, 2, 64}, + {0x28, 3, 64}, + {0x02, 2, 91}, + {0x09, 2, 91}, + {0x17, 2, 91}, + {0x28, 3, 91}, }, /* 86 */ { - {0x8003, 0}, - {0x8006, 0}, - {0x800a, 0}, - {0x800f, 0}, - {0x8018, 0}, - {0x801f, 0}, - {0x8029, 0}, - {0xc038, 0}, - {0x8003, 36}, - {0x8006, 36}, - {0x800a, 36}, - {0x800f, 36}, - {0x8018, 36}, - {0x801f, 36}, - {0x8029, 36}, - {0xc038, 36}, + {0x03, 2, 0}, + {0x06, 2, 0}, + {0x0a, 2, 0}, + {0x0f, 2, 0}, + {0x18, 2, 0}, + {0x1f, 2, 0}, + {0x29, 2, 0}, + {0x38, 3, 0}, + {0x03, 2, 36}, + {0x06, 2, 36}, + {0x0a, 2, 36}, + {0x0f, 2, 36}, + {0x18, 2, 36}, + {0x1f, 2, 36}, + {0x29, 2, 36}, + {0x38, 3, 36}, }, /* 87 */ { - {0x8003, 64}, - {0x8006, 64}, - {0x800a, 64}, - {0x800f, 64}, - {0x8018, 64}, - {0x801f, 64}, - {0x8029, 64}, - {0xc038, 64}, - {0x8003, 91}, - {0x8006, 91}, - {0x800a, 91}, - {0x800f, 91}, - {0x8018, 91}, - {0x801f, 91}, - {0x8029, 91}, - {0xc038, 91}, + {0x03, 2, 64}, + {0x06, 2, 64}, + {0x0a, 2, 64}, + {0x0f, 2, 64}, + {0x18, 2, 64}, + {0x1f, 2, 64}, + {0x29, 2, 64}, + {0x38, 3, 64}, + {0x03, 2, 91}, + {0x06, 2, 91}, + {0x0a, 2, 91}, + {0x0f, 2, 91}, + {0x18, 2, 91}, + {0x1f, 2, 91}, + {0x29, 2, 91}, + {0x38, 3, 91}, }, /* 88 */ { - {0x8002, 93}, - {0x8009, 93}, - {0x8017, 93}, - {0xc028, 93}, - {0x8002, 126}, - {0x8009, 126}, - {0x8017, 126}, - {0xc028, 126}, - {0x8001, 94}, - {0xc016, 94}, - {0x8001, 125}, - {0xc016, 125}, - {0xc000, 60}, - {0xc000, 96}, - {0xc000, 123}, - {0x5f, 0}, + {0x02, 2, 93}, + {0x09, 2, 93}, + {0x17, 2, 93}, + {0x28, 3, 93}, + {0x02, 2, 126}, + {0x09, 2, 126}, + {0x17, 2, 126}, + {0x28, 3, 126}, + {0x01, 2, 94}, + {0x16, 3, 94}, + {0x01, 2, 125}, + {0x16, 3, 125}, + {0x00, 3, 60}, + {0x00, 3, 96}, + {0x00, 3, 123}, + {0x5f, 0, 0}, }, /* 89 */ { - {0x8003, 93}, - {0x8006, 93}, - {0x800a, 93}, - {0x800f, 93}, - {0x8018, 93}, - {0x801f, 93}, - {0x8029, 93}, - {0xc038, 93}, - {0x8003, 126}, - {0x8006, 126}, - {0x800a, 126}, - {0x800f, 126}, - {0x8018, 126}, - {0x801f, 126}, - {0x8029, 126}, - {0xc038, 126}, + {0x03, 2, 93}, + {0x06, 2, 93}, + {0x0a, 2, 93}, + {0x0f, 2, 93}, + {0x18, 2, 93}, + {0x1f, 2, 93}, + {0x29, 2, 93}, + {0x38, 3, 93}, + {0x03, 2, 126}, + {0x06, 2, 126}, + {0x0a, 2, 126}, + {0x0f, 2, 126}, + {0x18, 2, 126}, + {0x1f, 2, 126}, + {0x29, 2, 126}, + {0x38, 3, 126}, }, /* 90 */ { - {0x8002, 94}, - {0x8009, 94}, - {0x8017, 94}, - {0xc028, 94}, - {0x8002, 125}, - {0x8009, 125}, - {0x8017, 125}, - {0xc028, 125}, - {0x8001, 60}, - {0xc016, 60}, - {0x8001, 96}, - {0xc016, 96}, - {0x8001, 123}, - {0xc016, 123}, - {0x60, 0}, - {0x6e, 0}, + {0x02, 2, 94}, + {0x09, 2, 94}, + {0x17, 2, 94}, + {0x28, 3, 94}, + {0x02, 2, 125}, + {0x09, 2, 125}, + {0x17, 2, 125}, + {0x28, 3, 125}, + {0x01, 2, 60}, + {0x16, 3, 60}, + {0x01, 2, 96}, + {0x16, 3, 96}, + {0x01, 2, 123}, + {0x16, 3, 123}, + {0x60, 0, 0}, + {0x6e, 0, 0}, }, /* 91 */ { - {0x8003, 94}, - {0x8006, 94}, - {0x800a, 94}, - {0x800f, 94}, - {0x8018, 94}, - {0x801f, 94}, - {0x8029, 94}, - {0xc038, 94}, - {0x8003, 125}, - {0x8006, 125}, - {0x800a, 125}, - {0x800f, 125}, - {0x8018, 125}, - {0x801f, 125}, - {0x8029, 125}, - {0xc038, 125}, + {0x03, 2, 94}, + {0x06, 2, 94}, + {0x0a, 2, 94}, + {0x0f, 2, 94}, + {0x18, 2, 94}, + {0x1f, 2, 94}, + {0x29, 2, 94}, + {0x38, 3, 94}, + {0x03, 2, 125}, + {0x06, 2, 125}, + {0x0a, 2, 125}, + {0x0f, 2, 125}, + {0x18, 2, 125}, + {0x1f, 2, 125}, + {0x29, 2, 125}, + {0x38, 3, 125}, }, /* 92 */ { - {0x8002, 60}, - {0x8009, 60}, - {0x8017, 60}, - {0xc028, 60}, - {0x8002, 96}, - {0x8009, 96}, - {0x8017, 96}, - {0xc028, 96}, - {0x8002, 123}, - {0x8009, 123}, - {0x8017, 123}, - {0xc028, 123}, - {0x61, 0}, - {0x65, 0}, - {0x6f, 0}, - {0x85, 0}, + {0x02, 2, 60}, + {0x09, 2, 60}, + {0x17, 2, 60}, + {0x28, 3, 60}, + {0x02, 2, 96}, + {0x09, 2, 96}, + {0x17, 2, 96}, + {0x28, 3, 96}, + {0x02, 2, 123}, + {0x09, 2, 123}, + {0x17, 2, 123}, + {0x28, 3, 123}, + {0x61, 0, 0}, + {0x65, 0, 0}, + {0x6f, 0, 0}, + {0x85, 0, 0}, }, /* 93 */ { - {0x8003, 60}, - {0x8006, 60}, - {0x800a, 60}, - {0x800f, 60}, - {0x8018, 60}, - {0x801f, 60}, - {0x8029, 60}, - {0xc038, 60}, - {0x8003, 96}, - {0x8006, 96}, - {0x800a, 96}, - {0x800f, 96}, - {0x8018, 96}, - {0x801f, 96}, - {0x8029, 96}, - {0xc038, 96}, + {0x03, 2, 60}, + {0x06, 2, 60}, + {0x0a, 2, 60}, + {0x0f, 2, 60}, + {0x18, 2, 60}, + {0x1f, 2, 60}, + {0x29, 2, 60}, + {0x38, 3, 60}, + {0x03, 2, 96}, + {0x06, 2, 96}, + {0x0a, 2, 96}, + {0x0f, 2, 96}, + {0x18, 2, 96}, + {0x1f, 2, 96}, + {0x29, 2, 96}, + {0x38, 3, 96}, }, /* 94 */ { - {0x8003, 123}, - {0x8006, 123}, - {0x800a, 123}, - {0x800f, 123}, - {0x8018, 123}, - {0x801f, 123}, - {0x8029, 123}, - {0xc038, 123}, - {0x62, 0}, - {0x63, 0}, - {0x66, 0}, - {0x69, 0}, - {0x70, 0}, - {0x77, 0}, - {0x86, 0}, - {0x99, 0}, + {0x03, 2, 123}, + {0x06, 2, 123}, + {0x0a, 2, 123}, + {0x0f, 2, 123}, + {0x18, 2, 123}, + {0x1f, 2, 123}, + {0x29, 2, 123}, + {0x38, 3, 123}, + {0x62, 0, 0}, + {0x63, 0, 0}, + {0x66, 0, 0}, + {0x69, 0, 0}, + {0x70, 0, 0}, + {0x77, 0, 0}, + {0x86, 0, 0}, + {0x99, 0, 0}, }, /* 95 */ { - {0xc000, 92}, - {0xc000, 195}, - {0xc000, 208}, - {0x64, 0}, - {0x67, 0}, - {0x68, 0}, - {0x6a, 0}, - {0x6b, 0}, - {0x71, 0}, - {0x74, 0}, - {0x78, 0}, - {0x7e, 0}, - {0x87, 0}, - {0x8e, 0}, - {0x9a, 0}, - {0xa9, 0}, + {0x00, 3, 92}, + {0x00, 3, 195}, + {0x00, 3, 208}, + {0x64, 0, 0}, + {0x67, 0, 0}, + {0x68, 0, 0}, + {0x6a, 0, 0}, + {0x6b, 0, 0}, + {0x71, 0, 0}, + {0x74, 0, 0}, + {0x78, 0, 0}, + {0x7e, 0, 0}, + {0x87, 0, 0}, + {0x8e, 0, 0}, + {0x9a, 0, 0}, + {0xa9, 0, 0}, }, /* 96 */ { - {0x8001, 92}, - {0xc016, 92}, - {0x8001, 195}, - {0xc016, 195}, - {0x8001, 208}, - {0xc016, 208}, - {0xc000, 128}, - {0xc000, 130}, - {0xc000, 131}, - {0xc000, 162}, - {0xc000, 184}, - {0xc000, 194}, - {0xc000, 224}, - {0xc000, 226}, - {0x6c, 0}, - {0x6d, 0}, + {0x01, 2, 92}, + {0x16, 3, 92}, + {0x01, 2, 195}, + {0x16, 3, 195}, + {0x01, 2, 208}, + {0x16, 3, 208}, + {0x00, 3, 128}, + {0x00, 3, 130}, + {0x00, 3, 131}, + {0x00, 3, 162}, + {0x00, 3, 184}, + {0x00, 3, 194}, + {0x00, 3, 224}, + {0x00, 3, 226}, + {0x6c, 0, 0}, + {0x6d, 0, 0}, }, /* 97 */ { - {0x8002, 92}, - {0x8009, 92}, - {0x8017, 92}, - {0xc028, 92}, - {0x8002, 195}, - {0x8009, 195}, - {0x8017, 195}, - {0xc028, 195}, - {0x8002, 208}, - {0x8009, 208}, - {0x8017, 208}, - {0xc028, 208}, - {0x8001, 128}, - {0xc016, 128}, - {0x8001, 130}, - {0xc016, 130}, + {0x02, 2, 92}, + {0x09, 2, 92}, + {0x17, 2, 92}, + {0x28, 3, 92}, + {0x02, 2, 195}, + {0x09, 2, 195}, + {0x17, 2, 195}, + {0x28, 3, 195}, + {0x02, 2, 208}, + {0x09, 2, 208}, + {0x17, 2, 208}, + {0x28, 3, 208}, + {0x01, 2, 128}, + {0x16, 3, 128}, + {0x01, 2, 130}, + {0x16, 3, 130}, }, /* 98 */ { - {0x8003, 92}, - {0x8006, 92}, - {0x800a, 92}, - {0x800f, 92}, - {0x8018, 92}, - {0x801f, 92}, - {0x8029, 92}, - {0xc038, 92}, - {0x8003, 195}, - {0x8006, 195}, - {0x800a, 195}, - {0x800f, 195}, - {0x8018, 195}, - {0x801f, 195}, - {0x8029, 195}, - {0xc038, 195}, + {0x03, 2, 92}, + {0x06, 2, 92}, + {0x0a, 2, 92}, + {0x0f, 2, 92}, + {0x18, 2, 92}, + {0x1f, 2, 92}, + {0x29, 2, 92}, + {0x38, 3, 92}, + {0x03, 2, 195}, + {0x06, 2, 195}, + {0x0a, 2, 195}, + {0x0f, 2, 195}, + {0x18, 2, 195}, + {0x1f, 2, 195}, + {0x29, 2, 195}, + {0x38, 3, 195}, }, /* 99 */ { - {0x8003, 208}, - {0x8006, 208}, - {0x800a, 208}, - {0x800f, 208}, - {0x8018, 208}, - {0x801f, 208}, - {0x8029, 208}, - {0xc038, 208}, - {0x8002, 128}, - {0x8009, 128}, - {0x8017, 128}, - {0xc028, 128}, - {0x8002, 130}, - {0x8009, 130}, - {0x8017, 130}, - {0xc028, 130}, + {0x03, 2, 208}, + {0x06, 2, 208}, + {0x0a, 2, 208}, + {0x0f, 2, 208}, + {0x18, 2, 208}, + {0x1f, 2, 208}, + {0x29, 2, 208}, + {0x38, 3, 208}, + {0x02, 2, 128}, + {0x09, 2, 128}, + {0x17, 2, 128}, + {0x28, 3, 128}, + {0x02, 2, 130}, + {0x09, 2, 130}, + {0x17, 2, 130}, + {0x28, 3, 130}, }, /* 100 */ { - {0x8003, 128}, - {0x8006, 128}, - {0x800a, 128}, - {0x800f, 128}, - {0x8018, 128}, - {0x801f, 128}, - {0x8029, 128}, - {0xc038, 128}, - {0x8003, 130}, - {0x8006, 130}, - {0x800a, 130}, - {0x800f, 130}, - {0x8018, 130}, - {0x801f, 130}, - {0x8029, 130}, - {0xc038, 130}, + {0x03, 2, 128}, + {0x06, 2, 128}, + {0x0a, 2, 128}, + {0x0f, 2, 128}, + {0x18, 2, 128}, + {0x1f, 2, 128}, + {0x29, 2, 128}, + {0x38, 3, 128}, + {0x03, 2, 130}, + {0x06, 2, 130}, + {0x0a, 2, 130}, + {0x0f, 2, 130}, + {0x18, 2, 130}, + {0x1f, 2, 130}, + {0x29, 2, 130}, + {0x38, 3, 130}, }, /* 101 */ { - {0x8001, 131}, - {0xc016, 131}, - {0x8001, 162}, - {0xc016, 162}, - {0x8001, 184}, - {0xc016, 184}, - {0x8001, 194}, - {0xc016, 194}, - {0x8001, 224}, - {0xc016, 224}, - {0x8001, 226}, - {0xc016, 226}, - {0xc000, 153}, - {0xc000, 161}, - {0xc000, 167}, - {0xc000, 172}, + {0x01, 2, 131}, + {0x16, 3, 131}, + {0x01, 2, 162}, + {0x16, 3, 162}, + {0x01, 2, 184}, + {0x16, 3, 184}, + {0x01, 2, 194}, + {0x16, 3, 194}, + {0x01, 2, 224}, + {0x16, 3, 224}, + {0x01, 2, 226}, + {0x16, 3, 226}, + {0x00, 3, 153}, + {0x00, 3, 161}, + {0x00, 3, 167}, + {0x00, 3, 172}, }, /* 102 */ { - {0x8002, 131}, - {0x8009, 131}, - {0x8017, 131}, - {0xc028, 131}, - {0x8002, 162}, - {0x8009, 162}, - {0x8017, 162}, - {0xc028, 162}, - {0x8002, 184}, - {0x8009, 184}, - {0x8017, 184}, - {0xc028, 184}, - {0x8002, 194}, - {0x8009, 194}, - {0x8017, 194}, - {0xc028, 194}, + {0x02, 2, 131}, + {0x09, 2, 131}, + {0x17, 2, 131}, + {0x28, 3, 131}, + {0x02, 2, 162}, + {0x09, 2, 162}, + {0x17, 2, 162}, + {0x28, 3, 162}, + {0x02, 2, 184}, + {0x09, 2, 184}, + {0x17, 2, 184}, + {0x28, 3, 184}, + {0x02, 2, 194}, + {0x09, 2, 194}, + {0x17, 2, 194}, + {0x28, 3, 194}, }, /* 103 */ { - {0x8003, 131}, - {0x8006, 131}, - {0x800a, 131}, - {0x800f, 131}, - {0x8018, 131}, - {0x801f, 131}, - {0x8029, 131}, - {0xc038, 131}, - {0x8003, 162}, - {0x8006, 162}, - {0x800a, 162}, - {0x800f, 162}, - {0x8018, 162}, - {0x801f, 162}, - {0x8029, 162}, - {0xc038, 162}, + {0x03, 2, 131}, + {0x06, 2, 131}, + {0x0a, 2, 131}, + {0x0f, 2, 131}, + {0x18, 2, 131}, + {0x1f, 2, 131}, + {0x29, 2, 131}, + {0x38, 3, 131}, + {0x03, 2, 162}, + {0x06, 2, 162}, + {0x0a, 2, 162}, + {0x0f, 2, 162}, + {0x18, 2, 162}, + {0x1f, 2, 162}, + {0x29, 2, 162}, + {0x38, 3, 162}, }, /* 104 */ { - {0x8003, 184}, - {0x8006, 184}, - {0x800a, 184}, - {0x800f, 184}, - {0x8018, 184}, - {0x801f, 184}, - {0x8029, 184}, - {0xc038, 184}, - {0x8003, 194}, - {0x8006, 194}, - {0x800a, 194}, - {0x800f, 194}, - {0x8018, 194}, - {0x801f, 194}, - {0x8029, 194}, - {0xc038, 194}, + {0x03, 2, 184}, + {0x06, 2, 184}, + {0x0a, 2, 184}, + {0x0f, 2, 184}, + {0x18, 2, 184}, + {0x1f, 2, 184}, + {0x29, 2, 184}, + {0x38, 3, 184}, + {0x03, 2, 194}, + {0x06, 2, 194}, + {0x0a, 2, 194}, + {0x0f, 2, 194}, + {0x18, 2, 194}, + {0x1f, 2, 194}, + {0x29, 2, 194}, + {0x38, 3, 194}, }, /* 105 */ { - {0x8002, 224}, - {0x8009, 224}, - {0x8017, 224}, - {0xc028, 224}, - {0x8002, 226}, - {0x8009, 226}, - {0x8017, 226}, - {0xc028, 226}, - {0x8001, 153}, - {0xc016, 153}, - {0x8001, 161}, - {0xc016, 161}, - {0x8001, 167}, - {0xc016, 167}, - {0x8001, 172}, - {0xc016, 172}, + {0x02, 2, 224}, + {0x09, 2, 224}, + {0x17, 2, 224}, + {0x28, 3, 224}, + {0x02, 2, 226}, + {0x09, 2, 226}, + {0x17, 2, 226}, + {0x28, 3, 226}, + {0x01, 2, 153}, + {0x16, 3, 153}, + {0x01, 2, 161}, + {0x16, 3, 161}, + {0x01, 2, 167}, + {0x16, 3, 167}, + {0x01, 2, 172}, + {0x16, 3, 172}, }, /* 106 */ { - {0x8003, 224}, - {0x8006, 224}, - {0x800a, 224}, - {0x800f, 224}, - {0x8018, 224}, - {0x801f, 224}, - {0x8029, 224}, - {0xc038, 224}, - {0x8003, 226}, - {0x8006, 226}, - {0x800a, 226}, - {0x800f, 226}, - {0x8018, 226}, - {0x801f, 226}, - {0x8029, 226}, - {0xc038, 226}, + {0x03, 2, 224}, + {0x06, 2, 224}, + {0x0a, 2, 224}, + {0x0f, 2, 224}, + {0x18, 2, 224}, + {0x1f, 2, 224}, + {0x29, 2, 224}, + {0x38, 3, 224}, + {0x03, 2, 226}, + {0x06, 2, 226}, + {0x0a, 2, 226}, + {0x0f, 2, 226}, + {0x18, 2, 226}, + {0x1f, 2, 226}, + {0x29, 2, 226}, + {0x38, 3, 226}, }, /* 107 */ { - {0x8002, 153}, - {0x8009, 153}, - {0x8017, 153}, - {0xc028, 153}, - {0x8002, 161}, - {0x8009, 161}, - {0x8017, 161}, - {0xc028, 161}, - {0x8002, 167}, - {0x8009, 167}, - {0x8017, 167}, - {0xc028, 167}, - {0x8002, 172}, - {0x8009, 172}, - {0x8017, 172}, - {0xc028, 172}, + {0x02, 2, 153}, + {0x09, 2, 153}, + {0x17, 2, 153}, + {0x28, 3, 153}, + {0x02, 2, 161}, + {0x09, 2, 161}, + {0x17, 2, 161}, + {0x28, 3, 161}, + {0x02, 2, 167}, + {0x09, 2, 167}, + {0x17, 2, 167}, + {0x28, 3, 167}, + {0x02, 2, 172}, + {0x09, 2, 172}, + {0x17, 2, 172}, + {0x28, 3, 172}, }, /* 108 */ { - {0x8003, 153}, - {0x8006, 153}, - {0x800a, 153}, - {0x800f, 153}, - {0x8018, 153}, - {0x801f, 153}, - {0x8029, 153}, - {0xc038, 153}, - {0x8003, 161}, - {0x8006, 161}, - {0x800a, 161}, - {0x800f, 161}, - {0x8018, 161}, - {0x801f, 161}, - {0x8029, 161}, - {0xc038, 161}, + {0x03, 2, 153}, + {0x06, 2, 153}, + {0x0a, 2, 153}, + {0x0f, 2, 153}, + {0x18, 2, 153}, + {0x1f, 2, 153}, + {0x29, 2, 153}, + {0x38, 3, 153}, + {0x03, 2, 161}, + {0x06, 2, 161}, + {0x0a, 2, 161}, + {0x0f, 2, 161}, + {0x18, 2, 161}, + {0x1f, 2, 161}, + {0x29, 2, 161}, + {0x38, 3, 161}, }, /* 109 */ { - {0x8003, 167}, - {0x8006, 167}, - {0x800a, 167}, - {0x800f, 167}, - {0x8018, 167}, - {0x801f, 167}, - {0x8029, 167}, - {0xc038, 167}, - {0x8003, 172}, - {0x8006, 172}, - {0x800a, 172}, - {0x800f, 172}, - {0x8018, 172}, - {0x801f, 172}, - {0x8029, 172}, - {0xc038, 172}, + {0x03, 2, 167}, + {0x06, 2, 167}, + {0x0a, 2, 167}, + {0x0f, 2, 167}, + {0x18, 2, 167}, + {0x1f, 2, 167}, + {0x29, 2, 167}, + {0x38, 3, 167}, + {0x03, 2, 172}, + {0x06, 2, 172}, + {0x0a, 2, 172}, + {0x0f, 2, 172}, + {0x18, 2, 172}, + {0x1f, 2, 172}, + {0x29, 2, 172}, + {0x38, 3, 172}, }, /* 110 */ { - {0x72, 0}, - {0x73, 0}, - {0x75, 0}, - {0x76, 0}, - {0x79, 0}, - {0x7b, 0}, - {0x7f, 0}, - {0x82, 0}, - {0x88, 0}, - {0x8b, 0}, - {0x8f, 0}, - {0x92, 0}, - {0x9b, 0}, - {0xa2, 0}, - {0xaa, 0}, - {0xb4, 0}, + {0x72, 0, 0}, + {0x73, 0, 0}, + {0x75, 0, 0}, + {0x76, 0, 0}, + {0x79, 0, 0}, + {0x7b, 0, 0}, + {0x7f, 0, 0}, + {0x82, 0, 0}, + {0x88, 0, 0}, + {0x8b, 0, 0}, + {0x8f, 0, 0}, + {0x92, 0, 0}, + {0x9b, 0, 0}, + {0xa2, 0, 0}, + {0xaa, 0, 0}, + {0xb4, 0, 0}, }, /* 111 */ { - {0xc000, 176}, - {0xc000, 177}, - {0xc000, 179}, - {0xc000, 209}, - {0xc000, 216}, - {0xc000, 217}, - {0xc000, 227}, - {0xc000, 229}, - {0xc000, 230}, - {0x7a, 0}, - {0x7c, 0}, - {0x7d, 0}, - {0x80, 0}, - {0x81, 0}, - {0x83, 0}, - {0x84, 0}, + {0x00, 3, 176}, + {0x00, 3, 177}, + {0x00, 3, 179}, + {0x00, 3, 209}, + {0x00, 3, 216}, + {0x00, 3, 217}, + {0x00, 3, 227}, + {0x00, 3, 229}, + {0x00, 3, 230}, + {0x7a, 0, 0}, + {0x7c, 0, 0}, + {0x7d, 0, 0}, + {0x80, 0, 0}, + {0x81, 0, 0}, + {0x83, 0, 0}, + {0x84, 0, 0}, }, /* 112 */ { - {0x8001, 176}, - {0xc016, 176}, - {0x8001, 177}, - {0xc016, 177}, - {0x8001, 179}, - {0xc016, 179}, - {0x8001, 209}, - {0xc016, 209}, - {0x8001, 216}, - {0xc016, 216}, - {0x8001, 217}, - {0xc016, 217}, - {0x8001, 227}, - {0xc016, 227}, - {0x8001, 229}, - {0xc016, 229}, + {0x01, 2, 176}, + {0x16, 3, 176}, + {0x01, 2, 177}, + {0x16, 3, 177}, + {0x01, 2, 179}, + {0x16, 3, 179}, + {0x01, 2, 209}, + {0x16, 3, 209}, + {0x01, 2, 216}, + {0x16, 3, 216}, + {0x01, 2, 217}, + {0x16, 3, 217}, + {0x01, 2, 227}, + {0x16, 3, 227}, + {0x01, 2, 229}, + {0x16, 3, 229}, }, /* 113 */ { - {0x8002, 176}, - {0x8009, 176}, - {0x8017, 176}, - {0xc028, 176}, - {0x8002, 177}, - {0x8009, 177}, - {0x8017, 177}, - {0xc028, 177}, - {0x8002, 179}, - {0x8009, 179}, - {0x8017, 179}, - {0xc028, 179}, - {0x8002, 209}, - {0x8009, 209}, - {0x8017, 209}, - {0xc028, 209}, + {0x02, 2, 176}, + {0x09, 2, 176}, + {0x17, 2, 176}, + {0x28, 3, 176}, + {0x02, 2, 177}, + {0x09, 2, 177}, + {0x17, 2, 177}, + {0x28, 3, 177}, + {0x02, 2, 179}, + {0x09, 2, 179}, + {0x17, 2, 179}, + {0x28, 3, 179}, + {0x02, 2, 209}, + {0x09, 2, 209}, + {0x17, 2, 209}, + {0x28, 3, 209}, }, /* 114 */ { - {0x8003, 176}, - {0x8006, 176}, - {0x800a, 176}, - {0x800f, 176}, - {0x8018, 176}, - {0x801f, 176}, - {0x8029, 176}, - {0xc038, 176}, - {0x8003, 177}, - {0x8006, 177}, - {0x800a, 177}, - {0x800f, 177}, - {0x8018, 177}, - {0x801f, 177}, - {0x8029, 177}, - {0xc038, 177}, + {0x03, 2, 176}, + {0x06, 2, 176}, + {0x0a, 2, 176}, + {0x0f, 2, 176}, + {0x18, 2, 176}, + {0x1f, 2, 176}, + {0x29, 2, 176}, + {0x38, 3, 176}, + {0x03, 2, 177}, + {0x06, 2, 177}, + {0x0a, 2, 177}, + {0x0f, 2, 177}, + {0x18, 2, 177}, + {0x1f, 2, 177}, + {0x29, 2, 177}, + {0x38, 3, 177}, }, /* 115 */ { - {0x8003, 179}, - {0x8006, 179}, - {0x800a, 179}, - {0x800f, 179}, - {0x8018, 179}, - {0x801f, 179}, - {0x8029, 179}, - {0xc038, 179}, - {0x8003, 209}, - {0x8006, 209}, - {0x800a, 209}, - {0x800f, 209}, - {0x8018, 209}, - {0x801f, 209}, - {0x8029, 209}, - {0xc038, 209}, + {0x03, 2, 179}, + {0x06, 2, 179}, + {0x0a, 2, 179}, + {0x0f, 2, 179}, + {0x18, 2, 179}, + {0x1f, 2, 179}, + {0x29, 2, 179}, + {0x38, 3, 179}, + {0x03, 2, 209}, + {0x06, 2, 209}, + {0x0a, 2, 209}, + {0x0f, 2, 209}, + {0x18, 2, 209}, + {0x1f, 2, 209}, + {0x29, 2, 209}, + {0x38, 3, 209}, }, /* 116 */ { - {0x8002, 216}, - {0x8009, 216}, - {0x8017, 216}, - {0xc028, 216}, - {0x8002, 217}, - {0x8009, 217}, - {0x8017, 217}, - {0xc028, 217}, - {0x8002, 227}, - {0x8009, 227}, - {0x8017, 227}, - {0xc028, 227}, - {0x8002, 229}, - {0x8009, 229}, - {0x8017, 229}, - {0xc028, 229}, + {0x02, 2, 216}, + {0x09, 2, 216}, + {0x17, 2, 216}, + {0x28, 3, 216}, + {0x02, 2, 217}, + {0x09, 2, 217}, + {0x17, 2, 217}, + {0x28, 3, 217}, + {0x02, 2, 227}, + {0x09, 2, 227}, + {0x17, 2, 227}, + {0x28, 3, 227}, + {0x02, 2, 229}, + {0x09, 2, 229}, + {0x17, 2, 229}, + {0x28, 3, 229}, }, /* 117 */ { - {0x8003, 216}, - {0x8006, 216}, - {0x800a, 216}, - {0x800f, 216}, - {0x8018, 216}, - {0x801f, 216}, - {0x8029, 216}, - {0xc038, 216}, - {0x8003, 217}, - {0x8006, 217}, - {0x800a, 217}, - {0x800f, 217}, - {0x8018, 217}, - {0x801f, 217}, - {0x8029, 217}, - {0xc038, 217}, + {0x03, 2, 216}, + {0x06, 2, 216}, + {0x0a, 2, 216}, + {0x0f, 2, 216}, + {0x18, 2, 216}, + {0x1f, 2, 216}, + {0x29, 2, 216}, + {0x38, 3, 216}, + {0x03, 2, 217}, + {0x06, 2, 217}, + {0x0a, 2, 217}, + {0x0f, 2, 217}, + {0x18, 2, 217}, + {0x1f, 2, 217}, + {0x29, 2, 217}, + {0x38, 3, 217}, }, /* 118 */ { - {0x8003, 227}, - {0x8006, 227}, - {0x800a, 227}, - {0x800f, 227}, - {0x8018, 227}, - {0x801f, 227}, - {0x8029, 227}, - {0xc038, 227}, - {0x8003, 229}, - {0x8006, 229}, - {0x800a, 229}, - {0x800f, 229}, - {0x8018, 229}, - {0x801f, 229}, - {0x8029, 229}, - {0xc038, 229}, + {0x03, 2, 227}, + {0x06, 2, 227}, + {0x0a, 2, 227}, + {0x0f, 2, 227}, + {0x18, 2, 227}, + {0x1f, 2, 227}, + {0x29, 2, 227}, + {0x38, 3, 227}, + {0x03, 2, 229}, + {0x06, 2, 229}, + {0x0a, 2, 229}, + {0x0f, 2, 229}, + {0x18, 2, 229}, + {0x1f, 2, 229}, + {0x29, 2, 229}, + {0x38, 3, 229}, }, /* 119 */ { - {0x8001, 230}, - {0xc016, 230}, - {0xc000, 129}, - {0xc000, 132}, - {0xc000, 133}, - {0xc000, 134}, - {0xc000, 136}, - {0xc000, 146}, - {0xc000, 154}, - {0xc000, 156}, - {0xc000, 160}, - {0xc000, 163}, - {0xc000, 164}, - {0xc000, 169}, - {0xc000, 170}, - {0xc000, 173}, + {0x01, 2, 230}, + {0x16, 3, 230}, + {0x00, 3, 129}, + {0x00, 3, 132}, + {0x00, 3, 133}, + {0x00, 3, 134}, + {0x00, 3, 136}, + {0x00, 3, 146}, + {0x00, 3, 154}, + {0x00, 3, 156}, + {0x00, 3, 160}, + {0x00, 3, 163}, + {0x00, 3, 164}, + {0x00, 3, 169}, + {0x00, 3, 170}, + {0x00, 3, 173}, }, /* 120 */ { - {0x8002, 230}, - {0x8009, 230}, - {0x8017, 230}, - {0xc028, 230}, - {0x8001, 129}, - {0xc016, 129}, - {0x8001, 132}, - {0xc016, 132}, - {0x8001, 133}, - {0xc016, 133}, - {0x8001, 134}, - {0xc016, 134}, - {0x8001, 136}, - {0xc016, 136}, - {0x8001, 146}, - {0xc016, 146}, + {0x02, 2, 230}, + {0x09, 2, 230}, + {0x17, 2, 230}, + {0x28, 3, 230}, + {0x01, 2, 129}, + {0x16, 3, 129}, + {0x01, 2, 132}, + {0x16, 3, 132}, + {0x01, 2, 133}, + {0x16, 3, 133}, + {0x01, 2, 134}, + {0x16, 3, 134}, + {0x01, 2, 136}, + {0x16, 3, 136}, + {0x01, 2, 146}, + {0x16, 3, 146}, }, /* 121 */ { - {0x8003, 230}, - {0x8006, 230}, - {0x800a, 230}, - {0x800f, 230}, - {0x8018, 230}, - {0x801f, 230}, - {0x8029, 230}, - {0xc038, 230}, - {0x8002, 129}, - {0x8009, 129}, - {0x8017, 129}, - {0xc028, 129}, - {0x8002, 132}, - {0x8009, 132}, - {0x8017, 132}, - {0xc028, 132}, + {0x03, 2, 230}, + {0x06, 2, 230}, + {0x0a, 2, 230}, + {0x0f, 2, 230}, + {0x18, 2, 230}, + {0x1f, 2, 230}, + {0x29, 2, 230}, + {0x38, 3, 230}, + {0x02, 2, 129}, + {0x09, 2, 129}, + {0x17, 2, 129}, + {0x28, 3, 129}, + {0x02, 2, 132}, + {0x09, 2, 132}, + {0x17, 2, 132}, + {0x28, 3, 132}, }, /* 122 */ { - {0x8003, 129}, - {0x8006, 129}, - {0x800a, 129}, - {0x800f, 129}, - {0x8018, 129}, - {0x801f, 129}, - {0x8029, 129}, - {0xc038, 129}, - {0x8003, 132}, - {0x8006, 132}, - {0x800a, 132}, - {0x800f, 132}, - {0x8018, 132}, - {0x801f, 132}, - {0x8029, 132}, - {0xc038, 132}, + {0x03, 2, 129}, + {0x06, 2, 129}, + {0x0a, 2, 129}, + {0x0f, 2, 129}, + {0x18, 2, 129}, + {0x1f, 2, 129}, + {0x29, 2, 129}, + {0x38, 3, 129}, + {0x03, 2, 132}, + {0x06, 2, 132}, + {0x0a, 2, 132}, + {0x0f, 2, 132}, + {0x18, 2, 132}, + {0x1f, 2, 132}, + {0x29, 2, 132}, + {0x38, 3, 132}, }, /* 123 */ { - {0x8002, 133}, - {0x8009, 133}, - {0x8017, 133}, - {0xc028, 133}, - {0x8002, 134}, - {0x8009, 134}, - {0x8017, 134}, - {0xc028, 134}, - {0x8002, 136}, - {0x8009, 136}, - {0x8017, 136}, - {0xc028, 136}, - {0x8002, 146}, - {0x8009, 146}, - {0x8017, 146}, - {0xc028, 146}, + {0x02, 2, 133}, + {0x09, 2, 133}, + {0x17, 2, 133}, + {0x28, 3, 133}, + {0x02, 2, 134}, + {0x09, 2, 134}, + {0x17, 2, 134}, + {0x28, 3, 134}, + {0x02, 2, 136}, + {0x09, 2, 136}, + {0x17, 2, 136}, + {0x28, 3, 136}, + {0x02, 2, 146}, + {0x09, 2, 146}, + {0x17, 2, 146}, + {0x28, 3, 146}, }, /* 124 */ { - {0x8003, 133}, - {0x8006, 133}, - {0x800a, 133}, - {0x800f, 133}, - {0x8018, 133}, - {0x801f, 133}, - {0x8029, 133}, - {0xc038, 133}, - {0x8003, 134}, - {0x8006, 134}, - {0x800a, 134}, - {0x800f, 134}, - {0x8018, 134}, - {0x801f, 134}, - {0x8029, 134}, - {0xc038, 134}, + {0x03, 2, 133}, + {0x06, 2, 133}, + {0x0a, 2, 133}, + {0x0f, 2, 133}, + {0x18, 2, 133}, + {0x1f, 2, 133}, + {0x29, 2, 133}, + {0x38, 3, 133}, + {0x03, 2, 134}, + {0x06, 2, 134}, + {0x0a, 2, 134}, + {0x0f, 2, 134}, + {0x18, 2, 134}, + {0x1f, 2, 134}, + {0x29, 2, 134}, + {0x38, 3, 134}, }, /* 125 */ { - {0x8003, 136}, - {0x8006, 136}, - {0x800a, 136}, - {0x800f, 136}, - {0x8018, 136}, - {0x801f, 136}, - {0x8029, 136}, - {0xc038, 136}, - {0x8003, 146}, - {0x8006, 146}, - {0x800a, 146}, - {0x800f, 146}, - {0x8018, 146}, - {0x801f, 146}, - {0x8029, 146}, - {0xc038, 146}, + {0x03, 2, 136}, + {0x06, 2, 136}, + {0x0a, 2, 136}, + {0x0f, 2, 136}, + {0x18, 2, 136}, + {0x1f, 2, 136}, + {0x29, 2, 136}, + {0x38, 3, 136}, + {0x03, 2, 146}, + {0x06, 2, 146}, + {0x0a, 2, 146}, + {0x0f, 2, 146}, + {0x18, 2, 146}, + {0x1f, 2, 146}, + {0x29, 2, 146}, + {0x38, 3, 146}, }, /* 126 */ { - {0x8001, 154}, - {0xc016, 154}, - {0x8001, 156}, - {0xc016, 156}, - {0x8001, 160}, - {0xc016, 160}, - {0x8001, 163}, - {0xc016, 163}, - {0x8001, 164}, - {0xc016, 164}, - {0x8001, 169}, - {0xc016, 169}, - {0x8001, 170}, - {0xc016, 170}, - {0x8001, 173}, - {0xc016, 173}, + {0x01, 2, 154}, + {0x16, 3, 154}, + {0x01, 2, 156}, + {0x16, 3, 156}, + {0x01, 2, 160}, + {0x16, 3, 160}, + {0x01, 2, 163}, + {0x16, 3, 163}, + {0x01, 2, 164}, + {0x16, 3, 164}, + {0x01, 2, 169}, + {0x16, 3, 169}, + {0x01, 2, 170}, + {0x16, 3, 170}, + {0x01, 2, 173}, + {0x16, 3, 173}, }, /* 127 */ { - {0x8002, 154}, - {0x8009, 154}, - {0x8017, 154}, - {0xc028, 154}, - {0x8002, 156}, - {0x8009, 156}, - {0x8017, 156}, - {0xc028, 156}, - {0x8002, 160}, - {0x8009, 160}, - {0x8017, 160}, - {0xc028, 160}, - {0x8002, 163}, - {0x8009, 163}, - {0x8017, 163}, - {0xc028, 163}, + {0x02, 2, 154}, + {0x09, 2, 154}, + {0x17, 2, 154}, + {0x28, 3, 154}, + {0x02, 2, 156}, + {0x09, 2, 156}, + {0x17, 2, 156}, + {0x28, 3, 156}, + {0x02, 2, 160}, + {0x09, 2, 160}, + {0x17, 2, 160}, + {0x28, 3, 160}, + {0x02, 2, 163}, + {0x09, 2, 163}, + {0x17, 2, 163}, + {0x28, 3, 163}, }, /* 128 */ { - {0x8003, 154}, - {0x8006, 154}, - {0x800a, 154}, - {0x800f, 154}, - {0x8018, 154}, - {0x801f, 154}, - {0x8029, 154}, - {0xc038, 154}, - {0x8003, 156}, - {0x8006, 156}, - {0x800a, 156}, - {0x800f, 156}, - {0x8018, 156}, - {0x801f, 156}, - {0x8029, 156}, - {0xc038, 156}, + {0x03, 2, 154}, + {0x06, 2, 154}, + {0x0a, 2, 154}, + {0x0f, 2, 154}, + {0x18, 2, 154}, + {0x1f, 2, 154}, + {0x29, 2, 154}, + {0x38, 3, 154}, + {0x03, 2, 156}, + {0x06, 2, 156}, + {0x0a, 2, 156}, + {0x0f, 2, 156}, + {0x18, 2, 156}, + {0x1f, 2, 156}, + {0x29, 2, 156}, + {0x38, 3, 156}, }, /* 129 */ { - {0x8003, 160}, - {0x8006, 160}, - {0x800a, 160}, - {0x800f, 160}, - {0x8018, 160}, - {0x801f, 160}, - {0x8029, 160}, - {0xc038, 160}, - {0x8003, 163}, - {0x8006, 163}, - {0x800a, 163}, - {0x800f, 163}, - {0x8018, 163}, - {0x801f, 163}, - {0x8029, 163}, - {0xc038, 163}, + {0x03, 2, 160}, + {0x06, 2, 160}, + {0x0a, 2, 160}, + {0x0f, 2, 160}, + {0x18, 2, 160}, + {0x1f, 2, 160}, + {0x29, 2, 160}, + {0x38, 3, 160}, + {0x03, 2, 163}, + {0x06, 2, 163}, + {0x0a, 2, 163}, + {0x0f, 2, 163}, + {0x18, 2, 163}, + {0x1f, 2, 163}, + {0x29, 2, 163}, + {0x38, 3, 163}, }, /* 130 */ { - {0x8002, 164}, - {0x8009, 164}, - {0x8017, 164}, - {0xc028, 164}, - {0x8002, 169}, - {0x8009, 169}, - {0x8017, 169}, - {0xc028, 169}, - {0x8002, 170}, - {0x8009, 170}, - {0x8017, 170}, - {0xc028, 170}, - {0x8002, 173}, - {0x8009, 173}, - {0x8017, 173}, - {0xc028, 173}, + {0x02, 2, 164}, + {0x09, 2, 164}, + {0x17, 2, 164}, + {0x28, 3, 164}, + {0x02, 2, 169}, + {0x09, 2, 169}, + {0x17, 2, 169}, + {0x28, 3, 169}, + {0x02, 2, 170}, + {0x09, 2, 170}, + {0x17, 2, 170}, + {0x28, 3, 170}, + {0x02, 2, 173}, + {0x09, 2, 173}, + {0x17, 2, 173}, + {0x28, 3, 173}, }, /* 131 */ { - {0x8003, 164}, - {0x8006, 164}, - {0x800a, 164}, - {0x800f, 164}, - {0x8018, 164}, - {0x801f, 164}, - {0x8029, 164}, - {0xc038, 164}, - {0x8003, 169}, - {0x8006, 169}, - {0x800a, 169}, - {0x800f, 169}, - {0x8018, 169}, - {0x801f, 169}, - {0x8029, 169}, - {0xc038, 169}, + {0x03, 2, 164}, + {0x06, 2, 164}, + {0x0a, 2, 164}, + {0x0f, 2, 164}, + {0x18, 2, 164}, + {0x1f, 2, 164}, + {0x29, 2, 164}, + {0x38, 3, 164}, + {0x03, 2, 169}, + {0x06, 2, 169}, + {0x0a, 2, 169}, + {0x0f, 2, 169}, + {0x18, 2, 169}, + {0x1f, 2, 169}, + {0x29, 2, 169}, + {0x38, 3, 169}, }, /* 132 */ { - {0x8003, 170}, - {0x8006, 170}, - {0x800a, 170}, - {0x800f, 170}, - {0x8018, 170}, - {0x801f, 170}, - {0x8029, 170}, - {0xc038, 170}, - {0x8003, 173}, - {0x8006, 173}, - {0x800a, 173}, - {0x800f, 173}, - {0x8018, 173}, - {0x801f, 173}, - {0x8029, 173}, - {0xc038, 173}, + {0x03, 2, 170}, + {0x06, 2, 170}, + {0x0a, 2, 170}, + {0x0f, 2, 170}, + {0x18, 2, 170}, + {0x1f, 2, 170}, + {0x29, 2, 170}, + {0x38, 3, 170}, + {0x03, 2, 173}, + {0x06, 2, 173}, + {0x0a, 2, 173}, + {0x0f, 2, 173}, + {0x18, 2, 173}, + {0x1f, 2, 173}, + {0x29, 2, 173}, + {0x38, 3, 173}, }, /* 133 */ { - {0x89, 0}, - {0x8a, 0}, - {0x8c, 0}, - {0x8d, 0}, - {0x90, 0}, - {0x91, 0}, - {0x93, 0}, - {0x96, 0}, - {0x9c, 0}, - {0x9f, 0}, - {0xa3, 0}, - {0xa6, 0}, - {0xab, 0}, - {0xae, 0}, - {0xb5, 0}, - {0xbe, 0}, + {0x89, 0, 0}, + {0x8a, 0, 0}, + {0x8c, 0, 0}, + {0x8d, 0, 0}, + {0x90, 0, 0}, + {0x91, 0, 0}, + {0x93, 0, 0}, + {0x96, 0, 0}, + {0x9c, 0, 0}, + {0x9f, 0, 0}, + {0xa3, 0, 0}, + {0xa6, 0, 0}, + {0xab, 0, 0}, + {0xae, 0, 0}, + {0xb5, 0, 0}, + {0xbe, 0, 0}, }, /* 134 */ { - {0xc000, 178}, - {0xc000, 181}, - {0xc000, 185}, - {0xc000, 186}, - {0xc000, 187}, - {0xc000, 189}, - {0xc000, 190}, - {0xc000, 196}, - {0xc000, 198}, - {0xc000, 228}, - {0xc000, 232}, - {0xc000, 233}, - {0x94, 0}, - {0x95, 0}, - {0x97, 0}, - {0x98, 0}, + {0x00, 3, 178}, + {0x00, 3, 181}, + {0x00, 3, 185}, + {0x00, 3, 186}, + {0x00, 3, 187}, + {0x00, 3, 189}, + {0x00, 3, 190}, + {0x00, 3, 196}, + {0x00, 3, 198}, + {0x00, 3, 228}, + {0x00, 3, 232}, + {0x00, 3, 233}, + {0x94, 0, 0}, + {0x95, 0, 0}, + {0x97, 0, 0}, + {0x98, 0, 0}, }, /* 135 */ { - {0x8001, 178}, - {0xc016, 178}, - {0x8001, 181}, - {0xc016, 181}, - {0x8001, 185}, - {0xc016, 185}, - {0x8001, 186}, - {0xc016, 186}, - {0x8001, 187}, - {0xc016, 187}, - {0x8001, 189}, - {0xc016, 189}, - {0x8001, 190}, - {0xc016, 190}, - {0x8001, 196}, - {0xc016, 196}, + {0x01, 2, 178}, + {0x16, 3, 178}, + {0x01, 2, 181}, + {0x16, 3, 181}, + {0x01, 2, 185}, + {0x16, 3, 185}, + {0x01, 2, 186}, + {0x16, 3, 186}, + {0x01, 2, 187}, + {0x16, 3, 187}, + {0x01, 2, 189}, + {0x16, 3, 189}, + {0x01, 2, 190}, + {0x16, 3, 190}, + {0x01, 2, 196}, + {0x16, 3, 196}, }, /* 136 */ { - {0x8002, 178}, - {0x8009, 178}, - {0x8017, 178}, - {0xc028, 178}, - {0x8002, 181}, - {0x8009, 181}, - {0x8017, 181}, - {0xc028, 181}, - {0x8002, 185}, - {0x8009, 185}, - {0x8017, 185}, - {0xc028, 185}, - {0x8002, 186}, - {0x8009, 186}, - {0x8017, 186}, - {0xc028, 186}, + {0x02, 2, 178}, + {0x09, 2, 178}, + {0x17, 2, 178}, + {0x28, 3, 178}, + {0x02, 2, 181}, + {0x09, 2, 181}, + {0x17, 2, 181}, + {0x28, 3, 181}, + {0x02, 2, 185}, + {0x09, 2, 185}, + {0x17, 2, 185}, + {0x28, 3, 185}, + {0x02, 2, 186}, + {0x09, 2, 186}, + {0x17, 2, 186}, + {0x28, 3, 186}, }, /* 137 */ { - {0x8003, 178}, - {0x8006, 178}, - {0x800a, 178}, - {0x800f, 178}, - {0x8018, 178}, - {0x801f, 178}, - {0x8029, 178}, - {0xc038, 178}, - {0x8003, 181}, - {0x8006, 181}, - {0x800a, 181}, - {0x800f, 181}, - {0x8018, 181}, - {0x801f, 181}, - {0x8029, 181}, - {0xc038, 181}, + {0x03, 2, 178}, + {0x06, 2, 178}, + {0x0a, 2, 178}, + {0x0f, 2, 178}, + {0x18, 2, 178}, + {0x1f, 2, 178}, + {0x29, 2, 178}, + {0x38, 3, 178}, + {0x03, 2, 181}, + {0x06, 2, 181}, + {0x0a, 2, 181}, + {0x0f, 2, 181}, + {0x18, 2, 181}, + {0x1f, 2, 181}, + {0x29, 2, 181}, + {0x38, 3, 181}, }, /* 138 */ { - {0x8003, 185}, - {0x8006, 185}, - {0x800a, 185}, - {0x800f, 185}, - {0x8018, 185}, - {0x801f, 185}, - {0x8029, 185}, - {0xc038, 185}, - {0x8003, 186}, - {0x8006, 186}, - {0x800a, 186}, - {0x800f, 186}, - {0x8018, 186}, - {0x801f, 186}, - {0x8029, 186}, - {0xc038, 186}, + {0x03, 2, 185}, + {0x06, 2, 185}, + {0x0a, 2, 185}, + {0x0f, 2, 185}, + {0x18, 2, 185}, + {0x1f, 2, 185}, + {0x29, 2, 185}, + {0x38, 3, 185}, + {0x03, 2, 186}, + {0x06, 2, 186}, + {0x0a, 2, 186}, + {0x0f, 2, 186}, + {0x18, 2, 186}, + {0x1f, 2, 186}, + {0x29, 2, 186}, + {0x38, 3, 186}, }, /* 139 */ { - {0x8002, 187}, - {0x8009, 187}, - {0x8017, 187}, - {0xc028, 187}, - {0x8002, 189}, - {0x8009, 189}, - {0x8017, 189}, - {0xc028, 189}, - {0x8002, 190}, - {0x8009, 190}, - {0x8017, 190}, - {0xc028, 190}, - {0x8002, 196}, - {0x8009, 196}, - {0x8017, 196}, - {0xc028, 196}, + {0x02, 2, 187}, + {0x09, 2, 187}, + {0x17, 2, 187}, + {0x28, 3, 187}, + {0x02, 2, 189}, + {0x09, 2, 189}, + {0x17, 2, 189}, + {0x28, 3, 189}, + {0x02, 2, 190}, + {0x09, 2, 190}, + {0x17, 2, 190}, + {0x28, 3, 190}, + {0x02, 2, 196}, + {0x09, 2, 196}, + {0x17, 2, 196}, + {0x28, 3, 196}, }, /* 140 */ { - {0x8003, 187}, - {0x8006, 187}, - {0x800a, 187}, - {0x800f, 187}, - {0x8018, 187}, - {0x801f, 187}, - {0x8029, 187}, - {0xc038, 187}, - {0x8003, 189}, - {0x8006, 189}, - {0x800a, 189}, - {0x800f, 189}, - {0x8018, 189}, - {0x801f, 189}, - {0x8029, 189}, - {0xc038, 189}, + {0x03, 2, 187}, + {0x06, 2, 187}, + {0x0a, 2, 187}, + {0x0f, 2, 187}, + {0x18, 2, 187}, + {0x1f, 2, 187}, + {0x29, 2, 187}, + {0x38, 3, 187}, + {0x03, 2, 189}, + {0x06, 2, 189}, + {0x0a, 2, 189}, + {0x0f, 2, 189}, + {0x18, 2, 189}, + {0x1f, 2, 189}, + {0x29, 2, 189}, + {0x38, 3, 189}, }, /* 141 */ { - {0x8003, 190}, - {0x8006, 190}, - {0x800a, 190}, - {0x800f, 190}, - {0x8018, 190}, - {0x801f, 190}, - {0x8029, 190}, - {0xc038, 190}, - {0x8003, 196}, - {0x8006, 196}, - {0x800a, 196}, - {0x800f, 196}, - {0x8018, 196}, - {0x801f, 196}, - {0x8029, 196}, - {0xc038, 196}, + {0x03, 2, 190}, + {0x06, 2, 190}, + {0x0a, 2, 190}, + {0x0f, 2, 190}, + {0x18, 2, 190}, + {0x1f, 2, 190}, + {0x29, 2, 190}, + {0x38, 3, 190}, + {0x03, 2, 196}, + {0x06, 2, 196}, + {0x0a, 2, 196}, + {0x0f, 2, 196}, + {0x18, 2, 196}, + {0x1f, 2, 196}, + {0x29, 2, 196}, + {0x38, 3, 196}, }, /* 142 */ { - {0x8001, 198}, - {0xc016, 198}, - {0x8001, 228}, - {0xc016, 228}, - {0x8001, 232}, - {0xc016, 232}, - {0x8001, 233}, - {0xc016, 233}, - {0xc000, 1}, - {0xc000, 135}, - {0xc000, 137}, - {0xc000, 138}, - {0xc000, 139}, - {0xc000, 140}, - {0xc000, 141}, - {0xc000, 143}, + {0x01, 2, 198}, + {0x16, 3, 198}, + {0x01, 2, 228}, + {0x16, 3, 228}, + {0x01, 2, 232}, + {0x16, 3, 232}, + {0x01, 2, 233}, + {0x16, 3, 233}, + {0x00, 3, 1}, + {0x00, 3, 135}, + {0x00, 3, 137}, + {0x00, 3, 138}, + {0x00, 3, 139}, + {0x00, 3, 140}, + {0x00, 3, 141}, + {0x00, 3, 143}, }, /* 143 */ { - {0x8002, 198}, - {0x8009, 198}, - {0x8017, 198}, - {0xc028, 198}, - {0x8002, 228}, - {0x8009, 228}, - {0x8017, 228}, - {0xc028, 228}, - {0x8002, 232}, - {0x8009, 232}, - {0x8017, 232}, - {0xc028, 232}, - {0x8002, 233}, - {0x8009, 233}, - {0x8017, 233}, - {0xc028, 233}, + {0x02, 2, 198}, + {0x09, 2, 198}, + {0x17, 2, 198}, + {0x28, 3, 198}, + {0x02, 2, 228}, + {0x09, 2, 228}, + {0x17, 2, 228}, + {0x28, 3, 228}, + {0x02, 2, 232}, + {0x09, 2, 232}, + {0x17, 2, 232}, + {0x28, 3, 232}, + {0x02, 2, 233}, + {0x09, 2, 233}, + {0x17, 2, 233}, + {0x28, 3, 233}, }, /* 144 */ { - {0x8003, 198}, - {0x8006, 198}, - {0x800a, 198}, - {0x800f, 198}, - {0x8018, 198}, - {0x801f, 198}, - {0x8029, 198}, - {0xc038, 198}, - {0x8003, 228}, - {0x8006, 228}, - {0x800a, 228}, - {0x800f, 228}, - {0x8018, 228}, - {0x801f, 228}, - {0x8029, 228}, - {0xc038, 228}, + {0x03, 2, 198}, + {0x06, 2, 198}, + {0x0a, 2, 198}, + {0x0f, 2, 198}, + {0x18, 2, 198}, + {0x1f, 2, 198}, + {0x29, 2, 198}, + {0x38, 3, 198}, + {0x03, 2, 228}, + {0x06, 2, 228}, + {0x0a, 2, 228}, + {0x0f, 2, 228}, + {0x18, 2, 228}, + {0x1f, 2, 228}, + {0x29, 2, 228}, + {0x38, 3, 228}, }, /* 145 */ { - {0x8003, 232}, - {0x8006, 232}, - {0x800a, 232}, - {0x800f, 232}, - {0x8018, 232}, - {0x801f, 232}, - {0x8029, 232}, - {0xc038, 232}, - {0x8003, 233}, - {0x8006, 233}, - {0x800a, 233}, - {0x800f, 233}, - {0x8018, 233}, - {0x801f, 233}, - {0x8029, 233}, - {0xc038, 233}, + {0x03, 2, 232}, + {0x06, 2, 232}, + {0x0a, 2, 232}, + {0x0f, 2, 232}, + {0x18, 2, 232}, + {0x1f, 2, 232}, + {0x29, 2, 232}, + {0x38, 3, 232}, + {0x03, 2, 233}, + {0x06, 2, 233}, + {0x0a, 2, 233}, + {0x0f, 2, 233}, + {0x18, 2, 233}, + {0x1f, 2, 233}, + {0x29, 2, 233}, + {0x38, 3, 233}, }, /* 146 */ { - {0x8001, 1}, - {0xc016, 1}, - {0x8001, 135}, - {0xc016, 135}, - {0x8001, 137}, - {0xc016, 137}, - {0x8001, 138}, - {0xc016, 138}, - {0x8001, 139}, - {0xc016, 139}, - {0x8001, 140}, - {0xc016, 140}, - {0x8001, 141}, - {0xc016, 141}, - {0x8001, 143}, - {0xc016, 143}, + {0x01, 2, 1}, + {0x16, 3, 1}, + {0x01, 2, 135}, + {0x16, 3, 135}, + {0x01, 2, 137}, + {0x16, 3, 137}, + {0x01, 2, 138}, + {0x16, 3, 138}, + {0x01, 2, 139}, + {0x16, 3, 139}, + {0x01, 2, 140}, + {0x16, 3, 140}, + {0x01, 2, 141}, + {0x16, 3, 141}, + {0x01, 2, 143}, + {0x16, 3, 143}, }, /* 147 */ { - {0x8002, 1}, - {0x8009, 1}, - {0x8017, 1}, - {0xc028, 1}, - {0x8002, 135}, - {0x8009, 135}, - {0x8017, 135}, - {0xc028, 135}, - {0x8002, 137}, - {0x8009, 137}, - {0x8017, 137}, - {0xc028, 137}, - {0x8002, 138}, - {0x8009, 138}, - {0x8017, 138}, - {0xc028, 138}, + {0x02, 2, 1}, + {0x09, 2, 1}, + {0x17, 2, 1}, + {0x28, 3, 1}, + {0x02, 2, 135}, + {0x09, 2, 135}, + {0x17, 2, 135}, + {0x28, 3, 135}, + {0x02, 2, 137}, + {0x09, 2, 137}, + {0x17, 2, 137}, + {0x28, 3, 137}, + {0x02, 2, 138}, + {0x09, 2, 138}, + {0x17, 2, 138}, + {0x28, 3, 138}, }, /* 148 */ { - {0x8003, 1}, - {0x8006, 1}, - {0x800a, 1}, - {0x800f, 1}, - {0x8018, 1}, - {0x801f, 1}, - {0x8029, 1}, - {0xc038, 1}, - {0x8003, 135}, - {0x8006, 135}, - {0x800a, 135}, - {0x800f, 135}, - {0x8018, 135}, - {0x801f, 135}, - {0x8029, 135}, - {0xc038, 135}, + {0x03, 2, 1}, + {0x06, 2, 1}, + {0x0a, 2, 1}, + {0x0f, 2, 1}, + {0x18, 2, 1}, + {0x1f, 2, 1}, + {0x29, 2, 1}, + {0x38, 3, 1}, + {0x03, 2, 135}, + {0x06, 2, 135}, + {0x0a, 2, 135}, + {0x0f, 2, 135}, + {0x18, 2, 135}, + {0x1f, 2, 135}, + {0x29, 2, 135}, + {0x38, 3, 135}, }, /* 149 */ { - {0x8003, 137}, - {0x8006, 137}, - {0x800a, 137}, - {0x800f, 137}, - {0x8018, 137}, - {0x801f, 137}, - {0x8029, 137}, - {0xc038, 137}, - {0x8003, 138}, - {0x8006, 138}, - {0x800a, 138}, - {0x800f, 138}, - {0x8018, 138}, - {0x801f, 138}, - {0x8029, 138}, - {0xc038, 138}, + {0x03, 2, 137}, + {0x06, 2, 137}, + {0x0a, 2, 137}, + {0x0f, 2, 137}, + {0x18, 2, 137}, + {0x1f, 2, 137}, + {0x29, 2, 137}, + {0x38, 3, 137}, + {0x03, 2, 138}, + {0x06, 2, 138}, + {0x0a, 2, 138}, + {0x0f, 2, 138}, + {0x18, 2, 138}, + {0x1f, 2, 138}, + {0x29, 2, 138}, + {0x38, 3, 138}, }, /* 150 */ { - {0x8002, 139}, - {0x8009, 139}, - {0x8017, 139}, - {0xc028, 139}, - {0x8002, 140}, - {0x8009, 140}, - {0x8017, 140}, - {0xc028, 140}, - {0x8002, 141}, - {0x8009, 141}, - {0x8017, 141}, - {0xc028, 141}, - {0x8002, 143}, - {0x8009, 143}, - {0x8017, 143}, - {0xc028, 143}, + {0x02, 2, 139}, + {0x09, 2, 139}, + {0x17, 2, 139}, + {0x28, 3, 139}, + {0x02, 2, 140}, + {0x09, 2, 140}, + {0x17, 2, 140}, + {0x28, 3, 140}, + {0x02, 2, 141}, + {0x09, 2, 141}, + {0x17, 2, 141}, + {0x28, 3, 141}, + {0x02, 2, 143}, + {0x09, 2, 143}, + {0x17, 2, 143}, + {0x28, 3, 143}, }, /* 151 */ { - {0x8003, 139}, - {0x8006, 139}, - {0x800a, 139}, - {0x800f, 139}, - {0x8018, 139}, - {0x801f, 139}, - {0x8029, 139}, - {0xc038, 139}, - {0x8003, 140}, - {0x8006, 140}, - {0x800a, 140}, - {0x800f, 140}, - {0x8018, 140}, - {0x801f, 140}, - {0x8029, 140}, - {0xc038, 140}, + {0x03, 2, 139}, + {0x06, 2, 139}, + {0x0a, 2, 139}, + {0x0f, 2, 139}, + {0x18, 2, 139}, + {0x1f, 2, 139}, + {0x29, 2, 139}, + {0x38, 3, 139}, + {0x03, 2, 140}, + {0x06, 2, 140}, + {0x0a, 2, 140}, + {0x0f, 2, 140}, + {0x18, 2, 140}, + {0x1f, 2, 140}, + {0x29, 2, 140}, + {0x38, 3, 140}, }, /* 152 */ { - {0x8003, 141}, - {0x8006, 141}, - {0x800a, 141}, - {0x800f, 141}, - {0x8018, 141}, - {0x801f, 141}, - {0x8029, 141}, - {0xc038, 141}, - {0x8003, 143}, - {0x8006, 143}, - {0x800a, 143}, - {0x800f, 143}, - {0x8018, 143}, - {0x801f, 143}, - {0x8029, 143}, - {0xc038, 143}, + {0x03, 2, 141}, + {0x06, 2, 141}, + {0x0a, 2, 141}, + {0x0f, 2, 141}, + {0x18, 2, 141}, + {0x1f, 2, 141}, + {0x29, 2, 141}, + {0x38, 3, 141}, + {0x03, 2, 143}, + {0x06, 2, 143}, + {0x0a, 2, 143}, + {0x0f, 2, 143}, + {0x18, 2, 143}, + {0x1f, 2, 143}, + {0x29, 2, 143}, + {0x38, 3, 143}, }, /* 153 */ { - {0x9d, 0}, - {0x9e, 0}, - {0xa0, 0}, - {0xa1, 0}, - {0xa4, 0}, - {0xa5, 0}, - {0xa7, 0}, - {0xa8, 0}, - {0xac, 0}, - {0xad, 0}, - {0xaf, 0}, - {0xb1, 0}, - {0xb6, 0}, - {0xb9, 0}, - {0xbf, 0}, - {0xcf, 0}, + {0x9d, 0, 0}, + {0x9e, 0, 0}, + {0xa0, 0, 0}, + {0xa1, 0, 0}, + {0xa4, 0, 0}, + {0xa5, 0, 0}, + {0xa7, 0, 0}, + {0xa8, 0, 0}, + {0xac, 0, 0}, + {0xad, 0, 0}, + {0xaf, 0, 0}, + {0xb1, 0, 0}, + {0xb6, 0, 0}, + {0xb9, 0, 0}, + {0xbf, 0, 0}, + {0xcf, 0, 0}, }, /* 154 */ { - {0xc000, 147}, - {0xc000, 149}, - {0xc000, 150}, - {0xc000, 151}, - {0xc000, 152}, - {0xc000, 155}, - {0xc000, 157}, - {0xc000, 158}, - {0xc000, 165}, - {0xc000, 166}, - {0xc000, 168}, - {0xc000, 174}, - {0xc000, 175}, - {0xc000, 180}, - {0xc000, 182}, - {0xc000, 183}, + {0x00, 3, 147}, + {0x00, 3, 149}, + {0x00, 3, 150}, + {0x00, 3, 151}, + {0x00, 3, 152}, + {0x00, 3, 155}, + {0x00, 3, 157}, + {0x00, 3, 158}, + {0x00, 3, 165}, + {0x00, 3, 166}, + {0x00, 3, 168}, + {0x00, 3, 174}, + {0x00, 3, 175}, + {0x00, 3, 180}, + {0x00, 3, 182}, + {0x00, 3, 183}, }, /* 155 */ { - {0x8001, 147}, - {0xc016, 147}, - {0x8001, 149}, - {0xc016, 149}, - {0x8001, 150}, - {0xc016, 150}, - {0x8001, 151}, - {0xc016, 151}, - {0x8001, 152}, - {0xc016, 152}, - {0x8001, 155}, - {0xc016, 155}, - {0x8001, 157}, - {0xc016, 157}, - {0x8001, 158}, - {0xc016, 158}, + {0x01, 2, 147}, + {0x16, 3, 147}, + {0x01, 2, 149}, + {0x16, 3, 149}, + {0x01, 2, 150}, + {0x16, 3, 150}, + {0x01, 2, 151}, + {0x16, 3, 151}, + {0x01, 2, 152}, + {0x16, 3, 152}, + {0x01, 2, 155}, + {0x16, 3, 155}, + {0x01, 2, 157}, + {0x16, 3, 157}, + {0x01, 2, 158}, + {0x16, 3, 158}, }, /* 156 */ { - {0x8002, 147}, - {0x8009, 147}, - {0x8017, 147}, - {0xc028, 147}, - {0x8002, 149}, - {0x8009, 149}, - {0x8017, 149}, - {0xc028, 149}, - {0x8002, 150}, - {0x8009, 150}, - {0x8017, 150}, - {0xc028, 150}, - {0x8002, 151}, - {0x8009, 151}, - {0x8017, 151}, - {0xc028, 151}, + {0x02, 2, 147}, + {0x09, 2, 147}, + {0x17, 2, 147}, + {0x28, 3, 147}, + {0x02, 2, 149}, + {0x09, 2, 149}, + {0x17, 2, 149}, + {0x28, 3, 149}, + {0x02, 2, 150}, + {0x09, 2, 150}, + {0x17, 2, 150}, + {0x28, 3, 150}, + {0x02, 2, 151}, + {0x09, 2, 151}, + {0x17, 2, 151}, + {0x28, 3, 151}, }, /* 157 */ { - {0x8003, 147}, - {0x8006, 147}, - {0x800a, 147}, - {0x800f, 147}, - {0x8018, 147}, - {0x801f, 147}, - {0x8029, 147}, - {0xc038, 147}, - {0x8003, 149}, - {0x8006, 149}, - {0x800a, 149}, - {0x800f, 149}, - {0x8018, 149}, - {0x801f, 149}, - {0x8029, 149}, - {0xc038, 149}, + {0x03, 2, 147}, + {0x06, 2, 147}, + {0x0a, 2, 147}, + {0x0f, 2, 147}, + {0x18, 2, 147}, + {0x1f, 2, 147}, + {0x29, 2, 147}, + {0x38, 3, 147}, + {0x03, 2, 149}, + {0x06, 2, 149}, + {0x0a, 2, 149}, + {0x0f, 2, 149}, + {0x18, 2, 149}, + {0x1f, 2, 149}, + {0x29, 2, 149}, + {0x38, 3, 149}, }, /* 158 */ { - {0x8003, 150}, - {0x8006, 150}, - {0x800a, 150}, - {0x800f, 150}, - {0x8018, 150}, - {0x801f, 150}, - {0x8029, 150}, - {0xc038, 150}, - {0x8003, 151}, - {0x8006, 151}, - {0x800a, 151}, - {0x800f, 151}, - {0x8018, 151}, - {0x801f, 151}, - {0x8029, 151}, - {0xc038, 151}, + {0x03, 2, 150}, + {0x06, 2, 150}, + {0x0a, 2, 150}, + {0x0f, 2, 150}, + {0x18, 2, 150}, + {0x1f, 2, 150}, + {0x29, 2, 150}, + {0x38, 3, 150}, + {0x03, 2, 151}, + {0x06, 2, 151}, + {0x0a, 2, 151}, + {0x0f, 2, 151}, + {0x18, 2, 151}, + {0x1f, 2, 151}, + {0x29, 2, 151}, + {0x38, 3, 151}, }, /* 159 */ { - {0x8002, 152}, - {0x8009, 152}, - {0x8017, 152}, - {0xc028, 152}, - {0x8002, 155}, - {0x8009, 155}, - {0x8017, 155}, - {0xc028, 155}, - {0x8002, 157}, - {0x8009, 157}, - {0x8017, 157}, - {0xc028, 157}, - {0x8002, 158}, - {0x8009, 158}, - {0x8017, 158}, - {0xc028, 158}, + {0x02, 2, 152}, + {0x09, 2, 152}, + {0x17, 2, 152}, + {0x28, 3, 152}, + {0x02, 2, 155}, + {0x09, 2, 155}, + {0x17, 2, 155}, + {0x28, 3, 155}, + {0x02, 2, 157}, + {0x09, 2, 157}, + {0x17, 2, 157}, + {0x28, 3, 157}, + {0x02, 2, 158}, + {0x09, 2, 158}, + {0x17, 2, 158}, + {0x28, 3, 158}, }, /* 160 */ { - {0x8003, 152}, - {0x8006, 152}, - {0x800a, 152}, - {0x800f, 152}, - {0x8018, 152}, - {0x801f, 152}, - {0x8029, 152}, - {0xc038, 152}, - {0x8003, 155}, - {0x8006, 155}, - {0x800a, 155}, - {0x800f, 155}, - {0x8018, 155}, - {0x801f, 155}, - {0x8029, 155}, - {0xc038, 155}, + {0x03, 2, 152}, + {0x06, 2, 152}, + {0x0a, 2, 152}, + {0x0f, 2, 152}, + {0x18, 2, 152}, + {0x1f, 2, 152}, + {0x29, 2, 152}, + {0x38, 3, 152}, + {0x03, 2, 155}, + {0x06, 2, 155}, + {0x0a, 2, 155}, + {0x0f, 2, 155}, + {0x18, 2, 155}, + {0x1f, 2, 155}, + {0x29, 2, 155}, + {0x38, 3, 155}, }, /* 161 */ { - {0x8003, 157}, - {0x8006, 157}, - {0x800a, 157}, - {0x800f, 157}, - {0x8018, 157}, - {0x801f, 157}, - {0x8029, 157}, - {0xc038, 157}, - {0x8003, 158}, - {0x8006, 158}, - {0x800a, 158}, - {0x800f, 158}, - {0x8018, 158}, - {0x801f, 158}, - {0x8029, 158}, - {0xc038, 158}, + {0x03, 2, 157}, + {0x06, 2, 157}, + {0x0a, 2, 157}, + {0x0f, 2, 157}, + {0x18, 2, 157}, + {0x1f, 2, 157}, + {0x29, 2, 157}, + {0x38, 3, 157}, + {0x03, 2, 158}, + {0x06, 2, 158}, + {0x0a, 2, 158}, + {0x0f, 2, 158}, + {0x18, 2, 158}, + {0x1f, 2, 158}, + {0x29, 2, 158}, + {0x38, 3, 158}, }, /* 162 */ { - {0x8001, 165}, - {0xc016, 165}, - {0x8001, 166}, - {0xc016, 166}, - {0x8001, 168}, - {0xc016, 168}, - {0x8001, 174}, - {0xc016, 174}, - {0x8001, 175}, - {0xc016, 175}, - {0x8001, 180}, - {0xc016, 180}, - {0x8001, 182}, - {0xc016, 182}, - {0x8001, 183}, - {0xc016, 183}, + {0x01, 2, 165}, + {0x16, 3, 165}, + {0x01, 2, 166}, + {0x16, 3, 166}, + {0x01, 2, 168}, + {0x16, 3, 168}, + {0x01, 2, 174}, + {0x16, 3, 174}, + {0x01, 2, 175}, + {0x16, 3, 175}, + {0x01, 2, 180}, + {0x16, 3, 180}, + {0x01, 2, 182}, + {0x16, 3, 182}, + {0x01, 2, 183}, + {0x16, 3, 183}, }, /* 163 */ { - {0x8002, 165}, - {0x8009, 165}, - {0x8017, 165}, - {0xc028, 165}, - {0x8002, 166}, - {0x8009, 166}, - {0x8017, 166}, - {0xc028, 166}, - {0x8002, 168}, - {0x8009, 168}, - {0x8017, 168}, - {0xc028, 168}, - {0x8002, 174}, - {0x8009, 174}, - {0x8017, 174}, - {0xc028, 174}, + {0x02, 2, 165}, + {0x09, 2, 165}, + {0x17, 2, 165}, + {0x28, 3, 165}, + {0x02, 2, 166}, + {0x09, 2, 166}, + {0x17, 2, 166}, + {0x28, 3, 166}, + {0x02, 2, 168}, + {0x09, 2, 168}, + {0x17, 2, 168}, + {0x28, 3, 168}, + {0x02, 2, 174}, + {0x09, 2, 174}, + {0x17, 2, 174}, + {0x28, 3, 174}, }, /* 164 */ { - {0x8003, 165}, - {0x8006, 165}, - {0x800a, 165}, - {0x800f, 165}, - {0x8018, 165}, - {0x801f, 165}, - {0x8029, 165}, - {0xc038, 165}, - {0x8003, 166}, - {0x8006, 166}, - {0x800a, 166}, - {0x800f, 166}, - {0x8018, 166}, - {0x801f, 166}, - {0x8029, 166}, - {0xc038, 166}, + {0x03, 2, 165}, + {0x06, 2, 165}, + {0x0a, 2, 165}, + {0x0f, 2, 165}, + {0x18, 2, 165}, + {0x1f, 2, 165}, + {0x29, 2, 165}, + {0x38, 3, 165}, + {0x03, 2, 166}, + {0x06, 2, 166}, + {0x0a, 2, 166}, + {0x0f, 2, 166}, + {0x18, 2, 166}, + {0x1f, 2, 166}, + {0x29, 2, 166}, + {0x38, 3, 166}, }, /* 165 */ { - {0x8003, 168}, - {0x8006, 168}, - {0x800a, 168}, - {0x800f, 168}, - {0x8018, 168}, - {0x801f, 168}, - {0x8029, 168}, - {0xc038, 168}, - {0x8003, 174}, - {0x8006, 174}, - {0x800a, 174}, - {0x800f, 174}, - {0x8018, 174}, - {0x801f, 174}, - {0x8029, 174}, - {0xc038, 174}, + {0x03, 2, 168}, + {0x06, 2, 168}, + {0x0a, 2, 168}, + {0x0f, 2, 168}, + {0x18, 2, 168}, + {0x1f, 2, 168}, + {0x29, 2, 168}, + {0x38, 3, 168}, + {0x03, 2, 174}, + {0x06, 2, 174}, + {0x0a, 2, 174}, + {0x0f, 2, 174}, + {0x18, 2, 174}, + {0x1f, 2, 174}, + {0x29, 2, 174}, + {0x38, 3, 174}, }, /* 166 */ { - {0x8002, 175}, - {0x8009, 175}, - {0x8017, 175}, - {0xc028, 175}, - {0x8002, 180}, - {0x8009, 180}, - {0x8017, 180}, - {0xc028, 180}, - {0x8002, 182}, - {0x8009, 182}, - {0x8017, 182}, - {0xc028, 182}, - {0x8002, 183}, - {0x8009, 183}, - {0x8017, 183}, - {0xc028, 183}, + {0x02, 2, 175}, + {0x09, 2, 175}, + {0x17, 2, 175}, + {0x28, 3, 175}, + {0x02, 2, 180}, + {0x09, 2, 180}, + {0x17, 2, 180}, + {0x28, 3, 180}, + {0x02, 2, 182}, + {0x09, 2, 182}, + {0x17, 2, 182}, + {0x28, 3, 182}, + {0x02, 2, 183}, + {0x09, 2, 183}, + {0x17, 2, 183}, + {0x28, 3, 183}, }, /* 167 */ { - {0x8003, 175}, - {0x8006, 175}, - {0x800a, 175}, - {0x800f, 175}, - {0x8018, 175}, - {0x801f, 175}, - {0x8029, 175}, - {0xc038, 175}, - {0x8003, 180}, - {0x8006, 180}, - {0x800a, 180}, - {0x800f, 180}, - {0x8018, 180}, - {0x801f, 180}, - {0x8029, 180}, - {0xc038, 180}, + {0x03, 2, 175}, + {0x06, 2, 175}, + {0x0a, 2, 175}, + {0x0f, 2, 175}, + {0x18, 2, 175}, + {0x1f, 2, 175}, + {0x29, 2, 175}, + {0x38, 3, 175}, + {0x03, 2, 180}, + {0x06, 2, 180}, + {0x0a, 2, 180}, + {0x0f, 2, 180}, + {0x18, 2, 180}, + {0x1f, 2, 180}, + {0x29, 2, 180}, + {0x38, 3, 180}, }, /* 168 */ { - {0x8003, 182}, - {0x8006, 182}, - {0x800a, 182}, - {0x800f, 182}, - {0x8018, 182}, - {0x801f, 182}, - {0x8029, 182}, - {0xc038, 182}, - {0x8003, 183}, - {0x8006, 183}, - {0x800a, 183}, - {0x800f, 183}, - {0x8018, 183}, - {0x801f, 183}, - {0x8029, 183}, - {0xc038, 183}, + {0x03, 2, 182}, + {0x06, 2, 182}, + {0x0a, 2, 182}, + {0x0f, 2, 182}, + {0x18, 2, 182}, + {0x1f, 2, 182}, + {0x29, 2, 182}, + {0x38, 3, 182}, + {0x03, 2, 183}, + {0x06, 2, 183}, + {0x0a, 2, 183}, + {0x0f, 2, 183}, + {0x18, 2, 183}, + {0x1f, 2, 183}, + {0x29, 2, 183}, + {0x38, 3, 183}, }, /* 169 */ { - {0xc000, 188}, - {0xc000, 191}, - {0xc000, 197}, - {0xc000, 231}, - {0xc000, 239}, - {0xb0, 0}, - {0xb2, 0}, - {0xb3, 0}, - {0xb7, 0}, - {0xb8, 0}, - {0xba, 0}, - {0xbb, 0}, - {0xc0, 0}, - {0xc7, 0}, - {0xd0, 0}, - {0xdf, 0}, + {0x00, 3, 188}, + {0x00, 3, 191}, + {0x00, 3, 197}, + {0x00, 3, 231}, + {0x00, 3, 239}, + {0xb0, 0, 0}, + {0xb2, 0, 0}, + {0xb3, 0, 0}, + {0xb7, 0, 0}, + {0xb8, 0, 0}, + {0xba, 0, 0}, + {0xbb, 0, 0}, + {0xc0, 0, 0}, + {0xc7, 0, 0}, + {0xd0, 0, 0}, + {0xdf, 0, 0}, }, /* 170 */ { - {0x8001, 188}, - {0xc016, 188}, - {0x8001, 191}, - {0xc016, 191}, - {0x8001, 197}, - {0xc016, 197}, - {0x8001, 231}, - {0xc016, 231}, - {0x8001, 239}, - {0xc016, 239}, - {0xc000, 9}, - {0xc000, 142}, - {0xc000, 144}, - {0xc000, 145}, - {0xc000, 148}, - {0xc000, 159}, + {0x01, 2, 188}, + {0x16, 3, 188}, + {0x01, 2, 191}, + {0x16, 3, 191}, + {0x01, 2, 197}, + {0x16, 3, 197}, + {0x01, 2, 231}, + {0x16, 3, 231}, + {0x01, 2, 239}, + {0x16, 3, 239}, + {0x00, 3, 9}, + {0x00, 3, 142}, + {0x00, 3, 144}, + {0x00, 3, 145}, + {0x00, 3, 148}, + {0x00, 3, 159}, }, /* 171 */ { - {0x8002, 188}, - {0x8009, 188}, - {0x8017, 188}, - {0xc028, 188}, - {0x8002, 191}, - {0x8009, 191}, - {0x8017, 191}, - {0xc028, 191}, - {0x8002, 197}, - {0x8009, 197}, - {0x8017, 197}, - {0xc028, 197}, - {0x8002, 231}, - {0x8009, 231}, - {0x8017, 231}, - {0xc028, 231}, + {0x02, 2, 188}, + {0x09, 2, 188}, + {0x17, 2, 188}, + {0x28, 3, 188}, + {0x02, 2, 191}, + {0x09, 2, 191}, + {0x17, 2, 191}, + {0x28, 3, 191}, + {0x02, 2, 197}, + {0x09, 2, 197}, + {0x17, 2, 197}, + {0x28, 3, 197}, + {0x02, 2, 231}, + {0x09, 2, 231}, + {0x17, 2, 231}, + {0x28, 3, 231}, }, /* 172 */ { - {0x8003, 188}, - {0x8006, 188}, - {0x800a, 188}, - {0x800f, 188}, - {0x8018, 188}, - {0x801f, 188}, - {0x8029, 188}, - {0xc038, 188}, - {0x8003, 191}, - {0x8006, 191}, - {0x800a, 191}, - {0x800f, 191}, - {0x8018, 191}, - {0x801f, 191}, - {0x8029, 191}, - {0xc038, 191}, + {0x03, 2, 188}, + {0x06, 2, 188}, + {0x0a, 2, 188}, + {0x0f, 2, 188}, + {0x18, 2, 188}, + {0x1f, 2, 188}, + {0x29, 2, 188}, + {0x38, 3, 188}, + {0x03, 2, 191}, + {0x06, 2, 191}, + {0x0a, 2, 191}, + {0x0f, 2, 191}, + {0x18, 2, 191}, + {0x1f, 2, 191}, + {0x29, 2, 191}, + {0x38, 3, 191}, }, /* 173 */ { - {0x8003, 197}, - {0x8006, 197}, - {0x800a, 197}, - {0x800f, 197}, - {0x8018, 197}, - {0x801f, 197}, - {0x8029, 197}, - {0xc038, 197}, - {0x8003, 231}, - {0x8006, 231}, - {0x800a, 231}, - {0x800f, 231}, - {0x8018, 231}, - {0x801f, 231}, - {0x8029, 231}, - {0xc038, 231}, + {0x03, 2, 197}, + {0x06, 2, 197}, + {0x0a, 2, 197}, + {0x0f, 2, 197}, + {0x18, 2, 197}, + {0x1f, 2, 197}, + {0x29, 2, 197}, + {0x38, 3, 197}, + {0x03, 2, 231}, + {0x06, 2, 231}, + {0x0a, 2, 231}, + {0x0f, 2, 231}, + {0x18, 2, 231}, + {0x1f, 2, 231}, + {0x29, 2, 231}, + {0x38, 3, 231}, }, /* 174 */ { - {0x8002, 239}, - {0x8009, 239}, - {0x8017, 239}, - {0xc028, 239}, - {0x8001, 9}, - {0xc016, 9}, - {0x8001, 142}, - {0xc016, 142}, - {0x8001, 144}, - {0xc016, 144}, - {0x8001, 145}, - {0xc016, 145}, - {0x8001, 148}, - {0xc016, 148}, - {0x8001, 159}, - {0xc016, 159}, + {0x02, 2, 239}, + {0x09, 2, 239}, + {0x17, 2, 239}, + {0x28, 3, 239}, + {0x01, 2, 9}, + {0x16, 3, 9}, + {0x01, 2, 142}, + {0x16, 3, 142}, + {0x01, 2, 144}, + {0x16, 3, 144}, + {0x01, 2, 145}, + {0x16, 3, 145}, + {0x01, 2, 148}, + {0x16, 3, 148}, + {0x01, 2, 159}, + {0x16, 3, 159}, }, /* 175 */ { - {0x8003, 239}, - {0x8006, 239}, - {0x800a, 239}, - {0x800f, 239}, - {0x8018, 239}, - {0x801f, 239}, - {0x8029, 239}, - {0xc038, 239}, - {0x8002, 9}, - {0x8009, 9}, - {0x8017, 9}, - {0xc028, 9}, - {0x8002, 142}, - {0x8009, 142}, - {0x8017, 142}, - {0xc028, 142}, + {0x03, 2, 239}, + {0x06, 2, 239}, + {0x0a, 2, 239}, + {0x0f, 2, 239}, + {0x18, 2, 239}, + {0x1f, 2, 239}, + {0x29, 2, 239}, + {0x38, 3, 239}, + {0x02, 2, 9}, + {0x09, 2, 9}, + {0x17, 2, 9}, + {0x28, 3, 9}, + {0x02, 2, 142}, + {0x09, 2, 142}, + {0x17, 2, 142}, + {0x28, 3, 142}, }, /* 176 */ { - {0x8003, 9}, - {0x8006, 9}, - {0x800a, 9}, - {0x800f, 9}, - {0x8018, 9}, - {0x801f, 9}, - {0x8029, 9}, - {0xc038, 9}, - {0x8003, 142}, - {0x8006, 142}, - {0x800a, 142}, - {0x800f, 142}, - {0x8018, 142}, - {0x801f, 142}, - {0x8029, 142}, - {0xc038, 142}, + {0x03, 2, 9}, + {0x06, 2, 9}, + {0x0a, 2, 9}, + {0x0f, 2, 9}, + {0x18, 2, 9}, + {0x1f, 2, 9}, + {0x29, 2, 9}, + {0x38, 3, 9}, + {0x03, 2, 142}, + {0x06, 2, 142}, + {0x0a, 2, 142}, + {0x0f, 2, 142}, + {0x18, 2, 142}, + {0x1f, 2, 142}, + {0x29, 2, 142}, + {0x38, 3, 142}, }, /* 177 */ { - {0x8002, 144}, - {0x8009, 144}, - {0x8017, 144}, - {0xc028, 144}, - {0x8002, 145}, - {0x8009, 145}, - {0x8017, 145}, - {0xc028, 145}, - {0x8002, 148}, - {0x8009, 148}, - {0x8017, 148}, - {0xc028, 148}, - {0x8002, 159}, - {0x8009, 159}, - {0x8017, 159}, - {0xc028, 159}, + {0x02, 2, 144}, + {0x09, 2, 144}, + {0x17, 2, 144}, + {0x28, 3, 144}, + {0x02, 2, 145}, + {0x09, 2, 145}, + {0x17, 2, 145}, + {0x28, 3, 145}, + {0x02, 2, 148}, + {0x09, 2, 148}, + {0x17, 2, 148}, + {0x28, 3, 148}, + {0x02, 2, 159}, + {0x09, 2, 159}, + {0x17, 2, 159}, + {0x28, 3, 159}, }, /* 178 */ { - {0x8003, 144}, - {0x8006, 144}, - {0x800a, 144}, - {0x800f, 144}, - {0x8018, 144}, - {0x801f, 144}, - {0x8029, 144}, - {0xc038, 144}, - {0x8003, 145}, - {0x8006, 145}, - {0x800a, 145}, - {0x800f, 145}, - {0x8018, 145}, - {0x801f, 145}, - {0x8029, 145}, - {0xc038, 145}, + {0x03, 2, 144}, + {0x06, 2, 144}, + {0x0a, 2, 144}, + {0x0f, 2, 144}, + {0x18, 2, 144}, + {0x1f, 2, 144}, + {0x29, 2, 144}, + {0x38, 3, 144}, + {0x03, 2, 145}, + {0x06, 2, 145}, + {0x0a, 2, 145}, + {0x0f, 2, 145}, + {0x18, 2, 145}, + {0x1f, 2, 145}, + {0x29, 2, 145}, + {0x38, 3, 145}, }, /* 179 */ { - {0x8003, 148}, - {0x8006, 148}, - {0x800a, 148}, - {0x800f, 148}, - {0x8018, 148}, - {0x801f, 148}, - {0x8029, 148}, - {0xc038, 148}, - {0x8003, 159}, - {0x8006, 159}, - {0x800a, 159}, - {0x800f, 159}, - {0x8018, 159}, - {0x801f, 159}, - {0x8029, 159}, - {0xc038, 159}, + {0x03, 2, 148}, + {0x06, 2, 148}, + {0x0a, 2, 148}, + {0x0f, 2, 148}, + {0x18, 2, 148}, + {0x1f, 2, 148}, + {0x29, 2, 148}, + {0x38, 3, 148}, + {0x03, 2, 159}, + {0x06, 2, 159}, + {0x0a, 2, 159}, + {0x0f, 2, 159}, + {0x18, 2, 159}, + {0x1f, 2, 159}, + {0x29, 2, 159}, + {0x38, 3, 159}, }, /* 180 */ { - {0xc000, 171}, - {0xc000, 206}, - {0xc000, 215}, - {0xc000, 225}, - {0xc000, 236}, - {0xc000, 237}, - {0xbc, 0}, - {0xbd, 0}, - {0xc1, 0}, - {0xc4, 0}, - {0xc8, 0}, - {0xcb, 0}, - {0xd1, 0}, - {0xd8, 0}, - {0xe0, 0}, - {0xee, 0}, + {0x00, 3, 171}, + {0x00, 3, 206}, + {0x00, 3, 215}, + {0x00, 3, 225}, + {0x00, 3, 236}, + {0x00, 3, 237}, + {0xbc, 0, 0}, + {0xbd, 0, 0}, + {0xc1, 0, 0}, + {0xc4, 0, 0}, + {0xc8, 0, 0}, + {0xcb, 0, 0}, + {0xd1, 0, 0}, + {0xd8, 0, 0}, + {0xe0, 0, 0}, + {0xee, 0, 0}, }, /* 181 */ { - {0x8001, 171}, - {0xc016, 171}, - {0x8001, 206}, - {0xc016, 206}, - {0x8001, 215}, - {0xc016, 215}, - {0x8001, 225}, - {0xc016, 225}, - {0x8001, 236}, - {0xc016, 236}, - {0x8001, 237}, - {0xc016, 237}, - {0xc000, 199}, - {0xc000, 207}, - {0xc000, 234}, - {0xc000, 235}, + {0x01, 2, 171}, + {0x16, 3, 171}, + {0x01, 2, 206}, + {0x16, 3, 206}, + {0x01, 2, 215}, + {0x16, 3, 215}, + {0x01, 2, 225}, + {0x16, 3, 225}, + {0x01, 2, 236}, + {0x16, 3, 236}, + {0x01, 2, 237}, + {0x16, 3, 237}, + {0x00, 3, 199}, + {0x00, 3, 207}, + {0x00, 3, 234}, + {0x00, 3, 235}, }, /* 182 */ { - {0x8002, 171}, - {0x8009, 171}, - {0x8017, 171}, - {0xc028, 171}, - {0x8002, 206}, - {0x8009, 206}, - {0x8017, 206}, - {0xc028, 206}, - {0x8002, 215}, - {0x8009, 215}, - {0x8017, 215}, - {0xc028, 215}, - {0x8002, 225}, - {0x8009, 225}, - {0x8017, 225}, - {0xc028, 225}, + {0x02, 2, 171}, + {0x09, 2, 171}, + {0x17, 2, 171}, + {0x28, 3, 171}, + {0x02, 2, 206}, + {0x09, 2, 206}, + {0x17, 2, 206}, + {0x28, 3, 206}, + {0x02, 2, 215}, + {0x09, 2, 215}, + {0x17, 2, 215}, + {0x28, 3, 215}, + {0x02, 2, 225}, + {0x09, 2, 225}, + {0x17, 2, 225}, + {0x28, 3, 225}, }, /* 183 */ { - {0x8003, 171}, - {0x8006, 171}, - {0x800a, 171}, - {0x800f, 171}, - {0x8018, 171}, - {0x801f, 171}, - {0x8029, 171}, - {0xc038, 171}, - {0x8003, 206}, - {0x8006, 206}, - {0x800a, 206}, - {0x800f, 206}, - {0x8018, 206}, - {0x801f, 206}, - {0x8029, 206}, - {0xc038, 206}, + {0x03, 2, 171}, + {0x06, 2, 171}, + {0x0a, 2, 171}, + {0x0f, 2, 171}, + {0x18, 2, 171}, + {0x1f, 2, 171}, + {0x29, 2, 171}, + {0x38, 3, 171}, + {0x03, 2, 206}, + {0x06, 2, 206}, + {0x0a, 2, 206}, + {0x0f, 2, 206}, + {0x18, 2, 206}, + {0x1f, 2, 206}, + {0x29, 2, 206}, + {0x38, 3, 206}, }, /* 184 */ { - {0x8003, 215}, - {0x8006, 215}, - {0x800a, 215}, - {0x800f, 215}, - {0x8018, 215}, - {0x801f, 215}, - {0x8029, 215}, - {0xc038, 215}, - {0x8003, 225}, - {0x8006, 225}, - {0x800a, 225}, - {0x800f, 225}, - {0x8018, 225}, - {0x801f, 225}, - {0x8029, 225}, - {0xc038, 225}, + {0x03, 2, 215}, + {0x06, 2, 215}, + {0x0a, 2, 215}, + {0x0f, 2, 215}, + {0x18, 2, 215}, + {0x1f, 2, 215}, + {0x29, 2, 215}, + {0x38, 3, 215}, + {0x03, 2, 225}, + {0x06, 2, 225}, + {0x0a, 2, 225}, + {0x0f, 2, 225}, + {0x18, 2, 225}, + {0x1f, 2, 225}, + {0x29, 2, 225}, + {0x38, 3, 225}, }, /* 185 */ { - {0x8002, 236}, - {0x8009, 236}, - {0x8017, 236}, - {0xc028, 236}, - {0x8002, 237}, - {0x8009, 237}, - {0x8017, 237}, - {0xc028, 237}, - {0x8001, 199}, - {0xc016, 199}, - {0x8001, 207}, - {0xc016, 207}, - {0x8001, 234}, - {0xc016, 234}, - {0x8001, 235}, - {0xc016, 235}, + {0x02, 2, 236}, + {0x09, 2, 236}, + {0x17, 2, 236}, + {0x28, 3, 236}, + {0x02, 2, 237}, + {0x09, 2, 237}, + {0x17, 2, 237}, + {0x28, 3, 237}, + {0x01, 2, 199}, + {0x16, 3, 199}, + {0x01, 2, 207}, + {0x16, 3, 207}, + {0x01, 2, 234}, + {0x16, 3, 234}, + {0x01, 2, 235}, + {0x16, 3, 235}, }, /* 186 */ { - {0x8003, 236}, - {0x8006, 236}, - {0x800a, 236}, - {0x800f, 236}, - {0x8018, 236}, - {0x801f, 236}, - {0x8029, 236}, - {0xc038, 236}, - {0x8003, 237}, - {0x8006, 237}, - {0x800a, 237}, - {0x800f, 237}, - {0x8018, 237}, - {0x801f, 237}, - {0x8029, 237}, - {0xc038, 237}, + {0x03, 2, 236}, + {0x06, 2, 236}, + {0x0a, 2, 236}, + {0x0f, 2, 236}, + {0x18, 2, 236}, + {0x1f, 2, 236}, + {0x29, 2, 236}, + {0x38, 3, 236}, + {0x03, 2, 237}, + {0x06, 2, 237}, + {0x0a, 2, 237}, + {0x0f, 2, 237}, + {0x18, 2, 237}, + {0x1f, 2, 237}, + {0x29, 2, 237}, + {0x38, 3, 237}, }, /* 187 */ { - {0x8002, 199}, - {0x8009, 199}, - {0x8017, 199}, - {0xc028, 199}, - {0x8002, 207}, - {0x8009, 207}, - {0x8017, 207}, - {0xc028, 207}, - {0x8002, 234}, - {0x8009, 234}, - {0x8017, 234}, - {0xc028, 234}, - {0x8002, 235}, - {0x8009, 235}, - {0x8017, 235}, - {0xc028, 235}, + {0x02, 2, 199}, + {0x09, 2, 199}, + {0x17, 2, 199}, + {0x28, 3, 199}, + {0x02, 2, 207}, + {0x09, 2, 207}, + {0x17, 2, 207}, + {0x28, 3, 207}, + {0x02, 2, 234}, + {0x09, 2, 234}, + {0x17, 2, 234}, + {0x28, 3, 234}, + {0x02, 2, 235}, + {0x09, 2, 235}, + {0x17, 2, 235}, + {0x28, 3, 235}, }, /* 188 */ { - {0x8003, 199}, - {0x8006, 199}, - {0x800a, 199}, - {0x800f, 199}, - {0x8018, 199}, - {0x801f, 199}, - {0x8029, 199}, - {0xc038, 199}, - {0x8003, 207}, - {0x8006, 207}, - {0x800a, 207}, - {0x800f, 207}, - {0x8018, 207}, - {0x801f, 207}, - {0x8029, 207}, - {0xc038, 207}, + {0x03, 2, 199}, + {0x06, 2, 199}, + {0x0a, 2, 199}, + {0x0f, 2, 199}, + {0x18, 2, 199}, + {0x1f, 2, 199}, + {0x29, 2, 199}, + {0x38, 3, 199}, + {0x03, 2, 207}, + {0x06, 2, 207}, + {0x0a, 2, 207}, + {0x0f, 2, 207}, + {0x18, 2, 207}, + {0x1f, 2, 207}, + {0x29, 2, 207}, + {0x38, 3, 207}, }, /* 189 */ { - {0x8003, 234}, - {0x8006, 234}, - {0x800a, 234}, - {0x800f, 234}, - {0x8018, 234}, - {0x801f, 234}, - {0x8029, 234}, - {0xc038, 234}, - {0x8003, 235}, - {0x8006, 235}, - {0x800a, 235}, - {0x800f, 235}, - {0x8018, 235}, - {0x801f, 235}, - {0x8029, 235}, - {0xc038, 235}, + {0x03, 2, 234}, + {0x06, 2, 234}, + {0x0a, 2, 234}, + {0x0f, 2, 234}, + {0x18, 2, 234}, + {0x1f, 2, 234}, + {0x29, 2, 234}, + {0x38, 3, 234}, + {0x03, 2, 235}, + {0x06, 2, 235}, + {0x0a, 2, 235}, + {0x0f, 2, 235}, + {0x18, 2, 235}, + {0x1f, 2, 235}, + {0x29, 2, 235}, + {0x38, 3, 235}, }, /* 190 */ { - {0xc2, 0}, - {0xc3, 0}, - {0xc5, 0}, - {0xc6, 0}, - {0xc9, 0}, - {0xca, 0}, - {0xcc, 0}, - {0xcd, 0}, - {0xd2, 0}, - {0xd5, 0}, - {0xd9, 0}, - {0xdc, 0}, - {0xe1, 0}, - {0xe7, 0}, - {0xef, 0}, - {0xf6, 0}, + {0xc2, 0, 0}, + {0xc3, 0, 0}, + {0xc5, 0, 0}, + {0xc6, 0, 0}, + {0xc9, 0, 0}, + {0xca, 0, 0}, + {0xcc, 0, 0}, + {0xcd, 0, 0}, + {0xd2, 0, 0}, + {0xd5, 0, 0}, + {0xd9, 0, 0}, + {0xdc, 0, 0}, + {0xe1, 0, 0}, + {0xe7, 0, 0}, + {0xef, 0, 0}, + {0xf6, 0, 0}, }, /* 191 */ { - {0xc000, 192}, - {0xc000, 193}, - {0xc000, 200}, - {0xc000, 201}, - {0xc000, 202}, - {0xc000, 205}, - {0xc000, 210}, - {0xc000, 213}, - {0xc000, 218}, - {0xc000, 219}, - {0xc000, 238}, - {0xc000, 240}, - {0xc000, 242}, - {0xc000, 243}, - {0xc000, 255}, - {0xce, 0}, + {0x00, 3, 192}, + {0x00, 3, 193}, + {0x00, 3, 200}, + {0x00, 3, 201}, + {0x00, 3, 202}, + {0x00, 3, 205}, + {0x00, 3, 210}, + {0x00, 3, 213}, + {0x00, 3, 218}, + {0x00, 3, 219}, + {0x00, 3, 238}, + {0x00, 3, 240}, + {0x00, 3, 242}, + {0x00, 3, 243}, + {0x00, 3, 255}, + {0xce, 0, 0}, }, /* 192 */ { - {0x8001, 192}, - {0xc016, 192}, - {0x8001, 193}, - {0xc016, 193}, - {0x8001, 200}, - {0xc016, 200}, - {0x8001, 201}, - {0xc016, 201}, - {0x8001, 202}, - {0xc016, 202}, - {0x8001, 205}, - {0xc016, 205}, - {0x8001, 210}, - {0xc016, 210}, - {0x8001, 213}, - {0xc016, 213}, + {0x01, 2, 192}, + {0x16, 3, 192}, + {0x01, 2, 193}, + {0x16, 3, 193}, + {0x01, 2, 200}, + {0x16, 3, 200}, + {0x01, 2, 201}, + {0x16, 3, 201}, + {0x01, 2, 202}, + {0x16, 3, 202}, + {0x01, 2, 205}, + {0x16, 3, 205}, + {0x01, 2, 210}, + {0x16, 3, 210}, + {0x01, 2, 213}, + {0x16, 3, 213}, }, /* 193 */ { - {0x8002, 192}, - {0x8009, 192}, - {0x8017, 192}, - {0xc028, 192}, - {0x8002, 193}, - {0x8009, 193}, - {0x8017, 193}, - {0xc028, 193}, - {0x8002, 200}, - {0x8009, 200}, - {0x8017, 200}, - {0xc028, 200}, - {0x8002, 201}, - {0x8009, 201}, - {0x8017, 201}, - {0xc028, 201}, + {0x02, 2, 192}, + {0x09, 2, 192}, + {0x17, 2, 192}, + {0x28, 3, 192}, + {0x02, 2, 193}, + {0x09, 2, 193}, + {0x17, 2, 193}, + {0x28, 3, 193}, + {0x02, 2, 200}, + {0x09, 2, 200}, + {0x17, 2, 200}, + {0x28, 3, 200}, + {0x02, 2, 201}, + {0x09, 2, 201}, + {0x17, 2, 201}, + {0x28, 3, 201}, }, /* 194 */ { - {0x8003, 192}, - {0x8006, 192}, - {0x800a, 192}, - {0x800f, 192}, - {0x8018, 192}, - {0x801f, 192}, - {0x8029, 192}, - {0xc038, 192}, - {0x8003, 193}, - {0x8006, 193}, - {0x800a, 193}, - {0x800f, 193}, - {0x8018, 193}, - {0x801f, 193}, - {0x8029, 193}, - {0xc038, 193}, + {0x03, 2, 192}, + {0x06, 2, 192}, + {0x0a, 2, 192}, + {0x0f, 2, 192}, + {0x18, 2, 192}, + {0x1f, 2, 192}, + {0x29, 2, 192}, + {0x38, 3, 192}, + {0x03, 2, 193}, + {0x06, 2, 193}, + {0x0a, 2, 193}, + {0x0f, 2, 193}, + {0x18, 2, 193}, + {0x1f, 2, 193}, + {0x29, 2, 193}, + {0x38, 3, 193}, }, /* 195 */ { - {0x8003, 200}, - {0x8006, 200}, - {0x800a, 200}, - {0x800f, 200}, - {0x8018, 200}, - {0x801f, 200}, - {0x8029, 200}, - {0xc038, 200}, - {0x8003, 201}, - {0x8006, 201}, - {0x800a, 201}, - {0x800f, 201}, - {0x8018, 201}, - {0x801f, 201}, - {0x8029, 201}, - {0xc038, 201}, + {0x03, 2, 200}, + {0x06, 2, 200}, + {0x0a, 2, 200}, + {0x0f, 2, 200}, + {0x18, 2, 200}, + {0x1f, 2, 200}, + {0x29, 2, 200}, + {0x38, 3, 200}, + {0x03, 2, 201}, + {0x06, 2, 201}, + {0x0a, 2, 201}, + {0x0f, 2, 201}, + {0x18, 2, 201}, + {0x1f, 2, 201}, + {0x29, 2, 201}, + {0x38, 3, 201}, }, /* 196 */ { - {0x8002, 202}, - {0x8009, 202}, - {0x8017, 202}, - {0xc028, 202}, - {0x8002, 205}, - {0x8009, 205}, - {0x8017, 205}, - {0xc028, 205}, - {0x8002, 210}, - {0x8009, 210}, - {0x8017, 210}, - {0xc028, 210}, - {0x8002, 213}, - {0x8009, 213}, - {0x8017, 213}, - {0xc028, 213}, + {0x02, 2, 202}, + {0x09, 2, 202}, + {0x17, 2, 202}, + {0x28, 3, 202}, + {0x02, 2, 205}, + {0x09, 2, 205}, + {0x17, 2, 205}, + {0x28, 3, 205}, + {0x02, 2, 210}, + {0x09, 2, 210}, + {0x17, 2, 210}, + {0x28, 3, 210}, + {0x02, 2, 213}, + {0x09, 2, 213}, + {0x17, 2, 213}, + {0x28, 3, 213}, }, /* 197 */ { - {0x8003, 202}, - {0x8006, 202}, - {0x800a, 202}, - {0x800f, 202}, - {0x8018, 202}, - {0x801f, 202}, - {0x8029, 202}, - {0xc038, 202}, - {0x8003, 205}, - {0x8006, 205}, - {0x800a, 205}, - {0x800f, 205}, - {0x8018, 205}, - {0x801f, 205}, - {0x8029, 205}, - {0xc038, 205}, + {0x03, 2, 202}, + {0x06, 2, 202}, + {0x0a, 2, 202}, + {0x0f, 2, 202}, + {0x18, 2, 202}, + {0x1f, 2, 202}, + {0x29, 2, 202}, + {0x38, 3, 202}, + {0x03, 2, 205}, + {0x06, 2, 205}, + {0x0a, 2, 205}, + {0x0f, 2, 205}, + {0x18, 2, 205}, + {0x1f, 2, 205}, + {0x29, 2, 205}, + {0x38, 3, 205}, }, /* 198 */ { - {0x8003, 210}, - {0x8006, 210}, - {0x800a, 210}, - {0x800f, 210}, - {0x8018, 210}, - {0x801f, 210}, - {0x8029, 210}, - {0xc038, 210}, - {0x8003, 213}, - {0x8006, 213}, - {0x800a, 213}, - {0x800f, 213}, - {0x8018, 213}, - {0x801f, 213}, - {0x8029, 213}, - {0xc038, 213}, + {0x03, 2, 210}, + {0x06, 2, 210}, + {0x0a, 2, 210}, + {0x0f, 2, 210}, + {0x18, 2, 210}, + {0x1f, 2, 210}, + {0x29, 2, 210}, + {0x38, 3, 210}, + {0x03, 2, 213}, + {0x06, 2, 213}, + {0x0a, 2, 213}, + {0x0f, 2, 213}, + {0x18, 2, 213}, + {0x1f, 2, 213}, + {0x29, 2, 213}, + {0x38, 3, 213}, }, /* 199 */ { - {0x8001, 218}, - {0xc016, 218}, - {0x8001, 219}, - {0xc016, 219}, - {0x8001, 238}, - {0xc016, 238}, - {0x8001, 240}, - {0xc016, 240}, - {0x8001, 242}, - {0xc016, 242}, - {0x8001, 243}, - {0xc016, 243}, - {0x8001, 255}, - {0xc016, 255}, - {0xc000, 203}, - {0xc000, 204}, + {0x01, 2, 218}, + {0x16, 3, 218}, + {0x01, 2, 219}, + {0x16, 3, 219}, + {0x01, 2, 238}, + {0x16, 3, 238}, + {0x01, 2, 240}, + {0x16, 3, 240}, + {0x01, 2, 242}, + {0x16, 3, 242}, + {0x01, 2, 243}, + {0x16, 3, 243}, + {0x01, 2, 255}, + {0x16, 3, 255}, + {0x00, 3, 203}, + {0x00, 3, 204}, }, /* 200 */ { - {0x8002, 218}, - {0x8009, 218}, - {0x8017, 218}, - {0xc028, 218}, - {0x8002, 219}, - {0x8009, 219}, - {0x8017, 219}, - {0xc028, 219}, - {0x8002, 238}, - {0x8009, 238}, - {0x8017, 238}, - {0xc028, 238}, - {0x8002, 240}, - {0x8009, 240}, - {0x8017, 240}, - {0xc028, 240}, + {0x02, 2, 218}, + {0x09, 2, 218}, + {0x17, 2, 218}, + {0x28, 3, 218}, + {0x02, 2, 219}, + {0x09, 2, 219}, + {0x17, 2, 219}, + {0x28, 3, 219}, + {0x02, 2, 238}, + {0x09, 2, 238}, + {0x17, 2, 238}, + {0x28, 3, 238}, + {0x02, 2, 240}, + {0x09, 2, 240}, + {0x17, 2, 240}, + {0x28, 3, 240}, }, /* 201 */ { - {0x8003, 218}, - {0x8006, 218}, - {0x800a, 218}, - {0x800f, 218}, - {0x8018, 218}, - {0x801f, 218}, - {0x8029, 218}, - {0xc038, 218}, - {0x8003, 219}, - {0x8006, 219}, - {0x800a, 219}, - {0x800f, 219}, - {0x8018, 219}, - {0x801f, 219}, - {0x8029, 219}, - {0xc038, 219}, + {0x03, 2, 218}, + {0x06, 2, 218}, + {0x0a, 2, 218}, + {0x0f, 2, 218}, + {0x18, 2, 218}, + {0x1f, 2, 218}, + {0x29, 2, 218}, + {0x38, 3, 218}, + {0x03, 2, 219}, + {0x06, 2, 219}, + {0x0a, 2, 219}, + {0x0f, 2, 219}, + {0x18, 2, 219}, + {0x1f, 2, 219}, + {0x29, 2, 219}, + {0x38, 3, 219}, }, /* 202 */ { - {0x8003, 238}, - {0x8006, 238}, - {0x800a, 238}, - {0x800f, 238}, - {0x8018, 238}, - {0x801f, 238}, - {0x8029, 238}, - {0xc038, 238}, - {0x8003, 240}, - {0x8006, 240}, - {0x800a, 240}, - {0x800f, 240}, - {0x8018, 240}, - {0x801f, 240}, - {0x8029, 240}, - {0xc038, 240}, + {0x03, 2, 238}, + {0x06, 2, 238}, + {0x0a, 2, 238}, + {0x0f, 2, 238}, + {0x18, 2, 238}, + {0x1f, 2, 238}, + {0x29, 2, 238}, + {0x38, 3, 238}, + {0x03, 2, 240}, + {0x06, 2, 240}, + {0x0a, 2, 240}, + {0x0f, 2, 240}, + {0x18, 2, 240}, + {0x1f, 2, 240}, + {0x29, 2, 240}, + {0x38, 3, 240}, }, /* 203 */ { - {0x8002, 242}, - {0x8009, 242}, - {0x8017, 242}, - {0xc028, 242}, - {0x8002, 243}, - {0x8009, 243}, - {0x8017, 243}, - {0xc028, 243}, - {0x8002, 255}, - {0x8009, 255}, - {0x8017, 255}, - {0xc028, 255}, - {0x8001, 203}, - {0xc016, 203}, - {0x8001, 204}, - {0xc016, 204}, + {0x02, 2, 242}, + {0x09, 2, 242}, + {0x17, 2, 242}, + {0x28, 3, 242}, + {0x02, 2, 243}, + {0x09, 2, 243}, + {0x17, 2, 243}, + {0x28, 3, 243}, + {0x02, 2, 255}, + {0x09, 2, 255}, + {0x17, 2, 255}, + {0x28, 3, 255}, + {0x01, 2, 203}, + {0x16, 3, 203}, + {0x01, 2, 204}, + {0x16, 3, 204}, }, /* 204 */ { - {0x8003, 242}, - {0x8006, 242}, - {0x800a, 242}, - {0x800f, 242}, - {0x8018, 242}, - {0x801f, 242}, - {0x8029, 242}, - {0xc038, 242}, - {0x8003, 243}, - {0x8006, 243}, - {0x800a, 243}, - {0x800f, 243}, - {0x8018, 243}, - {0x801f, 243}, - {0x8029, 243}, - {0xc038, 243}, + {0x03, 2, 242}, + {0x06, 2, 242}, + {0x0a, 2, 242}, + {0x0f, 2, 242}, + {0x18, 2, 242}, + {0x1f, 2, 242}, + {0x29, 2, 242}, + {0x38, 3, 242}, + {0x03, 2, 243}, + {0x06, 2, 243}, + {0x0a, 2, 243}, + {0x0f, 2, 243}, + {0x18, 2, 243}, + {0x1f, 2, 243}, + {0x29, 2, 243}, + {0x38, 3, 243}, }, /* 205 */ { - {0x8003, 255}, - {0x8006, 255}, - {0x800a, 255}, - {0x800f, 255}, - {0x8018, 255}, - {0x801f, 255}, - {0x8029, 255}, - {0xc038, 255}, - {0x8002, 203}, - {0x8009, 203}, - {0x8017, 203}, - {0xc028, 203}, - {0x8002, 204}, - {0x8009, 204}, - {0x8017, 204}, - {0xc028, 204}, + {0x03, 2, 255}, + {0x06, 2, 255}, + {0x0a, 2, 255}, + {0x0f, 2, 255}, + {0x18, 2, 255}, + {0x1f, 2, 255}, + {0x29, 2, 255}, + {0x38, 3, 255}, + {0x02, 2, 203}, + {0x09, 2, 203}, + {0x17, 2, 203}, + {0x28, 3, 203}, + {0x02, 2, 204}, + {0x09, 2, 204}, + {0x17, 2, 204}, + {0x28, 3, 204}, }, /* 206 */ { - {0x8003, 203}, - {0x8006, 203}, - {0x800a, 203}, - {0x800f, 203}, - {0x8018, 203}, - {0x801f, 203}, - {0x8029, 203}, - {0xc038, 203}, - {0x8003, 204}, - {0x8006, 204}, - {0x800a, 204}, - {0x800f, 204}, - {0x8018, 204}, - {0x801f, 204}, - {0x8029, 204}, - {0xc038, 204}, + {0x03, 2, 203}, + {0x06, 2, 203}, + {0x0a, 2, 203}, + {0x0f, 2, 203}, + {0x18, 2, 203}, + {0x1f, 2, 203}, + {0x29, 2, 203}, + {0x38, 3, 203}, + {0x03, 2, 204}, + {0x06, 2, 204}, + {0x0a, 2, 204}, + {0x0f, 2, 204}, + {0x18, 2, 204}, + {0x1f, 2, 204}, + {0x29, 2, 204}, + {0x38, 3, 204}, }, /* 207 */ { - {0xd3, 0}, - {0xd4, 0}, - {0xd6, 0}, - {0xd7, 0}, - {0xda, 0}, - {0xdb, 0}, - {0xdd, 0}, - {0xde, 0}, - {0xe2, 0}, - {0xe4, 0}, - {0xe8, 0}, - {0xeb, 0}, - {0xf0, 0}, - {0xf3, 0}, - {0xf7, 0}, - {0xfa, 0}, + {0xd3, 0, 0}, + {0xd4, 0, 0}, + {0xd6, 0, 0}, + {0xd7, 0, 0}, + {0xda, 0, 0}, + {0xdb, 0, 0}, + {0xdd, 0, 0}, + {0xde, 0, 0}, + {0xe2, 0, 0}, + {0xe4, 0, 0}, + {0xe8, 0, 0}, + {0xeb, 0, 0}, + {0xf0, 0, 0}, + {0xf3, 0, 0}, + {0xf7, 0, 0}, + {0xfa, 0, 0}, }, /* 208 */ { - {0xc000, 211}, - {0xc000, 212}, - {0xc000, 214}, - {0xc000, 221}, - {0xc000, 222}, - {0xc000, 223}, - {0xc000, 241}, - {0xc000, 244}, - {0xc000, 245}, - {0xc000, 246}, - {0xc000, 247}, - {0xc000, 248}, - {0xc000, 250}, - {0xc000, 251}, - {0xc000, 252}, - {0xc000, 253}, + {0x00, 3, 211}, + {0x00, 3, 212}, + {0x00, 3, 214}, + {0x00, 3, 221}, + {0x00, 3, 222}, + {0x00, 3, 223}, + {0x00, 3, 241}, + {0x00, 3, 244}, + {0x00, 3, 245}, + {0x00, 3, 246}, + {0x00, 3, 247}, + {0x00, 3, 248}, + {0x00, 3, 250}, + {0x00, 3, 251}, + {0x00, 3, 252}, + {0x00, 3, 253}, }, /* 209 */ { - {0x8001, 211}, - {0xc016, 211}, - {0x8001, 212}, - {0xc016, 212}, - {0x8001, 214}, - {0xc016, 214}, - {0x8001, 221}, - {0xc016, 221}, - {0x8001, 222}, - {0xc016, 222}, - {0x8001, 223}, - {0xc016, 223}, - {0x8001, 241}, - {0xc016, 241}, - {0x8001, 244}, - {0xc016, 244}, + {0x01, 2, 211}, + {0x16, 3, 211}, + {0x01, 2, 212}, + {0x16, 3, 212}, + {0x01, 2, 214}, + {0x16, 3, 214}, + {0x01, 2, 221}, + {0x16, 3, 221}, + {0x01, 2, 222}, + {0x16, 3, 222}, + {0x01, 2, 223}, + {0x16, 3, 223}, + {0x01, 2, 241}, + {0x16, 3, 241}, + {0x01, 2, 244}, + {0x16, 3, 244}, }, /* 210 */ { - {0x8002, 211}, - {0x8009, 211}, - {0x8017, 211}, - {0xc028, 211}, - {0x8002, 212}, - {0x8009, 212}, - {0x8017, 212}, - {0xc028, 212}, - {0x8002, 214}, - {0x8009, 214}, - {0x8017, 214}, - {0xc028, 214}, - {0x8002, 221}, - {0x8009, 221}, - {0x8017, 221}, - {0xc028, 221}, + {0x02, 2, 211}, + {0x09, 2, 211}, + {0x17, 2, 211}, + {0x28, 3, 211}, + {0x02, 2, 212}, + {0x09, 2, 212}, + {0x17, 2, 212}, + {0x28, 3, 212}, + {0x02, 2, 214}, + {0x09, 2, 214}, + {0x17, 2, 214}, + {0x28, 3, 214}, + {0x02, 2, 221}, + {0x09, 2, 221}, + {0x17, 2, 221}, + {0x28, 3, 221}, }, /* 211 */ { - {0x8003, 211}, - {0x8006, 211}, - {0x800a, 211}, - {0x800f, 211}, - {0x8018, 211}, - {0x801f, 211}, - {0x8029, 211}, - {0xc038, 211}, - {0x8003, 212}, - {0x8006, 212}, - {0x800a, 212}, - {0x800f, 212}, - {0x8018, 212}, - {0x801f, 212}, - {0x8029, 212}, - {0xc038, 212}, + {0x03, 2, 211}, + {0x06, 2, 211}, + {0x0a, 2, 211}, + {0x0f, 2, 211}, + {0x18, 2, 211}, + {0x1f, 2, 211}, + {0x29, 2, 211}, + {0x38, 3, 211}, + {0x03, 2, 212}, + {0x06, 2, 212}, + {0x0a, 2, 212}, + {0x0f, 2, 212}, + {0x18, 2, 212}, + {0x1f, 2, 212}, + {0x29, 2, 212}, + {0x38, 3, 212}, }, /* 212 */ { - {0x8003, 214}, - {0x8006, 214}, - {0x800a, 214}, - {0x800f, 214}, - {0x8018, 214}, - {0x801f, 214}, - {0x8029, 214}, - {0xc038, 214}, - {0x8003, 221}, - {0x8006, 221}, - {0x800a, 221}, - {0x800f, 221}, - {0x8018, 221}, - {0x801f, 221}, - {0x8029, 221}, - {0xc038, 221}, + {0x03, 2, 214}, + {0x06, 2, 214}, + {0x0a, 2, 214}, + {0x0f, 2, 214}, + {0x18, 2, 214}, + {0x1f, 2, 214}, + {0x29, 2, 214}, + {0x38, 3, 214}, + {0x03, 2, 221}, + {0x06, 2, 221}, + {0x0a, 2, 221}, + {0x0f, 2, 221}, + {0x18, 2, 221}, + {0x1f, 2, 221}, + {0x29, 2, 221}, + {0x38, 3, 221}, }, /* 213 */ { - {0x8002, 222}, - {0x8009, 222}, - {0x8017, 222}, - {0xc028, 222}, - {0x8002, 223}, - {0x8009, 223}, - {0x8017, 223}, - {0xc028, 223}, - {0x8002, 241}, - {0x8009, 241}, - {0x8017, 241}, - {0xc028, 241}, - {0x8002, 244}, - {0x8009, 244}, - {0x8017, 244}, - {0xc028, 244}, + {0x02, 2, 222}, + {0x09, 2, 222}, + {0x17, 2, 222}, + {0x28, 3, 222}, + {0x02, 2, 223}, + {0x09, 2, 223}, + {0x17, 2, 223}, + {0x28, 3, 223}, + {0x02, 2, 241}, + {0x09, 2, 241}, + {0x17, 2, 241}, + {0x28, 3, 241}, + {0x02, 2, 244}, + {0x09, 2, 244}, + {0x17, 2, 244}, + {0x28, 3, 244}, }, /* 214 */ { - {0x8003, 222}, - {0x8006, 222}, - {0x800a, 222}, - {0x800f, 222}, - {0x8018, 222}, - {0x801f, 222}, - {0x8029, 222}, - {0xc038, 222}, - {0x8003, 223}, - {0x8006, 223}, - {0x800a, 223}, - {0x800f, 223}, - {0x8018, 223}, - {0x801f, 223}, - {0x8029, 223}, - {0xc038, 223}, + {0x03, 2, 222}, + {0x06, 2, 222}, + {0x0a, 2, 222}, + {0x0f, 2, 222}, + {0x18, 2, 222}, + {0x1f, 2, 222}, + {0x29, 2, 222}, + {0x38, 3, 222}, + {0x03, 2, 223}, + {0x06, 2, 223}, + {0x0a, 2, 223}, + {0x0f, 2, 223}, + {0x18, 2, 223}, + {0x1f, 2, 223}, + {0x29, 2, 223}, + {0x38, 3, 223}, }, /* 215 */ { - {0x8003, 241}, - {0x8006, 241}, - {0x800a, 241}, - {0x800f, 241}, - {0x8018, 241}, - {0x801f, 241}, - {0x8029, 241}, - {0xc038, 241}, - {0x8003, 244}, - {0x8006, 244}, - {0x800a, 244}, - {0x800f, 244}, - {0x8018, 244}, - {0x801f, 244}, - {0x8029, 244}, - {0xc038, 244}, + {0x03, 2, 241}, + {0x06, 2, 241}, + {0x0a, 2, 241}, + {0x0f, 2, 241}, + {0x18, 2, 241}, + {0x1f, 2, 241}, + {0x29, 2, 241}, + {0x38, 3, 241}, + {0x03, 2, 244}, + {0x06, 2, 244}, + {0x0a, 2, 244}, + {0x0f, 2, 244}, + {0x18, 2, 244}, + {0x1f, 2, 244}, + {0x29, 2, 244}, + {0x38, 3, 244}, }, /* 216 */ { - {0x8001, 245}, - {0xc016, 245}, - {0x8001, 246}, - {0xc016, 246}, - {0x8001, 247}, - {0xc016, 247}, - {0x8001, 248}, - {0xc016, 248}, - {0x8001, 250}, - {0xc016, 250}, - {0x8001, 251}, - {0xc016, 251}, - {0x8001, 252}, - {0xc016, 252}, - {0x8001, 253}, - {0xc016, 253}, + {0x01, 2, 245}, + {0x16, 3, 245}, + {0x01, 2, 246}, + {0x16, 3, 246}, + {0x01, 2, 247}, + {0x16, 3, 247}, + {0x01, 2, 248}, + {0x16, 3, 248}, + {0x01, 2, 250}, + {0x16, 3, 250}, + {0x01, 2, 251}, + {0x16, 3, 251}, + {0x01, 2, 252}, + {0x16, 3, 252}, + {0x01, 2, 253}, + {0x16, 3, 253}, }, /* 217 */ { - {0x8002, 245}, - {0x8009, 245}, - {0x8017, 245}, - {0xc028, 245}, - {0x8002, 246}, - {0x8009, 246}, - {0x8017, 246}, - {0xc028, 246}, - {0x8002, 247}, - {0x8009, 247}, - {0x8017, 247}, - {0xc028, 247}, - {0x8002, 248}, - {0x8009, 248}, - {0x8017, 248}, - {0xc028, 248}, + {0x02, 2, 245}, + {0x09, 2, 245}, + {0x17, 2, 245}, + {0x28, 3, 245}, + {0x02, 2, 246}, + {0x09, 2, 246}, + {0x17, 2, 246}, + {0x28, 3, 246}, + {0x02, 2, 247}, + {0x09, 2, 247}, + {0x17, 2, 247}, + {0x28, 3, 247}, + {0x02, 2, 248}, + {0x09, 2, 248}, + {0x17, 2, 248}, + {0x28, 3, 248}, }, /* 218 */ { - {0x8003, 245}, - {0x8006, 245}, - {0x800a, 245}, - {0x800f, 245}, - {0x8018, 245}, - {0x801f, 245}, - {0x8029, 245}, - {0xc038, 245}, - {0x8003, 246}, - {0x8006, 246}, - {0x800a, 246}, - {0x800f, 246}, - {0x8018, 246}, - {0x801f, 246}, - {0x8029, 246}, - {0xc038, 246}, + {0x03, 2, 245}, + {0x06, 2, 245}, + {0x0a, 2, 245}, + {0x0f, 2, 245}, + {0x18, 2, 245}, + {0x1f, 2, 245}, + {0x29, 2, 245}, + {0x38, 3, 245}, + {0x03, 2, 246}, + {0x06, 2, 246}, + {0x0a, 2, 246}, + {0x0f, 2, 246}, + {0x18, 2, 246}, + {0x1f, 2, 246}, + {0x29, 2, 246}, + {0x38, 3, 246}, }, /* 219 */ { - {0x8003, 247}, - {0x8006, 247}, - {0x800a, 247}, - {0x800f, 247}, - {0x8018, 247}, - {0x801f, 247}, - {0x8029, 247}, - {0xc038, 247}, - {0x8003, 248}, - {0x8006, 248}, - {0x800a, 248}, - {0x800f, 248}, - {0x8018, 248}, - {0x801f, 248}, - {0x8029, 248}, - {0xc038, 248}, + {0x03, 2, 247}, + {0x06, 2, 247}, + {0x0a, 2, 247}, + {0x0f, 2, 247}, + {0x18, 2, 247}, + {0x1f, 2, 247}, + {0x29, 2, 247}, + {0x38, 3, 247}, + {0x03, 2, 248}, + {0x06, 2, 248}, + {0x0a, 2, 248}, + {0x0f, 2, 248}, + {0x18, 2, 248}, + {0x1f, 2, 248}, + {0x29, 2, 248}, + {0x38, 3, 248}, }, /* 220 */ { - {0x8002, 250}, - {0x8009, 250}, - {0x8017, 250}, - {0xc028, 250}, - {0x8002, 251}, - {0x8009, 251}, - {0x8017, 251}, - {0xc028, 251}, - {0x8002, 252}, - {0x8009, 252}, - {0x8017, 252}, - {0xc028, 252}, - {0x8002, 253}, - {0x8009, 253}, - {0x8017, 253}, - {0xc028, 253}, + {0x02, 2, 250}, + {0x09, 2, 250}, + {0x17, 2, 250}, + {0x28, 3, 250}, + {0x02, 2, 251}, + {0x09, 2, 251}, + {0x17, 2, 251}, + {0x28, 3, 251}, + {0x02, 2, 252}, + {0x09, 2, 252}, + {0x17, 2, 252}, + {0x28, 3, 252}, + {0x02, 2, 253}, + {0x09, 2, 253}, + {0x17, 2, 253}, + {0x28, 3, 253}, }, /* 221 */ { - {0x8003, 250}, - {0x8006, 250}, - {0x800a, 250}, - {0x800f, 250}, - {0x8018, 250}, - {0x801f, 250}, - {0x8029, 250}, - {0xc038, 250}, - {0x8003, 251}, - {0x8006, 251}, - {0x800a, 251}, - {0x800f, 251}, - {0x8018, 251}, - {0x801f, 251}, - {0x8029, 251}, - {0xc038, 251}, + {0x03, 2, 250}, + {0x06, 2, 250}, + {0x0a, 2, 250}, + {0x0f, 2, 250}, + {0x18, 2, 250}, + {0x1f, 2, 250}, + {0x29, 2, 250}, + {0x38, 3, 250}, + {0x03, 2, 251}, + {0x06, 2, 251}, + {0x0a, 2, 251}, + {0x0f, 2, 251}, + {0x18, 2, 251}, + {0x1f, 2, 251}, + {0x29, 2, 251}, + {0x38, 3, 251}, }, /* 222 */ { - {0x8003, 252}, - {0x8006, 252}, - {0x800a, 252}, - {0x800f, 252}, - {0x8018, 252}, - {0x801f, 252}, - {0x8029, 252}, - {0xc038, 252}, - {0x8003, 253}, - {0x8006, 253}, - {0x800a, 253}, - {0x800f, 253}, - {0x8018, 253}, - {0x801f, 253}, - {0x8029, 253}, - {0xc038, 253}, + {0x03, 2, 252}, + {0x06, 2, 252}, + {0x0a, 2, 252}, + {0x0f, 2, 252}, + {0x18, 2, 252}, + {0x1f, 2, 252}, + {0x29, 2, 252}, + {0x38, 3, 252}, + {0x03, 2, 253}, + {0x06, 2, 253}, + {0x0a, 2, 253}, + {0x0f, 2, 253}, + {0x18, 2, 253}, + {0x1f, 2, 253}, + {0x29, 2, 253}, + {0x38, 3, 253}, }, /* 223 */ { - {0xc000, 254}, - {0xe3, 0}, - {0xe5, 0}, - {0xe6, 0}, - {0xe9, 0}, - {0xea, 0}, - {0xec, 0}, - {0xed, 0}, - {0xf1, 0}, - {0xf2, 0}, - {0xf4, 0}, - {0xf5, 0}, - {0xf8, 0}, - {0xf9, 0}, - {0xfb, 0}, - {0xfc, 0}, + {0x00, 3, 254}, + {0xe3, 0, 0}, + {0xe5, 0, 0}, + {0xe6, 0, 0}, + {0xe9, 0, 0}, + {0xea, 0, 0}, + {0xec, 0, 0}, + {0xed, 0, 0}, + {0xf1, 0, 0}, + {0xf2, 0, 0}, + {0xf4, 0, 0}, + {0xf5, 0, 0}, + {0xf8, 0, 0}, + {0xf9, 0, 0}, + {0xfb, 0, 0}, + {0xfc, 0, 0}, }, /* 224 */ { - {0x8001, 254}, - {0xc016, 254}, - {0xc000, 2}, - {0xc000, 3}, - {0xc000, 4}, - {0xc000, 5}, - {0xc000, 6}, - {0xc000, 7}, - {0xc000, 8}, - {0xc000, 11}, - {0xc000, 12}, - {0xc000, 14}, - {0xc000, 15}, - {0xc000, 16}, - {0xc000, 17}, - {0xc000, 18}, + {0x01, 2, 254}, + {0x16, 3, 254}, + {0x00, 3, 2}, + {0x00, 3, 3}, + {0x00, 3, 4}, + {0x00, 3, 5}, + {0x00, 3, 6}, + {0x00, 3, 7}, + {0x00, 3, 8}, + {0x00, 3, 11}, + {0x00, 3, 12}, + {0x00, 3, 14}, + {0x00, 3, 15}, + {0x00, 3, 16}, + {0x00, 3, 17}, + {0x00, 3, 18}, }, /* 225 */ { - {0x8002, 254}, - {0x8009, 254}, - {0x8017, 254}, - {0xc028, 254}, - {0x8001, 2}, - {0xc016, 2}, - {0x8001, 3}, - {0xc016, 3}, - {0x8001, 4}, - {0xc016, 4}, - {0x8001, 5}, - {0xc016, 5}, - {0x8001, 6}, - {0xc016, 6}, - {0x8001, 7}, - {0xc016, 7}, + {0x02, 2, 254}, + {0x09, 2, 254}, + {0x17, 2, 254}, + {0x28, 3, 254}, + {0x01, 2, 2}, + {0x16, 3, 2}, + {0x01, 2, 3}, + {0x16, 3, 3}, + {0x01, 2, 4}, + {0x16, 3, 4}, + {0x01, 2, 5}, + {0x16, 3, 5}, + {0x01, 2, 6}, + {0x16, 3, 6}, + {0x01, 2, 7}, + {0x16, 3, 7}, }, /* 226 */ { - {0x8003, 254}, - {0x8006, 254}, - {0x800a, 254}, - {0x800f, 254}, - {0x8018, 254}, - {0x801f, 254}, - {0x8029, 254}, - {0xc038, 254}, - {0x8002, 2}, - {0x8009, 2}, - {0x8017, 2}, - {0xc028, 2}, - {0x8002, 3}, - {0x8009, 3}, - {0x8017, 3}, - {0xc028, 3}, + {0x03, 2, 254}, + {0x06, 2, 254}, + {0x0a, 2, 254}, + {0x0f, 2, 254}, + {0x18, 2, 254}, + {0x1f, 2, 254}, + {0x29, 2, 254}, + {0x38, 3, 254}, + {0x02, 2, 2}, + {0x09, 2, 2}, + {0x17, 2, 2}, + {0x28, 3, 2}, + {0x02, 2, 3}, + {0x09, 2, 3}, + {0x17, 2, 3}, + {0x28, 3, 3}, }, /* 227 */ { - {0x8003, 2}, - {0x8006, 2}, - {0x800a, 2}, - {0x800f, 2}, - {0x8018, 2}, - {0x801f, 2}, - {0x8029, 2}, - {0xc038, 2}, - {0x8003, 3}, - {0x8006, 3}, - {0x800a, 3}, - {0x800f, 3}, - {0x8018, 3}, - {0x801f, 3}, - {0x8029, 3}, - {0xc038, 3}, + {0x03, 2, 2}, + {0x06, 2, 2}, + {0x0a, 2, 2}, + {0x0f, 2, 2}, + {0x18, 2, 2}, + {0x1f, 2, 2}, + {0x29, 2, 2}, + {0x38, 3, 2}, + {0x03, 2, 3}, + {0x06, 2, 3}, + {0x0a, 2, 3}, + {0x0f, 2, 3}, + {0x18, 2, 3}, + {0x1f, 2, 3}, + {0x29, 2, 3}, + {0x38, 3, 3}, }, /* 228 */ { - {0x8002, 4}, - {0x8009, 4}, - {0x8017, 4}, - {0xc028, 4}, - {0x8002, 5}, - {0x8009, 5}, - {0x8017, 5}, - {0xc028, 5}, - {0x8002, 6}, - {0x8009, 6}, - {0x8017, 6}, - {0xc028, 6}, - {0x8002, 7}, - {0x8009, 7}, - {0x8017, 7}, - {0xc028, 7}, + {0x02, 2, 4}, + {0x09, 2, 4}, + {0x17, 2, 4}, + {0x28, 3, 4}, + {0x02, 2, 5}, + {0x09, 2, 5}, + {0x17, 2, 5}, + {0x28, 3, 5}, + {0x02, 2, 6}, + {0x09, 2, 6}, + {0x17, 2, 6}, + {0x28, 3, 6}, + {0x02, 2, 7}, + {0x09, 2, 7}, + {0x17, 2, 7}, + {0x28, 3, 7}, }, /* 229 */ { - {0x8003, 4}, - {0x8006, 4}, - {0x800a, 4}, - {0x800f, 4}, - {0x8018, 4}, - {0x801f, 4}, - {0x8029, 4}, - {0xc038, 4}, - {0x8003, 5}, - {0x8006, 5}, - {0x800a, 5}, - {0x800f, 5}, - {0x8018, 5}, - {0x801f, 5}, - {0x8029, 5}, - {0xc038, 5}, + {0x03, 2, 4}, + {0x06, 2, 4}, + {0x0a, 2, 4}, + {0x0f, 2, 4}, + {0x18, 2, 4}, + {0x1f, 2, 4}, + {0x29, 2, 4}, + {0x38, 3, 4}, + {0x03, 2, 5}, + {0x06, 2, 5}, + {0x0a, 2, 5}, + {0x0f, 2, 5}, + {0x18, 2, 5}, + {0x1f, 2, 5}, + {0x29, 2, 5}, + {0x38, 3, 5}, }, /* 230 */ { - {0x8003, 6}, - {0x8006, 6}, - {0x800a, 6}, - {0x800f, 6}, - {0x8018, 6}, - {0x801f, 6}, - {0x8029, 6}, - {0xc038, 6}, - {0x8003, 7}, - {0x8006, 7}, - {0x800a, 7}, - {0x800f, 7}, - {0x8018, 7}, - {0x801f, 7}, - {0x8029, 7}, - {0xc038, 7}, + {0x03, 2, 6}, + {0x06, 2, 6}, + {0x0a, 2, 6}, + {0x0f, 2, 6}, + {0x18, 2, 6}, + {0x1f, 2, 6}, + {0x29, 2, 6}, + {0x38, 3, 6}, + {0x03, 2, 7}, + {0x06, 2, 7}, + {0x0a, 2, 7}, + {0x0f, 2, 7}, + {0x18, 2, 7}, + {0x1f, 2, 7}, + {0x29, 2, 7}, + {0x38, 3, 7}, }, /* 231 */ { - {0x8001, 8}, - {0xc016, 8}, - {0x8001, 11}, - {0xc016, 11}, - {0x8001, 12}, - {0xc016, 12}, - {0x8001, 14}, - {0xc016, 14}, - {0x8001, 15}, - {0xc016, 15}, - {0x8001, 16}, - {0xc016, 16}, - {0x8001, 17}, - {0xc016, 17}, - {0x8001, 18}, - {0xc016, 18}, + {0x01, 2, 8}, + {0x16, 3, 8}, + {0x01, 2, 11}, + {0x16, 3, 11}, + {0x01, 2, 12}, + {0x16, 3, 12}, + {0x01, 2, 14}, + {0x16, 3, 14}, + {0x01, 2, 15}, + {0x16, 3, 15}, + {0x01, 2, 16}, + {0x16, 3, 16}, + {0x01, 2, 17}, + {0x16, 3, 17}, + {0x01, 2, 18}, + {0x16, 3, 18}, }, /* 232 */ { - {0x8002, 8}, - {0x8009, 8}, - {0x8017, 8}, - {0xc028, 8}, - {0x8002, 11}, - {0x8009, 11}, - {0x8017, 11}, - {0xc028, 11}, - {0x8002, 12}, - {0x8009, 12}, - {0x8017, 12}, - {0xc028, 12}, - {0x8002, 14}, - {0x8009, 14}, - {0x8017, 14}, - {0xc028, 14}, + {0x02, 2, 8}, + {0x09, 2, 8}, + {0x17, 2, 8}, + {0x28, 3, 8}, + {0x02, 2, 11}, + {0x09, 2, 11}, + {0x17, 2, 11}, + {0x28, 3, 11}, + {0x02, 2, 12}, + {0x09, 2, 12}, + {0x17, 2, 12}, + {0x28, 3, 12}, + {0x02, 2, 14}, + {0x09, 2, 14}, + {0x17, 2, 14}, + {0x28, 3, 14}, }, /* 233 */ { - {0x8003, 8}, - {0x8006, 8}, - {0x800a, 8}, - {0x800f, 8}, - {0x8018, 8}, - {0x801f, 8}, - {0x8029, 8}, - {0xc038, 8}, - {0x8003, 11}, - {0x8006, 11}, - {0x800a, 11}, - {0x800f, 11}, - {0x8018, 11}, - {0x801f, 11}, - {0x8029, 11}, - {0xc038, 11}, + {0x03, 2, 8}, + {0x06, 2, 8}, + {0x0a, 2, 8}, + {0x0f, 2, 8}, + {0x18, 2, 8}, + {0x1f, 2, 8}, + {0x29, 2, 8}, + {0x38, 3, 8}, + {0x03, 2, 11}, + {0x06, 2, 11}, + {0x0a, 2, 11}, + {0x0f, 2, 11}, + {0x18, 2, 11}, + {0x1f, 2, 11}, + {0x29, 2, 11}, + {0x38, 3, 11}, }, /* 234 */ { - {0x8003, 12}, - {0x8006, 12}, - {0x800a, 12}, - {0x800f, 12}, - {0x8018, 12}, - {0x801f, 12}, - {0x8029, 12}, - {0xc038, 12}, - {0x8003, 14}, - {0x8006, 14}, - {0x800a, 14}, - {0x800f, 14}, - {0x8018, 14}, - {0x801f, 14}, - {0x8029, 14}, - {0xc038, 14}, + {0x03, 2, 12}, + {0x06, 2, 12}, + {0x0a, 2, 12}, + {0x0f, 2, 12}, + {0x18, 2, 12}, + {0x1f, 2, 12}, + {0x29, 2, 12}, + {0x38, 3, 12}, + {0x03, 2, 14}, + {0x06, 2, 14}, + {0x0a, 2, 14}, + {0x0f, 2, 14}, + {0x18, 2, 14}, + {0x1f, 2, 14}, + {0x29, 2, 14}, + {0x38, 3, 14}, }, /* 235 */ { - {0x8002, 15}, - {0x8009, 15}, - {0x8017, 15}, - {0xc028, 15}, - {0x8002, 16}, - {0x8009, 16}, - {0x8017, 16}, - {0xc028, 16}, - {0x8002, 17}, - {0x8009, 17}, - {0x8017, 17}, - {0xc028, 17}, - {0x8002, 18}, - {0x8009, 18}, - {0x8017, 18}, - {0xc028, 18}, + {0x02, 2, 15}, + {0x09, 2, 15}, + {0x17, 2, 15}, + {0x28, 3, 15}, + {0x02, 2, 16}, + {0x09, 2, 16}, + {0x17, 2, 16}, + {0x28, 3, 16}, + {0x02, 2, 17}, + {0x09, 2, 17}, + {0x17, 2, 17}, + {0x28, 3, 17}, + {0x02, 2, 18}, + {0x09, 2, 18}, + {0x17, 2, 18}, + {0x28, 3, 18}, }, /* 236 */ { - {0x8003, 15}, - {0x8006, 15}, - {0x800a, 15}, - {0x800f, 15}, - {0x8018, 15}, - {0x801f, 15}, - {0x8029, 15}, - {0xc038, 15}, - {0x8003, 16}, - {0x8006, 16}, - {0x800a, 16}, - {0x800f, 16}, - {0x8018, 16}, - {0x801f, 16}, - {0x8029, 16}, - {0xc038, 16}, + {0x03, 2, 15}, + {0x06, 2, 15}, + {0x0a, 2, 15}, + {0x0f, 2, 15}, + {0x18, 2, 15}, + {0x1f, 2, 15}, + {0x29, 2, 15}, + {0x38, 3, 15}, + {0x03, 2, 16}, + {0x06, 2, 16}, + {0x0a, 2, 16}, + {0x0f, 2, 16}, + {0x18, 2, 16}, + {0x1f, 2, 16}, + {0x29, 2, 16}, + {0x38, 3, 16}, }, /* 237 */ { - {0x8003, 17}, - {0x8006, 17}, - {0x800a, 17}, - {0x800f, 17}, - {0x8018, 17}, - {0x801f, 17}, - {0x8029, 17}, - {0xc038, 17}, - {0x8003, 18}, - {0x8006, 18}, - {0x800a, 18}, - {0x800f, 18}, - {0x8018, 18}, - {0x801f, 18}, - {0x8029, 18}, - {0xc038, 18}, + {0x03, 2, 17}, + {0x06, 2, 17}, + {0x0a, 2, 17}, + {0x0f, 2, 17}, + {0x18, 2, 17}, + {0x1f, 2, 17}, + {0x29, 2, 17}, + {0x38, 3, 17}, + {0x03, 2, 18}, + {0x06, 2, 18}, + {0x0a, 2, 18}, + {0x0f, 2, 18}, + {0x18, 2, 18}, + {0x1f, 2, 18}, + {0x29, 2, 18}, + {0x38, 3, 18}, }, /* 238 */ { - {0xc000, 19}, - {0xc000, 20}, - {0xc000, 21}, - {0xc000, 23}, - {0xc000, 24}, - {0xc000, 25}, - {0xc000, 26}, - {0xc000, 27}, - {0xc000, 28}, - {0xc000, 29}, - {0xc000, 30}, - {0xc000, 31}, - {0xc000, 127}, - {0xc000, 220}, - {0xc000, 249}, - {0xfd, 0}, + {0x00, 3, 19}, + {0x00, 3, 20}, + {0x00, 3, 21}, + {0x00, 3, 23}, + {0x00, 3, 24}, + {0x00, 3, 25}, + {0x00, 3, 26}, + {0x00, 3, 27}, + {0x00, 3, 28}, + {0x00, 3, 29}, + {0x00, 3, 30}, + {0x00, 3, 31}, + {0x00, 3, 127}, + {0x00, 3, 220}, + {0x00, 3, 249}, + {0xfd, 0, 0}, }, /* 239 */ { - {0x8001, 19}, - {0xc016, 19}, - {0x8001, 20}, - {0xc016, 20}, - {0x8001, 21}, - {0xc016, 21}, - {0x8001, 23}, - {0xc016, 23}, - {0x8001, 24}, - {0xc016, 24}, - {0x8001, 25}, - {0xc016, 25}, - {0x8001, 26}, - {0xc016, 26}, - {0x8001, 27}, - {0xc016, 27}, + {0x01, 2, 19}, + {0x16, 3, 19}, + {0x01, 2, 20}, + {0x16, 3, 20}, + {0x01, 2, 21}, + {0x16, 3, 21}, + {0x01, 2, 23}, + {0x16, 3, 23}, + {0x01, 2, 24}, + {0x16, 3, 24}, + {0x01, 2, 25}, + {0x16, 3, 25}, + {0x01, 2, 26}, + {0x16, 3, 26}, + {0x01, 2, 27}, + {0x16, 3, 27}, }, /* 240 */ { - {0x8002, 19}, - {0x8009, 19}, - {0x8017, 19}, - {0xc028, 19}, - {0x8002, 20}, - {0x8009, 20}, - {0x8017, 20}, - {0xc028, 20}, - {0x8002, 21}, - {0x8009, 21}, - {0x8017, 21}, - {0xc028, 21}, - {0x8002, 23}, - {0x8009, 23}, - {0x8017, 23}, - {0xc028, 23}, + {0x02, 2, 19}, + {0x09, 2, 19}, + {0x17, 2, 19}, + {0x28, 3, 19}, + {0x02, 2, 20}, + {0x09, 2, 20}, + {0x17, 2, 20}, + {0x28, 3, 20}, + {0x02, 2, 21}, + {0x09, 2, 21}, + {0x17, 2, 21}, + {0x28, 3, 21}, + {0x02, 2, 23}, + {0x09, 2, 23}, + {0x17, 2, 23}, + {0x28, 3, 23}, }, /* 241 */ { - {0x8003, 19}, - {0x8006, 19}, - {0x800a, 19}, - {0x800f, 19}, - {0x8018, 19}, - {0x801f, 19}, - {0x8029, 19}, - {0xc038, 19}, - {0x8003, 20}, - {0x8006, 20}, - {0x800a, 20}, - {0x800f, 20}, - {0x8018, 20}, - {0x801f, 20}, - {0x8029, 20}, - {0xc038, 20}, + {0x03, 2, 19}, + {0x06, 2, 19}, + {0x0a, 2, 19}, + {0x0f, 2, 19}, + {0x18, 2, 19}, + {0x1f, 2, 19}, + {0x29, 2, 19}, + {0x38, 3, 19}, + {0x03, 2, 20}, + {0x06, 2, 20}, + {0x0a, 2, 20}, + {0x0f, 2, 20}, + {0x18, 2, 20}, + {0x1f, 2, 20}, + {0x29, 2, 20}, + {0x38, 3, 20}, }, /* 242 */ { - {0x8003, 21}, - {0x8006, 21}, - {0x800a, 21}, - {0x800f, 21}, - {0x8018, 21}, - {0x801f, 21}, - {0x8029, 21}, - {0xc038, 21}, - {0x8003, 23}, - {0x8006, 23}, - {0x800a, 23}, - {0x800f, 23}, - {0x8018, 23}, - {0x801f, 23}, - {0x8029, 23}, - {0xc038, 23}, + {0x03, 2, 21}, + {0x06, 2, 21}, + {0x0a, 2, 21}, + {0x0f, 2, 21}, + {0x18, 2, 21}, + {0x1f, 2, 21}, + {0x29, 2, 21}, + {0x38, 3, 21}, + {0x03, 2, 23}, + {0x06, 2, 23}, + {0x0a, 2, 23}, + {0x0f, 2, 23}, + {0x18, 2, 23}, + {0x1f, 2, 23}, + {0x29, 2, 23}, + {0x38, 3, 23}, }, /* 243 */ { - {0x8002, 24}, - {0x8009, 24}, - {0x8017, 24}, - {0xc028, 24}, - {0x8002, 25}, - {0x8009, 25}, - {0x8017, 25}, - {0xc028, 25}, - {0x8002, 26}, - {0x8009, 26}, - {0x8017, 26}, - {0xc028, 26}, - {0x8002, 27}, - {0x8009, 27}, - {0x8017, 27}, - {0xc028, 27}, + {0x02, 2, 24}, + {0x09, 2, 24}, + {0x17, 2, 24}, + {0x28, 3, 24}, + {0x02, 2, 25}, + {0x09, 2, 25}, + {0x17, 2, 25}, + {0x28, 3, 25}, + {0x02, 2, 26}, + {0x09, 2, 26}, + {0x17, 2, 26}, + {0x28, 3, 26}, + {0x02, 2, 27}, + {0x09, 2, 27}, + {0x17, 2, 27}, + {0x28, 3, 27}, }, /* 244 */ { - {0x8003, 24}, - {0x8006, 24}, - {0x800a, 24}, - {0x800f, 24}, - {0x8018, 24}, - {0x801f, 24}, - {0x8029, 24}, - {0xc038, 24}, - {0x8003, 25}, - {0x8006, 25}, - {0x800a, 25}, - {0x800f, 25}, - {0x8018, 25}, - {0x801f, 25}, - {0x8029, 25}, - {0xc038, 25}, + {0x03, 2, 24}, + {0x06, 2, 24}, + {0x0a, 2, 24}, + {0x0f, 2, 24}, + {0x18, 2, 24}, + {0x1f, 2, 24}, + {0x29, 2, 24}, + {0x38, 3, 24}, + {0x03, 2, 25}, + {0x06, 2, 25}, + {0x0a, 2, 25}, + {0x0f, 2, 25}, + {0x18, 2, 25}, + {0x1f, 2, 25}, + {0x29, 2, 25}, + {0x38, 3, 25}, }, /* 245 */ { - {0x8003, 26}, - {0x8006, 26}, - {0x800a, 26}, - {0x800f, 26}, - {0x8018, 26}, - {0x801f, 26}, - {0x8029, 26}, - {0xc038, 26}, - {0x8003, 27}, - {0x8006, 27}, - {0x800a, 27}, - {0x800f, 27}, - {0x8018, 27}, - {0x801f, 27}, - {0x8029, 27}, - {0xc038, 27}, + {0x03, 2, 26}, + {0x06, 2, 26}, + {0x0a, 2, 26}, + {0x0f, 2, 26}, + {0x18, 2, 26}, + {0x1f, 2, 26}, + {0x29, 2, 26}, + {0x38, 3, 26}, + {0x03, 2, 27}, + {0x06, 2, 27}, + {0x0a, 2, 27}, + {0x0f, 2, 27}, + {0x18, 2, 27}, + {0x1f, 2, 27}, + {0x29, 2, 27}, + {0x38, 3, 27}, }, /* 246 */ { - {0x8001, 28}, - {0xc016, 28}, - {0x8001, 29}, - {0xc016, 29}, - {0x8001, 30}, - {0xc016, 30}, - {0x8001, 31}, - {0xc016, 31}, - {0x8001, 127}, - {0xc016, 127}, - {0x8001, 220}, - {0xc016, 220}, - {0x8001, 249}, - {0xc016, 249}, - {0xfe, 0}, - {0xff, 0}, + {0x01, 2, 28}, + {0x16, 3, 28}, + {0x01, 2, 29}, + {0x16, 3, 29}, + {0x01, 2, 30}, + {0x16, 3, 30}, + {0x01, 2, 31}, + {0x16, 3, 31}, + {0x01, 2, 127}, + {0x16, 3, 127}, + {0x01, 2, 220}, + {0x16, 3, 220}, + {0x01, 2, 249}, + {0x16, 3, 249}, + {0xfe, 0, 0}, + {0xff, 0, 0}, }, /* 247 */ { - {0x8002, 28}, - {0x8009, 28}, - {0x8017, 28}, - {0xc028, 28}, - {0x8002, 29}, - {0x8009, 29}, - {0x8017, 29}, - {0xc028, 29}, - {0x8002, 30}, - {0x8009, 30}, - {0x8017, 30}, - {0xc028, 30}, - {0x8002, 31}, - {0x8009, 31}, - {0x8017, 31}, - {0xc028, 31}, + {0x02, 2, 28}, + {0x09, 2, 28}, + {0x17, 2, 28}, + {0x28, 3, 28}, + {0x02, 2, 29}, + {0x09, 2, 29}, + {0x17, 2, 29}, + {0x28, 3, 29}, + {0x02, 2, 30}, + {0x09, 2, 30}, + {0x17, 2, 30}, + {0x28, 3, 30}, + {0x02, 2, 31}, + {0x09, 2, 31}, + {0x17, 2, 31}, + {0x28, 3, 31}, }, /* 248 */ { - {0x8003, 28}, - {0x8006, 28}, - {0x800a, 28}, - {0x800f, 28}, - {0x8018, 28}, - {0x801f, 28}, - {0x8029, 28}, - {0xc038, 28}, - {0x8003, 29}, - {0x8006, 29}, - {0x800a, 29}, - {0x800f, 29}, - {0x8018, 29}, - {0x801f, 29}, - {0x8029, 29}, - {0xc038, 29}, + {0x03, 2, 28}, + {0x06, 2, 28}, + {0x0a, 2, 28}, + {0x0f, 2, 28}, + {0x18, 2, 28}, + {0x1f, 2, 28}, + {0x29, 2, 28}, + {0x38, 3, 28}, + {0x03, 2, 29}, + {0x06, 2, 29}, + {0x0a, 2, 29}, + {0x0f, 2, 29}, + {0x18, 2, 29}, + {0x1f, 2, 29}, + {0x29, 2, 29}, + {0x38, 3, 29}, }, /* 249 */ { - {0x8003, 30}, - {0x8006, 30}, - {0x800a, 30}, - {0x800f, 30}, - {0x8018, 30}, - {0x801f, 30}, - {0x8029, 30}, - {0xc038, 30}, - {0x8003, 31}, - {0x8006, 31}, - {0x800a, 31}, - {0x800f, 31}, - {0x8018, 31}, - {0x801f, 31}, - {0x8029, 31}, - {0xc038, 31}, + {0x03, 2, 30}, + {0x06, 2, 30}, + {0x0a, 2, 30}, + {0x0f, 2, 30}, + {0x18, 2, 30}, + {0x1f, 2, 30}, + {0x29, 2, 30}, + {0x38, 3, 30}, + {0x03, 2, 31}, + {0x06, 2, 31}, + {0x0a, 2, 31}, + {0x0f, 2, 31}, + {0x18, 2, 31}, + {0x1f, 2, 31}, + {0x29, 2, 31}, + {0x38, 3, 31}, }, /* 250 */ { - {0x8002, 127}, - {0x8009, 127}, - {0x8017, 127}, - {0xc028, 127}, - {0x8002, 220}, - {0x8009, 220}, - {0x8017, 220}, - {0xc028, 220}, - {0x8002, 249}, - {0x8009, 249}, - {0x8017, 249}, - {0xc028, 249}, - {0xc000, 10}, - {0xc000, 13}, - {0xc000, 22}, - {0x100, 0}, + {0x02, 2, 127}, + {0x09, 2, 127}, + {0x17, 2, 127}, + {0x28, 3, 127}, + {0x02, 2, 220}, + {0x09, 2, 220}, + {0x17, 2, 220}, + {0x28, 3, 220}, + {0x02, 2, 249}, + {0x09, 2, 249}, + {0x17, 2, 249}, + {0x28, 3, 249}, + {0x00, 3, 10}, + {0x00, 3, 13}, + {0x00, 3, 22}, + {0x100, 0, 0}, }, /* 251 */ { - {0x8003, 127}, - {0x8006, 127}, - {0x800a, 127}, - {0x800f, 127}, - {0x8018, 127}, - {0x801f, 127}, - {0x8029, 127}, - {0xc038, 127}, - {0x8003, 220}, - {0x8006, 220}, - {0x800a, 220}, - {0x800f, 220}, - {0x8018, 220}, - {0x801f, 220}, - {0x8029, 220}, - {0xc038, 220}, + {0x03, 2, 127}, + {0x06, 2, 127}, + {0x0a, 2, 127}, + {0x0f, 2, 127}, + {0x18, 2, 127}, + {0x1f, 2, 127}, + {0x29, 2, 127}, + {0x38, 3, 127}, + {0x03, 2, 220}, + {0x06, 2, 220}, + {0x0a, 2, 220}, + {0x0f, 2, 220}, + {0x18, 2, 220}, + {0x1f, 2, 220}, + {0x29, 2, 220}, + {0x38, 3, 220}, }, /* 252 */ { - {0x8003, 249}, - {0x8006, 249}, - {0x800a, 249}, - {0x800f, 249}, - {0x8018, 249}, - {0x801f, 249}, - {0x8029, 249}, - {0xc038, 249}, - {0x8001, 10}, - {0xc016, 10}, - {0x8001, 13}, - {0xc016, 13}, - {0x8001, 22}, - {0xc016, 22}, - {0x100, 0}, - {0x100, 0}, + {0x03, 2, 249}, + {0x06, 2, 249}, + {0x0a, 2, 249}, + {0x0f, 2, 249}, + {0x18, 2, 249}, + {0x1f, 2, 249}, + {0x29, 2, 249}, + {0x38, 3, 249}, + {0x01, 2, 10}, + {0x16, 3, 10}, + {0x01, 2, 13}, + {0x16, 3, 13}, + {0x01, 2, 22}, + {0x16, 3, 22}, + {0x100, 0, 0}, + {0x100, 0, 0}, }, /* 253 */ { - {0x8002, 10}, - {0x8009, 10}, - {0x8017, 10}, - {0xc028, 10}, - {0x8002, 13}, - {0x8009, 13}, - {0x8017, 13}, - {0xc028, 13}, - {0x8002, 22}, - {0x8009, 22}, - {0x8017, 22}, - {0xc028, 22}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, + {0x02, 2, 10}, + {0x09, 2, 10}, + {0x17, 2, 10}, + {0x28, 3, 10}, + {0x02, 2, 13}, + {0x09, 2, 13}, + {0x17, 2, 13}, + {0x28, 3, 13}, + {0x02, 2, 22}, + {0x09, 2, 22}, + {0x17, 2, 22}, + {0x28, 3, 22}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, }, /* 254 */ { - {0x8003, 10}, - {0x8006, 10}, - {0x800a, 10}, - {0x800f, 10}, - {0x8018, 10}, - {0x801f, 10}, - {0x8029, 10}, - {0xc038, 10}, - {0x8003, 13}, - {0x8006, 13}, - {0x800a, 13}, - {0x800f, 13}, - {0x8018, 13}, - {0x801f, 13}, - {0x8029, 13}, - {0xc038, 13}, + {0x03, 2, 10}, + {0x06, 2, 10}, + {0x0a, 2, 10}, + {0x0f, 2, 10}, + {0x18, 2, 10}, + {0x1f, 2, 10}, + {0x29, 2, 10}, + {0x38, 3, 10}, + {0x03, 2, 13}, + {0x06, 2, 13}, + {0x0a, 2, 13}, + {0x0f, 2, 13}, + {0x18, 2, 13}, + {0x1f, 2, 13}, + {0x29, 2, 13}, + {0x38, 3, 13}, }, /* 255 */ { - {0x8003, 22}, - {0x8006, 22}, - {0x800a, 22}, - {0x800f, 22}, - {0x8018, 22}, - {0x801f, 22}, - {0x8029, 22}, - {0xc038, 22}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, + {0x03, 2, 22}, + {0x06, 2, 22}, + {0x0a, 2, 22}, + {0x0f, 2, 22}, + {0x18, 2, 22}, + {0x1f, 2, 22}, + {0x29, 2, 22}, + {0x38, 3, 22}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, }, /* 256 */ { - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, - {0x100, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, + {0x100, 0, 0}, }, }; diff --git a/deps/nghttp2/lib/nghttp2_helper.h b/deps/nghttp2/lib/nghttp2_helper.h index 7d64076140ce88..5fde72e370f42b 100644 --- a/deps/nghttp2/lib/nghttp2_helper.h +++ b/deps/nghttp2/lib/nghttp2_helper.h @@ -61,7 +61,15 @@ nghttp2_min_def(uint32, uint32_t) nghttp2_min_def(uint64, uint64_t) nghttp2_min_def(size, size_t) -#define lstreq(A, B, N) ((sizeof((A)) - 1) == (N) && memcmp((A), (B), (N)) == 0) +/* + * nghttp2_strlen_lit returns the length of string literal |S|. This + * macro assumes |S| is NULL-terminated string literal. It must not + * be used with pointers. + */ +#define nghttp2_strlen_lit(S) (sizeof(S) - 1) + +#define lstreq(A, B, N) \ + (nghttp2_strlen_lit((A)) == (N) && memcmp((A), (B), (N)) == 0) #define nghttp2_struct_of(ptr, type, member) \ ((type *)(void *)((char *)(ptr) - offsetof(type, member))) diff --git a/deps/nghttp2/lib/nghttp2_http.c b/deps/nghttp2/lib/nghttp2_http.c index 60a0b01e66c1c8..a09005e807877a 100644 --- a/deps/nghttp2/lib/nghttp2_http.c +++ b/deps/nghttp2/lib/nghttp2_http.c @@ -49,7 +49,8 @@ static int memieq(const void *a, const void *b, size_t n) { return 1; } -#define lstrieq(A, B, N) ((sizeof((A)) - 1) == (N) && memieq((A), (B), (N))) +#define lstrieq(A, B, N) \ + (nghttp2_strlen_lit((A)) == (N) && memieq((A), (B), (N))) static int64_t parse_uint(const uint8_t *s, size_t len) { int64_t n = 0; diff --git a/deps/nghttp2/lib/nghttp2_int.h b/deps/nghttp2/lib/nghttp2_int.h index 4e3b26860daf07..2ac6fdac441498 100644 --- a/deps/nghttp2/lib/nghttp2_int.h +++ b/deps/nghttp2/lib/nghttp2_int.h @@ -39,7 +39,6 @@ typedef int (*nghttp2_less)(const void *lhs, const void *rhs); /* Internal error code. They must be in the range [-499, -100], inclusive. */ typedef enum { - NGHTTP2_ERR_CREDENTIAL_PENDING = -101, NGHTTP2_ERR_IGN_HEADER_BLOCK = -103, NGHTTP2_ERR_IGN_PAYLOAD = -104, /* @@ -52,7 +51,11 @@ typedef enum { * Unlike NGHTTP2_ERR_IGN_HTTP_HEADER, this does not invoke * nghttp2_on_invalid_header_callback. */ - NGHTTP2_ERR_REMOVE_HTTP_HEADER = -106 + NGHTTP2_ERR_REMOVE_HTTP_HEADER = -106, + /* + * Cancel pushed stream. + */ + NGHTTP2_ERR_PUSH_CANCEL = -107, } nghttp2_internal_error; #endif /* !defined(NGHTTP2_INT_H) */ diff --git a/deps/nghttp2/lib/nghttp2_map.c b/deps/nghttp2/lib/nghttp2_map.c index f89f310319a1a3..3b703a029328c8 100644 --- a/deps/nghttp2/lib/nghttp2_map.c +++ b/deps/nghttp2/lib/nghttp2_map.c @@ -33,12 +33,11 @@ #define NGHTTP2_INITIAL_HASHBITS 4 -void nghttp2_map_init(nghttp2_map *map, uint32_t seed, nghttp2_mem *mem) { - map->mem = mem; - map->hashbits = 0; - map->table = NULL; - map->seed = seed; - map->size = 0; +void nghttp2_map_init(nghttp2_map *map, uint64_t seed, nghttp2_mem *mem) { + *map = (nghttp2_map){ + .mem = mem, + .seed = seed, + }; } void nghttp2_map_free(nghttp2_map *map) { @@ -46,30 +45,27 @@ void nghttp2_map_free(nghttp2_map *map) { return; } - nghttp2_mem_free(map->mem, map->table); + nghttp2_mem_free(map->mem, map->keys); } int nghttp2_map_each(const nghttp2_map *map, int (*func)(void *data, void *ptr), void *ptr) { int rv; size_t i; - nghttp2_map_bucket *bkt; size_t tablelen; if (map->size == 0) { return 0; } - tablelen = 1u << map->hashbits; + tablelen = (size_t)1 << map->hashbits; for (i = 0; i < tablelen; ++i) { - bkt = &map->table[i]; - - if (bkt->data == NULL) { + if (map->psl[i] == 0) { continue; } - rv = func(bkt->data, ptr); + rv = func(map->data[i], ptr); if (rv != 0) { return rv; } @@ -78,175 +74,230 @@ int nghttp2_map_each(const nghttp2_map *map, int (*func)(void *data, void *ptr), return 0; } -static size_t map_hash(const nghttp2_map *map, nghttp2_map_key_type key) { - /* hasher from - https://github.com/rust-lang/rustc-hash/blob/dc5c33f1283de2da64d8d7a06401d91aded03ad4/src/lib.rs - We do not perform finalization here because we use top bits - anyway. */ - uint32_t h = ((uint32_t)key + map->seed) * 0x93d765dd; - return (size_t)((h * 2654435769u) >> (32 - map->hashbits)); -} +/* Hasher from + https://github.com/rust-lang/rustc-hash/blob/dc5c33f1283de2da64d8d7a06401d91aded03ad4/src/lib.rs + to maximize the output's sensitivity to all input bits. */ +#define NGHTTP2_MAP_HASHER 0xf1357aea2e62a9c5ull +/* 64-bit Fibonacci hashing constant, Golden Ratio constant, to get + the high bits with the good distribution. */ +#define NGHTTP2_MAP_FIBO 0x9e3779b97f4a7c15ull -static void map_bucket_swap(nghttp2_map_bucket *a, nghttp2_map_bucket *b) { - nghttp2_map_bucket c = *a; +static size_t map_index(const nghttp2_map *map, nghttp2_map_key_type key32) { + uint64_t key = (uint64_t)key32; - *a = *b; - *b = c; + key += map->seed; + key *= NGHTTP2_MAP_HASHER; + return (size_t)((key * NGHTTP2_MAP_FIBO) >> (64 - map->hashbits)); } #ifndef WIN32 void nghttp2_map_print_distance(const nghttp2_map *map) { size_t i; size_t idx; - nghttp2_map_bucket *bkt; size_t tablelen; if (map->size == 0) { return; } - tablelen = 1u << map->hashbits; + tablelen = (size_t)1 << map->hashbits; for (i = 0; i < tablelen; ++i) { - bkt = &map->table[i]; - - if (bkt->data == NULL) { + if (map->psl[i] == 0) { fprintf(stderr, "@%zu \n", i); continue; } - idx = map_hash(map, bkt->key); - fprintf(stderr, "@%zu hash=%zu key=%d base=%zu distance=%u\n", i, - map_hash(map, bkt->key), bkt->key, idx, bkt->psl); + idx = map_index(map, map->keys[i]); + fprintf(stderr, "@%zu key=%d base=%zu distance=%u\n", i, map->keys[i], idx, + map->psl[i] - 1); } } #endif /* !defined(WIN32) */ -static int map_insert(nghttp2_map *map, nghttp2_map_key_type key, void *data) { - size_t idx = map_hash(map, key); - nghttp2_map_bucket b = { - .key = key, - .data = data, - }; - nghttp2_map_bucket *bkt; - size_t mask = (1u << map->hashbits) - 1; +static void map_set_entry(nghttp2_map *map, size_t idx, + nghttp2_map_key_type key, void *data, size_t psl) { + map->keys[idx] = key; + map->data[idx] = data; + map->psl[idx] = (uint8_t)psl; +} + +#define NGHTTP2_SWAP(TYPE, A, B) \ + do { \ + TYPE t = (TYPE) * (A); \ + \ + *(A) = *(B); \ + *(B) = t; \ + } while (0) + +/* + * map_insert inserts |key| and |data| to |map|, and returns the index + * where the pair is stored if it succeeds. Otherwise, it returns one + * of the following negative error codes: + * + * NGHTTP2_ERR_INVALID_ARGUMENT + * The another data associated to |key| is already present. + */ +static nghttp2_ssize map_insert(nghttp2_map *map, nghttp2_map_key_type key, + void *data) { + size_t idx = map_index(map, key); + size_t mask = ((size_t)1 << map->hashbits) - 1; + size_t psl = 1; + size_t kpsl; for (;;) { - bkt = &map->table[idx]; + kpsl = map->psl[idx]; - if (bkt->data == NULL) { - *bkt = b; + if (kpsl == 0) { + map_set_entry(map, idx, key, data, psl); ++map->size; - return 0; + + return (nghttp2_ssize)idx; } - if (b.psl > bkt->psl) { - map_bucket_swap(bkt, &b); - } else if (bkt->key == key) { - /* TODO This check is just a waste after first swap or if this - function is called from map_resize. That said, there is no - difference with or without this conditional in performance - wise. */ + if (psl > kpsl) { + NGHTTP2_SWAP(nghttp2_map_key_type, &key, &map->keys[idx]); + NGHTTP2_SWAP(void *, &data, &map->data[idx]); + NGHTTP2_SWAP(uint8_t, &psl, &map->psl[idx]); + } else if (map->keys[idx] == key) { + /* This check ensures that no duplicate keys are inserted. But + it is just a waste after first swap or if this function is + called from map_resize. That said, there is no difference + with or without this conditional in performance wise. */ return NGHTTP2_ERR_INVALID_ARGUMENT; } - ++b.psl; + ++psl; idx = (idx + 1) & mask; } } +/* NGHTTP2_MAP_MAX_HASHBITS is the maximum number of bits used for + hash table. The theoretical limit of the maximum number of keys + that can be stored is 1 << NGHTTP2_MAP_MAX_HASHBITS. */ +#define NGHTTP2_MAP_MAX_HASHBITS (sizeof(size_t) * 8 - 1) + static int map_resize(nghttp2_map *map, size_t new_hashbits) { size_t i; - nghttp2_map_bucket *bkt; size_t tablelen; - int rv; + nghttp2_ssize idx; nghttp2_map new_map = { - .table = nghttp2_mem_calloc(map->mem, 1u << new_hashbits, - sizeof(nghttp2_map_bucket)), .mem = map->mem, .seed = map->seed, .hashbits = new_hashbits, }; - (void)rv; + void *buf; + (void)idx; + + if (new_hashbits > NGHTTP2_MAP_MAX_HASHBITS) { + return NGHTTP2_ERR_NOMEM; + } - if (new_map.table == NULL) { + tablelen = (size_t)1 << new_hashbits; + + buf = nghttp2_mem_calloc(map->mem, tablelen, + sizeof(nghttp2_map_key_type) + sizeof(void *) + + sizeof(uint8_t)); + if (buf == NULL) { return NGHTTP2_ERR_NOMEM; } + new_map.keys = buf; + new_map.data = + (void *)((uint8_t *)new_map.keys + tablelen * sizeof(nghttp2_map_key_type)); + new_map.psl = (uint8_t *)new_map.data + tablelen * sizeof(void *); + if (map->size) { - tablelen = 1u << map->hashbits; + tablelen = (size_t)1 << map->hashbits; for (i = 0; i < tablelen; ++i) { - bkt = &map->table[i]; - if (bkt->data == NULL) { + if (map->psl[i] == 0) { continue; } - rv = map_insert(&new_map, bkt->key, bkt->data); + idx = map_insert(&new_map, map->keys[i], map->data[i]); - assert(0 == rv); + /* map_insert must not fail because all keys are unique during + resize. */ + assert(idx >= 0); } } - nghttp2_mem_free(map->mem, map->table); - map->table = new_map.table; + nghttp2_mem_free(map->mem, map->keys); + map->keys = new_map.keys; + map->data = new_map.data; + map->psl = new_map.psl; map->hashbits = new_hashbits; return 0; } +/* NGHTTP2_MAX_PSL_RESIZE_THRESH is the maximum psl threshold. If + reached, resize the table. */ +#define NGHTTP2_MAX_PSL_RESIZE_THRESH 128 + int nghttp2_map_insert(nghttp2_map *map, nghttp2_map_key_type key, void *data) { int rv; + size_t tablelen; + nghttp2_ssize idx; assert(data); - /* Load factor is 7/8 */ - /* Under the very initial condition, that is map->size == 0 and - map->hashbits == 0, 8 > 7 still holds nicely. */ - if ((map->size + 1) * 8 > (1u << map->hashbits) * 7) { - if (map->hashbits) { - rv = map_resize(map, map->hashbits + 1); - if (rv != 0) { - return rv; - } - } else { - rv = map_resize(map, NGHTTP2_INITIAL_HASHBITS); - if (rv != 0) { - return rv; - } + /* tablelen is incorrect if map->hashbits == 0 which leads to + tablelen = 1, but it is only used to check the load factor, and + it works in this special case. */ + tablelen = (size_t)1 << map->hashbits; + + /* Load factor is 7 / 8. Because tablelen is power of 2, (tablelen + - (tablelen >> 3)) computes tablelen * 7 / 8. */ + if (map->size + 1 >= (tablelen - (tablelen >> 3))) { + rv = map_resize(map, map->hashbits ? map->hashbits + 1 + : NGHTTP2_INITIAL_HASHBITS); + if (rv != 0) { + return rv; + } + + idx = map_insert(map, key, data); + if (idx < 0) { + return (int)idx; } + + return 0; } - rv = map_insert(map, key, data); - if (rv != 0) { - return rv; + idx = map_insert(map, key, data); + if (idx < 0) { + return (int)idx; } - return 0; + /* Resize if psl reaches really large value which is almost + improbable, but just in case. */ + if (map->psl[idx] - 1 < NGHTTP2_MAX_PSL_RESIZE_THRESH) { + return 0; + } + + return map_resize(map, map->hashbits + 1); } void *nghttp2_map_find(const nghttp2_map *map, nghttp2_map_key_type key) { size_t idx; - nghttp2_map_bucket *bkt; - size_t psl = 0; + size_t psl = 1; size_t mask; if (map->size == 0) { return NULL; } - idx = map_hash(map, key); - mask = (1u << map->hashbits) - 1; + idx = map_index(map, key); + mask = ((size_t)1 << map->hashbits) - 1; for (;;) { - bkt = &map->table[idx]; - - if (bkt->data == NULL || psl > bkt->psl) { + if (psl > map->psl[idx]) { return NULL; } - if (bkt->key == key) { - return bkt->data; + if (map->keys[idx] == key) { + return map->data[idx]; } ++psl; @@ -256,38 +307,36 @@ void *nghttp2_map_find(const nghttp2_map *map, nghttp2_map_key_type key) { int nghttp2_map_remove(nghttp2_map *map, nghttp2_map_key_type key) { size_t idx; - nghttp2_map_bucket *b, *bkt; - size_t psl = 0; + size_t dest; + size_t psl = 1, kpsl; size_t mask; if (map->size == 0) { return NGHTTP2_ERR_INVALID_ARGUMENT; } - idx = map_hash(map, key); - mask = (1u << map->hashbits) - 1; + idx = map_index(map, key); + mask = ((size_t)1 << map->hashbits) - 1; for (;;) { - bkt = &map->table[idx]; - - if (bkt->data == NULL || psl > bkt->psl) { + if (psl > map->psl[idx]) { return NGHTTP2_ERR_INVALID_ARGUMENT; } - if (bkt->key == key) { - b = bkt; + if (map->keys[idx] == key) { + dest = idx; idx = (idx + 1) & mask; for (;;) { - bkt = &map->table[idx]; - if (bkt->data == NULL || bkt->psl == 0) { - b->data = NULL; + kpsl = map->psl[idx]; + if (kpsl <= 1) { + map->psl[dest] = 0; break; } - --bkt->psl; - *b = *bkt; - b = bkt; + map_set_entry(map, dest, map->keys[idx], map->data[idx], kpsl - 1); + + dest = idx; idx = (idx + 1) & mask; } @@ -307,7 +356,7 @@ void nghttp2_map_clear(nghttp2_map *map) { return; } - memset(map->table, 0, sizeof(*map->table) * (1u << map->hashbits)); + memset(map->psl, 0, sizeof(*map->psl) * ((size_t)1 << map->hashbits)); map->size = 0; } diff --git a/deps/nghttp2/lib/nghttp2_map.h b/deps/nghttp2/lib/nghttp2_map.h index e45685bce71768..c47b279345dee3 100644 --- a/deps/nghttp2/lib/nghttp2_map.h +++ b/deps/nghttp2/lib/nghttp2_map.h @@ -38,16 +38,15 @@ typedef int32_t nghttp2_map_key_type; -typedef struct nghttp2_map_bucket { - uint32_t psl; - nghttp2_map_key_type key; - void *data; -} nghttp2_map_bucket; - typedef struct nghttp2_map { - nghttp2_map_bucket *table; + nghttp2_map_key_type *keys; + void **data; + /* psl is the Probe Sequence Length. 0 has special meaning that the + element is not stored at i-th position if psl[i] == 0. Because + of this, the actual psl value is psl[i] - 1 if psl[i] > 0. */ + uint8_t *psl; nghttp2_mem *mem; - uint32_t seed; + uint64_t seed; size_t size; size_t hashbits; } nghttp2_map; @@ -55,7 +54,7 @@ typedef struct nghttp2_map { /* * nghttp2_map_init initializes the map |map|. */ -void nghttp2_map_init(nghttp2_map *map, uint32_t seed, nghttp2_mem *mem); +void nghttp2_map_init(nghttp2_map *map, uint64_t seed, nghttp2_mem *mem); /* * nghttp2_map_free deallocates any resources allocated for |map|. diff --git a/deps/nghttp2/lib/nghttp2_outbound_item.c b/deps/nghttp2/lib/nghttp2_outbound_item.c index a9e9f7693eda8c..fad1ee0a469086 100644 --- a/deps/nghttp2/lib/nghttp2_outbound_item.c +++ b/deps/nghttp2/lib/nghttp2_outbound_item.c @@ -53,6 +53,18 @@ nghttp2_data_provider_wrap_v2(nghttp2_data_provider_wrap *dpw, return dpw; } +int nghttp2_data_provider_wrap_contains_read_callback( + const nghttp2_data_provider_wrap *dpw) { + switch (dpw->version) { + case NGHTTP2_DATA_PROVIDER_V1: + return dpw->data_prd.v1.read_callback != NULL; + case NGHTTP2_DATA_PROVIDER_V2: + return dpw->data_prd.v2.read_callback != NULL; + default: + return 0; + } +} + void nghttp2_outbound_item_init(nghttp2_outbound_item *item) { item->cycle = 0; item->qnext = NULL; diff --git a/deps/nghttp2/lib/nghttp2_outbound_item.h b/deps/nghttp2/lib/nghttp2_outbound_item.h index 6e8e310cc475dd..9f280e616351d0 100644 --- a/deps/nghttp2/lib/nghttp2_outbound_item.h +++ b/deps/nghttp2/lib/nghttp2_outbound_item.h @@ -39,10 +39,6 @@ typedef struct nghttp2_data_provider_wrap { int version; union { - struct { - nghttp2_data_source source; - void *read_callback; - }; nghttp2_data_provider v1; nghttp2_data_provider2 v2; } data_prd; @@ -56,6 +52,11 @@ nghttp2_data_provider_wrap * nghttp2_data_provider_wrap_v2(nghttp2_data_provider_wrap *dpw, const nghttp2_data_provider2 *data_prd); +/* nghttp2_data_provider_wrap_contains_read_callback returns nonzero + if |dpw| contains read_callback in either version. */ +int nghttp2_data_provider_wrap_contains_read_callback( + const nghttp2_data_provider_wrap *dpw); + /* struct used for HEADERS and PUSH_PROMISE frame */ typedef struct { nghttp2_data_provider_wrap dpw; @@ -110,6 +111,12 @@ typedef struct { uint8_t flags; } nghttp2_goaway_aux_data; +typedef struct { + /* nonzero if RST_STREAM should be sent even if stream is not + found. */ + uint8_t continue_without_stream; +} nghttp2_rst_stream_aux_data; + /* struct used for extension frame */ typedef struct { /* nonzero if this extension frame is serialized by library @@ -122,6 +129,7 @@ typedef union { nghttp2_data_aux_data data; nghttp2_headers_aux_data headers; nghttp2_goaway_aux_data goaway; + nghttp2_rst_stream_aux_data rst_stream; nghttp2_ext_aux_data ext; } nghttp2_aux_data; diff --git a/deps/nghttp2/lib/nghttp2_session.c b/deps/nghttp2/lib/nghttp2_session.c index 97d7fda1d295d5..19e0b767c1639b 100644 --- a/deps/nghttp2/lib/nghttp2_session.c +++ b/deps/nghttp2/lib/nghttp2_session.c @@ -438,7 +438,7 @@ static int session_new(nghttp2_session **session_ptr, size_t max_deflate_dynamic_table_size = NGHTTP2_HD_DEFAULT_MAX_DEFLATE_BUFFER_SIZE; size_t i; - uint32_t map_seed; + uint64_t map_seed; if (mem == NULL) { mem = nghttp2_mem_default(); @@ -1051,7 +1051,6 @@ int nghttp2_session_add_item(nghttp2_session *session, nghttp2_outbound_queue_push(&session->ob_syn, item); item->queued = 1; return 0; - ; } nghttp2_outbound_queue_push(&session->ob_reg, item); @@ -1189,6 +1188,10 @@ int nghttp2_session_add_rst_stream_continue(nghttp2_session *session, frame = &item->frame; nghttp2_frame_rst_stream_init(&frame->rst_stream, stream_id, error_code); + + item->aux_data.rst_stream.continue_without_stream = + (uint8_t)(continue_without_stream != 0); + rv = nghttp2_session_add_item(session, item); if (rv != 0) { nghttp2_frame_rst_stream_free(&frame->rst_stream); @@ -2141,6 +2144,12 @@ static int session_prep_frame(nghttp2_session *session, if (session_is_closing(session)) { return NGHTTP2_ERR_SESSION_CLOSING; } + + if (!item->aux_data.rst_stream.continue_without_stream && + !nghttp2_session_get_stream(session, frame->rst_stream.hd.stream_id)) { + return NGHTTP2_ERR_STREAM_CLOSED; + } + nghttp2_frame_pack_rst_stream(&session->aob.framebufs, &frame->rst_stream); return 0; case NGHTTP2_SETTINGS: { @@ -2584,7 +2593,7 @@ static int session_after_frame_sent1(nghttp2_session *session) { } /* We assume aux_data is a pointer to nghttp2_headers_aux_data */ aux_data = &item->aux_data.headers; - if (aux_data->dpw.data_prd.read_callback) { + if (nghttp2_data_provider_wrap_contains_read_callback(&aux_data->dpw)) { /* nghttp2_submit_data_shared() makes a copy of aux_data->dpw */ rv = nghttp2_submit_data_shared(session, NGHTTP2_FLAG_END_STREAM, @@ -2615,7 +2624,7 @@ static int session_after_frame_sent1(nghttp2_session *session) { } /* We assume aux_data is a pointer to nghttp2_headers_aux_data */ aux_data = &item->aux_data.headers; - if (aux_data->dpw.data_prd.read_callback) { + if (nghttp2_data_provider_wrap_contains_read_callback(&aux_data->dpw)) { rv = nghttp2_submit_data_shared(session, NGHTTP2_FLAG_END_STREAM, frame->hd.stream_id, &aux_data->dpw); if (nghttp2_is_fatal(rv)) { @@ -2795,7 +2804,10 @@ static int session_call_send_data(nghttp2_session *session, aux_data = &item->aux_data.data; rv = session->callbacks.send_data_callback(session, frame, buf->pos, length, - &aux_data->dpw.data_prd.source, + /* This is fine because + of Common Initial + Sequence rule. */ + &aux_data->dpw.data_prd.v2.source, session->user_data); switch (rv) { @@ -2853,8 +2865,12 @@ static nghttp2_ssize nghttp2_session_mem_send_internal(nghttp2_session *session, nghttp2_frame *frame = &item->frame; /* The library is responsible for the transmission of WINDOW_UPDATE frame, so we don't call error callback for - it. */ + it. As for RST_STREAM, if it is not sent due to missing + stream, we also do not call error callback because it may + cause a lot of noises.*/ if (frame->hd.type != NGHTTP2_WINDOW_UPDATE && + (frame->hd.type != NGHTTP2_RST_STREAM || + rv != NGHTTP2_ERR_STREAM_CLOSED) && session->callbacks.on_frame_not_send_callback( session, frame, rv, session->user_data) != 0) { nghttp2_outbound_item_free(item, mem); @@ -3272,7 +3288,9 @@ static int session_call_on_invalid_header(nghttp2_session *session, session, frame, nv->name->base, nv->name->len, nv->value->base, nv->value->len, nv->flags, session->user_data); } else { - return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE; + /* If both callbacks are not set, the invalid field nv is + ignored. */ + return 0; } if (rv == NGHTTP2_ERR_PAUSE || rv == NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE) { @@ -3357,6 +3375,10 @@ static uint32_t get_error_code_from_lib_error_code(int lib_error_code) { case NGHTTP2_ERR_HTTP_HEADER: case NGHTTP2_ERR_HTTP_MESSAGING: return NGHTTP2_PROTOCOL_ERROR; + case NGHTTP2_ERR_INTERNAL: + return NGHTTP2_INTERNAL_ERROR; + case NGHTTP2_ERR_PUSH_CANCEL: + return NGHTTP2_CANCEL; default: return NGHTTP2_INTERNAL_ERROR; } @@ -3408,7 +3430,7 @@ static int session_handle_invalid_stream2(nghttp2_session *session, if (rv != 0) { return rv; } - if (session->callbacks.on_invalid_frame_recv_callback) { + if (frame && session->callbacks.on_invalid_frame_recv_callback) { if (session->callbacks.on_invalid_frame_recv_callback( session, frame, lib_error_code, session->user_data) != 0) { return NGHTTP2_ERR_CALLBACK_FAILURE; @@ -3495,6 +3517,7 @@ static int session_inflate_handle_invalid_connection(nghttp2_session *session, static int inflate_header_block(nghttp2_session *session, nghttp2_frame *frame, size_t *readlen_ptr, uint8_t *in, size_t inlen, int final, int call_header_cb) { + nghttp2_inbound_frame *iframe = &session->iframe; nghttp2_ssize proclen; int rv; int inflate_flags; @@ -3563,7 +3586,29 @@ static int inflate_header_block(nghttp2_session *session, nghttp2_frame *frame, rv2 = session_call_on_invalid_header(session, frame, &nv); if (rv2 == NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE) { - rv = NGHTTP2_ERR_HTTP_HEADER; + DEBUGF("recv: HTTP error: type=%u, id=%d, header %.*s: %.*s\n", + frame->hd.type, frame->hd.stream_id, (int)nv.name->len, + nv.name->base, (int)nv.value->len, nv.value->base); + + rv = session_call_error_callback( + session, NGHTTP2_ERR_HTTP_HEADER, + "Invalid HTTP header field was received: frame type: " + "%u, stream: %d, name: [%.*s], value: [%.*s]", + frame->hd.type, frame->hd.stream_id, (int)nv.name->len, + nv.name->base, (int)nv.value->len, nv.value->base); + + if (nghttp2_is_fatal(rv)) { + return rv; + } + + rv = session_handle_invalid_stream2( + session, subject_stream->stream_id, frame, + NGHTTP2_ERR_HTTP_HEADER); + if (nghttp2_is_fatal(rv)) { + return rv; + } + + return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE; } else { if (rv2 != 0) { return rv2; @@ -3609,6 +3654,16 @@ static int inflate_header_block(nghttp2_session *session, nghttp2_frame *frame, if (nghttp2_is_fatal(rv)) { return rv; } + + rv = session_update_glitch_ratelim(session); + if (rv != 0) { + return rv; + } + + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return 0; + } + return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE; } } @@ -3678,6 +3733,7 @@ static int session_end_stream_headers_received(nghttp2_session *session, static int session_after_header_block_received(nghttp2_session *session) { int rv = 0; nghttp2_frame *frame = &session->iframe.frame; + nghttp2_inbound_frame *iframe = &session->iframe; nghttp2_stream *stream; /* We don't call on_frame_recv_callback if stream has been closed @@ -3736,12 +3792,22 @@ static int session_after_header_block_received(nghttp2_session *session) { return rv; } + rv = session_update_glitch_ratelim(session); + if (rv != 0) { + return rv; + } + + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return 0; + } + if (frame->hd.type == NGHTTP2_HEADERS && (frame->hd.flags & NGHTTP2_FLAG_END_STREAM)) { nghttp2_stream_shutdown(stream, NGHTTP2_SHUT_RD); /* Don't call nghttp2_session_close_stream_if_shut_rdwr because RST_STREAM has been submitted. */ } + return 0; } } @@ -4078,8 +4144,7 @@ static int update_remote_initial_window_size_func(void *entry, void *ptr) { rv = nghttp2_stream_update_remote_initial_window_size( stream, arg->new_window_size, arg->old_window_size); if (rv != 0) { - return nghttp2_session_add_rst_stream(arg->session, stream->stream_id, - NGHTTP2_FLOW_CONTROL_ERROR); + return NGHTTP2_ERR_FLOW_CONTROL; } /* If window size gets positive, push deferred DATA frame to @@ -4105,6 +4170,8 @@ static int update_remote_initial_window_size_func(void *entry, void *ptr) { * * NGHTTP2_ERR_NOMEM * Out of memory. + * NGHTTP2_ERR_FLOW_CONTROL + * Window size gets out of range. */ static int session_update_remote_initial_window_size(nghttp2_session *session, @@ -4128,8 +4195,7 @@ static int update_local_initial_window_size_func(void *entry, void *ptr) { rv = nghttp2_stream_update_local_initial_window_size( stream, arg->new_window_size, arg->old_window_size); if (rv != 0) { - return nghttp2_session_add_rst_stream(arg->session, stream->stream_id, - NGHTTP2_FLOW_CONTROL_ERROR); + return NGHTTP2_ERR_FLOW_CONTROL; } if (stream->window_update_queued) { @@ -4163,6 +4229,8 @@ static int update_local_initial_window_size_func(void *entry, void *ptr) { * * NGHTTP2_ERR_NOMEM * Out of memory. + * NGHTTP2_ERR_FLOW_CONTROL + * Window size gets out of range. */ static int session_update_local_initial_window_size(nghttp2_session *session, @@ -4549,9 +4617,9 @@ int nghttp2_session_on_push_promise_received(nghttp2_session *session, session->max_incoming_reserved_streams) { /* Currently, client does not retain closed stream, so we don't check NGHTTP2_SHUT_RD condition here. */ - - rv = nghttp2_session_add_rst_stream( - session, frame->push_promise.promised_stream_id, NGHTTP2_CANCEL); + rv = session_handle_invalid_stream2(session, + frame->push_promise.promised_stream_id, + NULL, NGHTTP2_ERR_PUSH_CANCEL); if (rv != 0) { return rv; } @@ -4708,8 +4776,9 @@ static int session_on_stream_window_update_received(nghttp2_session *session, } if (NGHTTP2_MAX_WINDOW_SIZE - frame->window_update.window_size_increment < stream->remote_window_size) { - return session_handle_invalid_stream(session, frame, - NGHTTP2_ERR_FLOW_CONTROL); + return session_handle_invalid_connection( + session, frame, NGHTTP2_ERR_FLOW_CONTROL, + "WINDOW_UPDATE: window size overflow"); } stream->remote_window_size += frame->window_update.window_size_increment; @@ -4925,6 +4994,7 @@ int nghttp2_session_on_data_received(nghttp2_session *session, nghttp2_frame *frame) { int rv = 0; nghttp2_stream *stream; + nghttp2_inbound_frame *iframe = &session->iframe; /* We don't call on_frame_recv_callback if stream has been closed already or being closed. */ @@ -4939,15 +5009,26 @@ int nghttp2_session_on_data_received(nghttp2_session *session, if (session_enforce_http_messaging(session) && (frame->hd.flags & NGHTTP2_FLAG_END_STREAM)) { if (nghttp2_http_on_remote_end_stream(stream) != 0) { - rv = nghttp2_session_add_rst_stream(session, stream->stream_id, - NGHTTP2_PROTOCOL_ERROR); + rv = session_handle_invalid_stream2(session, stream->stream_id, frame, + NGHTTP2_ERR_HTTP_MESSAGING); if (nghttp2_is_fatal(rv)) { return rv; } + rv = session_update_glitch_ratelim(session); + if (rv != 0) { + return rv; + } + + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return 0; + } + nghttp2_stream_shutdown(stream, NGHTTP2_SHUT_RD); + /* Don't call nghttp2_session_close_stream_if_shut_rdwr because RST_STREAM has been submitted. */ + return 0; } } @@ -5006,8 +5087,8 @@ int nghttp2_session_update_recv_stream_window_size(nghttp2_session *session, rv = adjust_recv_window_size(&stream->recv_window_size, delta_size, stream->local_window_size); if (rv != 0) { - return nghttp2_session_add_rst_stream(session, stream->stream_id, - NGHTTP2_FLOW_CONTROL_ERROR); + return nghttp2_session_terminate_session(session, + NGHTTP2_FLOW_CONTROL_ERROR); } /* We don't have to send WINDOW_UPDATE if the data received is the last chunk in the incoming stream. */ @@ -5469,6 +5550,10 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, busy = 1; rv = session_on_data_received_fail_fast(session); + if (nghttp2_is_fatal(rv)) { + return rv; + } + if (iframe->state == NGHTTP2_IB_IGN_ALL) { return (nghttp2_ssize)inlen; } @@ -5476,23 +5561,10 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, DEBUGF("recv: DATA not allowed stream_id=%d\n", iframe->frame.hd.stream_id); - rv = session_update_glitch_ratelim(session); - if (rv != 0) { - return rv; - } - - if (iframe->state == NGHTTP2_IB_IGN_ALL) { - return (nghttp2_ssize)inlen; - } - iframe->state = NGHTTP2_IB_IGN_DATA; break; } - if (nghttp2_is_fatal(rv)) { - return rv; - } - rv = inbound_frame_handle_pad(iframe, &iframe->frame.hd); if (rv < 0) { rv = nghttp2_session_terminate_session_with_reason( @@ -5576,6 +5648,10 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, return rv; } + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return (nghttp2_ssize)inlen; + } + on_begin_frame_called = 1; rv = session_process_headers_frame(session); @@ -5590,8 +5666,8 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, } if (rv == NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE) { - rv = nghttp2_session_add_rst_stream( - session, iframe->frame.hd.stream_id, NGHTTP2_INTERNAL_ERROR); + rv = session_handle_invalid_stream2( + session, iframe->frame.hd.stream_id, NULL, NGHTTP2_ERR_INTERNAL); if (nghttp2_is_fatal(rv)) { return rv; } @@ -6044,6 +6120,10 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, if (nghttp2_is_fatal(rv)) { return rv; } + + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return (nghttp2_ssize)inlen; + } } } @@ -6107,8 +6187,8 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, } if (rv == NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE) { - rv = nghttp2_session_add_rst_stream( - session, iframe->frame.hd.stream_id, NGHTTP2_INTERNAL_ERROR); + rv = session_handle_invalid_stream2( + session, iframe->frame.hd.stream_id, NULL, NGHTTP2_ERR_INTERNAL); if (nghttp2_is_fatal(rv)) { return rv; } @@ -6191,9 +6271,9 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, } if (rv == NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE) { - rv = nghttp2_session_add_rst_stream( - session, iframe->frame.push_promise.promised_stream_id, - NGHTTP2_INTERNAL_ERROR); + rv = session_handle_invalid_stream2( + session, iframe->frame.push_promise.promised_stream_id, NULL, + NGHTTP2_ERR_INTERNAL); if (nghttp2_is_fatal(rv)) { return rv; } @@ -6296,6 +6376,10 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, return rv; } + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return (nghttp2_ssize)inlen; + } + session_inbound_frame_reset(session); break; @@ -6371,12 +6455,12 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, iframe->payloadleft -= hd_proclen; /* Use promised stream ID for PUSH_PROMISE */ - rv = nghttp2_session_add_rst_stream( + rv = session_handle_invalid_stream2( session, iframe->frame.hd.type == NGHTTP2_PUSH_PROMISE ? iframe->frame.push_promise.promised_stream_id : iframe->frame.hd.stream_id, - NGHTTP2_INTERNAL_ERROR); + NULL, NGHTTP2_ERR_INTERNAL); if (nghttp2_is_fatal(rv)) { return rv; } @@ -6423,6 +6507,10 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, if (nghttp2_is_fatal(rv)) { return rv; } + + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return (nghttp2_ssize)inlen; + } } session_inbound_frame_reset(session); @@ -6598,6 +6686,10 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, if (nghttp2_is_fatal(rv)) { return rv; } + + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return (nghttp2_ssize)inlen; + } } else { iframe->state = NGHTTP2_IB_IGN_HEADER_BLOCK; } @@ -6648,6 +6740,10 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, if (nghttp2_is_fatal(rv)) { return rv; } + + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return (nghttp2_ssize)inlen; + } } busy = 1; @@ -6720,6 +6816,10 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, return rv; } + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return (nghttp2_ssize)inlen; + } + data_readlen = inbound_frame_effective_readlen(iframe, iframe->payloadleft, readlen); @@ -6763,13 +6863,25 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, } } - rv = nghttp2_session_add_rst_stream( - session, iframe->frame.hd.stream_id, NGHTTP2_PROTOCOL_ERROR); + rv = session_handle_invalid_stream2( + session, iframe->frame.hd.stream_id, &iframe->frame, + NGHTTP2_ERR_PROTO); if (nghttp2_is_fatal(rv)) { return rv; } + + rv = session_update_glitch_ratelim(session); + if (rv != 0) { + return rv; + } + + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return (nghttp2_ssize)inlen; + } + busy = 1; iframe->state = NGHTTP2_IB_IGN_DATA; + break; } } @@ -6777,13 +6889,17 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, rv = session->callbacks.on_data_chunk_recv_callback( session, iframe->frame.hd.flags, iframe->frame.hd.stream_id, in - readlen, (size_t)data_readlen, session->user_data); - if (rv == NGHTTP2_ERR_PAUSE) { - return (nghttp2_ssize)(in - first); - } - if (nghttp2_is_fatal(rv)) { return NGHTTP2_ERR_CALLBACK_FAILURE; } + + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return (nghttp2_ssize)inlen; + } + + if (rv == NGHTTP2_ERR_PAUSE) { + return (nghttp2_ssize)(in - first); + } } } } @@ -6797,6 +6913,10 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, return rv; } + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return (nghttp2_ssize)inlen; + } + session_inbound_frame_reset(session); break; @@ -6863,6 +6983,10 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, return rv; } + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return (nghttp2_ssize)inlen; + } + if (rv != 0) { busy = 1; @@ -6881,6 +7005,10 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, return rv; } + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return (nghttp2_ssize)inlen; + } + session_inbound_frame_reset(session); break; @@ -6909,6 +7037,10 @@ nghttp2_ssize nghttp2_session_mem_recv2(nghttp2_session *session, return rv; } + if (iframe->state == NGHTTP2_IB_IGN_ALL) { + return (nghttp2_ssize)inlen; + } + session_inbound_frame_reset(session); break; @@ -7372,13 +7504,13 @@ int nghttp2_session_pack_data(nghttp2_session *session, nghttp2_bufs *bufs, case NGHTTP2_DATA_PROVIDER_V1: payloadlen = (nghttp2_ssize)aux_data->dpw.data_prd.v1.read_callback( session, frame->hd.stream_id, buf->pos, datamax, &data_flags, - &aux_data->dpw.data_prd.source, session->user_data); + &aux_data->dpw.data_prd.v1.source, session->user_data); break; case NGHTTP2_DATA_PROVIDER_V2: payloadlen = aux_data->dpw.data_prd.v2.read_callback( session, frame->hd.stream_id, buf->pos, datamax, &data_flags, - &aux_data->dpw.data_prd.source, session->user_data); + &aux_data->dpw.data_prd.v2.source, session->user_data); break; default: diff --git a/deps/nghttp2/lib/nghttp2_session.h b/deps/nghttp2/lib/nghttp2_session.h index edbef80d397123..cab30687c075df 100644 --- a/deps/nghttp2/lib/nghttp2_session.h +++ b/deps/nghttp2/lib/nghttp2_session.h @@ -107,8 +107,8 @@ typedef struct { #define NGHTTP2_DEFAULT_STREAM_RESET_RATE 33 /* The default values for glitch rate limiter. */ -#define NGHTTP2_DEFAULT_GLITCH_BURST 1000 -#define NGHTTP2_DEFAULT_GLITCH_RATE 33 +#define NGHTTP2_DEFAULT_GLITCH_BURST 10000 +#define NGHTTP2_DEFAULT_GLITCH_RATE 330 /* The default max number of CONTINUATION frames following an incoming HEADER frame. */ diff --git a/deps/nghttp2/lib/nghttp2_submit.c b/deps/nghttp2/lib/nghttp2_submit.c index 8a90f714e4a4b5..d6bcae9deaf504 100644 --- a/deps/nghttp2/lib/nghttp2_submit.c +++ b/deps/nghttp2/lib/nghttp2_submit.c @@ -57,7 +57,7 @@ static int32_t submit_headers_shared(nghttp2_session *session, uint8_t flags, nghttp2_outbound_item_init(item); - if (dpw != NULL && dpw->data_prd.read_callback != NULL) { + if (dpw != NULL && nghttp2_data_provider_wrap_contains_read_callback(dpw)) { item->aux_data.headers.dpw = *dpw; } @@ -649,7 +649,7 @@ int nghttp2_submit_priority_update(nghttp2_session *session, uint8_t flags, static uint8_t set_request_flags(const nghttp2_data_provider_wrap *dpw) { uint8_t flags = NGHTTP2_FLAG_NONE; - if (dpw == NULL || dpw->data_prd.read_callback == NULL) { + if (dpw == NULL || !nghttp2_data_provider_wrap_contains_read_callback(dpw)) { flags |= NGHTTP2_FLAG_END_STREAM; } @@ -700,7 +700,7 @@ int32_t nghttp2_submit_request2(nghttp2_session *session, static uint8_t set_response_flags(const nghttp2_data_provider_wrap *dpw) { uint8_t flags = NGHTTP2_FLAG_NONE; - if (dpw == NULL || dpw->data_prd.read_callback == NULL) { + if (dpw == NULL || !nghttp2_data_provider_wrap_contains_read_callback(dpw)) { flags |= NGHTTP2_FLAG_END_STREAM; } return flags; From 4a32c00fb8dbe55c3bcf9ef43343968c9fe449e6 Mon Sep 17 00:00:00 2001 From: Tim Perry Date: Wed, 22 Apr 2026 13:36:27 +0200 Subject: [PATCH 013/168] deps: fix integration issues with the latest nghttp2 This is a set of src & tests fixes for nghttp2 due to changes in v1.67.0+ which require a selection of changes to how we handle low-level protocol errors when using the latest versions of nghttp2, changing both some src error handling and updating some tests to match. Signed-off-by: Tim Perry PR-URL: https://github.com/nodejs/node/pull/62891 Reviewed-By: Luigi Pinca Reviewed-By: Stephen Belanger Reviewed-By: Antoine du Hamel --- src/node_http2.cc | 31 +++++++ src/node_http2.h | 2 + ...t-http2-misbehaving-flow-control-paused.js | 29 ++++-- .../test-http2-misbehaving-flow-control.js | 29 ++++-- ...tp2-options-max-headers-exceeds-nghttp2.js | 12 ++- ...http2-session-cleanup-on-nghttp2-goaway.js | 91 +++++++++++++++++++ tools/nix/sharedLibDeps.nix | 13 +-- 7 files changed, 177 insertions(+), 30 deletions(-) create mode 100644 test/parallel/test-http2-session-cleanup-on-nghttp2-goaway.js diff --git a/src/node_http2.cc b/src/node_http2.cc index 084a4773673e5b..55bca557a81e4d 100644 --- a/src/node_http2.cc +++ b/src/node_http2.cc @@ -1265,6 +1265,24 @@ int Http2Session::OnFrameSent(nghttp2_session* handle, void* user_data) { Http2Session* session = static_cast(user_data); session->statistics_.frame_sent += 1; + + // If nghttp2 has internally terminated the session (e.g. due to a protocol + // error like oversized frames, padding errors, or HPACK compression + // failures), it calls nghttp2_session_terminate_session() directly which + // queues a GOAWAY but does not invoke any application-level callback. + // Detect that case here: a GOAWAY was sent but we never initiated it + // (no Close(), no session.close(), no session.goaway()). + // + // We set a flag here, and then throw the error at the end of + // SendPendingData, to wait until the GOAWAY is written before the session + // is torn down. + if (frame->hd.type == NGHTTP2_GOAWAY && !session->is_closing() && + !session->is_destroyed() && !session->IsGracefulCloseInitiated() && + !session->goaway_initiated_) { + Debug(session, "nghttp2 session terminated internally"); + session->internal_goaway_sent_ = true; + } + return 0; } @@ -1999,6 +2017,18 @@ uint8_t Http2Session::SendPendingData() { MaybeStopReading(); + // If nghttp2 has internally torn down the session (detected in OnFrameSent) + // during the nghttp2_session_mem_send loop above, at this point we error: + if (internal_goaway_sent_) { + internal_goaway_sent_ = false; + if (!is_closing() && !is_destroyed()) { + Isolate* isolate = env()->isolate(); + HandleScope scope(isolate); + Local arg = Integer::New(isolate, NGHTTP2_ERR_PROTO); + MakeCallback(env()->http2session_on_error_function(), 1, &arg); + } + } + return 0; } @@ -2940,6 +2970,7 @@ void Http2Session::Goaway(uint32_t code, if (is_destroyed()) return; + goaway_initiated_ = true; Http2Scope h2scope(this); // the last proc stream id is the most recently created Http2Stream. if (lastStreamID <= 0) diff --git a/src/node_http2.h b/src/node_http2.h index 259b71840b66d4..28245d7b98e06b 100644 --- a/src/node_http2.h +++ b/src/node_http2.h @@ -971,6 +971,8 @@ class Http2Session : public AsyncWrap, // Flag to indicate that JavaScript has initiated a graceful closure bool graceful_close_initiated_ = false; + bool goaway_initiated_ = false; + bool internal_goaway_sent_ = false; }; struct Http2SessionPerformanceEntryTraits { diff --git a/test/parallel/test-http2-misbehaving-flow-control-paused.js b/test/parallel/test-http2-misbehaving-flow-control-paused.js index 7059cf950e699b..b9a0d5cb81ecd5 100644 --- a/test/parallel/test-http2-misbehaving-flow-control-paused.js +++ b/test/parallel/test-http2-misbehaving-flow-control-paused.js @@ -47,23 +47,29 @@ const data = Buffer.from([ // Bad client! Bad! // // Fortunately, nghttp2 handles this situation for us by keeping track -// of the flow control window and responding with a FLOW_CONTROL_ERROR -// causing the stream to get shut down... -// -// At least, that's what is supposed to happen. +// of the flow control window and sending GOAWAY to end the session. let client; const server = h2.createServer({ settings: { initialWindowSize: 36 } }); + +server.on('session', common.mustCall((session) => { + session.on('error', common.expectsError({ + code: 'ERR_HTTP2_ERROR', + name: 'Error', + message: 'Protocol error' + })); +})); + server.on('stream', common.mustCall((stream) => { // Set the high water mark to zero, since otherwise we still accept // reads from the source stream (if we can consume them). stream._readableState.highWaterMark = 0; stream.pause(); stream.on('error', common.expectsError({ - code: 'ERR_HTTP2_STREAM_ERROR', + code: 'ERR_HTTP2_ERROR', name: 'Error', - message: 'Stream closed with error code NGHTTP2_FLOW_CONTROL_ERROR' + message: 'Protocol error' })); stream.on('close', common.mustCall(() => { server.close(); @@ -72,11 +78,14 @@ server.on('stream', common.mustCall((stream) => { stream.on('end', common.mustNotCall()); })); -server.listen(0, () => { - client = net.connect(server.address().port, () => { +server.listen(0, common.mustCall(() => { + client = net.connect(server.address().port, common.mustCall(() => { client.write(preamble); client.write(data); client.write(data); client.write(data); - }); -}); + + // TCP connection is closed by the server + client.on('close', common.mustCall()); + })); +})); diff --git a/test/parallel/test-http2-misbehaving-flow-control.js b/test/parallel/test-http2-misbehaving-flow-control.js index 0fb876ecdd4018..fb0f7a1e0f9aff 100644 --- a/test/parallel/test-http2-misbehaving-flow-control.js +++ b/test/parallel/test-http2-misbehaving-flow-control.js @@ -58,18 +58,24 @@ const data = Buffer.from([ // Bad client! Bad! // // Fortunately, nghttp2 handles this situation for us by keeping track -// of the flow control window and responding with a FLOW_CONTROL_ERROR -// causing the stream to get shut down... -// -// At least, that's what is supposed to happen. +// of the flow control window and sending GOAWAY to end the session. let client; const server = h2.createServer({ settings: { initialWindowSize: 18 } }); + +server.on('session', common.mustCall((session) => { + session.on('error', common.expectsError({ + code: 'ERR_HTTP2_ERROR', + name: 'Error', + message: 'Protocol error' + })); +})); + server.on('stream', common.mustCall((stream) => { stream.on('error', common.expectsError({ - code: 'ERR_HTTP2_STREAM_ERROR', + code: 'ERR_HTTP2_ERROR', name: 'Error', - message: 'Stream closed with error code NGHTTP2_FLOW_CONTROL_ERROR' + message: 'Protocol error' })); stream.on('close', common.mustCall(() => { server.close(common.mustCall()); @@ -82,10 +88,13 @@ server.on('stream', common.mustCall((stream) => { server.on('close', common.mustCall()); -server.listen(0, () => { - client = net.connect(server.address().port, () => { +server.listen(0, common.mustCall(() => { + client = net.connect(server.address().port, common.mustCall(() => { client.write(preamble); client.write(data); client.write(data); - }); -}); + + // TCP connection is closed by the server + client.on('close', common.mustCall()); + })); +})); diff --git a/test/parallel/test-http2-options-max-headers-exceeds-nghttp2.js b/test/parallel/test-http2-options-max-headers-exceeds-nghttp2.js index 7767dbbc503814..46f560f96c27e8 100644 --- a/test/parallel/test-http2-options-max-headers-exceeds-nghttp2.js +++ b/test/parallel/test-http2-options-max-headers-exceeds-nghttp2.js @@ -90,11 +90,19 @@ server.listen(0, common.mustCall(() => { 0, common.mustCall(() => { const client = h2.connect(`http://localhost:${server.address().port}`); - client.on('error', common.mustNotCall()); + // The server sends oversized headers that cause a compression error on + // the client side, so nghttp2 internally terminates the client session. + client.on('error', common.expectsError({ + code: 'ERR_HTTP2_ERROR', + name: 'Error', + })); const req = client.request(); req.on('response', common.mustNotCall()); - req.on('error', common.mustNotCall()); + req.on('error', common.expectsError({ + code: 'ERR_HTTP2_ERROR', + name: 'Error', + })); req.end(); }), ); diff --git a/test/parallel/test-http2-session-cleanup-on-nghttp2-goaway.js b/test/parallel/test-http2-session-cleanup-on-nghttp2-goaway.js new file mode 100644 index 00000000000000..f3576f9f59bcbf --- /dev/null +++ b/test/parallel/test-http2-session-cleanup-on-nghttp2-goaway.js @@ -0,0 +1,91 @@ +'use strict'; + +const common = require('../common'); + +if (!common.hasCrypto) + common.skip('missing crypto'); + +const http2 = require('http2'); +const net = require('net'); + +// When nghttp2 internally sends a GOAWAY frame due to a protocol error, it +// may call nghttp2_session_terminate_session() directly, bypassing the +// on_invalid_frame_recv_callback entirely. This test ensures that even +// in that scenario, we still correctly clean up the session & connection. +// +// This test reproduces this with a client who sends a frame header with +// a length exceeding the default max_frame_size (16384). nghttp2 responds +// with GOAWAY(FRAME_SIZE_ERROR) without notifying Node through any callback. + +const server = http2.createServer(); + +server.on('session', common.mustCall((session) => { + session.on('error', common.expectsError({ + code: 'ERR_HTTP2_ERROR', + name: 'Error', + message: 'Protocol error' + })); + + session.on('close', common.mustCall(() => server.close())); +})); + +server.listen(0, common.mustCall(() => { + const conn = net.connect({ + port: server.address().port, + allowHalfOpen: true, + }); + + // HTTP/2 client connection preface. + conn.write('PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n'); + + // Empty SETTINGS frame. + const settingsFrame = Buffer.alloc(9); + settingsFrame[3] = 0x04; // type: SETTINGS + conn.write(settingsFrame); + + let inbuf = Buffer.alloc(0); + let state = 'settingsHeader'; + let settingsFrameLength; + + conn.on('data', (chunk) => { + inbuf = Buffer.concat([inbuf, chunk]); + + switch (state) { + case 'settingsHeader': + if (inbuf.length < 9) return; + settingsFrameLength = inbuf.readUIntBE(0, 3); + inbuf = inbuf.slice(9); + state = 'readingSettings'; + // Fallthrough + case 'readingSettings': { + if (inbuf.length < settingsFrameLength) return; + inbuf = inbuf.slice(settingsFrameLength); + state = 'done'; + + // ACK the server SETTINGS. + const ack = Buffer.alloc(9); + ack[3] = 0x04; // type: SETTINGS + ack[4] = 0x01; // flag: ACK + conn.write(ack); + + // Send a HEADERS frame header claiming length 16385, which exceeds + // the default max_frame_size of 16384. nghttp2 checks the length + // before reading any payload, so no body is needed. This triggers + // nghttp2_session_terminate_session(FRAME_SIZE_ERROR) directly in + // nghttp2_session_mem_recv2 — bypassing on_invalid_frame_recv_callback. + const oversized = Buffer.alloc(9); + oversized.writeUIntBE(16385, 0, 3); // length: 16385 (one over max) + oversized[3] = 0x01; // type: HEADERS + oversized[4] = 0x04; // flags: END_HEADERS + oversized.writeUInt32BE(1, 5); // stream id: 1 + conn.write(oversized); + + // No need to write the data - the header alone triggers the check. + } + } + }); + + // The server must close the connection after sending GOAWAY: + conn.on('end', common.mustCall(() => conn.end())); + conn.on('close', common.mustCall()); +})); diff --git a/tools/nix/sharedLibDeps.nix b/tools/nix/sharedLibDeps.nix index 27e97c132ec71b..524fd13308b72c 100644 --- a/tools/nix/sharedLibDeps.nix +++ b/tools/nix/sharedLibDeps.nix @@ -25,14 +25,11 @@ hdr-histogram = pkgs.hdrhistogram_c; http-parser = pkgs.llhttp; nghttp2 = pkgs.nghttp2.overrideAttrs { - patches = [ - (pkgs.fetchpatch2 { - url = "https://github.com/nghttp2/nghttp2/commit/7784fa979d0bcf801a35f1afbb25fb048d815cd7.patch?full_index=1"; - revert = true; - excludes = [ "lib/includes/nghttp2/nghttp2.h" ]; - hash = "sha256-RG87Qifjpl7HTP9ac2JwHj2XAbDlFgOpAnpZX3ET6gU="; - }) - ]; + version = "1.69.0"; + src = pkgs.fetchurl { + url = "https://github.com/nghttp2/nghttp2/releases/download/v1.69.0/nghttp2-1.69.0.tar.bz2"; + hash = "sha256-PxhfWxw+d4heuc8/LE2ksan3OiS/WVe4KRg60Tf4Lcg="; + }; }; } // (pkgs.lib.optionalAttrs withLief { From 74c6f850429d4eaf3908cb25f9465f34d2036d37 Mon Sep 17 00:00:00 2001 From: Daijiro Wachi Date: Wed, 29 Apr 2026 22:40:48 +0900 Subject: [PATCH 014/168] doc: use mjs/cjs blocks for callbackify null reason example PR-URL: https://github.com/nodejs/node/pull/62884 Reviewed-By: Luigi Pinca --- doc/api/util.md | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/doc/api/util.md b/doc/api/util.md index 378cec3ca894c9..4c2a8b3e5fd889 100644 --- a/doc/api/util.md +++ b/doc/api/util.md @@ -76,7 +76,24 @@ wrapped function rejects a `Promise` with a falsy value as a reason, the value is wrapped in an `Error` with the original value stored in a field named `reason`. -```js +```mjs +import util from 'node:util'; + +function fn() { + return Promise.reject(null); +} +const callbackFunction = util.callbackify(fn); + +callbackFunction((err, ret) => { + // When the Promise was rejected with `null` it is wrapped with an Error and + // the original value is stored in `reason`. + err && Object.hasOwn(err, 'reason') && err.reason === null; // true +}); +``` + +```cjs +const util = require('node:util'); + function fn() { return Promise.reject(null); } From 31da818417601e98cdd0bba1748d5f2701187de7 Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Wed, 29 Apr 2026 16:05:31 +0200 Subject: [PATCH 015/168] tools: do not include HTML docs in slim tarball Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/62989 Reviewed-By: Filip Skokan Reviewed-By: Luigi Pinca --- Makefile | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/Makefile b/Makefile index fb4a43bfed7864..9c9aa320963c8e 100644 --- a/Makefile +++ b/Makefile @@ -1244,11 +1244,18 @@ pkg-upload: pkg ssh $(STAGINGSERVER) "rclone copyto nodejs/$(DISTTYPEDIR)/$(FULLVERSION)/$(TARNAME).pkg $(CLOUDFLARE_BUCKET)/nodejs/$(DISTTYPEDIR)/$(FULLVERSION)/$(TARNAME).pkg" ssh $(STAGINGSERVER) "touch nodejs/$(DISTTYPEDIR)/$(FULLVERSION)/$(TARNAME).pkg.done" -$(TARBALL): release-only doc-only +TARBALL_DEPS=release-only +ifneq ($(SKIP_SHARED_DEPS), 1) +TARBALL_DEPS+= doc-only +endif + +$(TARBALL): $(TARBALL_DEPS) git checkout-index -a -f --prefix=$(TARNAME)/ +ifneq ($(SKIP_SHARED_DEPS), 1) mkdir -p $(TARNAME)/doc/api cp doc/node.1 $(TARNAME)/doc/node.1 cp -r out/doc/api/* $(TARNAME)/doc/api/ +endif sed 's/fileset = fileset.intersection (fileset.gitTracked root)/fileset =/' tools/nix/v8.nix > $(TARNAME)/tools/nix/v8.nix $(RM) -r $(TARNAME)/.editorconfig $(RM) -r $(TARNAME)/.git* @@ -1290,7 +1297,6 @@ endif $(RM) -r $(TARNAME)/deps/v8/samples $(RM) -r $(TARNAME)/deps/v8/tools/profviz $(RM) -r $(TARNAME)/deps/v8/tools/run-tests.py - $(RM) -r $(TARNAME)/doc/images # too big $(RM) -r $(TARNAME)/test*.tap $(RM) -r $(TARNAME)/tools/cpplint.py $(RM) -r $(TARNAME)/tools/eslint From af8eba276fa33a6efc5cecbba8ff40b6d229f532 Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Wed, 29 Apr 2026 17:06:06 +0200 Subject: [PATCH 016/168] tools: reuse V8 builds even without Cachix on test-shared Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/62980 Reviewed-By: Filip Skokan Reviewed-By: Colin Ihrig --- .github/actions/build-shared/action.yml | 13 +---- .github/workflows/test-shared.yml | 73 ++++++++++++++++++------- 2 files changed, 55 insertions(+), 31 deletions(-) diff --git a/.github/actions/build-shared/action.yml b/.github/actions/build-shared/action.yml index 757440f1f36812..d809f3ec2cf76d 100644 --- a/.github/actions/build-shared/action.yml +++ b/.github/actions/build-shared/action.yml @@ -5,11 +5,8 @@ description: > test suite inside the pinned nix-shell. inputs: - system: - description: System label (e.g. x86_64-linux, aarch64-darwin). - required: true - extra-nix-args: - description: Additional arguments appended to the nix-shell invocation. + extra-nix-flags: + description: Additional CLI arguments appended to the nix-shell invocation. required: false default: '' cachix-auth-token: @@ -21,13 +18,11 @@ runs: using: composite steps: - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 - if: ${{ github.event_name != 'workflow_dispatch' }} with: name: tarballs path: tarballs - name: Extract tarball - if: ${{ github.event_name != 'workflow_dispatch' }} shell: bash run: | tar xzf tarballs/*.tar.gz -C "$RUNNER_TEMP" @@ -61,12 +56,10 @@ runs: --pure --keep TAR_DIR --keep FLAKY_TESTS \ --keep SCCACHE_GHA_ENABLED --keep ACTIONS_CACHE_SERVICE_V2 --keep ACTIONS_RESULTS_URL --keep ACTIONS_RUNTIME_TOKEN \ --arg loadJSBuiltinsDynamically false \ - --arg useSeparateDerivationForV8 true \ --arg ccache "${NIX_SCCACHE:-null}" \ --arg devTools '[]' \ --arg benchmarkTools '[]' \ - ${{ endsWith(inputs.system, '-darwin') && '--arg withAmaro false --arg withLief false --arg withSQLite false --arg withFFI false --arg extraConfigFlags ''["--without-inspector" "--without-node-options"]'' \' || '\' }} - ${{ inputs.extra-nix-args }} \ + ${{ inputs.extra-nix-flags }} \ --run ' make -C "$TAR_DIR" run-ci -j4 V=1 TEST_CI_ARGS="-p actions --measure-flakiness 9 --skip-tests=$CI_SKIP_TESTS" ' "$TAR_DIR/shell.nix" diff --git a/.github/workflows/test-shared.yml b/.github/workflows/test-shared.yml index b5732d00423c46..e9d009fa95d6dd 100644 --- a/.github/workflows/test-shared.yml +++ b/.github/workflows/test-shared.yml @@ -117,12 +117,10 @@ jobs: runs-on: ubuntu-slim steps: - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 - if: ${{ github.event_name != 'workflow_dispatch' }} with: persist-credentials: false - name: Make tarball - if: ${{ github.event_name != 'workflow_dispatch' }} run: | export DATESTRING=$(date "+%Y-%m-%d") export COMMIT=$(git rev-parse --short=10 "$GITHUB_SHA") @@ -131,7 +129,6 @@ jobs: DISTTYPE: nightly - name: Upload tarball artifact - if: ${{ github.event_name != 'workflow_dispatch' }} uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 with: name: tarballs @@ -157,55 +154,78 @@ jobs: runs-on: ${{ matrix.runner }} steps: - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 - if: ${{ github.event_name != 'workflow_dispatch' }} with: persist-credentials: false sparse-checkout: .github/actions + sparse-checkout-cone-mode: false - uses: ./.github/actions/build-shared - if: ${{ github.event_name != 'workflow_dispatch' }} + name: Build and test Node.js with: - system: ${{ matrix.system }} cachix-auth-token: ${{ secrets.CACHIX_AUTH_TOKEN }} + extra-nix-flags: | + --arg useSeparateDerivationForV8 true \ + ${{ endsWith(matrix.system, '-darwin') && '--arg withAmaro false --arg withLief false --arg withSQLite false --arg withFFI false --arg extraConfigFlags ''["--without-inspector" "--without-node-options"]'' \' || '\' }} build-aarch64-linux-v8: needs: build-tarball runs-on: ubuntu-24.04-arm name: 'aarch64-linux: Cache V8 build' + outputs: + local-cache: ${{ steps.upload.outcome != 'skipped' && 'true' || '' }} steps: - - name: Check if Cachix is available - id: cachix-check - run: echo 'IS_AVAILABLE=${{ secrets.CACHIX_AUTH_TOKEN && 'true' }}' >> "$GITHUB_OUTPUT" - - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 - if: ${{ steps.cachix-check.outputs.IS_AVAILABLE == 'true' }} with: name: tarballs path: tarballs - name: Extract tarball - if: ${{ steps.cachix-check.outputs.IS_AVAILABLE == 'true' }} shell: bash run: | tar xzf tarballs/*.tar.gz -C "$RUNNER_TEMP" echo "TAR_DIR=$RUNNER_TEMP/$(basename tarballs/*.tar.gz .tar.gz)" >> "$GITHUB_ENV" - uses: cachix/install-nix-action@ab739621df7a23f52766f9ccc97f38da6b7af14f # v31.10.5 - if: ${{ steps.cachix-check.outputs.IS_AVAILABLE == 'true' }} with: extra_nix_config: sandbox = true + - name: Evaluate V8 derivation + id: v8-drv + run: | + V8_DRV=$( + nix-instantiate -E "builtins.filter (p: p.pname == ''v8'') (import $TAR_DIR/shell.nix { useSeparateDerivationForV8=true; }).buildInputs" + ) + echo "V8_DRV=$V8_DRV" >> "$GITHUB_OUTPUT" + echo "STORE_PATH=$(nix-store -q --outputs "$V8_DRV")" >> "$GITHUB_OUTPUT" + + - name: Check if available on Cachix + id: cachix-check + run: | + echo 'HAS_WRITE_TOKEN=${{ secrets.CACHIX_AUTH_TOKEN && 'true' }}' >> "$GITHUB_OUTPUT" + set -x + [ "$(curl -ISsw "%{http_code}" -o /dev/null "https://nodejs.cachix.org/$(basename ${V8_STORE_PATH%-v8-*}).narinfo")" != "200" ] || + echo "ALREADY_CACHED=true" >> "$GITHUB_OUTPUT" + env: + V8_STORE_PATH: ${{ steps.v8-drv.outputs.STORE_PATH }} + - uses: cachix/cachix-action@1eb2ef646ac0255473d23a5907ad7b04ce94065c # v17 - if: ${{ steps.cachix-check.outputs.IS_AVAILABLE == 'true' }} + if: ${{ steps.cachix-check.outputs.ALREADY_CACHED != 'true' }} with: name: nodejs authToken: ${{ secrets.CACHIX_AUTH_TOKEN }} - name: Build V8 derivation - if: ${{ steps.cachix-check.outputs.IS_AVAILABLE == 'true' }} - run: | - nix-build "$( - nix-instantiate -E "builtins.filter (p: p.pname == ''v8'') (import $TAR_DIR/shell.nix { useSeparateDerivationForV8=true; }).buildInputs" - )" + if: ${{ steps.cachix-check.outputs.ALREADY_CACHED != 'true' }} + run: nix-store --export "$(nix-build "$V8_DRV")" > libv8 + env: + V8_DRV: ${{ steps.v8-drv.outputs.V8_DRV }} + + - name: Upload libv8 + if: ${{ steps.cachix-check.outputs.ALREADY_CACHED != 'true' && steps.cachix-check.outputs.HAS_WRITE_TOKEN != 'true' }} + id: upload + uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0 + with: + name: libv8 + path: libv8 # Builds the matrix for `build-openssl` from tools/nix/openssl-matrix.json. # Output shape: @@ -253,9 +273,16 @@ jobs: with: persist-credentials: false sparse-checkout: .github/actions + sparse-checkout-cone-mode: false + + - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 + if: ${{ needs.build-aarch64-linux-v8.outputs.local-cache }} + with: + name: libv8 + - uses: ./.github/actions/build-shared + name: Build and test Node.js with: - system: aarch64-linux cachix-auth-token: ${{ secrets.CACHIX_AUTH_TOKEN }} # Override just the `openssl` attr of the default shared-lib set with # the matrix-selected nixpkgs attribute (e.g. `openssl_3_6`). All @@ -263,4 +290,8 @@ jobs: # `permittedInsecurePackages` whitelists just the matrix-selected # release (e.g. `openssl-1.1.1w`) so EOL-with-extended-support # cycles evaluate without relaxing nixpkgs' meta check globally. - extra-nix-args: --arg sharedLibDeps "(import $TAR_DIR/tools/nix/sharedLibDeps.nix {}) // { openssl = (import $TAR_DIR/tools/nix/pkgs.nix { config.permittedInsecurePackages = [ \"openssl-$OPENSSL_VERSION\" ]; }).$OPENSSL_ATTR; }" + extra-nix-flags: | + --arg useSeparateDerivationForV8 ${{ needs.build-aarch64-linux-v8.outputs.local-cache && '"$(nix-store --import < libv8)"' || 'true' }} \ + --arg sharedLibDeps "(import $TAR_DIR/tools/nix/sharedLibDeps.nix {}) // { + openssl = (import $TAR_DIR/tools/nix/pkgs.nix { config.permittedInsecurePackages = [ \"openssl-$OPENSSL_VERSION\" ]; }).$OPENSSL_ATTR; + }" \ From 5d578c5cfd7f4b10966d678c3d8f618889547432 Mon Sep 17 00:00:00 2001 From: Marco Ippolito Date: Wed, 29 Apr 2026 18:09:19 +0200 Subject: [PATCH 017/168] src: make node.config.json throw at unknown fields Signed-off-by: Marco Ippolito PR-URL: https://github.com/nodejs/node/pull/62992 Reviewed-By: Pietro Marchini Reviewed-By: Joyee Cheung --- src/node_config_file.cc | 9 +++++++-- test/fixtures/rc/schema.json | 6 ++++++ test/parallel/test-config-file.js | 16 ++++++++++++++-- 3 files changed, 27 insertions(+), 4 deletions(-) create mode 100644 test/fixtures/rc/schema.json diff --git a/src/node_config_file.cc b/src/node_config_file.cc index 925d71fecc52a3..b2c87970b6ebc1 100644 --- a/src/node_config_file.cc +++ b/src/node_config_file.cc @@ -8,6 +8,7 @@ constexpr std::string_view kConfigFileFlag = "--experimental-config-file"; constexpr std::string_view kDefaultConfigFileFlag = "--experimental-default-config-file"; constexpr std::string_view kDefaultConfigFileName = "node.config.json"; +constexpr std::string_view kSchemaField = "$schema"; inline bool HasEqualsPrefix(std::string_view arg, std::string_view flag) { return arg.size() > flag.size() && arg.starts_with(flag) && @@ -290,10 +291,14 @@ ParseResult ConfigReader::ParseConfig(const std::string_view& config_path) { return ParseResult::InvalidContent; } + if (namespace_name == kSchemaField) { + continue; + } + // Check if this field is a valid namespace if (!valid_namespaces.contains(namespace_name)) { - // If not, skip it - continue; + FPrintF(stderr, "Unknown namespace %s\n", namespace_name); + return ParseResult::InvalidContent; } // List of implicit namespace flags diff --git a/test/fixtures/rc/schema.json b/test/fixtures/rc/schema.json new file mode 100644 index 00000000000000..2ed2a6711ce6ec --- /dev/null +++ b/test/fixtures/rc/schema.json @@ -0,0 +1,6 @@ +{ + "$schema": "https://nodejs.org/dist/vX.Y.Z/docs/node-config-schema.json", + "nodeOptions": { + "max-http-header-size": 10 + } +} diff --git a/test/parallel/test-config-file.js b/test/parallel/test-config-file.js index 334884d9ed893a..dc70242855de65 100644 --- a/test/parallel/test-config-file.js +++ b/test/parallel/test-config-file.js @@ -517,14 +517,26 @@ describe('namespace-scoped options', () => { assert.strictEqual(result.code, 9); }); - it('should not throw an error when a namespace is not recognised', async () => { + it('should throw an error when a namespace is not recognised', async () => { const result = await spawnPromisified(process.execPath, [ '--no-warnings', `--experimental-config-file=${fixtures.path('rc/unknown-namespace.json')}`, '-p', '"Hello, World!"', ]); + assert.match(result.stderr, /Unknown namespace an-invalid-namespace/); + assert.match(result.stderr, /unknown-namespace\.json: invalid content/); + assert.strictEqual(result.stdout, ''); + assert.strictEqual(result.code, 9); + }); + + it('should allow the $schema field', async () => { + const result = await spawnPromisified(process.execPath, [ + '--no-warnings', + `--experimental-config-file=${fixtures.path('rc/schema.json')}`, + '-p', 'http.maxHeaderSize', + ]); assert.strictEqual(result.stderr, ''); - assert.strictEqual(result.stdout, 'Hello, World!\n'); + assert.strictEqual(result.stdout, '10\n'); assert.strictEqual(result.code, 0); }); From e7f57b58e0bd110456de267de44abd961ee2b428 Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Wed, 29 Apr 2026 19:22:09 +0200 Subject: [PATCH 018/168] tools: update labels for nixpkgs pin bumps MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/62994 Reviewed-By: René Reviewed-By: Michaël Zasso --- .github/workflows/tools.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/tools.yml b/.github/workflows/tools.yml index c81865bcde2b71..c4ac6bc77f70aa 100644 --- a/.github/workflows/tools.yml +++ b/.github/workflows/tools.yml @@ -207,7 +207,7 @@ jobs: # dont-land labels are there so we can guarantee released versions of # Node.js can be built with the same env along the whole release line life – or # at least we can detect and document necessary updates. - label: tools, dont-land-on-v20.x, dont-land-on-v22.x, dont-land-on-v24.x, dont-land-on-v25.x + label: tools, dont-land-on-v22.x, dont-land-on-v24.x, dont-land-on-v26.x run: | ./tools/dep_updaters/update-nixpkgs-pin.sh > temp-output cat temp-output From a962e72c388ffbae1e70d47c78ddf02536764b79 Mon Sep 17 00:00:00 2001 From: Bryan English Date: Wed, 29 Apr 2026 13:55:57 -0400 Subject: [PATCH 019/168] doc: correct diagnostics_channel built-in channel names The names listed under the Modules and Process built-in channel sections did not match the channel names actually published by the runtime, so subscribing with the documented names produced no events. Signed-off-by: Bryan English PR-URL: https://github.com/nodejs/node/pull/62995 Reviewed-By: Luigi Pinca Reviewed-By: Stephen Belanger --- doc/api/diagnostics_channel.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/doc/api/diagnostics_channel.md b/doc/api/diagnostics_channel.md index 038c7cb29dd2d1..b47f98ce64211c 100644 --- a/doc/api/diagnostics_channel.md +++ b/doc/api/diagnostics_channel.md @@ -1713,7 +1713,7 @@ closing the stream can be retrieved using the `stream.rstCode` property. > Stability: 1 - Experimental -##### Event: `'module.require.start'` +##### Event: `'tracing:module.require:start'` * `event` {Object} containing the following properties * `id` Argument passed to `require()`. Module name. @@ -1721,7 +1721,7 @@ closing the stream can be retrieved using the `stream.rstCode` property. Emitted when `require()` is executed. See [`start` event][]. -##### Event: `'module.require.end'` +##### Event: `'tracing:module.require:end'` * `event` {Object} containing the following properties * `id` Argument passed to `require()`. Module name. @@ -1729,7 +1729,7 @@ Emitted when `require()` is executed. See [`start` event][]. Emitted when a `require()` call returns. See [`end` event][]. -##### Event: `'module.require.error'` +##### Event: `'tracing:module.require:error'` * `event` {Object} containing the following properties * `id` Argument passed to `require()`. Module name. @@ -1738,7 +1738,7 @@ Emitted when a `require()` call returns. See [`end` event][]. Emitted when a `require()` throws an error. See [`error` event][]. -##### Event: `'module.import.asyncStart'` +##### Event: `'tracing:module.import:asyncStart'` * `event` {Object} containing the following properties * `id` Argument passed to `import()`. Module name. @@ -1746,7 +1746,7 @@ Emitted when a `require()` throws an error. See [`error` event][]. Emitted when `import()` is invoked. See [`asyncStart` event][]. -##### Event: `'module.import.asyncEnd'` +##### Event: `'tracing:module.import:asyncEnd'` * `event` {Object} containing the following properties * `id` Argument passed to `import()`. Module name. @@ -1754,7 +1754,7 @@ Emitted when `import()` is invoked. See [`asyncStart` event][]. Emitted when `import()` has completed. See [`asyncEnd` event][]. -##### Event: `'module.import.error'` +##### Event: `'tracing:module.import:error'` * `event` {Object} containing the following properties * `id` Argument passed to `import()`. Module name. @@ -1845,7 +1845,7 @@ process has been created. Emitted when [`child_process.spawn()`][] encounters an error. -##### Event: `'execve'` +##### Event: `'process.execve'` * `execPath` {string} * `args` {string\[]} From a7f487fcc80f716edc5d03c39f6bdb2b9b0c180b Mon Sep 17 00:00:00 2001 From: Charles Kerr Date: Wed, 29 Apr 2026 23:28:41 -0500 Subject: [PATCH 020/168] src: add missing for abort() declaration MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit builtin_info.cc calls `abort()` but didn't call `` to pick up its declaration. This has been working because `abort()` got picked up by a transitive declaration from another header, but it broke in Electron when we rolled our LLVM libc++ snapshot from commit 8e870711923 to 9aaa9a2ee87. Signed-off-by: Charles Kerr PR-URL: https://github.com/nodejs/node/pull/63001 Reviewed-By: Michaël Zasso Reviewed-By: Richard Lau Reviewed-By: Darshan Sen Reviewed-By: Luigi Pinca --- src/builtin_info.cc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/builtin_info.cc b/src/builtin_info.cc index d5309265ac3733..496cbc0e682653 100644 --- a/src/builtin_info.cc +++ b/src/builtin_info.cc @@ -1,4 +1,5 @@ #include "builtin_info.h" +#include namespace node { namespace builtins { @@ -41,7 +42,7 @@ std::string GetBuiltinSourceTypeName(BuiltinSourceType type) { case BuiltinSourceType::kSourceTextModule: return "kSourceTextModule"; } - abort(); + std::abort(); } } // namespace builtins From f625c4b9e3376b981f53b1394ddb8f58cf22b78d Mon Sep 17 00:00:00 2001 From: T <6601329+cookesan@users.noreply.github.com> Date: Thu, 30 Apr 2026 07:16:06 -0400 Subject: [PATCH 021/168] http2: expose writable stream state on compat response Signed-off-by: Terry Chen PR-URL: https://github.com/nodejs/node/pull/63003 Fixes: https://github.com/nodejs/node/issues/63000 Reviewed-By: Matteo Collina Reviewed-By: Tim Perry --- lib/internal/http2/compat.js | 8 ++++++++ test/parallel/test-http2-res-writable-properties.js | 3 +++ 2 files changed, 11 insertions(+) diff --git a/lib/internal/http2/compat.js b/lib/internal/http2/compat.js index 41909ffa5756f8..86dc7dc047fd78 100644 --- a/lib/internal/http2/compat.js +++ b/lib/internal/http2/compat.js @@ -551,6 +551,10 @@ class Http2ServerResponse extends Stream { return this[kStream].writableHighWaterMark; } + get writableObjectMode() { + return this[kStream].writableObjectMode; + } + get writableFinished() { return this[kStream].writableFinished; } @@ -559,6 +563,10 @@ class Http2ServerResponse extends Stream { return this[kStream].writableLength; } + get writableNeedDrain() { + return this[kStream].writableNeedDrain; + } + set statusCode(code) { code |= 0; if (code >= 100 && code < 200) diff --git a/test/parallel/test-http2-res-writable-properties.js b/test/parallel/test-http2-res-writable-properties.js index 488cb1babf3e8a..5cee258a9f572b 100644 --- a/test/parallel/test-http2-res-writable-properties.js +++ b/test/parallel/test-http2-res-writable-properties.js @@ -7,11 +7,14 @@ const http2 = require('http2'); const server = http2.createServer(common.mustCall((req, res) => { const hwm = req.socket.writableHighWaterMark; assert.strictEqual(res.writableHighWaterMark, hwm); + assert.strictEqual(res.writableObjectMode, res.stream.writableObjectMode); + assert.strictEqual(res.writableNeedDrain, res.stream.writableNeedDrain); assert.strictEqual(res.writableLength, 0); res.write(''); const len = res.writableLength; res.write('asd'); assert.strictEqual(res.writableLength, len + 3); + assert.strictEqual(res.writableNeedDrain, res.stream.writableNeedDrain); res.end(); res.on('finish', common.mustCall(() => { assert.strictEqual(res.writableLength, 0); From 66054cc90efbc095f9646ae788c3486b740a586f Mon Sep 17 00:00:00 2001 From: Richard Lau Date: Thu, 30 Apr 2026 16:23:41 +0100 Subject: [PATCH 022/168] build: add rust target for macOS cross compiles When we build the macOS pkg, we build Node.js twice (on arm64): - Once for arm64 (native) - Once for x64, using a combination of Rosetta 2 and compiler flags before combining both into a universal binary. For the x64 case, pass target flag to `rustc` so that the binary is built for the correct target architecture. Signed-off-by: Richard Lau PR-URL: https://github.com/nodejs/node/pull/63015 Reviewed-By: Stewart X Addison Reviewed-By: Antoine du Hamel Reviewed-By: Rafael Gonzaga --- configure.py | 4 ++++ deps/crates/crates.gyp | 13 +++++++++---- 2 files changed, 13 insertions(+), 4 deletions(-) diff --git a/configure.py b/configure.py index c167a0a0b27358..ffdd538bf71834 100755 --- a/configure.py +++ b/configure.py @@ -1855,6 +1855,10 @@ def configure_node(o): if flavor == 'win': o['variables']['cargo_rust_target'] = \ 'aarch64-pc-windows-msvc' if target_arch == 'arm64' else 'x86_64-pc-windows-msvc' + # Always set the Rust target for x64 macOS in case we will be building + # under Rosetta 2. + if flavor == 'mac' and target_arch == 'x64': + o['variables']['cargo_rust_target'] = 'x86_64-apple-darwin' # Allow overriding the compiler - needed by embedders. if options.use_clang: diff --git a/deps/crates/crates.gyp b/deps/crates/crates.gyp index fa2387281839f2..5c1dc9d782cbfe 100644 --- a/deps/crates/crates.gyp +++ b/deps/crates/crates.gyp @@ -11,12 +11,17 @@ }, 'conditions': [ ['cargo_rust_target!=""', { + 'variables': { + 'cargo_build_flags': ['--target', '<(cargo_rust_target)'], + } + }], + ['OS=="win"', { 'variables': { 'node_crates_libpath': '<(SHARED_INTERMEDIATE_DIR)/$(Platform)/release/node_crates.lib', }, }, { 'variables': { - 'node_crates_libpath': '<(SHARED_INTERMEDIATE_DIR)/release/<(STATIC_LIB_PREFIX)node_crates<(STATIC_LIB_SUFFIX)', + 'node_crates_libpath': '<(SHARED_INTERMEDIATE_DIR)/<(cargo_rust_target)/release/<(STATIC_LIB_PREFIX)node_crates<(STATIC_LIB_SUFFIX)', }, }], ], @@ -25,13 +30,13 @@ 'cargo_build_flags': [], }, 'conditions': [ - ['cargo_rust_target!=""', { + ['OS=="win"', { 'variables': { 'node_crates_libpath': '<(SHARED_INTERMEDIATE_DIR)/$(Platform)/debug/node_crates.lib', }, }, { 'variables': { - 'node_crates_libpath': '<(SHARED_INTERMEDIATE_DIR)/debug/<(STATIC_LIB_PREFIX)node_crates<(STATIC_LIB_SUFFIX)', + 'node_crates_libpath': '<(SHARED_INTERMEDIATE_DIR)/<(cargo_rust_target)/debug/<(STATIC_LIB_PREFIX)node_crates<(STATIC_LIB_SUFFIX)', }, }], ], @@ -62,7 +67,7 @@ ], }, 'conditions': [ - ['cargo_rust_target!=""', { + ['OS=="win"', { 'actions': [ { 'action_name': 'cargo_build', From 80e0f14f8eaf4909e330900c3caebd3ddd3d210b Mon Sep 17 00:00:00 2001 From: Nicola Del Gobbo Date: Thu, 30 Apr 2026 18:52:48 +0200 Subject: [PATCH 023/168] url: process crash via malformed UNC hostname in pathToFileURL() MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fixes: https://github.com/nodejs/node/issues/62546 PR-URL: https://github.com/nodejs/node/pull/62574 Reviewed-By: René Reviewed-By: Marco Ippolito Reviewed-By: Claudio Wunder --- src/node_url.cc | 7 +++++-- test/parallel/test-url-pathtofileurl.js | 8 ++++++++ 2 files changed, 13 insertions(+), 2 deletions(-) diff --git a/src/node_url.cc b/src/node_url.cc index 6294cd03667980..75aaf468f508f2 100644 --- a/src/node_url.cc +++ b/src/node_url.cc @@ -93,7 +93,6 @@ constexpr auto lookup_table = []() consteval { case CHAR: \ result[i] = {{'%', HEX_DIGIT_2, HEX_DIGIT_1, 0}}; \ break; - ENCODE_CHAR('\0', '0', '0') // '\0' == 0x00 ENCODE_CHAR('\t', '0', '9') // '\t' == 0x09 ENCODE_CHAR('\n', '0', 'A') // '\n' == 0x0A @@ -169,7 +168,11 @@ void BindingData::PathToFileURL(const FunctionCallbackInfo& args) { [[unlikely]] { CHECK(args[2]->IsString()); Utf8Value hostname(isolate, args[2]); - CHECK(out->set_hostname(hostname.ToStringView())); + if (!out->set_hostname(hostname.ToStringView())) { + return ThrowInvalidURL(realm->env(), + input.ToStringView(), + std::string(hostname.ToStringView())); + } } binding_data->UpdateComponents(out->get_components(), out->type); diff --git a/test/parallel/test-url-pathtofileurl.js b/test/parallel/test-url-pathtofileurl.js index 089232caeb3b2d..01d27f2b736d75 100644 --- a/test/parallel/test-url-pathtofileurl.js +++ b/test/parallel/test-url-pathtofileurl.js @@ -21,6 +21,14 @@ const url = require('url'); assert.ok(fileURL.includes('%25')); } +{ + assert.throws(() => { + url.pathToFileURL('\\\\exa mple\\share\\file.txt', { windows: true }); + }, { + code: 'ERR_INVALID_URL', + }); +} + { if (isWindows) { // UNC path: \\server\share\resource From fc192ee030ee076b948ce7d9d72cba6c101989b8 Mon Sep 17 00:00:00 2001 From: Ryan Fitzgerald <114442851+rf-figma@users.noreply.github.com> Date: Thu, 30 Apr 2026 14:42:15 -0700 Subject: [PATCH 024/168] doc: reserve NMV 148 for Electron 43 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Ryan Fitzgerald PR-URL: https://github.com/nodejs/node/pull/63016 Reviewed-By: Richard Lau Reviewed-By: Chengzhong Wu Reviewed-By: Shelley Vohr Reviewed-By: Luigi Pinca Reviewed-By: Ulises Gascón --- doc/abi_version_registry.json | 1 + 1 file changed, 1 insertion(+) diff --git a/doc/abi_version_registry.json b/doc/abi_version_registry.json index 305bf3fc1607f8..a7640c3ed5fde3 100644 --- a/doc/abi_version_registry.json +++ b/doc/abi_version_registry.json @@ -1,5 +1,6 @@ { "NODE_MODULE_VERSION": [ + { "modules": 148,"runtime": "electron", "variant": "electron", "versions": "43" }, { "modules": 147,"runtime": "node", "variant": "v8_14.6", "versions": "26.0.0-pre" }, { "modules": 146,"runtime": "electron", "variant": "electron", "versions": "42" }, { "modules": 145,"runtime": "electron", "variant": "electron", "versions": "41" }, From 31d71418179afce18448d53ca50f3ec6028702df Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ren=C3=A9?= Date: Fri, 1 May 2026 10:10:27 +0100 Subject: [PATCH 025/168] test: run Temporal presence checks without V8 flag Signed-off-by: Renegade334 PR-URL: https://github.com/nodejs/node/pull/63028 Reviewed-By: Richard Lau Reviewed-By: Antoine du Hamel Reviewed-By: Luigi Pinca Reviewed-By: Chengzhong Wu --- test/common/index.js | 2 ++ test/common/index.mjs | 2 ++ test/parallel/test-temporal-with-zoneinfo.js | 4 +--- test/parallel/test-temporal.js | 4 +--- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/test/common/index.js b/test/common/index.js index c50057e3c5c8e7..09962cecd31932 100755 --- a/test/common/index.js +++ b/test/common/index.js @@ -35,6 +35,7 @@ const tmpdir = require('./tmpdir'); const bits = ['arm64', 'loong64', 'mips', 'mipsel', 'ppc64', 'riscv64', 's390x', 'x64'] .includes(process.arch) ? 64 : 32; const hasIntl = !!process.config.variables.v8_enable_i18n_support; +const hasTemporal = !!process.config.variables.v8_enable_temporal_support; // small-icu doesn't support non-English locales const hasFullICU = (() => { @@ -980,6 +981,7 @@ const common = { getBufferSources, getTTYfd, hasIntl, + hasTemporal, hasFullICU, hasCrypto, hasQuic, diff --git a/test/common/index.mjs b/test/common/index.mjs index 1a2844f8604917..d42172ff18f984 100644 --- a/test/common/index.mjs +++ b/test/common/index.mjs @@ -22,6 +22,7 @@ const { hasFFI, hasLocalStorage, hasIntl, + hasTemporal, hasIPv6, isAIX, isAlive, @@ -78,6 +79,7 @@ export { hasFFI, hasLocalStorage, hasIntl, + hasTemporal, hasIPv6, isAIX, isAlive, diff --git a/test/parallel/test-temporal-with-zoneinfo.js b/test/parallel/test-temporal-with-zoneinfo.js index 70dfaf016d1137..0ff8a4f0012091 100644 --- a/test/parallel/test-temporal-with-zoneinfo.js +++ b/test/parallel/test-temporal-with-zoneinfo.js @@ -1,10 +1,8 @@ -// Flags: --harmony-temporal - 'use strict'; const common = require('../common'); const assert = require('assert'); -if (!process.config.variables.v8_enable_temporal_support) { +if (!common.hasTemporal) { common.skip('Temporal is not enabled'); } diff --git a/test/parallel/test-temporal.js b/test/parallel/test-temporal.js index 5921a837624d55..61a3f35046841a 100644 --- a/test/parallel/test-temporal.js +++ b/test/parallel/test-temporal.js @@ -1,10 +1,8 @@ -// Flags: --harmony-temporal - 'use strict'; const common = require('../common'); const assert = require('assert'); -if (!process.config.variables.v8_enable_temporal_support) { +if (!common.hasTemporal) { common.skip('Temporal is not enabled'); } From 637a98adff0f39be2af62b9ced5f47316ee3b5ef Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ren=C3=A9?= Date: Fri, 1 May 2026 10:10:40 +0100 Subject: [PATCH 026/168] lib: add Temporal to frozen intrinsics Signed-off-by: Renegade334 PR-URL: https://github.com/nodejs/node/pull/63029 Reviewed-By: Antoine du Hamel Reviewed-By: Jordan Harband Reviewed-By: Yagiz Nizipli Reviewed-By: Chengzhong Wu --- lib/internal/freeze_intrinsics.js | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/lib/internal/freeze_intrinsics.js b/lib/internal/freeze_intrinsics.js index 1d793d719f5fbf..4f083dc34f44d2 100644 --- a/lib/internal/freeze_intrinsics.js +++ b/lib/internal/freeze_intrinsics.js @@ -132,6 +132,7 @@ const { const { Intl, SharedArrayBuffer, + Temporal, WebAssembly, } = globalThis; @@ -372,6 +373,20 @@ module.exports = function() { ArrayPrototypePush(intrinsics, Intl); } + if (typeof Temporal !== 'undefined') { + ArrayPrototypePush(intrinsicPrototypes, + Temporal.Duration.prototype, + Temporal.Instant.prototype, + Temporal.PlainDate.prototype, + Temporal.PlainDateTime.prototype, + Temporal.PlainMonthDay.prototype, + Temporal.PlainTime.prototype, + Temporal.PlainYearMonth.prototype, + Temporal.ZonedDateTime.prototype, + ); + ArrayPrototypePush(intrinsics, Temporal); + } + ArrayPrototypeForEach(intrinsicPrototypes, enableDerivedOverrides); const frozenSet = new WeakSet(); From 9c0101860e771b69b5229ced41bbfcae84fe554d Mon Sep 17 00:00:00 2001 From: semimikoh Date: Fri, 1 May 2026 18:52:10 +0900 Subject: [PATCH 027/168] ffi: prevent premature GC of DynamicLibrary Signed-off-by: semimikoh PR-URL: https://github.com/nodejs/node/pull/63024 Fixes: https://github.com/nodejs/node/issues/63010 Reviewed-By: Paolo Insogna Reviewed-By: Anna Henningsen Reviewed-By: Matteo Collina Reviewed-By: Bryan English --- src/node_ffi.cc | 2 ++ src/node_ffi.h | 2 ++ test/ffi/test-ffi-dynamic-library.js | 24 +++++++++++++++++++++++- 3 files changed, 27 insertions(+), 1 deletion(-) diff --git a/src/node_ffi.cc b/src/node_ffi.cc index 89018c8e6e4b32..22aeb8fd22f108 100644 --- a/src/node_ffi.cc +++ b/src/node_ffi.cc @@ -194,6 +194,7 @@ void DynamicLibrary::CleanupFunctionInfo( FFIFunctionInfo* info = data.GetParameter(); info->fn.reset(); info->self.Reset(); + info->library.Reset(); delete info; } @@ -313,6 +314,7 @@ MaybeLocal DynamicLibrary::CreateFunction( } info->self.Reset(isolate, ret); + info->library.Reset(isolate, object()); info->self.SetWeak(info.release(), DynamicLibrary::CleanupFunctionInfo, WeakCallbackType::kParameter); diff --git a/src/node_ffi.h b/src/node_ffi.h index 14362963f288ce..22d78a2ad4f35a 100644 --- a/src/node_ffi.h +++ b/src/node_ffi.h @@ -33,6 +33,8 @@ struct FFIFunctionInfo { std::shared_ptr fn; v8::Global self; std::shared_ptr sb_backing; + // Keep the owning DynamicLibrary alive while the generated function is alive. + v8::Global library; }; struct FFICallback { diff --git a/test/ffi/test-ffi-dynamic-library.js b/test/ffi/test-ffi-dynamic-library.js index a80fe5286afab9..ebe3af80586b45 100644 --- a/test/ffi/test-ffi-dynamic-library.js +++ b/test/ffi/test-ffi-dynamic-library.js @@ -1,7 +1,8 @@ -// Flags: --experimental-ffi +// Flags: --experimental-ffi --expose-gc 'use strict'; const common = require('../common'); common.skipIfFFIMissing(); +const { gcUntil } = require('../common/gc'); const assert = require('node:assert'); const { test } = require('node:test'); const ffi = require('node:ffi'); @@ -117,6 +118,27 @@ test('getFunction caches signatures consistently', () => { } }); +test('FFI functions keep their owning library alive', async () => { + let lib = new ffi.DynamicLibrary(libraryPath); + const addI32 = lib.getFunction('add_i32', fixtureSymbols.add_i32); + const ref = new WeakRef(lib); + + lib = null; + + for (let i = 0; i < 5; i++) { + await gcUntil( + 'FFI function keeps its owning library alive', + () => true, + 1, + ); + assert.ok(ref.deref() instanceof ffi.DynamicLibrary); + assert.strictEqual(addI32(20, 22), 42); + } + + ref.deref().close(); + assert.throws(() => addI32(20, 22), /Library is closed/); +}); + test('closed libraries reject subsequent operations', () => { const { lib, functions } = ffi.dlopen(libraryPath, { add_i32: fixtureSymbols.add_i32, From 6a949577ee49b5ff11373f725c2169defea5fdbb Mon Sep 17 00:00:00 2001 From: Joyee Cheung Date: Fri, 1 May 2026 15:44:02 +0200 Subject: [PATCH 028/168] debugger: move ProbeInspectorSession and helpers to separate files Signed-off-by: Joyee Cheung PR-URL: https://github.com/nodejs/node/pull/63013 Reviewed-By: Jan Martin Reviewed-By: Jacob Smith Reviewed-By: Chengzhong Wu Reviewed-By: Aditi Singh --- lib/internal/debugger/inspect.js | 865 +---------------------- lib/internal/debugger/inspect_helpers.js | 132 ++++ lib/internal/debugger/inspect_probe.js | 785 ++++++++++++++++++++ 3 files changed, 925 insertions(+), 857 deletions(-) create mode 100644 lib/internal/debugger/inspect_helpers.js create mode 100644 lib/internal/debugger/inspect_probe.js diff --git a/lib/internal/debugger/inspect.js b/lib/internal/debugger/inspect.js index 259156dce21d85..bb54e0ef570448 100644 --- a/lib/internal/debugger/inspect.js +++ b/lib/internal/debugger/inspect.js @@ -1,876 +1,48 @@ 'use strict'; const { - ArrayFrom, - ArrayIsArray, ArrayPrototypeForEach, ArrayPrototypeJoin, ArrayPrototypeMap, ArrayPrototypePop, - ArrayPrototypePush, - ArrayPrototypePushApply, ArrayPrototypeShift, ArrayPrototypeSlice, FunctionPrototypeBind, - JSONStringify, Number, - NumberIsNaN, - NumberParseInt, - ObjectEntries, - Promise, PromisePrototypeThen, PromiseResolve, Proxy, RegExpPrototypeExec, RegExpPrototypeSymbolSplit, - SafeMap, - SafeSet, StringPrototypeEndsWith, - StringPrototypeIncludes, - StringPrototypeSlice, StringPrototypeSplit, - StringPrototypeStartsWith, } = primordials; -const { spawn } = require('child_process'); const { EventEmitter } = require('events'); -const net = require('net'); -const { clearTimeout, setTimeout } = require('timers'); const util = require('util'); const { - setInterval: pSetInterval, setTimeout: pSetTimeout, } = require('timers/promises'); -const { - AbortController, -} = require('internal/abort_controller'); -const { SideEffectFreeRegExpPrototypeSymbolReplace } = require('internal/util'); const InspectClient = require('internal/debugger/inspect_client'); +const { + launchChildProcess, + writeUsageAndExit, +} = require('internal/debugger/inspect_helpers'); +const { + startProbeMode, +} = require('internal/debugger/inspect_probe'); const createRepl = require('internal/debugger/inspect_repl'); const debuglog = util.debuglog('inspect'); -const { ERR_DEBUGGER_STARTUP_ERROR } = require('internal/errors').codes; const { exitCodes: { kGenericUserError, kNoFailure, - kInvalidCommandLineArgument, }, } = internalBinding('errors'); -const kProbeDefaultTimeout = 30000; -const kProbeVersion = 1; -const kProbeDisconnectSentinel = 'Waiting for the debugger to disconnect...'; -const kDigitsRegex = /^\d+$/; -const kInspectPortRegex = /^--inspect-port=(\d+)$/; -const kProbeArgOptions = { - __proto__: null, - expr: { type: 'string' }, - json: { type: 'boolean' }, - // Port and timeout use type 'string' because parseArgs has no - // numeric type; the values are parsed to integers in parseProbeArgv(). - port: { type: 'string' }, - preview: { type: 'boolean' }, - probe: { type: 'string' }, - timeout: { type: 'string' }, -}; - -async function portIsFree(host, port, timeout = 3000) { - if (port === 0) return; // Binding to a random port. - - const retryDelay = 150; - const ac = new AbortController(); - const { signal } = ac; - - pSetTimeout(timeout).then(() => ac.abort()); - - const asyncIterator = pSetInterval(retryDelay); - while (true) { - await asyncIterator.next(); - if (signal.aborted) { - throw new ERR_DEBUGGER_STARTUP_ERROR( - `Timeout (${timeout}) waiting for ${host}:${port} to be free`); - } - const error = await new Promise((resolve) => { - const socket = net.connect(port, host); - socket.on('error', resolve); - socket.on('connect', () => { - socket.end(); - resolve(); - }); - }); - if (error?.code === 'ECONNREFUSED') { - return; - } - } -} - -const debugRegex = /Debugger listening on ws:\/\/\[?(.+?)\]?:(\d+)\//; - -function getInspectUsage(invokedAs) { - return `Usage: ${invokedAs} script.js\n` + - ` ${invokedAs} :\n` + - ` ${invokedAs} --port= Use 0 for random port assignment\n` + - ` ${invokedAs} -p \n` + - ` ${invokedAs} [--json] [--timeout=] [--port=] ` + - `--probe :[:] --expr ` + - `[--probe :[:] --expr ...] ` + - `[--] [ ...] [args...]\n`; -} - -function writeUsageAndExit(invokedAs, message, exitCode = kInvalidCommandLineArgument) { - if (message) { - process.stderr.write(`${message}\n`); - } - process.stderr.write(getInspectUsage(invokedAs)); - process.exit(exitCode); -} - -function ensureTrailingNewline(text) { - return StringPrototypeEndsWith(text, '\n') ? text : `${text}\n`; -} - -function parseUnsignedInteger(value, name, allowZero = false) { - if (typeof value !== 'string' || RegExpPrototypeExec(kDigitsRegex, value) === null) { - throw new ERR_DEBUGGER_STARTUP_ERROR(`Invalid ${name}: ${value}`); - } - const parsed = NumberParseInt(value, 10); - if (NumberIsNaN(parsed) || (!allowZero && parsed < 1)) { - throw new ERR_DEBUGGER_STARTUP_ERROR(`Invalid ${name}: ${value}`); - } - return parsed; -} - -// Accepts file:line or file:line:column formats. -// Non-greedy (.+?) allows Windows drive-letter paths like C:\foo.js:10. -function parseProbeLocation(text) { - const match = RegExpPrototypeExec(/^(.+?):(\d+)(?::(\d+))?$/, text); - if (match === null) { - throw new ERR_DEBUGGER_STARTUP_ERROR(`Invalid probe location: ${text}`); - } - - const file = match[1]; - const line = parseUnsignedInteger(match[2], 'probe location'); - const column = match[3] !== undefined ? - parseUnsignedInteger(match[3], 'probe location') : undefined; - const target = column === undefined ? [file, line] : [file, line, column]; - - return { - file, - lineNumber: line - 1, - columnNumber: column === undefined ? undefined : column - 1, - target, - }; -} - -function formatPendingProbeLocations(probes, pending) { - const seen = new SafeSet(); - for (const probeIndex of pending) { - seen.add(ArrayPrototypeJoin(probes[probeIndex].target, ':')); - } - return ArrayPrototypeJoin(ArrayFrom(seen), ', '); -} - -function formatTargetExitMessage(probes, pending, exitCode, signal) { - const status = signal === null ? - `Target exited with code ${exitCode}` : - `Target exited with signal ${signal}`; - if (pending.length === 0) { - return `${status} before target completion`; - } - return `${status} before probes: ${formatPendingProbeLocations(probes, pending)}`; -} - -// Trim the "Waiting for the debugger to disconnect..." message from stderr for reporting child errors. -function trimProbeChildStderr(stderr) { - const lines = RegExpPrototypeSymbolSplit(/\r\n|\r|\n/g, stderr); - const kept = []; - for (let i = 0; i < lines.length; i++) { - const line = lines[i]; - if (line === '' && i === lines.length - 1) { continue; } - if (line === kProbeDisconnectSentinel) { continue; } - ArrayPrototypePush(kept, line); - } - return ArrayPrototypeJoin(kept, '\n'); -} - -function formatPreviewPropertyValue(property) { - if (property.type === 'string') { - return JSONStringify(property.value ?? ''); - } - return property.value ?? property.type; -} - -function trimRemoteObject(result) { - if (result === undefined || result === null || typeof result !== 'object') { - return result; - } - - if (ArrayIsArray(result)) { - return ArrayPrototypeMap(result, trimRemoteObject); - } - - const trimmed = { __proto__: null }; - for (const { 0: key, 1: value } of ObjectEntries(result)) { - if (key === 'objectId' || key === 'className') { - continue; - } - trimmed[key] = trimRemoteObject(value); - } - return trimmed; -} - -function stripProbePreviews(value) { - if (value === undefined || value === null || typeof value !== 'object') { - return value; - } - - if (ArrayIsArray(value)) { - return ArrayPrototypeMap(value, stripProbePreviews); - } - - const stripped = { __proto__: null }; - for (const { 0: key, 1: entry } of ObjectEntries(value)) { - if (key === 'preview') { - continue; - } - stripped[key] = stripProbePreviews(entry); - } - return stripped; -} - -// Format CDP RemoteObject values into more readable formats. -function formatRemoteObject(result) { - if (result === undefined) { return 'undefined'; } - - switch (result.type) { - case 'undefined': - return 'undefined'; - case 'string': - return JSONStringify(result.value); - case 'number': - if (result.unserializableValue !== undefined) { - return result.unserializableValue; - } - return `${result.value}`; - case 'boolean': - return `${result.value}`; - case 'symbol': - return result.description || 'Symbol()'; - case 'bigint': - return result.unserializableValue ?? result.description ?? '0n'; - case 'function': - return result.description || 'function()'; - case 'object': - if (result.subtype === 'null') { - return 'null'; - } - if (result.subtype === 'error') { - return result.description || 'Error'; - } - if (result.preview !== undefined) { - const properties = ArrayPrototypeJoin(ArrayPrototypeMap( - result.preview.properties, - result.preview.subtype === 'array' ? - (property) => formatPreviewPropertyValue(property) : - (property) => `${property.name}: ${formatPreviewPropertyValue(property)}`, - ), ', '); - const suffix = result.preview.overflow ? ', ...' : ''; - if (result.preview.subtype === 'array') { - return `[${properties}${suffix}]`; - } - return `{${properties}${suffix}}`; - } - return result.description || result.className || 'Object'; - default: - return `${result.value ?? result.description ?? ''}`; - } -} - -// Built human-readable text output for probe reports. -function buildProbeTextReport(report) { - const lines = []; - - for (const result of report.results) { - if (result.event === 'hit') { - const probe = report.probes[result.probe]; - const location = ArrayPrototypeJoin(probe.target, ':'); - ArrayPrototypePush(lines, `Hit ${result.hit} at ${location}`); - if (result.error !== undefined) { - ArrayPrototypePush(lines, - ` [error] ${probe.expr} = ` + - `${formatRemoteObject(result.error)}`); - } else { - ArrayPrototypePush(lines, - ` ${probe.expr} = ` + - `${formatRemoteObject(result.result)}`); - } - continue; - } - - if (result.event === 'completed') { - ArrayPrototypePush(lines, 'Completed'); - continue; - } - - if (result.event === 'miss') { - ArrayPrototypePush(lines, - `Missed probes: ` + - `${formatPendingProbeLocations(report.probes, result.pending)}`); - continue; - } - - if (result.event === 'timeout') { - ArrayPrototypePush(lines, result.error.message); - continue; - } - - if (result.event === 'error') { - ArrayPrototypePush(lines, result.error.message); - if (result.error.stderr !== undefined) { - ArrayPrototypePush(lines, ' [stderr]'); - const stderrLines = RegExpPrototypeSymbolSplit( - /\r\n|\r|\n/g, - result.error.stderr, - ); - for (let i = 0; i < stderrLines.length; i++) { - if (stderrLines[i] === '' && i === stderrLines.length - 1) { - continue; - } - ArrayPrototypePush(lines, ` ${stderrLines[i]}`); - } - } - } - } - - return ensureTrailingNewline(ArrayPrototypeJoin(lines, '\n')); -} - -function hasTopLevelProbeOption(args) { - const { tokens } = util.parseArgs({ - args, - allowPositionals: true, - options: kProbeArgOptions, - strict: false, - tokens: true, - }); - - for (const token of tokens) { - if (token.kind === 'option' && token.name === 'probe') { - return true; - } - - if (token.kind === 'option-terminator' || token.kind === 'positional') { - return false; - } - } - - return false; -} - -function parseProbeArgv(args) { - let port = 0; - let preview = false; - let timeout = kProbeDefaultTimeout; - let json = false; - let sawSeparator = false; - let childStartIndex = args.length; - let pendingLocation; - let expectedExprIndex = -1; - const probes = []; - - const { tokens } = util.parseArgs({ - args, - allowPositionals: true, - options: kProbeArgOptions, - strict: false, - tokens: true, - }); - - for (const token of tokens) { - if (token.kind === 'option-terminator') { - sawSeparator = true; - childStartIndex = token.index + 1; - break; - } - - if (pendingLocation !== undefined) { - if (token.kind === 'option' && - token.name === 'expr' && - token.index === expectedExprIndex && - token.value !== undefined) { - ArrayPrototypePush(probes, { - expr: token.value, - location: pendingLocation, - }); - pendingLocation = undefined; - continue; - } - - throw new ERR_DEBUGGER_STARTUP_ERROR( - 'Each --probe must be followed immediately by --expr '); - } - - if (token.kind === 'positional') { - childStartIndex = token.index; - break; - } - - switch (token.name) { - case 'json': - json = true; - break; - case 'timeout': - if (token.value === undefined) { - throw new ERR_DEBUGGER_STARTUP_ERROR(`Missing value for ${token.rawName}`); - } - timeout = parseUnsignedInteger(token.value, 'timeout', true); - break; - case 'port': - if (token.value === undefined) { - throw new ERR_DEBUGGER_STARTUP_ERROR(`Missing value for ${token.rawName}`); - } - port = parseUnsignedInteger(token.value, 'inspector port', true); - break; - case 'preview': - preview = true; - break; - case 'probe': - pendingLocation = parseProbeLocation(token.value); - expectedExprIndex = token.index + (token.inlineValue ? 1 : 2); - break; - case 'expr': - throw new ERR_DEBUGGER_STARTUP_ERROR('Unexpected --expr before --probe'); - default: - if (probes.length > 0) { - throw new ERR_DEBUGGER_STARTUP_ERROR( - 'Use -- before child Node.js flags in probe mode'); - } - throw new ERR_DEBUGGER_STARTUP_ERROR(`Unknown probe option: ${token.rawName}`); - } - } - - if (pendingLocation !== undefined) { - throw new ERR_DEBUGGER_STARTUP_ERROR( - 'Each --probe must be followed immediately by --expr '); - } - - if (probes.length === 0) { - throw new ERR_DEBUGGER_STARTUP_ERROR( - 'Probe mode requires at least one --probe --expr group'); - } - - const childArgv = ArrayPrototypeSlice(args, childStartIndex); - if (childArgv.length === 0) { - throw new ERR_DEBUGGER_STARTUP_ERROR('Probe mode requires a child script'); - } - - if (!sawSeparator && StringPrototypeStartsWith(childArgv[0], '-')) { - throw new ERR_DEBUGGER_STARTUP_ERROR('Use -- before child Node.js flags in probe mode'); - } - - let skipPortPreflight = port === 0; - for (const arg of childArgv) { - const inspectPortMatch = RegExpPrototypeExec(kInspectPortRegex, arg); - if (inspectPortMatch === null) { - continue; - } - if (inspectPortMatch[1] === '0') { - skipPortPreflight = true; - continue; - } - throw new ERR_DEBUGGER_STARTUP_ERROR( - 'Only child --inspect-port=0 is supported in probe mode'); - } - - return { - host: '127.0.0.1', - port, - preview, - timeout, - json, - probes, - childArgv, - skipPortPreflight, - }; -} - -async function launchChildProcess(childArgs, inspectHost, inspectPort, - childOutput, options = { __proto__: null }) { - if (!options.skipPortPreflight) { - await portIsFree(inspectHost, inspectPort); - } - - const args = [`--inspect-brk=${inspectPort}`]; - ArrayPrototypePushApply(args, childArgs); - - const child = spawn(process.execPath, args); - child.stdout.setEncoding('utf8'); - child.stderr.setEncoding('utf8'); - child.stdout.on('data', (chunk) => childOutput(chunk, 'stdout')); - child.stderr.on('data', (chunk) => childOutput(chunk, 'stderr')); - - let stderrOutput = ''; - return new Promise((resolve, reject) => { - function rejectLaunch(message) { - reject(new ERR_DEBUGGER_STARTUP_ERROR(message, { childStderr: stderrOutput })); - } - - function onExit(code, signal) { - const suffix = signal !== null ? ` (${signal})` : ` (code ${code})`; - rejectLaunch(`Target exited before the inspector was ready${suffix}`); - } - - function onError(error) { - rejectLaunch(error.message); - } - - function onStderr(text) { - stderrOutput += text; - const debug = RegExpPrototypeExec(debugRegex, stderrOutput); - if (debug) { - child.stderr.removeListener('data', onStderr); - child.removeListener('exit', onExit); - child.removeListener('error', onError); - resolve([child, Number(debug[2]), debug[1]]); - } - } - - child.once('exit', onExit); - child.once('error', onError); - child.stderr.on('data', onStderr); - }); -} - -// TODO(joyeecheung): move it to a separate file. Currently moving it -// somehow breaks the snapshot reproducibility which probably involves a -// pre-existing V8 bug. -class ProbeInspectorSession { - constructor(options) { - this.options = options; - this.client = new InspectClient(); - this.child = null; - this.cleanupStarted = false; - this.childStderr = ''; - this.disconnectRequested = false; - this.finished = false; - this.started = false; - this.stderrBuffer = ''; - this.breakpointDefinitions = new SafeMap(); - this.results = []; - this.timeout = null; - this.resolveCompletion = null; - this.completionPromise = new Promise((resolve) => { - this.resolveCompletion = resolve; - }); - this.probes = ArrayPrototypeMap(options.probes, (probe) => ({ - expr: probe.expr, - target: probe.location.target, - location: probe.location, - hits: 0, - })); - - this.onChildOutput = FunctionPrototypeBind(this.onChildOutput, this); - this.onChildExit = FunctionPrototypeBind(this.onChildExit, this); - this.onClientClose = FunctionPrototypeBind(this.onClientClose, this); - this.onPaused = FunctionPrototypeBind(this.onPaused, this); - } - - finish(state) { - if (this.finished) { return; } - this.finished = true; - if (this.timeout !== null) { - clearTimeout(this.timeout); - this.timeout = null; - } - this.resolveCompletion(state); - } - - onChildOutput(text, which) { - if (which !== 'stderr') { return; } - - if (this.started) { - this.childStderr += text; - } - - const combined = this.stderrBuffer + text; - if (this.started && - StringPrototypeIncludes(combined, kProbeDisconnectSentinel)) { - this.disconnectRequested = true; - this.client.reset(); - } - - if (combined.length > kProbeDisconnectSentinel.length) { - this.stderrBuffer = StringPrototypeSlice(combined, - combined.length - - kProbeDisconnectSentinel.length); - } else { - this.stderrBuffer = combined; - } - } - - onChildExit(code, signal) { - if (this.started) { - if (code !== 0 || signal !== null) { - this.finish({ - __proto__: null, - event: 'error', - exitCode: code, - signal, - stderr: trimProbeChildStderr(this.childStderr), - }); - } else { - this.finish('complete'); - } - } - } - - onClientClose() { - if (!this.started || this.child === null) { return; } - - // TODO(joyeecheung): Surface mid-probe inspector disconnects as terminal probe errors - // instead of deferring to timeout or miss classification. - if (this.disconnectRequested) { return; } - - if (this.child.exitCode !== null || this.child.signalCode !== null) { - this.onChildExit(this.child.exitCode, this.child.signalCode); - } - } - - onPaused(params) { - // TODO(joyeecheung): Preserve evaluation and resume failures as terminal probe errors - // instead of collapsing them into a synthetic completion. - this.handlePaused(params).catch((error) => { - if (!this.finished) { - if (error?.code === 'ERR_DEBUGGER_ERROR') { - if (this.child !== null && - (this.child.exitCode !== null || this.child.signalCode !== null)) { - this.onChildExit(this.child.exitCode, this.child.signalCode); - } - return; - } - this.finish('complete'); - } - }); - } - - async handlePaused(params) { - if (this.finished) { return; } - - const hitBreakpoints = params.hitBreakpoints; - if (hitBreakpoints === undefined || hitBreakpoints.length === 0) { - await this.resume(); - return; - } - - const callFrameId = params.callFrames?.[0]?.callFrameId; - if (callFrameId === undefined) { - await this.resume(); - return; - } - - for (const breakpointId of hitBreakpoints) { - const definition = this.breakpointDefinitions.get(breakpointId); - if (definition === undefined) { continue; } - for (const probeIndex of definition.probeIndices) { - await this.evaluateProbe(callFrameId, probeIndex); - } - } - - await this.resume(); - } - - async evaluateProbe(callFrameId, probeIndex) { - const probe = this.probes[probeIndex]; - const evaluation = await this.client.callMethod('Debugger.evaluateOnCallFrame', { - callFrameId, - expression: probe.expr, - generatePreview: true, - }); - - probe.hits++; - const result = { probe: probeIndex, event: 'hit', hit: probe.hits }; - - if (evaluation.exceptionDetails !== undefined) { - result.error = evaluation.result === undefined ? { - type: 'object', - subtype: 'error', - description: 'Probe expression failed', - } : trimRemoteObject(evaluation.result); - } else { - result.result = trimRemoteObject(evaluation.result); - } - - ArrayPrototypePush(this.results, result); - } - - async resume() { - if (this.finished) { return; } - await this.client.callMethod('Debugger.resume'); - } - - startTimeout() { - this.timeout = setTimeout(() => { this.finish('timeout'); }, this.options.timeout); - this.timeout.unref(); - } - - attachListeners() { - this.child.on('exit', this.onChildExit); - this.client.on('close', this.onClientClose); - this.client.on('Debugger.paused', this.onPaused); - } - - async bindBreakpoints() { - const uniqueLocations = new SafeMap(); - - for (let probeIndex = 0; probeIndex < this.probes.length; probeIndex++) { - const probe = this.probes[probeIndex]; - const key = `${probe.location.file}\n${probe.location.lineNumber}\n` + - `${probe.location.columnNumber === undefined ? '' : probe.location.columnNumber}`; - let entry = uniqueLocations.get(key); - if (entry === undefined) { - entry = { location: probe.location, probeIndices: [] }; - uniqueLocations.set(key, entry); - } - ArrayPrototypePush(entry.probeIndices, probeIndex); - } - - for (const { location, probeIndices } of uniqueLocations.values()) { - // TODO(joyeecheung): Normalize relative probe paths and avoid suffix matches that can - // bind unrelated loaded scripts with the same basename. - // On Windows, normalize backslashes to forward slashes so the regex matches - // V8 script URLs which always use forward slashes. - const normalizedFile = process.platform === 'win32' ? - SideEffectFreeRegExpPrototypeSymbolReplace(/\\/g, location.file, '/') : - location.file; - const escapedPath = SideEffectFreeRegExpPrototypeSymbolReplace( - /([/\\.?*()^${}|[\]])/g, - normalizedFile, - '\\$1', - ); - const params = { - urlRegex: `^(.*[\\/\\\\])?${escapedPath}$`, - lineNumber: location.lineNumber, - }; - if (location.columnNumber !== undefined) { - params.columnNumber = location.columnNumber; - } - - const result = await this.client.callMethod('Debugger.setBreakpointByUrl', params); - this.breakpointDefinitions.set(result.breakpointId, { probeIndices }); - } - } - - getPendingProbeIndices() { - const pending = []; - for (let probeIndex = 0; probeIndex < this.probes.length; probeIndex++) { - if (this.probes[probeIndex].hits === 0) { - ArrayPrototypePush(pending, probeIndex); - } - } - return pending; - } - - buildReport(state) { - const pending = this.getPendingProbeIndices(); - const report = { - v: kProbeVersion, - probes: ArrayPrototypeMap(this.probes, (probe) => { - return { expr: probe.expr, target: probe.target }; - }), - results: ArrayPrototypeSlice(this.results), - }; - - if (state === 'timeout') { - ArrayPrototypePush(report.results, { - event: 'timeout', - pending, - error: { - code: 'probe_timeout', - message: pending.length === 0 ? - `Timed out after ${this.options.timeout}ms waiting for target completion` : - `Timed out after ${this.options.timeout}ms waiting for probes: ` + - `${formatPendingProbeLocations(this.probes, pending)}`, - }, - }); - return { code: kGenericUserError, report }; - } - - if (state?.event === 'error') { - const error = { - __proto__: null, - code: 'probe_target_exit', - message: formatTargetExitMessage(this.probes, pending, state.exitCode, state.signal), - }; - if (state.exitCode !== null) { - error.exitCode = state.exitCode; - } - if (state.signal !== null) { - error.signal = state.signal; - } - error.stderr = state.stderr; - ArrayPrototypePush(report.results, { event: 'error', pending, error }); - return { code: kNoFailure, report }; - } - - if (pending.length === 0) { - ArrayPrototypePush(report.results, { event: 'completed' }); - } else { - ArrayPrototypePush(report.results, { event: 'miss', pending }); - } - - return { code: kNoFailure, report }; - } - - async cleanup() { - if (this.cleanupStarted) { return; } - this.cleanupStarted = true; - - if (this.timeout !== null) { - clearTimeout(this.timeout); - this.timeout = null; - } - - this.client.reset(); - - if (this.child === null) { return; } - - if (this.child.exitCode === null && this.child.signalCode === null) { - this.child.kill(); - } - } - - async run() { - try { - const { childArgv, host, port, skipPortPreflight } = this.options; - const { 0: child, 1: actualPort, 2: actualHost } = - await launchChildProcess(childArgv, - host, - port, - this.onChildOutput, - { skipPortPreflight }); - this.child = child; - this.attachListeners(); - - await this.client.connect(actualPort, actualHost); - await this.client.callMethod('Runtime.enable'); - await this.client.callMethod('Debugger.enable'); - await this.bindBreakpoints(); - this.started = true; - this.startTimeout(); - - await this.client.callMethod('Runtime.runIfWaitingForDebugger'); - - const state = await this.completionPromise; - return this.buildReport(state); - } finally { - await this.cleanup(); - } - } -} - function createAgentProxy(domain, client) { const agent = new EventEmitter(); agent.then = (then, _catch) => { @@ -1101,28 +273,7 @@ function startInspect(argv = ArrayPrototypeSlice(process.argv, 2), writeUsageAndExit(invokedAs); } - if (hasTopLevelProbeOption(argv)) { - let probeOptions; - try { - probeOptions = parseProbeArgv(argv); - } catch (error) { - writeUsageAndExit(invokedAs, error.message, kGenericUserError); - } - - (async () => { - const session = new ProbeInspectorSession(probeOptions); - const { code, report } = await session.run(); - stdout.write(probeOptions.json ? - `${JSONStringify(probeOptions.preview ? report : stripProbePreviews(report))}\n` : - buildProbeTextReport(report)); - process.exit(code); - })().catch((error) => { - if (error.childStderr) { - process.stderr.write(error.childStderr); - } - process.stderr.write(ensureTrailingNewline(error.message)); - process.exit(kGenericUserError); - }); + if (startProbeMode(invokedAs, argv, stdout)) { return; } diff --git a/lib/internal/debugger/inspect_helpers.js b/lib/internal/debugger/inspect_helpers.js new file mode 100644 index 00000000000000..61c07f4150441f --- /dev/null +++ b/lib/internal/debugger/inspect_helpers.js @@ -0,0 +1,132 @@ +'use strict'; + +const { + ArrayPrototypePushApply, + Number, + Promise, + RegExpPrototypeExec, + StringPrototypeEndsWith, +} = primordials; + +const { spawn } = require('child_process'); +const net = require('net'); +const { + setInterval: pSetInterval, + setTimeout: pSetTimeout, +} = require('timers/promises'); +const { + AbortController, +} = require('internal/abort_controller'); + +const { ERR_DEBUGGER_STARTUP_ERROR } = require('internal/errors').codes; +const { + exitCodes: { + kInvalidCommandLineArgument, + }, +} = internalBinding('errors'); + +const debugRegex = /Debugger listening on ws:\/\/\[?(.+?)\]?:(\d+)\//; + +async function portIsFree(host, port, timeout = 3000) { + if (port === 0) return; // Binding to a random port. + + const retryDelay = 150; + const ac = new AbortController(); + const { signal } = ac; + + pSetTimeout(timeout).then(() => ac.abort()); + + const asyncIterator = pSetInterval(retryDelay); + while (true) { + await asyncIterator.next(); + if (signal.aborted) { + throw new ERR_DEBUGGER_STARTUP_ERROR( + `Timeout (${timeout}) waiting for ${host}:${port} to be free`); + } + const error = await new Promise((resolve) => { + const socket = net.connect(port, host); + socket.on('error', resolve); + socket.on('connect', () => { + socket.end(); + resolve(); + }); + }); + if (error?.code === 'ECONNREFUSED') { + return; + } + } +} + +function ensureTrailingNewline(text) { + return StringPrototypeEndsWith(text, '\n') ? text : `${text}\n`; +} + +function writeUsageAndExit(invokedAs, message, exitCode = kInvalidCommandLineArgument) { + if (message) { + process.stderr.write(`${message}\n`); + } + const text = + `Usage: ${invokedAs} script.js\n` + + ` ${invokedAs} :\n` + + ` ${invokedAs} --port= Use 0 for random port assignment\n` + + ` ${invokedAs} -p \n` + + ` ${invokedAs} [--json] [--timeout=] [--port=] ` + + `--probe :[:] --expr ` + + `[--probe :[:] --expr ...] ` + + `[--] [ ...] [args...]\n`; + process.stderr.write(text); + process.exit(exitCode); +} + +async function launchChildProcess(childArgs, inspectHost, inspectPort, + childOutput, options = { __proto__: null }) { + if (!options.skipPortPreflight) { + await portIsFree(inspectHost, inspectPort); + } + + const args = [`--inspect-brk=${inspectPort}`]; + ArrayPrototypePushApply(args, childArgs); + + const child = spawn(process.execPath, args); + child.stdout.setEncoding('utf8'); + child.stderr.setEncoding('utf8'); + child.stdout.on('data', (chunk) => childOutput(chunk, 'stdout')); + child.stderr.on('data', (chunk) => childOutput(chunk, 'stderr')); + + let stderrOutput = ''; + return new Promise((resolve, reject) => { + function rejectLaunch(message) { + reject(new ERR_DEBUGGER_STARTUP_ERROR(message, { childStderr: stderrOutput })); + } + + function onExit(code, signal) { + const suffix = signal !== null ? ` (${signal})` : ` (code ${code})`; + rejectLaunch(`Target exited before the inspector was ready${suffix}`); + } + + function onError(error) { + rejectLaunch(error.message); + } + + function onStderr(text) { + stderrOutput += text; + const debug = RegExpPrototypeExec(debugRegex, stderrOutput); + if (debug) { + child.stderr.removeListener('data', onStderr); + child.removeListener('exit', onExit); + child.removeListener('error', onError); + resolve([child, Number(debug[2]), debug[1]]); + } + } + + child.once('exit', onExit); + child.once('error', onError); + child.stderr.on('data', onStderr); + }); +} + +module.exports = { + ensureTrailingNewline, + launchChildProcess, + writeUsageAndExit, +}; diff --git a/lib/internal/debugger/inspect_probe.js b/lib/internal/debugger/inspect_probe.js new file mode 100644 index 00000000000000..ccee22e1691fa5 --- /dev/null +++ b/lib/internal/debugger/inspect_probe.js @@ -0,0 +1,785 @@ +'use strict'; + +const { + ArrayFrom, + ArrayIsArray, + ArrayPrototypeJoin, + ArrayPrototypeMap, + ArrayPrototypePush, + ArrayPrototypeSlice, + FunctionPrototypeBind, + JSONStringify, + NumberIsNaN, + NumberParseInt, + ObjectEntries, + Promise, + RegExpPrototypeExec, + RegExpPrototypeSymbolSplit, + SafeMap, + SafeSet, + StringPrototypeIncludes, + StringPrototypeSlice, + StringPrototypeStartsWith, +} = primordials; + +const { clearTimeout, setTimeout } = require('timers'); +const util = require('util'); +const { SideEffectFreeRegExpPrototypeSymbolReplace } = require('internal/util'); + +const InspectClient = require('internal/debugger/inspect_client'); +const { + ensureTrailingNewline, + launchChildProcess, + writeUsageAndExit, +} = require('internal/debugger/inspect_helpers'); + +const { ERR_DEBUGGER_STARTUP_ERROR } = require('internal/errors').codes; +const { + exitCodes: { + kGenericUserError, + kNoFailure, + }, +} = internalBinding('errors'); + +const kProbeDefaultTimeout = 30000; +const kProbeVersion = 1; +const kProbeDisconnectSentinel = 'Waiting for the debugger to disconnect...'; +const kDigitsRegex = /^\d+$/; +const kInspectPortRegex = /^--inspect-port=(\d+)$/; +const kProbeArgOptions = { + __proto__: null, + expr: { type: 'string' }, + json: { type: 'boolean' }, + // Port and timeout use type 'string' because parseArgs has no + // numeric type; the values are parsed to integers in parseProbeArgv(). + port: { type: 'string' }, + preview: { type: 'boolean' }, + probe: { type: 'string' }, + timeout: { type: 'string' }, +}; + +function parseUnsignedInteger(value, name, allowZero = false) { + if (typeof value !== 'string' || RegExpPrototypeExec(kDigitsRegex, value) === null) { + throw new ERR_DEBUGGER_STARTUP_ERROR(`Invalid ${name}: ${value}`); + } + const parsed = NumberParseInt(value, 10); + if (NumberIsNaN(parsed) || (!allowZero && parsed < 1)) { + throw new ERR_DEBUGGER_STARTUP_ERROR(`Invalid ${name}: ${value}`); + } + return parsed; +} + +// Accepts file:line or file:line:column formats. +// Non-greedy (.+?) allows Windows drive-letter paths like C:\foo.js:10. +function parseProbeLocation(text) { + const match = RegExpPrototypeExec(/^(.+?):(\d+)(?::(\d+))?$/, text); + if (match === null) { + throw new ERR_DEBUGGER_STARTUP_ERROR(`Invalid probe location: ${text}`); + } + + const file = match[1]; + const line = parseUnsignedInteger(match[2], 'probe location'); + const column = match[3] !== undefined ? + parseUnsignedInteger(match[3], 'probe location') : undefined; + const target = column === undefined ? [file, line] : [file, line, column]; + + return { + file, + lineNumber: line - 1, + columnNumber: column === undefined ? undefined : column - 1, + target, + }; +} + +function formatPendingProbeLocations(probes, pending) { + const seen = new SafeSet(); + for (const probeIndex of pending) { + seen.add(ArrayPrototypeJoin(probes[probeIndex].target, ':')); + } + return ArrayPrototypeJoin(ArrayFrom(seen), ', '); +} + +function formatTargetExitMessage(probes, pending, exitCode, signal) { + const status = signal === null ? + `Target exited with code ${exitCode}` : + `Target exited with signal ${signal}`; + if (pending.length === 0) { + return `${status} before target completion`; + } + return `${status} before probes: ${formatPendingProbeLocations(probes, pending)}`; +} + +// Trim the "Waiting for the debugger to disconnect..." message from stderr for reporting child errors. +function trimProbeChildStderr(stderr) { + const lines = RegExpPrototypeSymbolSplit(/\r\n|\r|\n/g, stderr); + const kept = []; + for (let i = 0; i < lines.length; i++) { + const line = lines[i]; + if (line === '' && i === lines.length - 1) { continue; } + if (line === kProbeDisconnectSentinel) { continue; } + ArrayPrototypePush(kept, line); + } + return ArrayPrototypeJoin(kept, '\n'); +} + +function formatPreviewPropertyValue(property) { + if (property.type === 'string') { + return JSONStringify(property.value ?? ''); + } + return property.value ?? property.type; +} + +function trimRemoteObject(result) { + if (result === undefined || result === null || typeof result !== 'object') { + return result; + } + + if (ArrayIsArray(result)) { + return ArrayPrototypeMap(result, trimRemoteObject); + } + + const trimmed = { __proto__: null }; + for (const { 0: key, 1: value } of ObjectEntries(result)) { + if (key === 'objectId' || key === 'className') { + continue; + } + trimmed[key] = trimRemoteObject(value); + } + return trimmed; +} + +function stripProbePreviews(value) { + if (value === undefined || value === null || typeof value !== 'object') { + return value; + } + + if (ArrayIsArray(value)) { + return ArrayPrototypeMap(value, stripProbePreviews); + } + + const stripped = { __proto__: null }; + for (const { 0: key, 1: entry } of ObjectEntries(value)) { + if (key === 'preview') { + continue; + } + stripped[key] = stripProbePreviews(entry); + } + return stripped; +} + +// Format CDP RemoteObject values into more readable formats. +function formatRemoteObject(result) { + if (result === undefined) { return 'undefined'; } + + switch (result.type) { + case 'undefined': + return 'undefined'; + case 'string': + return JSONStringify(result.value); + case 'number': + if (result.unserializableValue !== undefined) { + return result.unserializableValue; + } + return `${result.value}`; + case 'boolean': + return `${result.value}`; + case 'symbol': + return result.description || 'Symbol()'; + case 'bigint': + return result.unserializableValue ?? result.description ?? '0n'; + case 'function': + return result.description || 'function()'; + case 'object': + if (result.subtype === 'null') { + return 'null'; + } + if (result.subtype === 'error') { + return result.description || 'Error'; + } + if (result.preview !== undefined) { + const properties = ArrayPrototypeJoin(ArrayPrototypeMap( + result.preview.properties, + result.preview.subtype === 'array' ? + (property) => formatPreviewPropertyValue(property) : + (property) => `${property.name}: ${formatPreviewPropertyValue(property)}`, + ), ', '); + const suffix = result.preview.overflow ? ', ...' : ''; + if (result.preview.subtype === 'array') { + return `[${properties}${suffix}]`; + } + return `{${properties}${suffix}}`; + } + return result.description || result.className || 'Object'; + default: + return `${result.value ?? result.description ?? ''}`; + } +} + +// Built human-readable text output for probe reports. +function buildProbeTextReport(report) { + const lines = []; + + for (const result of report.results) { + if (result.event === 'hit') { + const probe = report.probes[result.probe]; + const location = ArrayPrototypeJoin(probe.target, ':'); + ArrayPrototypePush(lines, `Hit ${result.hit} at ${location}`); + if (result.error !== undefined) { + ArrayPrototypePush(lines, + ` [error] ${probe.expr} = ` + + `${formatRemoteObject(result.error)}`); + } else { + ArrayPrototypePush(lines, + ` ${probe.expr} = ` + + `${formatRemoteObject(result.result)}`); + } + continue; + } + + if (result.event === 'completed') { + ArrayPrototypePush(lines, 'Completed'); + continue; + } + + if (result.event === 'miss') { + ArrayPrototypePush(lines, + `Missed probes: ` + + `${formatPendingProbeLocations(report.probes, result.pending)}`); + continue; + } + + if (result.event === 'timeout') { + ArrayPrototypePush(lines, result.error.message); + continue; + } + + if (result.event === 'error') { + ArrayPrototypePush(lines, result.error.message); + if (result.error.stderr !== undefined) { + ArrayPrototypePush(lines, ' [stderr]'); + const stderrLines = RegExpPrototypeSymbolSplit( + /\r\n|\r|\n/g, + result.error.stderr, + ); + for (let i = 0; i < stderrLines.length; i++) { + if (stderrLines[i] === '' && i === stderrLines.length - 1) { + continue; + } + ArrayPrototypePush(lines, ` ${stderrLines[i]}`); + } + } + } + } + + return ensureTrailingNewline(ArrayPrototypeJoin(lines, '\n')); +} + +function hasTopLevelProbeOption(args) { + const { tokens } = util.parseArgs({ + args, + allowPositionals: true, + options: kProbeArgOptions, + strict: false, + tokens: true, + }); + + for (const token of tokens) { + if (token.kind === 'option' && token.name === 'probe') { + return true; + } + + if (token.kind === 'option-terminator' || token.kind === 'positional') { + return false; + } + } + + return false; +} + +function parseProbeArgv(args) { + let port = 0; + let preview = false; + let timeout = kProbeDefaultTimeout; + let json = false; + let sawSeparator = false; + let childStartIndex = args.length; + let pendingLocation; + let expectedExprIndex = -1; + const probes = []; + + const { tokens } = util.parseArgs({ + args, + allowPositionals: true, + options: kProbeArgOptions, + strict: false, + tokens: true, + }); + + for (const token of tokens) { + if (token.kind === 'option-terminator') { + sawSeparator = true; + childStartIndex = token.index + 1; + break; + } + + if (pendingLocation !== undefined) { + if (token.kind === 'option' && + token.name === 'expr' && + token.index === expectedExprIndex && + token.value !== undefined) { + ArrayPrototypePush(probes, { + expr: token.value, + location: pendingLocation, + }); + pendingLocation = undefined; + continue; + } + + throw new ERR_DEBUGGER_STARTUP_ERROR( + 'Each --probe must be followed immediately by --expr '); + } + + if (token.kind === 'positional') { + childStartIndex = token.index; + break; + } + + switch (token.name) { + case 'json': + json = true; + break; + case 'timeout': + if (token.value === undefined) { + throw new ERR_DEBUGGER_STARTUP_ERROR(`Missing value for ${token.rawName}`); + } + timeout = parseUnsignedInteger(token.value, 'timeout', true); + break; + case 'port': + if (token.value === undefined) { + throw new ERR_DEBUGGER_STARTUP_ERROR(`Missing value for ${token.rawName}`); + } + port = parseUnsignedInteger(token.value, 'inspector port', true); + break; + case 'preview': + preview = true; + break; + case 'probe': + pendingLocation = parseProbeLocation(token.value); + expectedExprIndex = token.index + (token.inlineValue ? 1 : 2); + break; + case 'expr': + throw new ERR_DEBUGGER_STARTUP_ERROR('Unexpected --expr before --probe'); + default: + if (probes.length > 0) { + throw new ERR_DEBUGGER_STARTUP_ERROR( + 'Use -- before child Node.js flags in probe mode'); + } + throw new ERR_DEBUGGER_STARTUP_ERROR(`Unknown probe option: ${token.rawName}`); + } + } + + if (pendingLocation !== undefined) { + throw new ERR_DEBUGGER_STARTUP_ERROR( + 'Each --probe must be followed immediately by --expr '); + } + + if (probes.length === 0) { + throw new ERR_DEBUGGER_STARTUP_ERROR( + 'Probe mode requires at least one --probe --expr group'); + } + + const childArgv = ArrayPrototypeSlice(args, childStartIndex); + if (childArgv.length === 0) { + throw new ERR_DEBUGGER_STARTUP_ERROR('Probe mode requires a child script'); + } + + if (!sawSeparator && StringPrototypeStartsWith(childArgv[0], '-')) { + throw new ERR_DEBUGGER_STARTUP_ERROR('Use -- before child Node.js flags in probe mode'); + } + + let skipPortPreflight = port === 0; + for (const arg of childArgv) { + const inspectPortMatch = RegExpPrototypeExec(kInspectPortRegex, arg); + if (inspectPortMatch === null) { + continue; + } + if (inspectPortMatch[1] === '0') { + skipPortPreflight = true; + continue; + } + throw new ERR_DEBUGGER_STARTUP_ERROR( + 'Only child --inspect-port=0 is supported in probe mode'); + } + + return { + host: '127.0.0.1', + port, + preview, + timeout, + json, + probes, + childArgv, + skipPortPreflight, + }; +} + +class ProbeInspectorSession { + constructor(options) { + this.options = options; + this.client = new InspectClient(); + this.child = null; + this.cleanupStarted = false; + this.childStderr = ''; + this.disconnectRequested = false; + this.finished = false; + this.started = false; + this.stderrBuffer = ''; + this.breakpointDefinitions = new SafeMap(); + this.results = []; + this.timeout = null; + this.resolveCompletion = null; + this.completionPromise = new Promise((resolve) => { + this.resolveCompletion = resolve; + }); + this.probes = ArrayPrototypeMap(options.probes, (probe) => ({ + expr: probe.expr, + target: probe.location.target, + location: probe.location, + hits: 0, + })); + + this.onChildOutput = FunctionPrototypeBind(this.onChildOutput, this); + this.onChildExit = FunctionPrototypeBind(this.onChildExit, this); + this.onClientClose = FunctionPrototypeBind(this.onClientClose, this); + this.onPaused = FunctionPrototypeBind(this.onPaused, this); + } + + finish(state) { + if (this.finished) { return; } + this.finished = true; + if (this.timeout !== null) { + clearTimeout(this.timeout); + this.timeout = null; + } + this.resolveCompletion(state); + } + + onChildOutput(text, which) { + if (which !== 'stderr') { return; } + + if (this.started) { + this.childStderr += text; + } + + const combined = this.stderrBuffer + text; + if (this.started && + StringPrototypeIncludes(combined, kProbeDisconnectSentinel)) { + this.disconnectRequested = true; + this.client.reset(); + } + + if (combined.length > kProbeDisconnectSentinel.length) { + this.stderrBuffer = StringPrototypeSlice(combined, + combined.length - + kProbeDisconnectSentinel.length); + } else { + this.stderrBuffer = combined; + } + } + + onChildExit(code, signal) { + if (this.started) { + if (code !== 0 || signal !== null) { + this.finish({ + __proto__: null, + event: 'error', + exitCode: code, + signal, + stderr: trimProbeChildStderr(this.childStderr), + }); + } else { + this.finish('complete'); + } + } + } + + onClientClose() { + if (!this.started || this.child === null) { return; } + + // TODO(joyeecheung): Surface mid-probe inspector disconnects as terminal probe errors + // instead of deferring to timeout or miss classification. + if (this.disconnectRequested) { return; } + + if (this.child.exitCode !== null || this.child.signalCode !== null) { + this.onChildExit(this.child.exitCode, this.child.signalCode); + } + } + + onPaused(params) { + // TODO(joyeecheung): Preserve evaluation and resume failures as terminal probe errors + // instead of collapsing them into a synthetic completion. + this.handlePaused(params).catch((error) => { + if (!this.finished) { + if (error?.code === 'ERR_DEBUGGER_ERROR') { + if (this.child !== null && + (this.child.exitCode !== null || this.child.signalCode !== null)) { + this.onChildExit(this.child.exitCode, this.child.signalCode); + } + return; + } + this.finish('complete'); + } + }); + } + + async handlePaused(params) { + if (this.finished) { return; } + + const hitBreakpoints = params.hitBreakpoints; + if (hitBreakpoints === undefined || hitBreakpoints.length === 0) { + await this.resume(); + return; + } + + const callFrameId = params.callFrames?.[0]?.callFrameId; + if (callFrameId === undefined) { + await this.resume(); + return; + } + + for (const breakpointId of hitBreakpoints) { + const definition = this.breakpointDefinitions.get(breakpointId); + if (definition === undefined) { continue; } + for (const probeIndex of definition.probeIndices) { + await this.evaluateProbe(callFrameId, probeIndex); + } + } + + await this.resume(); + } + + async evaluateProbe(callFrameId, probeIndex) { + const probe = this.probes[probeIndex]; + const evaluation = await this.client.callMethod('Debugger.evaluateOnCallFrame', { + callFrameId, + expression: probe.expr, + generatePreview: true, + }); + + probe.hits++; + const result = { probe: probeIndex, event: 'hit', hit: probe.hits }; + + if (evaluation.exceptionDetails !== undefined) { + result.error = evaluation.result === undefined ? { + type: 'object', + subtype: 'error', + description: 'Probe expression failed', + } : trimRemoteObject(evaluation.result); + } else { + result.result = trimRemoteObject(evaluation.result); + } + + ArrayPrototypePush(this.results, result); + } + + async resume() { + if (this.finished) { return; } + await this.client.callMethod('Debugger.resume'); + } + + startTimeout() { + this.timeout = setTimeout(() => { this.finish('timeout'); }, this.options.timeout); + this.timeout.unref(); + } + + attachListeners() { + this.child.on('exit', this.onChildExit); + this.client.on('close', this.onClientClose); + this.client.on('Debugger.paused', this.onPaused); + } + + async bindBreakpoints() { + const uniqueLocations = new SafeMap(); + + for (let probeIndex = 0; probeIndex < this.probes.length; probeIndex++) { + const probe = this.probes[probeIndex]; + const key = `${probe.location.file}\n${probe.location.lineNumber}\n` + + `${probe.location.columnNumber === undefined ? '' : probe.location.columnNumber}`; + let entry = uniqueLocations.get(key); + if (entry === undefined) { + entry = { location: probe.location, probeIndices: [] }; + uniqueLocations.set(key, entry); + } + ArrayPrototypePush(entry.probeIndices, probeIndex); + } + + for (const { location, probeIndices } of uniqueLocations.values()) { + // TODO(joyeecheung): Normalize relative probe paths and avoid suffix matches that can + // bind unrelated loaded scripts with the same basename. + // On Windows, normalize backslashes to forward slashes so the regex matches + // V8 script URLs which always use forward slashes. + const normalizedFile = process.platform === 'win32' ? + SideEffectFreeRegExpPrototypeSymbolReplace(/\\/g, location.file, '/') : + location.file; + const escapedPath = SideEffectFreeRegExpPrototypeSymbolReplace( + /([/\\.?*()^${}|[\]])/g, + normalizedFile, + '\\$1', + ); + const params = { + urlRegex: `^(.*[\\/\\\\])?${escapedPath}$`, + lineNumber: location.lineNumber, + }; + if (location.columnNumber !== undefined) { + params.columnNumber = location.columnNumber; + } + + const result = await this.client.callMethod('Debugger.setBreakpointByUrl', params); + this.breakpointDefinitions.set(result.breakpointId, { probeIndices }); + } + } + + getPendingProbeIndices() { + const pending = []; + for (let probeIndex = 0; probeIndex < this.probes.length; probeIndex++) { + if (this.probes[probeIndex].hits === 0) { + ArrayPrototypePush(pending, probeIndex); + } + } + return pending; + } + + buildReport(state) { + const pending = this.getPendingProbeIndices(); + const report = { + v: kProbeVersion, + probes: ArrayPrototypeMap(this.probes, (probe) => { + return { expr: probe.expr, target: probe.target }; + }), + results: ArrayPrototypeSlice(this.results), + }; + + if (state === 'timeout') { + ArrayPrototypePush(report.results, { + event: 'timeout', + pending, + error: { + code: 'probe_timeout', + message: pending.length === 0 ? + `Timed out after ${this.options.timeout}ms waiting for target completion` : + `Timed out after ${this.options.timeout}ms waiting for probes: ` + + `${formatPendingProbeLocations(this.probes, pending)}`, + }, + }); + return { code: kGenericUserError, report }; + } + + if (state?.event === 'error') { + const error = { + __proto__: null, + code: 'probe_target_exit', + message: formatTargetExitMessage(this.probes, pending, state.exitCode, state.signal), + }; + if (state.exitCode !== null) { + error.exitCode = state.exitCode; + } + if (state.signal !== null) { + error.signal = state.signal; + } + error.stderr = state.stderr; + ArrayPrototypePush(report.results, { event: 'error', pending, error }); + return { code: kNoFailure, report }; + } + + if (pending.length === 0) { + ArrayPrototypePush(report.results, { event: 'completed' }); + } else { + ArrayPrototypePush(report.results, { event: 'miss', pending }); + } + + return { code: kNoFailure, report }; + } + + async cleanup() { + if (this.cleanupStarted) { return; } + this.cleanupStarted = true; + + if (this.timeout !== null) { + clearTimeout(this.timeout); + this.timeout = null; + } + + this.client.reset(); + + if (this.child === null) { return; } + + if (this.child.exitCode === null && this.child.signalCode === null) { + this.child.kill(); + } + } + + async run() { + try { + const { childArgv, host, port, skipPortPreflight } = this.options; + const { 0: child, 1: actualPort, 2: actualHost } = + await launchChildProcess(childArgv, + host, + port, + this.onChildOutput, + { skipPortPreflight }); + this.child = child; + this.attachListeners(); + + await this.client.connect(actualPort, actualHost); + await this.client.callMethod('Runtime.enable'); + await this.client.callMethod('Debugger.enable'); + await this.bindBreakpoints(); + this.started = true; + this.startTimeout(); + + await this.client.callMethod('Runtime.runIfWaitingForDebugger'); + + const state = await this.completionPromise; + return this.buildReport(state); + } finally { + await this.cleanup(); + } + } +} + +async function runProbeMode(stdout, probeOptions) { + try { + const session = new ProbeInspectorSession(probeOptions); + const { code, report } = await session.run(); + stdout.write(probeOptions.json ? + `${JSONStringify(probeOptions.preview ? report : stripProbePreviews(report))}\n` : + buildProbeTextReport(report)); + process.exit(code); + } catch (error) { + if (error.childStderr) { + process.stderr.write(error.childStderr); + } + process.stderr.write(ensureTrailingNewline(error.message)); + process.exit(kGenericUserError); + } +} + +function startProbeMode(invokedAs, args, stdout) { + if (!hasTopLevelProbeOption(args)) { + return false; + } + + let probeOptions; + try { + probeOptions = parseProbeArgv(args); + } catch (error) { + writeUsageAndExit(invokedAs, error.message, kGenericUserError); + } + + runProbeMode(stdout, probeOptions); + return true; +} + +module.exports = { + startProbeMode, +}; From 9ab960a07b7f599e6dc671e710fd741f08654da1 Mon Sep 17 00:00:00 2001 From: Ilyas Shabi Date: Fri, 1 May 2026 16:14:25 +0200 Subject: [PATCH 029/168] src: split profiling helpers from util Signed-off-by: ishabi PR-URL: https://github.com/nodejs/node/pull/63008 Reviewed-By: Joyee Cheung Reviewed-By: Anna Henningsen --- node.gyp | 2 + src/env.h | 1 + src/node_profiling.cc | 130 ++++++++++++++++++++++++++++++++++++++++++ src/node_profiling.h | 59 +++++++++++++++++++ src/node_v8.cc | 1 + src/node_worker.cc | 1 + src/util.cc | 96 ------------------------------- src/util.h | 20 ------- 8 files changed, 194 insertions(+), 116 deletions(-) create mode 100644 src/node_profiling.cc create mode 100644 src/node_profiling.h diff --git a/node.gyp b/node.gyp index 77acf529698db1..b129c3db8d88c1 100644 --- a/node.gyp +++ b/node.gyp @@ -141,6 +141,7 @@ 'src/node_os.cc', 'src/node_perf.cc', 'src/node_platform.cc', + 'src/node_profiling.cc', 'src/node_postmortem_metadata.cc', 'src/node_process_events.cc', 'src/node_process_methods.cc', @@ -283,6 +284,7 @@ 'src/node_perf.h', 'src/node_perf_common.h', 'src/node_platform.h', + 'src/node_profiling.h', 'src/node_process.h', 'src/node_process-inl.h', 'src/node_realm.h', diff --git a/src/env.h b/src/env.h index 5414edb1aea8ef..616f6e7d04109a 100644 --- a/src/env.h +++ b/src/env.h @@ -42,6 +42,7 @@ #include "node_main_instance.h" #include "node_options.h" #include "node_perf_common.h" +#include "node_profiling.h" #include "node_realm.h" #include "node_snapshotable.h" #include "permission/permission.h" diff --git a/src/node_profiling.cc b/src/node_profiling.cc new file mode 100644 index 00000000000000..bc403776c33f8e --- /dev/null +++ b/src/node_profiling.cc @@ -0,0 +1,130 @@ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +#include "node_profiling.h" + +#include "json_utils.h" +#include "util.h" + +#include + +namespace node { + +using v8::AllocationProfile; +using v8::HandleScope; +using v8::HeapProfiler; +using v8::Isolate; +using v8::Value; + +static void BuildHeapProfileNode(Isolate* isolate, + const AllocationProfile::Node* node, + JSONWriter* writer) { + size_t selfSize = 0; + for (const auto& allocation : node->allocations) + selfSize += allocation.size * allocation.count; + + writer->json_keyvalue("selfSize", selfSize); + writer->json_keyvalue("id", node->node_id); + writer->json_objectstart("callFrame"); + writer->json_keyvalue("scriptId", node->script_id); + writer->json_keyvalue("lineNumber", node->line_number - 1); + writer->json_keyvalue("columnNumber", node->column_number - 1); + Utf8Value name(isolate, node->name); + Utf8Value script_name(isolate, node->script_name); + writer->json_keyvalue("functionName", *name); + writer->json_keyvalue("url", *script_name); + writer->json_objectend(); + + writer->json_arraystart("children"); + for (const auto* child : node->children) { + writer->json_start(); + BuildHeapProfileNode(isolate, child, writer); + writer->json_end(); + } + writer->json_arrayend(); +} + +bool SerializeHeapProfile(Isolate* isolate, std::ostringstream& out_stream) { + HandleScope scope(isolate); + HeapProfiler* profiler = isolate->GetHeapProfiler(); + std::unique_ptr profile(profiler->GetAllocationProfile()); + if (!profile) { + return false; + } + profiler->StopSamplingHeapProfiler(); + JSONWriter writer(out_stream, true); + writer.json_start(); + + writer.json_arraystart("samples"); + for (const auto& sample : profile->GetSamples()) { + writer.json_start(); + writer.json_keyvalue("size", sample.size * sample.count); + writer.json_keyvalue("nodeId", sample.node_id); + writer.json_keyvalue("ordinal", static_cast(sample.sample_id)); + writer.json_end(); + } + writer.json_arrayend(); + + writer.json_objectstart("head"); + BuildHeapProfileNode(isolate, profile->GetRootNode(), &writer); + writer.json_objectend(); + + writer.json_end(); + return true; +} + +HeapProfileOptions ParseHeapProfileOptions( + const v8::FunctionCallbackInfo& args) { + HeapProfileOptions options; + CHECK_LE(args.Length(), 3); + if (args.Length() > 0) { + CHECK(args[0]->IsNumber()); + options.sample_interval = + static_cast(args[0].As()->Value()); + } + if (args.Length() > 1) { + CHECK(args[1]->IsInt32()); + options.stack_depth = args[1].As()->Value(); + } + if (args.Length() > 2) { + CHECK(args[2]->IsUint32()); + options.flags = static_cast( + args[2].As()->Value()); + } + return options; +} + +CpuProfileOptions ParseCpuProfileOptions( + const v8::FunctionCallbackInfo& args) { + CpuProfileOptions options; + CHECK_LE(args.Length(), 2); + if (args.Length() > 0) { + CHECK(args[0]->IsInt32()); + options.sampling_interval_us = args[0].As()->Value(); + } + if (args.Length() > 1) { + CHECK(args[1]->IsUint32()); + options.max_samples = args[1].As()->Value(); + } + return options; +} + +} // namespace node diff --git a/src/node_profiling.h b/src/node_profiling.h new file mode 100644 index 00000000000000..c6fc396cbc6ab1 --- /dev/null +++ b/src/node_profiling.h @@ -0,0 +1,59 @@ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +#ifndef SRC_NODE_PROFILING_H_ +#define SRC_NODE_PROFILING_H_ + +#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS + +#include "v8-profiler.h" +#include "v8.h" + +#include +#include + +namespace node { + +struct HeapProfileOptions { + uint64_t sample_interval = 512 * 1024; + int stack_depth = 16; + v8::HeapProfiler::SamplingFlags flags = + v8::HeapProfiler::SamplingFlags::kSamplingNoFlags; +}; + +HeapProfileOptions ParseHeapProfileOptions( + const v8::FunctionCallbackInfo& args); + +bool SerializeHeapProfile(v8::Isolate* isolate, std::ostringstream& out_stream); + +struct CpuProfileOptions { + int sampling_interval_us = 0; + uint32_t max_samples = v8::CpuProfilingOptions::kNoSampleLimit; +}; + +CpuProfileOptions ParseCpuProfileOptions( + const v8::FunctionCallbackInfo& args); + +} // namespace node + +#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS + +#endif // SRC_NODE_PROFILING_H_ diff --git a/src/node_v8.cc b/src/node_v8.cc index fc0f16d340bcd5..b49c29443a4287 100644 --- a/src/node_v8.cc +++ b/src/node_v8.cc @@ -26,6 +26,7 @@ #include "memory_tracker-inl.h" #include "node.h" #include "node_external_reference.h" +#include "node_profiling.h" #include "util-inl.h" #include "v8-profiler.h" #include "v8.h" diff --git a/src/node_worker.cc b/src/node_worker.cc index 7d131f61cf97a2..edc21e7e556157 100644 --- a/src/node_worker.cc +++ b/src/node_worker.cc @@ -8,6 +8,7 @@ #include "node_external_reference.h" #include "node_options-inl.h" #include "node_perf.h" +#include "node_profiling.h" #include "node_snapshot_builder.h" #include "permission/permission.h" #include "util-inl.h" diff --git a/src/util.cc b/src/util.cc index 4bc7ddea92905a..1ea51cf7012963 100644 --- a/src/util.cc +++ b/src/util.cc @@ -26,7 +26,6 @@ #include "debug_utils-inl.h" #include "env-inl.h" -#include "json_utils.h" #include "node_buffer.h" #include "node_errors.h" #include "node_internals.h" @@ -86,13 +85,10 @@ constexpr int kMaximumCopyMode = namespace node { -using v8::AllocationProfile; using v8::ArrayBuffer; using v8::ArrayBufferView; using v8::Context; using v8::FunctionTemplate; -using v8::HandleScope; -using v8::HeapProfiler; using v8::Isolate; using v8::Local; using v8::Object; @@ -816,96 +812,4 @@ v8::Maybe GetValidFileMode(Environment* env, return v8::Just(mode); } -static void BuildHeapProfileNode(Isolate* isolate, - const AllocationProfile::Node* node, - JSONWriter* writer) { - size_t selfSize = 0; - for (const auto& allocation : node->allocations) - selfSize += allocation.size * allocation.count; - - writer->json_keyvalue("selfSize", selfSize); - writer->json_keyvalue("id", node->node_id); - writer->json_objectstart("callFrame"); - writer->json_keyvalue("scriptId", node->script_id); - writer->json_keyvalue("lineNumber", node->line_number - 1); - writer->json_keyvalue("columnNumber", node->column_number - 1); - Utf8Value name(isolate, node->name); - Utf8Value script_name(isolate, node->script_name); - writer->json_keyvalue("functionName", *name); - writer->json_keyvalue("url", *script_name); - writer->json_objectend(); - - writer->json_arraystart("children"); - for (const auto* child : node->children) { - writer->json_start(); - BuildHeapProfileNode(isolate, child, writer); - writer->json_end(); - } - writer->json_arrayend(); -} - -bool SerializeHeapProfile(Isolate* isolate, std::ostringstream& out_stream) { - HandleScope scope(isolate); - HeapProfiler* profiler = isolate->GetHeapProfiler(); - std::unique_ptr profile(profiler->GetAllocationProfile()); - if (!profile) { - return false; - } - profiler->StopSamplingHeapProfiler(); - JSONWriter writer(out_stream, true); - writer.json_start(); - - writer.json_arraystart("samples"); - for (const auto& sample : profile->GetSamples()) { - writer.json_start(); - writer.json_keyvalue("size", sample.size * sample.count); - writer.json_keyvalue("nodeId", sample.node_id); - writer.json_keyvalue("ordinal", static_cast(sample.sample_id)); - writer.json_end(); - } - writer.json_arrayend(); - - writer.json_objectstart("head"); - BuildHeapProfileNode(isolate, profile->GetRootNode(), &writer); - writer.json_objectend(); - - writer.json_end(); - return true; -} - -HeapProfileOptions ParseHeapProfileOptions( - const v8::FunctionCallbackInfo& args) { - HeapProfileOptions options; - CHECK_LE(args.Length(), 3); - if (args.Length() > 0) { - CHECK(args[0]->IsNumber()); - options.sample_interval = - static_cast(args[0].As()->Value()); - } - if (args.Length() > 1) { - CHECK(args[1]->IsInt32()); - options.stack_depth = args[1].As()->Value(); - } - if (args.Length() > 2) { - CHECK(args[2]->IsUint32()); - options.flags = static_cast( - args[2].As()->Value()); - } - return options; -} - -CpuProfileOptions ParseCpuProfileOptions( - const v8::FunctionCallbackInfo& args) { - CpuProfileOptions options; - CHECK_LE(args.Length(), 2); - if (args.Length() > 0) { - CHECK(args[0]->IsInt32()); - options.sampling_interval_us = args[0].As()->Value(); - } - if (args.Length() > 1) { - CHECK(args[1]->IsUint32()); - options.max_samples = args[1].As()->Value(); - } - return options; -} } // namespace node diff --git a/src/util.h b/src/util.h index 28b69491a141a9..3dedeca4d227e9 100644 --- a/src/util.h +++ b/src/util.h @@ -1078,26 +1078,6 @@ inline v8::Local Uint32ToString(v8::Local context, ->ToString(context) .ToLocalChecked(); } -bool SerializeHeapProfile(v8::Isolate* isolate, std::ostringstream& out_stream); - -struct HeapProfileOptions { - uint64_t sample_interval = 512 * 1024; - int stack_depth = 16; - v8::HeapProfiler::SamplingFlags flags = - v8::HeapProfiler::SamplingFlags::kSamplingNoFlags; -}; - -HeapProfileOptions ParseHeapProfileOptions( - const v8::FunctionCallbackInfo& args); - -struct CpuProfileOptions { - int sampling_interval_us = 0; - uint32_t max_samples = v8::CpuProfilingOptions::kNoSampleLimit; -}; - -CpuProfileOptions ParseCpuProfileOptions( - const v8::FunctionCallbackInfo& args); - } // namespace node #endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS From d179c7ebca91e63d626f5ab642e9e6066baffc9a Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Fri, 1 May 2026 17:33:37 +0200 Subject: [PATCH 030/168] tools: migrate from `openssl-matrix.json` to `openssl-matrix.nix` Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/63036 Reviewed-By: Filip Skokan Reviewed-By: Colin Ihrig --- .github/workflows/test-shared.yml | 38 +++++--------- tools/dep_updaters/update-nixpkgs-pin.sh | 34 ++++++++++++- tools/nix/collect-openssl-matrix.sh | 65 ------------------------ tools/nix/openssl-matrix.json | 27 ---------- tools/nix/openssl-matrix.nix | 15 ++++++ tools/nix/sharedLibDeps.nix | 2 +- 6 files changed, 62 insertions(+), 119 deletions(-) delete mode 100755 tools/nix/collect-openssl-matrix.sh delete mode 100644 tools/nix/openssl-matrix.json create mode 100644 tools/nix/openssl-matrix.nix diff --git a/.github/workflows/test-shared.yml b/.github/workflows/test-shared.yml index e9d009fa95d6dd..f9a2df843c5572 100644 --- a/.github/workflows/test-shared.yml +++ b/.github/workflows/test-shared.yml @@ -172,6 +172,7 @@ jobs: name: 'aarch64-linux: Cache V8 build' outputs: local-cache: ${{ steps.upload.outcome != 'skipped' && 'true' || '' }} + matrix: ${{ steps.query.outputs.matrix }} steps: - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 with: @@ -227,25 +228,17 @@ jobs: name: libv8 path: libv8 - # Builds the matrix for `build-openssl` from tools/nix/openssl-matrix.json. - # Output shape: - # [{ "version": "3.6.1", "attr": "openssl_3_6", "continue-on-error": false }, ...] - collect-openssl-versions: - if: github.event.pull_request.draft == false - runs-on: ubuntu-slim - outputs: - matrix: ${{ steps.query.outputs.matrix }} - steps: - - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 - with: - persist-credentials: false - sparse-checkout: tools/nix/openssl-matrix.json - sparse-checkout-cone-mode: false - - id: query + - name: Collect matrix of support OpenSSL versions + id: query run: | { echo 'matrix<> "$GITHUB_OUTPUT" @@ -255,19 +248,16 @@ jobs: # entry, while all other shared libs remain at their defaults. Only runs on # a single runner/system (aarch64-linux) to keep the matrix to a minimum. build-openssl: - needs: - - build-aarch64-linux-v8 - - collect-openssl-versions + needs: build-aarch64-linux-v8 strategy: fail-fast: false matrix: - openssl: ${{ fromJSON(needs.collect-openssl-versions.outputs.matrix) }} - name: 'aarch64-linux: with shared ${{ matrix.openssl.attr }} (${{ matrix.openssl.version }})' + openssl: ${{ fromJSON(needs.build-aarch64-linux-v8.outputs.matrix) }} + name: 'aarch64-linux: with shared ${{ matrix.openssl.name }}' runs-on: ubuntu-24.04-arm - continue-on-error: ${{ matrix.openssl['continue-on-error'] }} + continue-on-error: false env: OPENSSL_ATTR: ${{ matrix.openssl.attr }} - OPENSSL_VERSION: ${{ matrix.openssl.version }} steps: - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 with: @@ -293,5 +283,5 @@ jobs: extra-nix-flags: | --arg useSeparateDerivationForV8 ${{ needs.build-aarch64-linux-v8.outputs.local-cache && '"$(nix-store --import < libv8)"' || 'true' }} \ --arg sharedLibDeps "(import $TAR_DIR/tools/nix/sharedLibDeps.nix {}) // { - openssl = (import $TAR_DIR/tools/nix/pkgs.nix { config.permittedInsecurePackages = [ \"openssl-$OPENSSL_VERSION\" ]; }).$OPENSSL_ATTR; + openssl = (import $TAR_DIR/tools/nix/openssl-matrix.nix {}).$OPENSSL_ATTR; }" \ diff --git a/tools/dep_updaters/update-nixpkgs-pin.sh b/tools/dep_updaters/update-nixpkgs-pin.sh index 271624a8da0fcb..97bcd878181c7b 100755 --- a/tools/dep_updaters/update-nixpkgs-pin.sh +++ b/tools/dep_updaters/update-nixpkgs-pin.sh @@ -5,7 +5,7 @@ set -ex BASE_DIR=$(cd "$(dirname "$0")/../.." && pwd) NIXPKGS_PIN_FILE="$BASE_DIR/tools/nix/pkgs.nix" -OPENSSL_MATRIX_FILE="$BASE_DIR/tools/nix/openssl-matrix.json" +OPENSSL_MATRIX_FILE="$BASE_DIR/tools/nix/openssl-matrix.nix" NIXPKGS_REPO=$(grep 'repo =' "$NIXPKGS_PIN_FILE" | awk -F'"' '{ print $2 }') CURRENT_VERSION_SHA1=$(grep 'rev =' "$NIXPKGS_PIN_FILE" | awk -F'"' '{ print $2 }') @@ -26,7 +26,37 @@ TMP_FILE=$(mktemp) sed "s/$CURRENT_VERSION_SHA1/$NEW_UPSTREAM_SHA1/;s/$CURRENT_TARBALL_HASH/$NEW_TARBALL_HASH/" "$NIXPKGS_PIN_FILE" > "$TMP_FILE" mv "$TMP_FILE" "$NIXPKGS_PIN_FILE" -"$BASE_DIR/tools/nix/collect-openssl-matrix.sh" | jq . > "$OPENSSL_MATRIX_FILE" +nix-instantiate -I "nixpkgs=$NIXPKGS_PIN_FILE" --eval --strict --json -E " + let + pkgs = import {}; + attrs = builtins.filter + (n: + let t = builtins.tryEval pkgs.\${n}; in + t.success && (builtins.tryEval t.value.version).success + ) + ( + builtins.filter + (n: builtins.match \"openssl_[0-9]+(_[0-9]+)?\" n != null) + (builtins.attrNames pkgs) + ); + in + { + inherit attrs; + permittedInsecurePackages = builtins.map (attr: pkgs.\${attr}.name) ( + builtins.filter (attr: (pkgs.\${attr}.meta.insecure)) attrs + ); + } +" | jq -r '"{ + pkgs ? import ./pkgs.nix { + config.permittedInsecurePackages = [ \(.permittedInsecurePackages | map(@json) | join(" ")) ]; + }, +}: + +{ + inherit (pkgs) + \(.attrs | join("\n ")) + ; +}"' > "$OPENSSL_MATRIX_FILE" cat -< $today or .extendedSupport == true) - | .cycle as $v - | ($nix - | map(select(.version | test("^" + ($v | gsub("\\."; "\\.")) + "([.a-z]|$)"))) - | first) as $m - | select($m != null) - | { - version: $m.version, - attr: $m.attr, - "continue-on-error": (cycle_tuple($v) > cycle_tuple($supported)) - } - ]' diff --git a/tools/nix/openssl-matrix.json b/tools/nix/openssl-matrix.json deleted file mode 100644 index ec1597df8cede9..00000000000000 --- a/tools/nix/openssl-matrix.json +++ /dev/null @@ -1,27 +0,0 @@ -[ - { - "version": "4.0.0", - "attr": "openssl_4_0", - "continue-on-error": false - }, - { - "version": "3.6.1", - "attr": "openssl_3_6", - "continue-on-error": false - }, - { - "version": "3.5.5", - "attr": "openssl_3_5", - "continue-on-error": false - }, - { - "version": "3.0.19", - "attr": "openssl_3", - "continue-on-error": false - }, - { - "version": "1.1.1w", - "attr": "openssl_1_1", - "continue-on-error": false - } -] diff --git a/tools/nix/openssl-matrix.nix b/tools/nix/openssl-matrix.nix new file mode 100644 index 00000000000000..3f9476acd7f7e0 --- /dev/null +++ b/tools/nix/openssl-matrix.nix @@ -0,0 +1,15 @@ +{ + pkgs ? import ./pkgs.nix { + config.permittedInsecurePackages = [ "openssl-1.1.1w" ]; + }, +}: + +{ + inherit (pkgs) + openssl_1_1 + openssl_3 + openssl_3_5 + openssl_3_6 + openssl_4_0 + ; +} diff --git a/tools/nix/sharedLibDeps.nix b/tools/nix/sharedLibDeps.nix index 524fd13308b72c..11ad545587f8b6 100644 --- a/tools/nix/sharedLibDeps.nix +++ b/tools/nix/sharedLibDeps.nix @@ -48,7 +48,7 @@ ffi = pkgs.libffiReal; }) // (pkgs.lib.optionalAttrs withSSL ({ - openssl = pkgs.openssl_3_5; + openssl = (import ./openssl-matrix.nix { inherit pkgs; }).openssl_3_5; })) // (pkgs.lib.optionalAttrs withTemporal { inherit (pkgs) temporal_capi; From 69a970f76814d40f55cf162d0cc3632fe8a7e599 Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Fri, 1 May 2026 18:18:51 +0200 Subject: [PATCH 031/168] tools: do not run `test-linux` on unrelated tools changes Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/63037 Reviewed-By: Yagiz Nizipli Reviewed-By: Luigi Pinca --- .github/workflows/test-linux.yml | 6 ++++++ .github/workflows/timezone-update.yml | 4 ++-- tools/{ => dep_updaters}/update-timezone.mjs | 2 +- 3 files changed, 9 insertions(+), 3 deletions(-) rename tools/{ => dep_updaters}/update-timezone.mjs (96%) diff --git a/.github/workflows/test-linux.yml b/.github/workflows/test-linux.yml index 8d878c26f74888..5887a99eb8b991 100644 --- a/.github/workflows/test-linux.yml +++ b/.github/workflows/test-linux.yml @@ -6,6 +6,9 @@ on: - .mailmap - README.md - vcbuild.bat + - tools/actions/** + - tools/clang-format/** + - tools/dep_updaters/** - test/internet/** - '**.nix' - .github/** @@ -21,6 +24,9 @@ on: - .mailmap - README.md - vcbuild.bat + - tools/actions/** + - tools/clang-format/** + - tools/dep_updaters/** - test/internet/** - '**.nix' - .github/** diff --git a/.github/workflows/timezone-update.yml b/.github/workflows/timezone-update.yml index 3901a589ab2fa2..4063115182c442 100644 --- a/.github/workflows/timezone-update.yml +++ b/.github/workflows/timezone-update.yml @@ -42,7 +42,7 @@ jobs: run: | echo "Comparing current version ${{ env.current_version }} to new version ${{ env.new_version }}" - - run: ./tools/update-timezone.mjs + - run: ./tools/dep_updaters/update-timezone.mjs if: ${{ env.new_version != env.current_version }} - name: Update the expected timezone version in test @@ -57,7 +57,7 @@ jobs: with: author: Node.js GitHub Bot body: | - This PR was generated by `.github/workflows/timezone-update.yml` and `tools/update-timezone.mjs`. + This PR was generated by `.github/workflows/timezone-update.yml` and `tools/dep_updaters/update-timezone.mjs`. Updates the ICU files as per the instructions present in https://github.com/nodejs/node/blob/main/doc/contributing/maintaining/maintaining-icu.md#time-zone-data diff --git a/tools/update-timezone.mjs b/tools/dep_updaters/update-timezone.mjs similarity index 96% rename from tools/update-timezone.mjs rename to tools/dep_updaters/update-timezone.mjs index bf3a706bdb0684..5462c1e2172f37 100755 --- a/tools/update-timezone.mjs +++ b/tools/dep_updaters/update-timezone.mjs @@ -1,5 +1,5 @@ #!/usr/bin/env node -// Usage: tools/update-timezone.mjs + import { execSync } from 'node:child_process'; import { renameSync, readdirSync, rmSync } from 'node:fs'; From 5e61a07d03569ecc6429b9dc00f3d2e42b7c818b Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Sat, 2 May 2026 00:08:25 +0200 Subject: [PATCH 032/168] stream: simplify `setPromiseHandled` utility MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/63032 Reviewed-By: Michaël Zasso Reviewed-By: Matteo Collina --- lib/internal/webstreams/util.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/internal/webstreams/util.js b/lib/internal/webstreams/util.js index 81e65815eabe6b..de92c11bb12573 100644 --- a/lib/internal/webstreams/util.js +++ b/lib/internal/webstreams/util.js @@ -178,7 +178,7 @@ function setPromiseHandled(promise) { // MarkAsHandled, but this avoids the extra boundary cross // and is hopefully faster at the cost of an extra Promise // allocation. - PromisePrototypeThen(promise, () => {}, () => {}); + PromisePrototypeThen(promise, undefined, () => {}); } async function nonOpFlush() {} From 11112fc6fd7af67a53958851fba8e5eb6d001fc1 Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Sat, 2 May 2026 11:49:00 +0200 Subject: [PATCH 033/168] tools: simplify `update-undici.sh` MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/63044 Reviewed-By: Michaël Zasso Reviewed-By: Richard Lau --- tools/dep_updaters/update-undici.sh | 25 ++++++++++--------------- 1 file changed, 10 insertions(+), 15 deletions(-) diff --git a/tools/dep_updaters/update-undici.sh b/tools/dep_updaters/update-undici.sh index 087038cfd45ed1..4ba532f99bf423 100755 --- a/tools/dep_updaters/update-undici.sh +++ b/tools/dep_updaters/update-undici.sh @@ -5,7 +5,7 @@ # This script must be in the tools directory when it runs because it uses the # script source file path to determine directories to work in. -set -e +set -ex ROOT=$(cd "$(dirname "$0")/../.." && pwd) DEPS_DIR="$ROOT/deps" @@ -40,29 +40,24 @@ compare_dependency_version "undici" "$NEW_VERSION" "$CURRENT_VERSION" rm -rf deps/undici/src rm -f deps/undici/undici.js -WORKSPACE=$(mktemp -d 2> /dev/null || mktemp -d -t 'tmp') -echo "$WORKSPACE" +TARBALL=$(mktemp 2> /dev/null || mktemp -t 'tmp') + cleanup () { EXIT_CODE=$? - [ -d "$WORKSPACE" ] && rm -rf "$WORKSPACE" + [ -e "$TARBALL" ] && rm "$TARBALL" exit $EXIT_CODE } trap cleanup INT TERM EXIT -UNDICI_ZIP="undici-$NEW_VERSION" -cd "$WORKSPACE" - echo "Fetching UNDICI source archive..." -curl -sL -o "$UNDICI_ZIP.zip" "https://github.com/nodejs/undici/archive/refs/tags/v$NEW_VERSION.zip" +curl -fsSLo "$TARBALL" "https://github.com/nodejs/undici/archive/refs/tags/v$NEW_VERSION.tar.gz" -log_and_verify_sha256sum "undici" "$UNDICI_ZIP.zip" +log_and_verify_sha256sum "undici" "$TARBALL" echo "Unzipping..." -unzip "$UNDICI_ZIP.zip" -d "src" -mv "src/$UNDICI_ZIP" "$DEPS_DIR/undici/src" -rm "$UNDICI_ZIP.zip" -cd "$ROOT" +tar -xzf "$TARBALL" -C "$DEPS_DIR/undici" +mv "$DEPS_DIR/undici"/undici-* "$DEPS_DIR/undici/src" ( cd "$DEPS_DIR/undici/src" @@ -96,8 +91,8 @@ cat > "$ROOT/src/undici_version.h" < Date: Sat, 2 May 2026 06:57:20 -0400 Subject: [PATCH 034/168] deps: update llhttp to 9.4.1 PR-URL: https://github.com/nodejs/node/pull/63045 Reviewed-By: Paolo Insogna Reviewed-By: Matteo Collina Reviewed-By: Tim Perry Reviewed-By: Marco Ippolito Reviewed-By: Luigi Pinca --- deps/llhttp/CMakeLists.txt | 45 ++- deps/llhttp/LICENSE | 4 +- deps/llhttp/README.md | 12 +- deps/llhttp/cmake/llhttpConfig.cmake.in | 19 + deps/llhttp/include/llhttp.h | 22 +- deps/llhttp/src/api.c | 8 + deps/llhttp/src/llhttp.c | 476 ++++++++++++++++-------- 7 files changed, 413 insertions(+), 173 deletions(-) create mode 100644 deps/llhttp/cmake/llhttpConfig.cmake.in diff --git a/deps/llhttp/CMakeLists.txt b/deps/llhttp/CMakeLists.txt index 6398043145c879..ebcddbcd478210 100644 --- a/deps/llhttp/CMakeLists.txt +++ b/deps/llhttp/CMakeLists.txt @@ -1,8 +1,9 @@ cmake_minimum_required(VERSION 3.25.0) cmake_policy(SET CMP0069 NEW) -project(llhttp VERSION 9.3.1) +project(llhttp VERSION 9.4.1) include(GNUInstallDirs) +include(CMakePackageConfigHelpers) set(CMAKE_C_STANDARD 99) @@ -66,18 +67,6 @@ function(config_library target) ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} ) - - install(FILES - ${CMAKE_CURRENT_SOURCE_DIR}/libllhttp.pc - DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig - ) - - # This is required to work with FetchContent - install(EXPORT llhttp - FILE llhttp-config.cmake - NAMESPACE llhttp:: - DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/llhttp - ) endfunction(config_library target) if(LLHTTP_BUILD_SHARED_LIBS) @@ -98,6 +87,36 @@ if(LLHTTP_BUILD_STATIC_LIBS) config_library(llhttp_static) endif() +if(TARGET llhttp_shared OR TARGET llhttp_static) + install(FILES + ${CMAKE_CURRENT_SOURCE_DIR}/libllhttp.pc + DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig + ) + + install(EXPORT llhttp + FILE llhttp-targets.cmake + NAMESPACE llhttp:: + DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/llhttp + ) + + configure_package_config_file( + ${CMAKE_CURRENT_SOURCE_DIR}/cmake/llhttpConfig.cmake.in + ${CMAKE_CURRENT_BINARY_DIR}/llhttpConfig.cmake + INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/llhttp + ) + + write_basic_package_version_file( + ${CMAKE_CURRENT_BINARY_DIR}/llhttpConfigVersion.cmake + COMPATIBILITY AnyNewerVersion + ) + + install(FILES + ${CMAKE_CURRENT_BINARY_DIR}/llhttpConfig.cmake + ${CMAKE_CURRENT_BINARY_DIR}/llhttpConfigVersion.cmake + DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/llhttp + ) +endif() + # On windows with Visual Studio, add a debug postfix so that release # and debug libraries can coexist. if(MSVC) diff --git a/deps/llhttp/LICENSE b/deps/llhttp/LICENSE index 6c1512dd6bcd6d..23682c03875844 100644 --- a/deps/llhttp/LICENSE +++ b/deps/llhttp/LICENSE @@ -1,6 +1,6 @@ -This software is licensed under the MIT License. +MIT License -Copyright Fedor Indutny, 2018. +Copyright © 2018 Fedor Indutny Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the diff --git a/deps/llhttp/README.md b/deps/llhttp/README.md index 008b7e622bc962..019a1d15226510 100644 --- a/deps/llhttp/README.md +++ b/deps/llhttp/README.md @@ -112,7 +112,7 @@ The following callbacks can return `0` (proceed normally), `-1` (error) or `HPE_ * `on_message_complete`: Invoked when a request/response has been completedly parsed. * `on_url_complete`: Invoked after the URL has been parsed. * `on_method_complete`: Invoked after the HTTP method has been parsed. -* `on_protocol_complete`: Invoked after the HTTP version has been parsed. +* `on_protocol_complete`: Invoked after the protocol has been parsed. * `on_version_complete`: Invoked after the HTTP version has been parsed. * `on_status_complete`: Invoked after the status code has been parsed. * `on_header_field_complete`: Invoked after a header name has been parsed. @@ -397,6 +397,16 @@ With this flag this check is disabled. **Enabling this flag can pose a security issue since you will be exposed to request smuggling attacks. USE WITH CAUTION!** +### `void llhttp_set_lenient_header_value_relaxed(llhttp_t* parser, int enabled)` + +Enables/disables relaxed handling of control characters in header values. + +Normally `llhttp` would error when header values contain characters not in the valid set (HTAB, SP, VCHAR, OBS_TEXT). With +this flag, control characters (except for NULL, CR & LF) will be accepted in header values. + +This does not create any known security issue, but does allow content considered 'invalid' by +[RFC 9110](https://www.rfc-editor.org/rfc/rfc9110#name-field-values) and so should be avoided by default. + ## Build Instructions Make sure you have [Node.js](https://nodejs.org/), npm and npx installed. Then under project directory run: diff --git a/deps/llhttp/cmake/llhttpConfig.cmake.in b/deps/llhttp/cmake/llhttpConfig.cmake.in new file mode 100644 index 00000000000000..4d7e02c775230e --- /dev/null +++ b/deps/llhttp/cmake/llhttpConfig.cmake.in @@ -0,0 +1,19 @@ +@PACKAGE_INIT@ + +include("${CMAKE_CURRENT_LIST_DIR}/llhttp-targets.cmake") + +if(NOT TARGET llhttp::llhttp) + if(TARGET llhttp::llhttp_shared) + add_library(llhttp::llhttp INTERFACE IMPORTED) + set_property(TARGET llhttp::llhttp PROPERTY + INTERFACE_LINK_LIBRARIES llhttp::llhttp_shared + ) + elseif(TARGET llhttp::llhttp_static) + add_library(llhttp::llhttp INTERFACE IMPORTED) + set_property(TARGET llhttp::llhttp PROPERTY + INTERFACE_LINK_LIBRARIES llhttp::llhttp_static + ) + endif() +endif() + +check_required_components(llhttp) diff --git a/deps/llhttp/include/llhttp.h b/deps/llhttp/include/llhttp.h index 194fee8c906ed3..0ef2f64712af7b 100644 --- a/deps/llhttp/include/llhttp.h +++ b/deps/llhttp/include/llhttp.h @@ -3,7 +3,7 @@ #define INCLUDE_LLHTTP_H_ #define LLHTTP_VERSION_MAJOR 9 -#define LLHTTP_VERSION_MINOR 3 +#define LLHTTP_VERSION_MINOR 4 #define LLHTTP_VERSION_PATCH 1 #ifndef INCLUDE_LLHTTP_ITSELF_H_ @@ -118,7 +118,8 @@ enum llhttp_lenient_flags { LENIENT_OPTIONAL_LF_AFTER_CR = 0x40, LENIENT_OPTIONAL_CRLF_AFTER_CHUNK = 0x80, LENIENT_OPTIONAL_CR_BEFORE_LF = 0x100, - LENIENT_SPACES_AFTER_CHUNK_SIZE = 0x200 + LENIENT_SPACES_AFTER_CHUNK_SIZE = 0x200, + LENIENT_HEADER_VALUE_RELAXED = 0x400 }; typedef enum llhttp_lenient_flags llhttp_lenient_flags_t; @@ -898,6 +899,23 @@ void llhttp_set_lenient_optional_crlf_after_chunk(llhttp_t* parser, int enabled) LLHTTP_EXPORT void llhttp_set_lenient_spaces_after_chunk_size(llhttp_t* parser, int enabled); +/* Enables/disables relaxed handling of unusual characters in header values. + * + * RFC 9110 describes NULL, CR and LF as 'dangerous' and says they MUST be + * rejected, while other control characters are merely 'invalid' and discouraged, + * and are explicitly allowed by other standards (e.g. WHATWG Fetch) and + * in surprisingly common use on the web. + * + * This flag enables these 'invalid but common' characters, aiming to + * maximize compatibility without enabling any potentially dangerous scenarios. + * + * Unlike `llhttp_set_lenient_headers()`, this does NOT enable any other + * potentially unsafe behaviors (like accepting whitespace before colons + * or after the start line). + */ +LLHTTP_EXPORT +void llhttp_set_lenient_header_value_relaxed(llhttp_t* parser, int enabled); + #ifdef __cplusplus } /* extern "C" */ #endif diff --git a/deps/llhttp/src/api.c b/deps/llhttp/src/api.c index 0245254177ac8c..ae5e862d98055a 100644 --- a/deps/llhttp/src/api.c +++ b/deps/llhttp/src/api.c @@ -316,6 +316,14 @@ void llhttp_set_lenient_spaces_after_chunk_size(llhttp_t* parser, int enabled) { } } +void llhttp_set_lenient_header_value_relaxed(llhttp_t* parser, int enabled) { + if (enabled) { + parser->lenient_flags |= LENIENT_HEADER_VALUE_RELAXED; + } else { + parser->lenient_flags &= ~LENIENT_HEADER_VALUE_RELAXED; + } +} + /* Callbacks */ diff --git a/deps/llhttp/src/llhttp.c b/deps/llhttp/src/llhttp.c index 515ba512abbdb0..7e21348b2bc874 100644 --- a/deps/llhttp/src/llhttp.c +++ b/deps/llhttp/src/llhttp.c @@ -40,195 +40,201 @@ static const unsigned char llparse_blob1[] = { static const unsigned char llparse_blob2[] = { 'l', 'o', 's', 'e' }; -static const unsigned char llparse_blob3[] = { - 'e', 'e', 'p', '-', 'a', 'l', 'i', 'v', 'e' +#ifdef __SSE4_2__ +static const unsigned char ALIGN(16) llparse_blob3[] = { + 0x1, 0x9, 0xb, 0xc, 0xe, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0 }; +#endif /* __SSE4_2__ */ static const unsigned char llparse_blob4[] = { - 'p', 'g', 'r', 'a', 'd', 'e' + 'e', 'e', 'p', '-', 'a', 'l', 'i', 'v', 'e' }; static const unsigned char llparse_blob5[] = { + 'p', 'g', 'r', 'a', 'd', 'e' +}; +static const unsigned char llparse_blob6[] = { 'c', 'h', 'u', 'n', 'k', 'e', 'd' }; #ifdef __SSE4_2__ -static const unsigned char ALIGN(16) llparse_blob6[] = { +static const unsigned char ALIGN(16) llparse_blob7[] = { 0x9, 0x9, ' ', '~', 0x80, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }; #endif /* __SSE4_2__ */ #ifdef __SSE4_2__ -static const unsigned char ALIGN(16) llparse_blob7[] = { +static const unsigned char ALIGN(16) llparse_blob8[] = { '!', '!', '#', '\'', '*', '+', '-', '.', '0', '9', 'A', 'Z', '^', 'z', '|', '|' }; #endif /* __SSE4_2__ */ #ifdef __SSE4_2__ -static const unsigned char ALIGN(16) llparse_blob8[] = { +static const unsigned char ALIGN(16) llparse_blob9[] = { '~', '~', 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }; #endif /* __SSE4_2__ */ -static const unsigned char llparse_blob9[] = { +static const unsigned char llparse_blob10[] = { 'e', 'n', 't', '-', 'l', 'e', 'n', 'g', 't', 'h' }; -static const unsigned char llparse_blob10[] = { +static const unsigned char llparse_blob11[] = { 'r', 'o', 'x', 'y', '-', 'c', 'o', 'n', 'n', 'e', 'c', 't', 'i', 'o', 'n' }; -static const unsigned char llparse_blob11[] = { +static const unsigned char llparse_blob12[] = { 'r', 'a', 'n', 's', 'f', 'e', 'r', '-', 'e', 'n', 'c', 'o', 'd', 'i', 'n', 'g' }; -static const unsigned char llparse_blob12[] = { +static const unsigned char llparse_blob13[] = { 'p', 'g', 'r', 'a', 'd', 'e' }; -static const unsigned char llparse_blob13[] = { +static const unsigned char llparse_blob14[] = { 'T', 'T', 'P' }; -static const unsigned char llparse_blob14[] = { +static const unsigned char llparse_blob15[] = { 0xd, 0xa, 0xd, 0xa, 'S', 'M', 0xd, 0xa, 0xd, 0xa }; -static const unsigned char llparse_blob15[] = { +static const unsigned char llparse_blob16[] = { 'C', 'E' }; -static const unsigned char llparse_blob16[] = { +static const unsigned char llparse_blob17[] = { 'T', 'S', 'P' }; -static const unsigned char llparse_blob17[] = { +static const unsigned char llparse_blob18[] = { 'N', 'O', 'U', 'N', 'C', 'E' }; -static const unsigned char llparse_blob18[] = { +static const unsigned char llparse_blob19[] = { 'I', 'N', 'D' }; -static const unsigned char llparse_blob19[] = { +static const unsigned char llparse_blob20[] = { 'E', 'C', 'K', 'O', 'U', 'T' }; -static const unsigned char llparse_blob20[] = { +static const unsigned char llparse_blob21[] = { 'N', 'E', 'C', 'T' }; -static const unsigned char llparse_blob21[] = { +static const unsigned char llparse_blob22[] = { 'E', 'T', 'E' }; -static const unsigned char llparse_blob22[] = { +static const unsigned char llparse_blob23[] = { 'C', 'R', 'I', 'B', 'E' }; -static const unsigned char llparse_blob23[] = { +static const unsigned char llparse_blob24[] = { 'L', 'U', 'S', 'H' }; -static const unsigned char llparse_blob24[] = { +static const unsigned char llparse_blob25[] = { 'E', 'T' }; -static const unsigned char llparse_blob25[] = { +static const unsigned char llparse_blob26[] = { 'P', 'A', 'R', 'A', 'M', 'E', 'T', 'E', 'R' }; -static const unsigned char llparse_blob26[] = { +static const unsigned char llparse_blob27[] = { 'E', 'A', 'D' }; -static const unsigned char llparse_blob27[] = { +static const unsigned char llparse_blob28[] = { 'N', 'K' }; -static const unsigned char llparse_blob28[] = { +static const unsigned char llparse_blob29[] = { 'C', 'K' }; -static const unsigned char llparse_blob29[] = { +static const unsigned char llparse_blob30[] = { 'S', 'E', 'A', 'R', 'C', 'H' }; -static const unsigned char llparse_blob30[] = { +static const unsigned char llparse_blob31[] = { 'R', 'G', 'E' }; -static const unsigned char llparse_blob31[] = { +static const unsigned char llparse_blob32[] = { 'C', 'T', 'I', 'V', 'I', 'T', 'Y' }; -static const unsigned char llparse_blob32[] = { +static const unsigned char llparse_blob33[] = { 'L', 'E', 'N', 'D', 'A', 'R' }; -static const unsigned char llparse_blob33[] = { +static const unsigned char llparse_blob34[] = { 'V', 'E' }; -static const unsigned char llparse_blob34[] = { +static const unsigned char llparse_blob35[] = { 'O', 'T', 'I', 'F', 'Y' }; -static const unsigned char llparse_blob35[] = { +static const unsigned char llparse_blob36[] = { 'P', 'T', 'I', 'O', 'N', 'S' }; -static const unsigned char llparse_blob36[] = { +static const unsigned char llparse_blob37[] = { 'C', 'H' }; -static const unsigned char llparse_blob37[] = { +static const unsigned char llparse_blob38[] = { 'S', 'E' }; -static const unsigned char llparse_blob38[] = { +static const unsigned char llparse_blob39[] = { 'A', 'Y' }; -static const unsigned char llparse_blob39[] = { +static const unsigned char llparse_blob40[] = { 'S', 'T' }; -static const unsigned char llparse_blob40[] = { +static const unsigned char llparse_blob41[] = { 'I', 'N', 'D' }; -static const unsigned char llparse_blob41[] = { +static const unsigned char llparse_blob42[] = { 'A', 'T', 'C', 'H' }; -static const unsigned char llparse_blob42[] = { +static const unsigned char llparse_blob43[] = { 'G', 'E' }; -static const unsigned char llparse_blob43[] = { +static const unsigned char llparse_blob44[] = { 'U', 'E', 'R', 'Y' }; -static const unsigned char llparse_blob44[] = { +static const unsigned char llparse_blob45[] = { 'I', 'N', 'D' }; -static const unsigned char llparse_blob45[] = { +static const unsigned char llparse_blob46[] = { 'O', 'R', 'D' }; -static const unsigned char llparse_blob46[] = { +static const unsigned char llparse_blob47[] = { 'I', 'R', 'E', 'C', 'T' }; -static const unsigned char llparse_blob47[] = { +static const unsigned char llparse_blob48[] = { 'O', 'R', 'T' }; -static const unsigned char llparse_blob48[] = { +static const unsigned char llparse_blob49[] = { 'R', 'C', 'H' }; -static const unsigned char llparse_blob49[] = { +static const unsigned char llparse_blob50[] = { 'P', 'A', 'R', 'A', 'M', 'E', 'T', 'E', 'R' }; -static const unsigned char llparse_blob50[] = { +static const unsigned char llparse_blob51[] = { 'U', 'R', 'C', 'E' }; -static const unsigned char llparse_blob51[] = { +static const unsigned char llparse_blob52[] = { 'B', 'S', 'C', 'R', 'I', 'B', 'E' }; -static const unsigned char llparse_blob52[] = { +static const unsigned char llparse_blob53[] = { 'A', 'R', 'D', 'O', 'W', 'N' }; -static const unsigned char llparse_blob53[] = { +static const unsigned char llparse_blob54[] = { 'A', 'C', 'E' }; -static const unsigned char llparse_blob54[] = { +static const unsigned char llparse_blob55[] = { 'I', 'N', 'D' }; -static const unsigned char llparse_blob55[] = { +static const unsigned char llparse_blob56[] = { 'N', 'K' }; -static const unsigned char llparse_blob56[] = { +static const unsigned char llparse_blob57[] = { 'C', 'K' }; -static const unsigned char llparse_blob57[] = { +static const unsigned char llparse_blob58[] = { 'U', 'B', 'S', 'C', 'R', 'I', 'B', 'E' }; -static const unsigned char llparse_blob58[] = { +static const unsigned char llparse_blob59[] = { 'T', 'T', 'P' }; -static const unsigned char llparse_blob59[] = { +static const unsigned char llparse_blob60[] = { 'C', 'E' }; -static const unsigned char llparse_blob60[] = { +static const unsigned char llparse_blob61[] = { 'T', 'S', 'P' }; -static const unsigned char llparse_blob61[] = { +static const unsigned char llparse_blob62[] = { 'A', 'D' }; -static const unsigned char llparse_blob62[] = { +static const unsigned char llparse_blob63[] = { 'T', 'P', '/' }; @@ -395,6 +401,7 @@ enum llparse_state_e { s_n_llhttp__internal__n_header_value_almost_done, s_n_llhttp__internal__n_invoke_test_lenient_flags_17, s_n_llhttp__internal__n_header_value_lenient, + s_n_llhttp__internal__n_header_value_relaxed, s_n_llhttp__internal__n_error_54, s_n_llhttp__internal__n_header_value_otherwise, s_n_llhttp__internal__n_header_value_connection_token, @@ -560,7 +567,7 @@ enum llparse_state_e { s_n_llhttp__internal__n_after_start_req, s_n_llhttp__internal__n_span_start_llhttp__on_method_1, s_n_llhttp__internal__n_res_line_almost_done, - s_n_llhttp__internal__n_invoke_test_lenient_flags_30, + s_n_llhttp__internal__n_invoke_test_lenient_flags_31, s_n_llhttp__internal__n_res_status, s_n_llhttp__internal__n_span_start_llhttp__on_status, s_n_llhttp__internal__n_res_status_code_otherwise, @@ -924,7 +931,7 @@ int llhttp__internal__c_test_flags_4( return (state->flags & 512) == 512; } -int llhttp__internal__c_test_lenient_flags_22( +int llhttp__internal__c_test_lenient_flags_23( llhttp__internal_t* state, const unsigned char* p, const unsigned char* endp) { @@ -991,6 +998,13 @@ int llhttp__internal__c_update_header_state_1( return 0; } +int llhttp__internal__c_test_lenient_flags_20( + llhttp__internal_t* state, + const unsigned char* p, + const unsigned char* endp) { + return (state->lenient_flags & 1024) == 1024; +} + int llhttp__internal__c_update_header_state_6( llhttp__internal_t* state, const unsigned char* p, @@ -1055,7 +1069,7 @@ int llhttp__internal__c_test_flags_3( return (state->flags & 8) == 8; } -int llhttp__internal__c_test_lenient_flags_20( +int llhttp__internal__c_test_lenient_flags_21( llhttp__internal_t* state, const unsigned char* p, const unsigned char* endp) { @@ -1123,7 +1137,7 @@ int llhttp__internal__c_store_http_minor( return 0; } -int llhttp__internal__c_test_lenient_flags_24( +int llhttp__internal__c_test_lenient_flags_25( llhttp__internal_t* state, const unsigned char* p, const unsigned char* endp) { @@ -2247,6 +2261,145 @@ static llparse_state_t llhttp__internal__run( } UNREACHABLE; } + case s_n_llhttp__internal__n_header_value_relaxed: + s_n_llhttp__internal__n_header_value_relaxed: { + static uint8_t lookup_table[] = { + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 + }; + if (p == endp) { + return s_n_llhttp__internal__n_header_value_relaxed; + } + #ifdef __SSE4_2__ + if (endp - p >= 16) { + __m128i ranges; + __m128i input; + int match_len; + + /* Load input */ + input = _mm_loadu_si128((__m128i const*) p); + ranges = _mm_loadu_si128((__m128i const*) llparse_blob3); + + /* Find first character that does not match `ranges` */ + match_len = _mm_cmpestri(ranges, 6, + input, 16, + _SIDD_UBYTE_OPS | _SIDD_CMP_RANGES | + _SIDD_NEGATIVE_POLARITY); + + if (match_len != 0) { + p += match_len; + goto s_n_llhttp__internal__n_header_value_relaxed; + } + goto s_n_llhttp__internal__n_header_value_otherwise; + } + #endif /* __SSE4_2__ */ + #if defined(__ARM_NEON__) || defined(__ARM_NEON) + while (endp - p >= 16) { + uint8x16_t input; + uint8x16_t single; + uint8x16_t mask; + uint8x8_t narrow; + uint64_t match_mask; + int match_len; + + /* Load input */ + input = vld1q_u8(p); + /* Find first character that does not match `ranges` */ + single = vandq_u8( + vcgeq_u8(input, vdupq_n_u8(0x1)), + vcleq_u8(input, vdupq_n_u8(0x9)) + ); + mask = single; + single = vandq_u8( + vcgeq_u8(input, vdupq_n_u8(0xb)), + vcleq_u8(input, vdupq_n_u8(0xc)) + ); + mask = vorrq_u8(mask, single); + single = vandq_u8( + vcgeq_u8(input, vdupq_n_u8(0xe)), + vcleq_u8(input, vdupq_n_u8(0xff)) + ); + mask = vorrq_u8(mask, single); + narrow = vshrn_n_u16(vreinterpretq_u16_u8(mask), 4); + match_mask = ~vget_lane_u64(vreinterpret_u64_u8(narrow), 0); + if (match_mask == 0) { + match_len = 16; + } else { + match_len = __builtin_ctzll(match_mask) >> 2; + } + if (match_len != 16) { + p += match_len; + goto s_n_llhttp__internal__n_header_value_otherwise; + } + p += 16; + } + if (p == endp) { + return s_n_llhttp__internal__n_header_value_relaxed; + } + #endif /* __ARM_NEON__ */ + #ifdef __wasm_simd128__ + while (endp - p >= 16) { + v128_t input; + v128_t mask; + v128_t single; + int match_len; + + /* Load input */ + input = wasm_v128_load(p); + /* Find first character that does not match `ranges` */ + single = wasm_v128_and( + wasm_i8x16_ge(input, wasm_u8x16_const_splat(0x1)), + wasm_i8x16_le(input, wasm_u8x16_const_splat(0x9)) + ); + mask = single; + single = wasm_v128_and( + wasm_i8x16_ge(input, wasm_u8x16_const_splat(0xb)), + wasm_i8x16_le(input, wasm_u8x16_const_splat(0xc)) + ); + mask = wasm_v128_or(mask, single); + single = wasm_v128_and( + wasm_i8x16_ge(input, wasm_u8x16_const_splat(0xe)), + wasm_i8x16_le(input, wasm_u8x16_const_splat(0xff)) + ); + mask = wasm_v128_or(mask, single); + match_len = __builtin_ctz( + ~wasm_i8x16_bitmask(mask) + ); + if (match_len != 16) { + p += match_len; + goto s_n_llhttp__internal__n_header_value_otherwise; + } + p += 16; + } + if (p == endp) { + return s_n_llhttp__internal__n_header_value_relaxed; + } + #endif /* __wasm_simd128__ */ + switch (lookup_table[(uint8_t) *p]) { + case 1: { + p++; + goto s_n_llhttp__internal__n_header_value_relaxed; + } + default: { + goto s_n_llhttp__internal__n_header_value_otherwise; + } + } + UNREACHABLE; + } case s_n_llhttp__internal__n_error_54: s_n_llhttp__internal__n_error_54: { state->error = 0xa; @@ -2368,7 +2521,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_header_value_connection_2; } - match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob3, 9); + match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob4, 9); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -2391,7 +2544,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_header_value_connection_3; } - match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob4, 6); + match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob5, 6); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -2463,6 +2616,10 @@ static llparse_state_t llhttp__internal__run( return s_n_llhttp__internal__n_header_value_content_length_ws; } switch (*p) { + case 9: { + p++; + goto s_n_llhttp__internal__n_header_value_content_length_ws; + } case 10: { goto s_n_llhttp__internal__n_invoke_or_flags_17; } @@ -2610,7 +2767,7 @@ static llparse_state_t llhttp__internal__run( /* Load input */ input = _mm_loadu_si128((__m128i const*) p); - ranges = _mm_loadu_si128((__m128i const*) llparse_blob6); + ranges = _mm_loadu_si128((__m128i const*) llparse_blob7); /* Find first character that does not match `ranges` */ match_len = _mm_cmpestri(ranges, 6, @@ -2782,7 +2939,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_header_value_te_chunked; } - match_seq = llparse__match_sequence_to_lower_unsafe(state, p, endp, llparse_blob5, 7); + match_seq = llparse__match_sequence_to_lower_unsafe(state, p, endp, llparse_blob6, 7); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -2906,7 +3063,7 @@ static llparse_state_t llhttp__internal__run( /* Load input */ input = _mm_loadu_si128((__m128i const*) p); - ranges = _mm_loadu_si128((__m128i const*) llparse_blob7); + ranges = _mm_loadu_si128((__m128i const*) llparse_blob8); /* Find first character that does not match `ranges` */ match_len = _mm_cmpestri(ranges, 16, @@ -2918,7 +3075,7 @@ static llparse_state_t llhttp__internal__run( p += match_len; goto s_n_llhttp__internal__n_header_field_general; } - ranges = _mm_loadu_si128((__m128i const*) llparse_blob8); + ranges = _mm_loadu_si128((__m128i const*) llparse_blob9); /* Find first character that does not match `ranges` */ match_len = _mm_cmpestri(ranges, 2, @@ -2993,7 +3150,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_header_field_4; } - match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob9, 10); + match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob10, 10); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -3060,7 +3217,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_header_field_5; } - match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob10, 15); + match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob11, 15); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -3084,7 +3241,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_header_field_6; } - match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob11, 16); + match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob12, 16); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -3108,7 +3265,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_header_field_7; } - match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob12, 6); + match_seq = llparse__match_sequence_to_lower(state, p, endp, llparse_blob13, 6); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -3290,7 +3447,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_req_pri_upgrade; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob14, 10); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob15, 10); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -3317,7 +3474,7 @@ static llparse_state_t llhttp__internal__run( goto s_n_llhttp__internal__n_headers_start; } default: { - goto s_n_llhttp__internal__n_invoke_test_lenient_flags_26; + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_27; } } UNREACHABLE; @@ -3330,7 +3487,7 @@ static llparse_state_t llhttp__internal__run( switch (*p) { case 10: { p++; - goto s_n_llhttp__internal__n_invoke_test_lenient_flags_25; + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_26; } case 13: { p++; @@ -3674,7 +3831,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_req_after_http_start_1; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob13, 3); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob14, 3); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -3719,7 +3876,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_req_after_http_start_2; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob15, 2); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob16, 2); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -3790,7 +3947,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_req_after_http_start_3; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob16, 3); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob17, 3); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -4491,7 +4648,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_3; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob17, 6); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob18, 6); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -4535,7 +4692,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_4; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob18, 3); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob19, 3); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -4559,7 +4716,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_6; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob19, 6); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob20, 6); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -4583,7 +4740,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_8; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob20, 4); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob21, 4); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -4664,7 +4821,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_12; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob21, 3); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob22, 3); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -4688,7 +4845,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_13; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob22, 5); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob23, 5); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -4748,7 +4905,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_14; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob23, 4); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob24, 4); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -4772,7 +4929,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_17; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob25, 9); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob26, 9); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -4813,7 +4970,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_15; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob24, 2); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob25, 2); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -4836,7 +4993,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_18; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob26, 3); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob27, 3); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -4860,7 +5017,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_20; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob27, 2); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob28, 2); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -4884,7 +5041,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_21; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob28, 2); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob29, 2); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -4928,7 +5085,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_23; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob29, 6); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob30, 6); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -4952,7 +5109,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_24; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob30, 3); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob31, 3); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -4976,7 +5133,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_26; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob31, 7); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob32, 7); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -5000,7 +5157,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_28; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob32, 6); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob33, 6); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -5081,7 +5238,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_30; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob33, 2); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob34, 2); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -5133,7 +5290,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_31; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob34, 5); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob35, 5); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -5157,7 +5314,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_32; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob35, 6); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob36, 6); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -5181,7 +5338,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_35; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob36, 2); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob37, 2); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -5205,7 +5362,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_36; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob37, 2); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob38, 2); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -5249,7 +5406,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_37; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob38, 2); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob39, 2); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -5273,7 +5430,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_38; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob39, 2); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob40, 2); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -5297,7 +5454,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_42; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob40, 3); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob41, 3); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -5321,7 +5478,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_43; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob41, 4); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob42, 4); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -5402,7 +5559,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_45; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob42, 2); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob43, 2); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -5479,7 +5636,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_46; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob43, 4); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob44, 4); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -5503,7 +5660,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_49; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob44, 3); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob45, 3); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -5527,7 +5684,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_50; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob45, 3); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob46, 3); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -5551,7 +5708,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_51; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob46, 5); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob47, 5); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -5575,7 +5732,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_52; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob47, 3); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob48, 3); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -5643,7 +5800,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_55; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob48, 3); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob49, 3); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -5684,7 +5841,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_58; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob49, 9); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob50, 9); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -5748,7 +5905,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_59; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob50, 4); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob51, 4); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -5772,7 +5929,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_60; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob51, 7); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob52, 7); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -5820,7 +5977,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_62; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob52, 6); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob53, 6); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -5844,7 +6001,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_63; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob53, 3); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob54, 3); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -5888,7 +6045,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_66; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob54, 3); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob55, 3); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -5912,7 +6069,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_68; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob55, 2); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob56, 2); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -5936,7 +6093,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_69; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob56, 2); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob57, 2); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -5980,7 +6137,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_after_start_req_70; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob57, 8); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob58, 8); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -6142,13 +6299,13 @@ static llparse_state_t llhttp__internal__run( goto s_n_llhttp__internal__n_invoke_llhttp__on_status_complete; } default: { - goto s_n_llhttp__internal__n_invoke_test_lenient_flags_29; + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_30; } } UNREACHABLE; } - case s_n_llhttp__internal__n_invoke_test_lenient_flags_30: - s_n_llhttp__internal__n_invoke_test_lenient_flags_30: { + case s_n_llhttp__internal__n_invoke_test_lenient_flags_31: + s_n_llhttp__internal__n_invoke_test_lenient_flags_31: { switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { case 1: goto s_n_llhttp__internal__n_invoke_llhttp__on_status_complete; @@ -6194,7 +6351,7 @@ static llparse_state_t llhttp__internal__run( switch (*p) { case 10: { p++; - goto s_n_llhttp__internal__n_invoke_test_lenient_flags_28; + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_29; } case 13: { p++; @@ -6654,7 +6811,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_res_after_start_1; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob58, 3); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob59, 3); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -6677,7 +6834,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_res_after_start_2; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob59, 2); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob60, 2); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -6700,7 +6857,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_res_after_start_3; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob60, 3); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob61, 3); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -6769,7 +6926,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_req_or_res_method_2; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob61, 2); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob62, 2); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -6801,7 +6958,7 @@ static llparse_state_t llhttp__internal__run( if (p == endp) { return s_n_llhttp__internal__n_req_or_res_method_3; } - match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob62, 3); + match_seq = llparse__match_sequence_id(state, p, endp, llparse_blob63, 3); p = match_seq.current; switch (match_seq.status) { case kMatchComplete: { @@ -8265,12 +8422,21 @@ static llparse_state_t llhttp__internal__run( goto s_n_llhttp__internal__n_error_54; UNREACHABLE; } + s_n_llhttp__internal__n_invoke_test_lenient_flags_20: { + switch (llhttp__internal__c_test_lenient_flags_20(state, p, endp)) { + case 1: + goto s_n_llhttp__internal__n_header_value_relaxed; + default: + goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_3; + } + UNREACHABLE; + } s_n_llhttp__internal__n_invoke_test_lenient_flags_19: { switch (llhttp__internal__c_test_lenient_flags(state, p, endp)) { case 1: goto s_n_llhttp__internal__n_header_value_lenient; default: - goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_3; + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_20; } UNREACHABLE; } @@ -8458,8 +8624,8 @@ static llparse_state_t llhttp__internal__run( goto s_n_llhttp__internal__n_error_58; UNREACHABLE; } - s_n_llhttp__internal__n_invoke_test_lenient_flags_20: { - switch (llhttp__internal__c_test_lenient_flags_20(state, p, endp)) { + s_n_llhttp__internal__n_invoke_test_lenient_flags_21: { + switch (llhttp__internal__c_test_lenient_flags_21(state, p, endp)) { case 0: goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_8; default: @@ -8470,7 +8636,7 @@ static llparse_state_t llhttp__internal__run( s_n_llhttp__internal__n_invoke_load_type_1: { switch (llhttp__internal__c_load_type(state, p, endp)) { case 1: - goto s_n_llhttp__internal__n_invoke_test_lenient_flags_20; + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_21; default: goto s_n_llhttp__internal__n_header_value_te_chunked; } @@ -8497,8 +8663,8 @@ static llparse_state_t llhttp__internal__run( } UNREACHABLE; } - s_n_llhttp__internal__n_invoke_test_lenient_flags_21: { - switch (llhttp__internal__c_test_lenient_flags_20(state, p, endp)) { + s_n_llhttp__internal__n_invoke_test_lenient_flags_22: { + switch (llhttp__internal__c_test_lenient_flags_21(state, p, endp)) { case 0: goto s_n_llhttp__internal__n_span_end_llhttp__on_header_value_9; default: @@ -8509,7 +8675,7 @@ static llparse_state_t llhttp__internal__run( s_n_llhttp__internal__n_invoke_load_type_2: { switch (llhttp__internal__c_load_type(state, p, endp)) { case 1: - goto s_n_llhttp__internal__n_invoke_test_lenient_flags_21; + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_22; default: goto s_n_llhttp__internal__n_invoke_or_flags_19; } @@ -8553,8 +8719,8 @@ static llparse_state_t llhttp__internal__run( } UNREACHABLE; } - s_n_llhttp__internal__n_invoke_test_lenient_flags_22: { - switch (llhttp__internal__c_test_lenient_flags_22(state, p, endp)) { + s_n_llhttp__internal__n_invoke_test_lenient_flags_23: { + switch (llhttp__internal__c_test_lenient_flags_23(state, p, endp)) { case 0: goto s_n_llhttp__internal__n_error_60; default: @@ -8565,7 +8731,7 @@ static llparse_state_t llhttp__internal__run( s_n_llhttp__internal__n_invoke_test_flags_4: { switch (llhttp__internal__c_test_flags_4(state, p, endp)) { case 1: - goto s_n_llhttp__internal__n_invoke_test_lenient_flags_22; + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_23; default: goto s_n_llhttp__internal__n_header_value_discard_ws; } @@ -8579,8 +8745,8 @@ static llparse_state_t llhttp__internal__run( return s_error; UNREACHABLE; } - s_n_llhttp__internal__n_invoke_test_lenient_flags_23: { - switch (llhttp__internal__c_test_lenient_flags_22(state, p, endp)) { + s_n_llhttp__internal__n_invoke_test_lenient_flags_24: { + switch (llhttp__internal__c_test_lenient_flags_23(state, p, endp)) { case 0: goto s_n_llhttp__internal__n_error_61; default: @@ -8591,7 +8757,7 @@ static llparse_state_t llhttp__internal__run( s_n_llhttp__internal__n_invoke_test_flags_5: { switch (llhttp__internal__c_test_flags_2(state, p, endp)) { case 1: - goto s_n_llhttp__internal__n_invoke_test_lenient_flags_23; + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_24; default: goto s_n_llhttp__internal__n_header_value_discard_ws; } @@ -8798,7 +8964,7 @@ static llparse_state_t llhttp__internal__run( return s_error; UNREACHABLE; } - s_n_llhttp__internal__n_invoke_test_lenient_flags_26: { + s_n_llhttp__internal__n_invoke_test_lenient_flags_27: { switch (llhttp__internal__c_test_lenient_flags_8(state, p, endp)) { case 1: goto s_n_llhttp__internal__n_headers_start; @@ -8815,7 +8981,7 @@ static llparse_state_t llhttp__internal__run( return s_error; UNREACHABLE; } - s_n_llhttp__internal__n_invoke_test_lenient_flags_25: { + s_n_llhttp__internal__n_invoke_test_lenient_flags_26: { switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { case 1: goto s_n_llhttp__internal__n_req_http_complete_crlf; @@ -8922,8 +9088,8 @@ static llparse_state_t llhttp__internal__run( } UNREACHABLE; } - s_n_llhttp__internal__n_invoke_test_lenient_flags_24: { - switch (llhttp__internal__c_test_lenient_flags_24(state, p, endp)) { + s_n_llhttp__internal__n_invoke_test_lenient_flags_25: { + switch (llhttp__internal__c_test_lenient_flags_25(state, p, endp)) { case 1: goto s_n_llhttp__internal__n_span_end_llhttp__on_version_1; default: @@ -8934,7 +9100,7 @@ static llparse_state_t llhttp__internal__run( s_n_llhttp__internal__n_invoke_store_http_minor: { switch (llhttp__internal__c_store_http_minor(state, p, endp, match)) { default: - goto s_n_llhttp__internal__n_invoke_test_lenient_flags_24; + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_25; } UNREACHABLE; } @@ -9567,7 +9733,7 @@ static llparse_state_t llhttp__internal__run( return s_error; UNREACHABLE; } - s_n_llhttp__internal__n_invoke_test_lenient_flags_28: { + s_n_llhttp__internal__n_invoke_test_lenient_flags_29: { switch (llhttp__internal__c_test_lenient_flags_1(state, p, endp)) { case 1: goto s_n_llhttp__internal__n_invoke_llhttp__on_status_complete; @@ -9584,7 +9750,7 @@ static llparse_state_t llhttp__internal__run( return s_error; UNREACHABLE; } - s_n_llhttp__internal__n_invoke_test_lenient_flags_29: { + s_n_llhttp__internal__n_invoke_test_lenient_flags_30: { switch (llhttp__internal__c_test_lenient_flags_8(state, p, endp)) { case 1: goto s_n_llhttp__internal__n_invoke_llhttp__on_status_complete; @@ -9611,11 +9777,11 @@ static llparse_state_t llhttp__internal__run( if (err != 0) { state->error = err; state->error_pos = (const char*) (p + 1); - state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_test_lenient_flags_30; + state->_current = (void*) (intptr_t) s_n_llhttp__internal__n_invoke_test_lenient_flags_31; return s_error; } p++; - goto s_n_llhttp__internal__n_invoke_test_lenient_flags_30; + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_31; UNREACHABLE; } s_n_llhttp__internal__n_span_end_llhttp__on_status_1: { @@ -9799,8 +9965,8 @@ static llparse_state_t llhttp__internal__run( } UNREACHABLE; } - s_n_llhttp__internal__n_invoke_test_lenient_flags_27: { - switch (llhttp__internal__c_test_lenient_flags_24(state, p, endp)) { + s_n_llhttp__internal__n_invoke_test_lenient_flags_28: { + switch (llhttp__internal__c_test_lenient_flags_25(state, p, endp)) { case 1: goto s_n_llhttp__internal__n_span_end_llhttp__on_version_6; default: @@ -9811,7 +9977,7 @@ static llparse_state_t llhttp__internal__run( s_n_llhttp__internal__n_invoke_store_http_minor_1: { switch (llhttp__internal__c_store_http_minor(state, p, endp, match)) { default: - goto s_n_llhttp__internal__n_invoke_test_lenient_flags_27; + goto s_n_llhttp__internal__n_invoke_test_lenient_flags_28; } UNREACHABLE; } From b2f6aa30653b14f30dc7364b17ddd9a1b85e790e Mon Sep 17 00:00:00 2001 From: bugyaluwang Date: Sun, 3 May 2026 11:04:40 +0800 Subject: [PATCH 035/168] inspector: fix absolute URLs in network http Some HTTP clients send an absolute URL in request.path. The network inspection code always prefixed request.protocol and host, which produced duplicated URLs such as http://hosthttp://host/path in Network.requestWillBeSent and Network.responseReceived. Handle absolute URL paths directly and keep the existing relative-path behavior unchanged. Extend the HTTP inspector test to cover both GET and POST requests that use an absolute URL as options.path and verify that getResponseBody still returns the expected payload. Signed-off-by: GrinZero <774933704@qq.com> PR-URL: https://github.com/nodejs/node/pull/62955 Reviewed-By: Ryuhei Shima Reviewed-By: Chengzhong Wu --- lib/internal/inspector/network_http.js | 16 +- test/parallel/test-inspector-network-http.js | 190 ++++++++++++++++--- 2 files changed, 175 insertions(+), 31 deletions(-) diff --git a/lib/internal/inspector/network_http.js b/lib/internal/inspector/network_http.js index 8d324c8c544eea..46bdd827c094a1 100644 --- a/lib/internal/inspector/network_http.js +++ b/lib/internal/inspector/network_http.js @@ -5,6 +5,7 @@ const { DateNow, ObjectEntries, String, + StringPrototypeStartsWith, Symbol, } = primordials; @@ -21,6 +22,19 @@ const EventEmitter = require('events'); const kRequestUrl = Symbol('kRequestUrl'); +function isAbsoluteURLPath(path) { + return typeof path === 'string' && + (StringPrototypeStartsWith(path, 'http://') || + StringPrototypeStartsWith(path, 'https://')); +} + +function getRequestURL(request, host) { + if (isAbsoluteURLPath(request.path)) { + return request.path; + } + return `${request.protocol}//${host}${request.path}`; +} + // Convert a Headers object (Map) to a plain object (Map) const convertHeaderObject = (headers = {}) => { // The 'host' header that contains the host and port of the URL. @@ -62,7 +76,7 @@ function onClientRequestCreated({ request }) { request[kInspectorRequestId] = getNextRequestId(); const { 0: headers, 1: host, 2: charset } = convertHeaderObject(request.getHeaders()); - const url = `${request.protocol}//${host}${request.path}`; + const url = getRequestURL(request, host); request[kRequestUrl] = url; Network.requestWillBeSent({ diff --git a/test/parallel/test-inspector-network-http.js b/test/parallel/test-inspector-network-http.js index 3f0014f2459253..88d717d83c896a 100644 --- a/test/parallel/test-inspector-network-http.js +++ b/test/parallel/test-inspector-network-http.js @@ -32,9 +32,28 @@ const setResponseHeaders = (res) => { const kTimeout = 1000; const kDelta = 200; +const kDefaultResponseHeaders = { + 'server': 'node', + 'etag': '12345', + 'set-cookie': 'key1=value1\nkey2=value2', + 'x-header2': 'value1, value2', +}; + +function getDefaultResponseExpect(url) { + return { + url, + mimeType: 'text/plain', + charset: 'utf-8', + responseHeaders: kDefaultResponseHeaders, + }; +} + +function getPathName(req) { + return new URL(req.url, `http://${req.headers.host}`).pathname; +} const handleRequest = (req, res) => { - const path = req.url; + const path = getPathName(req); switch (path) { case '/hello-world': setResponseHeaders(res); @@ -46,6 +65,22 @@ const handleRequest = (req, res) => { res.end('hello world\n'); }, kTimeout); break; + case '/echo-post': { + const chunks = []; + req.on('data', (chunk) => { + chunks.push(chunk); + }); + req.on('end', () => { + const body = Buffer.concat(chunks).toString(); + res.setHeader('Content-Type', 'application/json; charset=utf-8'); + res.writeHead(200); + res.end(JSON.stringify({ + method: req.method, + body, + })); + }); + break; + } default: assert.fail(`Unexpected path: ${path}`); } @@ -77,7 +112,7 @@ function verifyRequestWillBeSent({ method, params }, expect) { assert.ok(params.requestId.startsWith('node-network-event-')); assert.strictEqual(params.request.url, expect.url); - assert.strictEqual(params.request.method, 'GET'); + assert.strictEqual(params.request.method, expect.method ?? 'GET'); assert.strictEqual(typeof params.request.headers, 'object'); assert.strictEqual(params.request.headers['accept-language'], 'en-US'); assert.strictEqual(params.request.headers.cookie, 'k1=v1; k2=v2'); @@ -103,12 +138,20 @@ function verifyResponseReceived({ method, params }, expect) { assert.strictEqual(params.response.statusText, 'OK'); assert.strictEqual(params.response.url, expect.url); assert.strictEqual(typeof params.response.headers, 'object'); - assert.strictEqual(params.response.headers.server, 'node'); - assert.strictEqual(params.response.headers.etag, '12345'); - assert.strictEqual(params.response.headers['set-cookie'], 'key1=value1\nkey2=value2'); - assert.strictEqual(params.response.headers['x-header2'], 'value1, value2'); - assert.strictEqual(params.response.mimeType, 'text/plain'); - assert.strictEqual(params.response.charset, 'utf-8'); + if (expect.responseHeaders?.server) { + assert.strictEqual(params.response.headers.server, expect.responseHeaders.server); + } + if (expect.responseHeaders?.etag) { + assert.strictEqual(params.response.headers.etag, expect.responseHeaders.etag); + } + if (expect.responseHeaders?.['set-cookie']) { + assert.strictEqual(params.response.headers['set-cookie'], expect.responseHeaders['set-cookie']); + } + if (expect.responseHeaders?.['x-header2']) { + assert.strictEqual(params.response.headers['x-header2'], expect.responseHeaders['x-header2']); + } + assert.strictEqual(params.response.mimeType, expect.mimeType); + assert.strictEqual(params.response.charset, expect.charset); return params; } @@ -151,17 +194,46 @@ function verifyHttpResponse(response) { })); } -async function testHttpGet() { - const url = `http://127.0.0.1:${httpServer.address().port}/hello-world`; +function drainHttpResponse(response) { + response.resume(); +} + +function createRequestTracker(url, responseExpect, requestExpect = {}) { const requestWillBeSentFuture = once(session, 'Network.requestWillBeSent') - .then(([event]) => verifyRequestWillBeSent(event, { url })); + .then(([event]) => verifyRequestWillBeSent(event, { + url, + method: requestExpect.method, + })); const responseReceivedFuture = once(session, 'Network.responseReceived') - .then(([event]) => verifyResponseReceived(event, { url })); + .then(([event]) => verifyResponseReceived(event, responseExpect)); const loadingFinishedFuture = once(session, 'Network.loadingFinished') .then(([event]) => verifyLoadingFinished(event)); + return { + requestWillBeSentFuture, + responseReceivedFuture, + loadingFinishedFuture, + }; +} + +async function assertResponseBody(responseReceived, expectedBody, expectedBase64Encoded = false) { + const responseBody = await session.post('Network.getResponseBody', { + requestId: responseReceived.requestId, + }); + assert.strictEqual(responseBody.base64Encoded, expectedBase64Encoded); + assert.strictEqual(responseBody.body, expectedBody); +} + +async function testHttpGet() { + const url = `http://127.0.0.1:${httpServer.address().port}/hello-world`; + const { + requestWillBeSentFuture, + responseReceivedFuture, + loadingFinishedFuture, + } = createRequestTracker(url, getDefaultResponseExpect(url)); + http.get({ host: '127.0.0.1', port: httpServer.address().port, @@ -175,24 +247,83 @@ async function testHttpGet() { const delta = (loadingFinished.timestamp - responseReceived.timestamp) * 1000; assert.ok(delta > kDelta); + await assertResponseBody(responseReceived, '\nhello world\n'); +} - const responseBody = await session.post('Network.getResponseBody', { - requestId: responseReceived.requestId, +async function testHttpGetWithAbsoluteUrlPath() { + const url = `http://127.0.0.1:${httpServer.address().port}/hello-world`; + const { + requestWillBeSentFuture, + responseReceivedFuture, + loadingFinishedFuture, + } = createRequestTracker(url, getDefaultResponseExpect(url)); + + http.get({ + host: '127.0.0.1', + port: httpServer.address().port, + path: url, + headers: requestHeaders, + }, common.mustCall(verifyHttpResponse)); + + await requestWillBeSentFuture; + const responseReceived = await responseReceivedFuture; + const loadingFinished = await loadingFinishedFuture; + + const delta = (loadingFinished.timestamp - responseReceived.timestamp) * 1000; + assert.ok(delta > kDelta); + await assertResponseBody(responseReceived, '\nhello world\n'); +} + +async function testHttpPostWithAbsoluteUrlPath() { + const requestBody = JSON.stringify({ title: 'foo', type: 'post' }); + const url = `http://127.0.0.1:${httpServer.address().port}/echo-post`; + const { + requestWillBeSentFuture, + responseReceivedFuture, + loadingFinishedFuture, + } = createRequestTracker(url, { + url, + mimeType: 'application/json', + charset: 'utf-8', + }, { + method: 'POST', }); - assert.strictEqual(responseBody.base64Encoded, false); - assert.strictEqual(responseBody.body, '\nhello world\n'); + + const responsePromise = new Promise((resolve, reject) => { + const req = http.request({ + host: '127.0.0.1', + port: httpServer.address().port, + path: url, + method: 'POST', + headers: { + ...requestHeaders, + 'Content-Type': 'application/json', + 'Content-Length': Buffer.byteLength(requestBody), + }, + }, resolve); + req.on('error', reject); + req.end(requestBody); + }); + + const response = await responsePromise; + drainHttpResponse(response); + + await requestWillBeSentFuture; + const responseReceived = await responseReceivedFuture; + await loadingFinishedFuture; + await assertResponseBody(responseReceived, JSON.stringify({ + method: 'POST', + body: requestBody, + })); } async function testHttpsGet() { const url = `https://127.0.0.1:${httpsServer.address().port}/hello-world`; - const requestWillBeSentFuture = once(session, 'Network.requestWillBeSent') - .then(([event]) => verifyRequestWillBeSent(event, { url })); - - const responseReceivedFuture = once(session, 'Network.responseReceived') - .then(([event]) => verifyResponseReceived(event, { url })); - - const loadingFinishedFuture = once(session, 'Network.loadingFinished') - .then(([event]) => verifyLoadingFinished(event)); + const { + requestWillBeSentFuture, + responseReceivedFuture, + loadingFinishedFuture, + } = createRequestTracker(url, getDefaultResponseExpect(url)); https.get({ host: '127.0.0.1', @@ -208,12 +339,7 @@ async function testHttpsGet() { const delta = (loadingFinished.timestamp - responseReceived.timestamp) * 1000; assert.ok(delta > kDelta); - - const responseBody = await session.post('Network.getResponseBody', { - requestId: responseReceived.requestId, - }); - assert.strictEqual(responseBody.base64Encoded, false); - assert.strictEqual(responseBody.body, '\nhello world\n'); + await assertResponseBody(responseReceived, '\nhello world\n'); } async function testHttpError() { @@ -257,6 +383,10 @@ async function testHttpsError() { const testNetworkInspection = async () => { await testHttpGet(); session.removeAllListeners(); + await testHttpGetWithAbsoluteUrlPath(); + session.removeAllListeners(); + await testHttpPostWithAbsoluteUrlPath(); + session.removeAllListeners(); await testHttpsGet(); session.removeAllListeners(); await testHttpError(); From 01a096c64784a22d43fea1a6333cd4d61a3d09a3 Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Wed, 22 Apr 2026 08:47:27 +0200 Subject: [PATCH 036/168] crypto: add guards and adjust tests for BoringSSL Signed-off-by: Filip Skokan PR-URL: https://github.com/nodejs/node/pull/62883 Reviewed-By: Yagiz Nizipli --- deps/ncrypto/ncrypto.cc | 11 ++- deps/ncrypto/ncrypto.h | 9 +- src/crypto/crypto_cipher.cc | 2 + src/crypto/crypto_context.cc | 5 ++ src/crypto/crypto_dh.cc | 6 +- src/crypto/crypto_rsa.cc | 12 +++ src/crypto/crypto_util.cc | 85 ++++++++++--------- .../parallel/test-crypto-async-sign-verify.js | 20 +++-- test/parallel/test-crypto-authenticated.js | 47 ++++++---- .../test-crypto-cipheriv-decipheriv.js | 4 + ...st-crypto-default-shake-lengths-oneshot.js | 3 + test/parallel/test-crypto-dh-curves.js | 4 +- test/parallel/test-crypto-dh-group-setters.js | 4 + test/parallel/test-crypto-dh-modp2-views.js | 4 + test/parallel/test-crypto-dh-modp2.js | 5 ++ test/parallel/test-crypto-dh.js | 26 ++++-- ...st-crypto-ecdh-setpublickey-deprecation.js | 2 +- test/parallel/test-crypto-fips.js | 3 + test/parallel/test-crypto-getcipherinfo.js | 10 +++ test/parallel/test-crypto-hash-stream-pipe.js | 17 ++-- test/parallel/test-crypto-hash.js | 8 +- test/parallel/test-crypto-key-objects-raw.js | 29 +++++-- .../test-crypto-key-objects-to-crypto-key.js | 18 +++- test/parallel/test-crypto-key-objects.js | 39 +++++++-- ...test-crypto-keygen-async-dsa-key-object.js | 3 + test/parallel/test-crypto-keygen-async-dsa.js | 3 + ...ypto-keygen-async-elliptic-curve-jwk-ec.js | 8 +- ...-crypto-keygen-async-elliptic-curve-jwk.js | 13 ++- ...-explicit-elliptic-curve-encrypted-p256.js | 3 + ...nc-explicit-elliptic-curve-encrypted.js.js | 3 + ...to-keygen-async-explicit-elliptic-curve.js | 3 + .../parallel/test-crypto-keygen-bit-length.js | 4 + .../parallel/test-crypto-keygen-dh-classic.js | 3 + test/parallel/test-crypto-keygen-eddsa.js | 24 +++--- ...o-keygen-invalid-parameter-encoding-dsa.js | 3 + ...test-crypto-keygen-no-rsassa-pss-params.js | 3 + test/parallel/test-crypto-keygen-raw.js | 4 +- .../test-crypto-keygen-rfc8017-9-1.js | 3 + .../test-crypto-keygen-rfc8017-a-2-3.js | 3 + test/parallel/test-crypto-keygen-rsa-pss.js | 3 + test/parallel/test-crypto-oneshot-hash-xof.js | 4 + .../test-crypto-pqc-key-objects-ml-dsa.js | 4 + test/parallel/test-crypto-rsa-dsa.js | 30 +++++-- test/parallel/test-crypto-scrypt.js | 4 +- test/parallel/test-crypto-secure-heap.js | 4 + test/parallel/test-crypto-sign-verify.js | 44 +++++++--- test/parallel/test-crypto.js | 6 +- .../test-tls-dhparam-auto-boringssl.js | 19 +++++ .../test-webcrypto-export-import-cfrg.js | 2 +- ...-webcrypto-promise-prototype-pollution.mjs | 20 +++-- test/parallel/test-webcrypto-wrap-unwrap.js | 19 +++-- test/pummel/test-crypto-dh-keys.js | 15 ++-- .../test-webcrypto-derivebits-pbkdf2.js | 11 ++- 53 files changed, 473 insertions(+), 168 deletions(-) create mode 100644 test/parallel/test-tls-dhparam-auto-boringssl.js diff --git a/deps/ncrypto/ncrypto.cc b/deps/ncrypto/ncrypto.cc index 07049405de6239..b7a0c96ee2ea60 100644 --- a/deps/ncrypto/ncrypto.cc +++ b/deps/ncrypto/ncrypto.cc @@ -147,7 +147,12 @@ DataPointer DataPointer::SecureAlloc(size_t len) { #ifndef OPENSSL_IS_BORINGSSL auto ptr = OPENSSL_secure_zalloc(len); if (ptr == nullptr) return {}; - return DataPointer(ptr, len, true); + // OPENSSL_secure_zalloc transparently falls back to a regular allocation + // when the secure heap is not initialized or is exhausted. Reflect the + // actual provenance of the pointer so that reset() routes to the correct + // free function (OPENSSL_secure_clear_free vs. OPENSSL_clear_free) and + // callers of isSecure() get a truthful answer. + return DataPointer(ptr, len, CRYPTO_secure_allocated(ptr) == 1); #else // BoringSSL does not implement the OPENSSL_secure_zalloc API. auto ptr = OPENSSL_malloc(len); @@ -3103,9 +3108,13 @@ const Cipher Cipher::AES_256_GCM = Cipher::FromNid(NID_aes_256_gcm); const Cipher Cipher::AES_128_KW = Cipher::FromNid(NID_id_aes128_wrap); const Cipher Cipher::AES_192_KW = Cipher::FromNid(NID_id_aes192_wrap); const Cipher Cipher::AES_256_KW = Cipher::FromNid(NID_id_aes256_wrap); + +#ifndef OPENSSL_IS_BORINGSSL const Cipher Cipher::AES_128_OCB = Cipher::FromNid(NID_aes_128_ocb); const Cipher Cipher::AES_192_OCB = Cipher::FromNid(NID_aes_192_ocb); const Cipher Cipher::AES_256_OCB = Cipher::FromNid(NID_aes_256_ocb); +#endif + const Cipher Cipher::CHACHA20_POLY1305 = Cipher::FromNid(NID_chacha20_poly1305); bool Cipher::isGcmMode() const { diff --git a/deps/ncrypto/ncrypto.h b/deps/ncrypto/ncrypto.h index 4f86702da88267..1f116169f57a27 100644 --- a/deps/ncrypto/ncrypto.h +++ b/deps/ncrypto/ncrypto.h @@ -309,9 +309,12 @@ class Cipher final { #else static constexpr size_t MAX_AUTH_TAG_LENGTH = 16; #endif - static_assert(EVP_GCM_TLS_TAG_LEN <= MAX_AUTH_TAG_LENGTH && - EVP_CCM_TLS_TAG_LEN <= MAX_AUTH_TAG_LENGTH && - EVP_CHACHAPOLY_TLS_TAG_LEN <= MAX_AUTH_TAG_LENGTH); + static_assert(EVP_GCM_TLS_TAG_LEN <= MAX_AUTH_TAG_LENGTH +#ifndef OPENSSL_IS_BORINGSSL + && EVP_CCM_TLS_TAG_LEN <= MAX_AUTH_TAG_LENGTH && + EVP_CHACHAPOLY_TLS_TAG_LEN <= MAX_AUTH_TAG_LENGTH +#endif + ); // NOLINT(whitespace/parens) Cipher() = default; Cipher(const EVP_CIPHER* cipher) : cipher_(cipher) {} diff --git a/src/crypto/crypto_cipher.cc b/src/crypto/crypto_cipher.cc index 638dda0ad10593..2e9acf86099ee8 100644 --- a/src/crypto/crypto_cipher.cc +++ b/src/crypto/crypto_cipher.cc @@ -447,8 +447,10 @@ bool CipherBase::InitAuthenticated(const char* cipher_type, // Other modes (CCM, OCB) require an explicit tag length. if (ctx_.isGcmMode()) { auth_tag_len = EVP_GCM_TLS_TAG_LEN; +#ifdef EVP_CHACHAPOLY_TLS_TAG_LEN } else if (ctx_.isChaCha20Poly1305()) { auth_tag_len = EVP_CHACHAPOLY_TLS_TAG_LEN; +#endif } else { THROW_ERR_CRYPTO_INVALID_AUTH_TAG( env(), "authTagLength required for %s", cipher_type); diff --git a/src/crypto/crypto_context.cc b/src/crypto/crypto_context.cc index 5e5ebffa04cd7d..c744d67b97d445 100644 --- a/src/crypto/crypto_context.cc +++ b/src/crypto/crypto_context.cc @@ -1928,8 +1928,13 @@ void SecureContext::SetDHParam(const FunctionCallbackInfo& args) { // true to this function instead of the original string. Any other string // value will be interpreted as custom DH parameters below. if (args[0]->IsTrue()) { +#ifdef SSL_CTX_set_dh_auto CHECK(SSL_CTX_set_dh_auto(sc->ctx_.get(), true)); return; +#else + return THROW_ERR_CRYPTO_UNSUPPORTED_OPERATION( + env, "Automatic DH parameter selection is not supported"); +#endif } DHPointer dh; diff --git a/src/crypto/crypto_dh.cc b/src/crypto/crypto_dh.cc index 36e38e99f06fe0..fa8f36fa33c08f 100644 --- a/src/crypto/crypto_dh.cc +++ b/src/crypto/crypto_dh.cc @@ -309,15 +309,17 @@ void ComputeSecret(const FunctionCallbackInfo& args) { BignumPointer key(key_buf.data(), key_buf.size()); switch (dh.checkPublicKey(key)) { - case DHPointer::CheckPublicKeyResult::INVALID: - // Fall-through case DHPointer::CheckPublicKeyResult::CHECK_FAILED: return THROW_ERR_CRYPTO_INVALID_KEYTYPE(env, "Unspecified validation error"); +#ifndef OPENSSL_IS_BORINGSSL case DHPointer::CheckPublicKeyResult::TOO_SMALL: return THROW_ERR_CRYPTO_INVALID_KEYLEN(env, "Supplied key is too small"); case DHPointer::CheckPublicKeyResult::TOO_LARGE: return THROW_ERR_CRYPTO_INVALID_KEYLEN(env, "Supplied key is too large"); +#endif + case DHPointer::CheckPublicKeyResult::INVALID: + return THROW_ERR_CRYPTO_INVALID_KEYTYPE(env, "Supplied key is invalid"); case DHPointer::CheckPublicKeyResult::NONE: break; } diff --git a/src/crypto/crypto_rsa.cc b/src/crypto/crypto_rsa.cc index e39a7fe72de651..38122d14efe2e6 100644 --- a/src/crypto/crypto_rsa.cc +++ b/src/crypto/crypto_rsa.cc @@ -135,6 +135,18 @@ Maybe RsaKeyGenTraits::AdditionalConfig( params->params.modulus_bits = args[*offset + 1].As()->Value(); params->params.exponent = args[*offset + 2].As()->Value(); +#ifdef OPENSSL_IS_BORINGSSL + // BoringSSL hangs indefinitely generating an RSA key with e=1, and for + // other invalid exponents (e=0, even values) reports the misleading error + // RSA_R_TOO_MANY_ITERATIONS only after running the full keygen loop. Reject + // those up-front with a clear error. The constraint here (odd integer >= 3) + // matches BoringSSL's own rsa_check_public_key validation. + if (params->params.exponent < 3 || (params->params.exponent & 1) == 0) { + THROW_ERR_OUT_OF_RANGE(env, "publicExponent is invalid"); + return Nothing(); + } +#endif + *offset += 3; if (params->params.variant == kKeyVariantRSA_PSS) { diff --git a/src/crypto/crypto_util.cc b/src/crypto/crypto_util.cc index 4b921f1cf308f8..0e743135e8de15 100644 --- a/src/crypto/crypto_util.cc +++ b/src/crypto/crypto_util.cc @@ -553,44 +553,51 @@ Maybe Decorate(Environment* env, c = ToUpper(c); } -#define OSSL_ERROR_CODES_MAP(V) \ - V(SYS) \ - V(BN) \ - V(RSA) \ - V(DH) \ - V(EVP) \ - V(BUF) \ - V(OBJ) \ - V(PEM) \ - V(DSA) \ - V(X509) \ - V(ASN1) \ - V(CONF) \ - V(CRYPTO) \ - V(EC) \ - V(SSL) \ - V(BIO) \ - V(PKCS7) \ - V(X509V3) \ - V(PKCS12) \ - V(RAND) \ - V(DSO) \ - V(ENGINE) \ - V(OCSP) \ - V(UI) \ - V(COMP) \ - V(ECDSA) \ - V(ECDH) \ - V(OSSL_STORE) \ - V(FIPS) \ - V(CMS) \ - V(TS) \ - V(HMAC) \ - V(CT) \ - V(ASYNC) \ - V(KDF) \ - V(SM2) \ - V(USER) \ +#ifdef OPENSSL_IS_BORINGSSL +#define OSSL_ERROR_CODES_MAP_OPENSSL_ONLY(V) +#else +#define OSSL_ERROR_CODES_MAP_OPENSSL_ONLY(V) \ + V(PKCS12) \ + V(DSO) \ + V(OSSL_STORE) \ + V(FIPS) \ + V(TS) \ + V(CT) \ + V(ASYNC) \ + V(KDF) \ + V(SM2) +#endif + +#define OSSL_ERROR_CODES_MAP(V) \ + V(SYS) \ + V(BN) \ + V(RSA) \ + V(DH) \ + V(EVP) \ + V(BUF) \ + V(OBJ) \ + V(PEM) \ + V(DSA) \ + V(X509) \ + V(ASN1) \ + V(CONF) \ + V(CRYPTO) \ + V(EC) \ + V(SSL) \ + V(BIO) \ + V(PKCS7) \ + V(X509V3) \ + V(RAND) \ + V(ENGINE) \ + V(OCSP) \ + V(UI) \ + V(COMP) \ + V(ECDSA) \ + V(ECDH) \ + V(CMS) \ + V(HMAC) \ + V(USER) \ + OSSL_ERROR_CODES_MAP_OPENSSL_ONLY(V) #define V(name) case ERR_LIB_##name: lib = #name "_"; break; const char* lib = ""; @@ -600,6 +607,7 @@ Maybe Decorate(Environment* env, } #undef V #undef OSSL_ERROR_CODES_MAP +#undef OSSL_ERROR_CODES_MAP_OPENSSL_ONLY // Don't generate codes like "ERR_OSSL_SSL_". if (lib && strcmp(lib, "SSL_") == 0) prefix = ""; @@ -728,7 +736,6 @@ void SecureBuffer(const FunctionCallbackInfo& args) { uint32_t len = args[0].As()->Value(); auto data = DataPointer::SecureAlloc(len); - CHECK(data.isSecure()); if (!data) { return THROW_ERR_OPERATION_FAILED(env, "Allocation failed"); } diff --git a/test/parallel/test-crypto-async-sign-verify.js b/test/parallel/test-crypto-async-sign-verify.js index b5d356ea520d20..bee83eaf8de022 100644 --- a/test/parallel/test-crypto-async-sign-verify.js +++ b/test/parallel/test-crypto-async-sign-verify.js @@ -102,17 +102,19 @@ if (!process.features.openssl_is_boringssl) { // ECDSA w/ ieee-p1363 signature encoding test('ec_secp256k1_public.pem', 'ec_secp256k1_private.pem', 'sha384', false, { dsaEncoding: 'ieee-p1363' }); -} -// DSA w/ der signature encoding -test('dsa_public.pem', 'dsa_private.pem', 'sha256', - false); -test('dsa_public.pem', 'dsa_private.pem', 'sha256', - false, { dsaEncoding: 'der' }); + // DSA w/ der signature encoding + test('dsa_public.pem', 'dsa_private.pem', 'sha256', + false); + test('dsa_public.pem', 'dsa_private.pem', 'sha256', + false, { dsaEncoding: 'der' }); -// DSA w/ ieee-p1363 signature encoding -test('dsa_public.pem', 'dsa_private.pem', 'sha256', false, - { dsaEncoding: 'ieee-p1363' }); + // DSA w/ ieee-p1363 signature encoding + test('dsa_public.pem', 'dsa_private.pem', 'sha256', false, + { dsaEncoding: 'ieee-p1363' }); +} else { + common.printSkipMessage('Skipping unsupported ed448/secp256k1/dsa test cases'); +} // Test Parallel Execution w/ KeyObject is threadsafe in openssl3 { diff --git a/test/parallel/test-crypto-authenticated.js b/test/parallel/test-crypto-authenticated.js index 9778ea548e81d7..2a4e2a1520a353 100644 --- a/test/parallel/test-crypto-authenticated.js +++ b/test/parallel/test-crypto-authenticated.js @@ -626,22 +626,25 @@ for (const test of TEST_CASES) { { // CCM cipher without data should not crash, see https://github.com/nodejs/node/issues/38035. - const algo = 'aes-128-ccm'; - const key = Buffer.alloc(16); - const iv = Buffer.alloc(12); - const opts = { authTagLength: 10 }; + if (!ciphers.includes('aes-128-ccm')) { + common.printSkipMessage(`unsupported aes-128-ccm test`); + } else { + const key = Buffer.alloc(16); + const iv = Buffer.alloc(12); + const opts = { authTagLength: 10 }; - const cipher = crypto.createCipheriv(algo, key, iv, opts); - assert.throws(() => { - cipher.final(); - }, hasOpenSSL3 ? { - code: 'ERR_OSSL_TAG_NOT_SET' - } : { - message: /Unsupported state/ - }); + const cipher = crypto.createCipheriv('aes-128-ccm', key, iv, opts); + assert.throws(() => { + cipher.final(); + }, hasOpenSSL3 ? { + code: 'ERR_OSSL_TAG_NOT_SET' + } : { + message: /Unsupported state/ + }); + } } -{ +if (!process.features.openssl_is_boringssl) { const key = Buffer.alloc(32); const iv = Buffer.alloc(12); @@ -653,11 +656,13 @@ for (const test of TEST_CASES) { message: errMessages.authTagLength }); } +} else { + common.printSkipMessage('Skipping unsupported chacha20-poly1305 test'); } // ChaCha20-Poly1305 should respect the authTagLength option and should not // require the authentication tag before calls to update() during decryption. -{ +if (!process.features.openssl_is_boringssl) { const key = Buffer.alloc(32); const iv = Buffer.alloc(12); @@ -697,6 +702,8 @@ for (const test of TEST_CASES) { } } } +} else { + common.printSkipMessage('Skipping unsupported chacha20-poly1305 test'); } // ChaCha20-Poly1305 should default to an authTagLength of 16. When encrypting, @@ -706,7 +713,7 @@ for (const test of TEST_CASES) { // shorter tags as long as their length was valid according to NIST SP 800-38D. // For ChaCha20-Poly1305, we intentionally deviate from that because there are // no recommended or approved authentication tag lengths below 16 bytes. -{ +if (!process.features.openssl_is_boringssl) { const rfcTestCases = TEST_CASES.filter(({ algo, tampered }) => { return algo === 'chacha20-poly1305' && tampered === false; }); @@ -740,10 +747,12 @@ for (const test of TEST_CASES) { assert.strictEqual(plaintext.toString('hex'), testCase.plain); } +} else { + common.printSkipMessage('Skipping unsupported chacha20-poly1305 test'); } // https://github.com/nodejs/node/issues/45874 -{ +if (!process.features.openssl_is_boringssl) { const rfcTestCases = TEST_CASES.filter(({ algo, tampered }) => { return algo === 'chacha20-poly1305' && tampered === false; }); @@ -771,10 +780,12 @@ for (const test of TEST_CASES) { assert.throws(() => { decipher.final(); }, /Unsupported state or unable to authenticate data/); +} else { + common.printSkipMessage('Skipping unsupported chacha20-poly1305 test'); } // Refs: https://github.com/nodejs/node/issues/62342 -{ +if (ciphers.includes('aes-128-ccm')) { const key = crypto.randomBytes(16); const nonce = crypto.randomBytes(13); @@ -794,4 +805,6 @@ for (const test of TEST_CASES) { decipher.setAAD(Buffer.alloc(0), { plaintextLength: 0 }); decipher.update(new DataView(new ArrayBuffer(0))); decipher.final(); +} else { + common.printSkipMessage('Skipping unsupported aes-128-ccm test'); } diff --git a/test/parallel/test-crypto-cipheriv-decipheriv.js b/test/parallel/test-crypto-cipheriv-decipheriv.js index 3f0ea5b31ba189..095458e7d0b425 100644 --- a/test/parallel/test-crypto-cipheriv-decipheriv.js +++ b/test/parallel/test-crypto-cipheriv-decipheriv.js @@ -62,6 +62,10 @@ function testCipher2(key, iv) { function testCipher3(key, iv) { + if (!crypto.getCiphers().includes('id-aes128-wrap')) { + common.printSkipMessage(`unsupported id-aes128-wrap test`); + return; + } // Test encryption and decryption with explicit key and iv. // AES Key Wrap test vector comes from RFC3394 const plaintext = Buffer.from('00112233445566778899AABBCCDDEEFF', 'hex'); diff --git a/test/parallel/test-crypto-default-shake-lengths-oneshot.js b/test/parallel/test-crypto-default-shake-lengths-oneshot.js index 90b4c3de21a317..4aff888c104eb2 100644 --- a/test/parallel/test-crypto-default-shake-lengths-oneshot.js +++ b/test/parallel/test-crypto-default-shake-lengths-oneshot.js @@ -4,6 +4,9 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); +if (process.features.openssl_is_boringssl) + common.skip('not supported by BoringSSL'); + const { hash } = require('crypto'); common.expectWarning({ diff --git a/test/parallel/test-crypto-dh-curves.js b/test/parallel/test-crypto-dh-curves.js index 81a469c226c261..ddd5ea9377e63f 100644 --- a/test/parallel/test-crypto-dh-curves.js +++ b/test/parallel/test-crypto-dh-curves.js @@ -16,7 +16,9 @@ const p = 'FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74' + crypto.createDiffieHellman(p, 'hex'); // Confirm DH_check() results are exposed for optional examination. -const bad_dh = crypto.createDiffieHellman('02', 'hex'); +const bad_dh = process.features.openssl_is_boringssl ? + crypto.createDiffieHellman('abcd', 'hex', 0) : + crypto.createDiffieHellman('02', 'hex'); assert.notStrictEqual(bad_dh.verifyError, 0); const availableCurves = new Set(crypto.getCurves()); diff --git a/test/parallel/test-crypto-dh-group-setters.js b/test/parallel/test-crypto-dh-group-setters.js index 7c774111952ead..37d0a44d0e1e10 100644 --- a/test/parallel/test-crypto-dh-group-setters.js +++ b/test/parallel/test-crypto-dh-group-setters.js @@ -6,6 +6,10 @@ if (!common.hasCrypto) const assert = require('assert'); const crypto = require('crypto'); +if (process.features.openssl_is_boringssl) { + common.skip('Skipping unsupported Diffie-Hellman tests'); +} + // Unlike DiffieHellman, DiffieHellmanGroup does not have any setters. const dhg = crypto.getDiffieHellman('modp1'); assert.strictEqual(dhg.constructor, crypto.DiffieHellmanGroup); diff --git a/test/parallel/test-crypto-dh-modp2-views.js b/test/parallel/test-crypto-dh-modp2-views.js index 8d01731af79394..a28e615b7f35c7 100644 --- a/test/parallel/test-crypto-dh-modp2-views.js +++ b/test/parallel/test-crypto-dh-modp2-views.js @@ -7,6 +7,10 @@ const assert = require('assert'); const crypto = require('crypto'); const { modp2buf } = require('../common/crypto'); +if (process.features.openssl_is_boringssl) { + common.skip('Skipping unsupported Diffie-Hellman tests'); +} + const modp2 = crypto.createDiffieHellmanGroup('modp2'); const views = common.getArrayBufferViews(modp2buf); diff --git a/test/parallel/test-crypto-dh-modp2.js b/test/parallel/test-crypto-dh-modp2.js index 19767d26f4e5fb..eb262f235ff30b 100644 --- a/test/parallel/test-crypto-dh-modp2.js +++ b/test/parallel/test-crypto-dh-modp2.js @@ -6,6 +6,11 @@ if (!common.hasCrypto) const assert = require('assert'); const crypto = require('crypto'); const { modp2buf } = require('../common/crypto'); + +if (process.features.openssl_is_boringssl) { + common.skip('Skipping unsupported Diffie-Hellman tests'); +} + const modp2 = crypto.createDiffieHellmanGroup('modp2'); { diff --git a/test/parallel/test-crypto-dh.js b/test/parallel/test-crypto-dh.js index 3c00a5fc73bb9f..8a3dee5b0756d1 100644 --- a/test/parallel/test-crypto-dh.js +++ b/test/parallel/test-crypto-dh.js @@ -8,7 +8,6 @@ const assert = require('assert'); const crypto = require('crypto'); const { hasOpenSSL3, - hasOpenSSL, } = require('../common/crypto'); { @@ -90,13 +89,10 @@ const { } { - // Error message was changed in OpenSSL 3.0.x from 3.0.12, and 3.1.x from 3.1.4. - const hasOpenSSL3WithNewErrorMessage = (hasOpenSSL(3, 0, 12) && !hasOpenSSL(3, 1, 0)) || - (hasOpenSSL(3, 1, 4)); assert.throws(() => { dh3.computeSecret(''); - }, { message: hasOpenSSL3 && !hasOpenSSL3WithNewErrorMessage ? - 'Unspecified validation error' : + }, { message: process.features.openssl_is_boringssl ? + 'Supplied key is invalid' : 'Supplied key is too small' }); } } @@ -104,10 +100,24 @@ const { // Through a fluke of history, g=0 defaults to DH_GENERATOR (2). { const g = 0; - crypto.createDiffieHellman('abcdef', g); + if (process.features.openssl_is_boringssl) { + assert.throws(() => crypto.createDiffieHellman('abcdef', g), { + code: 'ERR_CRYPTO_OPERATION_FAILED', + name: 'Error' + }); + } else { + crypto.createDiffieHellman('abcdef', g); + } crypto.createDiffieHellman('abcdef', 'hex', g); } { - crypto.createDiffieHellman('abcdef', Buffer.from([2])); // OK + if (process.features.openssl_is_boringssl) { + assert.throws(() => crypto.createDiffieHellman('abcdef', Buffer.from([2])), { + code: 'ERR_CRYPTO_OPERATION_FAILED', + name: 'Error' + }); + } else { + crypto.createDiffieHellman('abcdef', Buffer.from([2])); // OK + } } diff --git a/test/parallel/test-crypto-ecdh-setpublickey-deprecation.js b/test/parallel/test-crypto-ecdh-setpublickey-deprecation.js index 81ee561c4efef7..317c219f501aaf 100644 --- a/test/parallel/test-crypto-ecdh-setpublickey-deprecation.js +++ b/test/parallel/test-crypto-ecdh-setpublickey-deprecation.js @@ -13,7 +13,7 @@ common.expectWarning( 'DeprecationWarning', 'ecdh.setPublicKey() is deprecated.', 'DEP0031'); -const ec = crypto.createECDH('secp256k1'); +const ec = crypto.createECDH('prime256v1'); try { // This will throw but we don't care about the error, // we just want to verify that the deprecation warning diff --git a/test/parallel/test-crypto-fips.js b/test/parallel/test-crypto-fips.js index a5e25b8fd1073a..04a95fa5fd37c9 100644 --- a/test/parallel/test-crypto-fips.js +++ b/test/parallel/test-crypto-fips.js @@ -4,6 +4,9 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); +if (process.features.openssl_is_boringssl) + common.skip('BoringSSL does not support FIPS'); + const assert = require('assert'); const spawnSync = require('child_process').spawnSync; const path = require('path'); diff --git a/test/parallel/test-crypto-getcipherinfo.js b/test/parallel/test-crypto-getcipherinfo.js index b0902908b5c454..d55985aa3c7f6b 100644 --- a/test/parallel/test-crypto-getcipherinfo.js +++ b/test/parallel/test-crypto-getcipherinfo.js @@ -18,6 +18,12 @@ assert.strictEqual(getCipherInfo('cipher that does not exist'), undefined); for (const cipher of ciphers) { const info = getCipherInfo(cipher); + if (process.features.openssl_is_boringssl && !info) { + // BoringSSL reports some legacy ciphers in getCiphers() but returns no + // info for them (e.g. des-ede3, des-ede3-ecb, rc2-40-cbc). + common.printSkipMessage(`Skipping unsupported ${cipher} test case`); + continue; + } assert(info); const info2 = getCipherInfo(info.nid); assert.deepStrictEqual(info, info2); @@ -65,10 +71,14 @@ assert(!getCipherInfo('aes-128-ccm', { ivLength: 14 })); if (!process.features.openssl_is_boringssl) { for (let n = 7; n <= 13; n++) assert(getCipherInfo('aes-128-ccm', { ivLength: n })); +} else { + common.printSkipMessage('Skipping unsupported aes-128-ccm test cases'); } assert(!getCipherInfo('aes-128-ocb', { ivLength: 16 })); if (!process.features.openssl_is_boringssl) { for (let n = 1; n < 16; n++) assert(getCipherInfo('aes-128-ocb', { ivLength: n })); +} else { + common.printSkipMessage('Skipping unsupported aes-128-ocb test cases'); } diff --git a/test/parallel/test-crypto-hash-stream-pipe.js b/test/parallel/test-crypto-hash-stream-pipe.js index d22281abbd5c3c..ac851646a91889 100644 --- a/test/parallel/test-crypto-hash-stream-pipe.js +++ b/test/parallel/test-crypto-hash-stream-pipe.js @@ -30,11 +30,18 @@ const crypto = require('crypto'); const stream = require('stream'); const s = new stream.PassThrough(); -const h = crypto.createHash('sha3-512'); -const expect = '36a38a2a35e698974d4e5791a3f05b05' + - '198235381e864f91a0e8cd6a26b677ec' + - 'dcde8e2b069bd7355fabd68abd6fc801' + - '19659f25e92f8efc961ee3a7c815c758'; +const h = process.features.openssl_is_boringssl ? + crypto.createHash('sha512') : + crypto.createHash('sha3-512'); +const expect = process.features.openssl_is_boringssl ? + 'fba055c6fd0c5b6645407749ed7a8b41' + + 'b8f629f2163c3ca3701d864adabda1f8' + + '93c37bf82b22fdd151ba8e357f611da4' + + '88a74b6a5525dd9b69554c6ce5138ad7' : + '36a38a2a35e698974d4e5791a3f05b05' + + '198235381e864f91a0e8cd6a26b677ec' + + 'dcde8e2b069bd7355fabd68abd6fc801' + + '19659f25e92f8efc961ee3a7c815c758'; s.pipe(h).on('data', common.mustCall(function(c) { assert.strictEqual(c, expect); diff --git a/test/parallel/test-crypto-hash.js b/test/parallel/test-crypto-hash.js index 5f18ad2d1ec137..79c20ea75983d5 100644 --- a/test/parallel/test-crypto-hash.js +++ b/test/parallel/test-crypto-hash.js @@ -8,8 +8,10 @@ common.expectWarning({ DeprecationWarning: [ ['crypto.Hash constructor is deprecated.', 'DEP0179'], - ['Creating SHAKE128/256 digests without an explicit options.outputLength is deprecated.', - 'DEP0198'], + ...(process.features.openssl_is_boringssl ? [] : [[ + 'Creating SHAKE128/256 digests without an explicit options.outputLength is deprecated.', + 'DEP0198', + ]]), ] }); @@ -269,6 +271,8 @@ if (!process.features.openssl_is_boringssl) { assert.throws(() => crypto.createHash('sha256', { outputLength }), { code: 'ERR_OUT_OF_RANGE' }); } +} else { + common.printSkipMessage('Skipping unsupported XOF hash test cases'); } { diff --git a/test/parallel/test-crypto-key-objects-raw.js b/test/parallel/test-crypto-key-objects-raw.js index 5658be6825823f..9ef4bd3b9004d1 100644 --- a/test/parallel/test-crypto-key-objects-raw.js +++ b/test/parallel/test-crypto-key-objects-raw.js @@ -78,10 +78,15 @@ if (hasOpenSSL(3, 5)) { // Key types that don't support raw-* formats { - for (const [type, pub, priv] of [ + const unsupportedKeyTypes = [ ['rsa', 'rsa_public_2048.pem', 'rsa_private_2048.pem'], - ['dsa', 'dsa_public.pem', 'dsa_private.pem'], - ]) { + ]; + if (!process.features.openssl_is_boringssl) { + unsupportedKeyTypes.push(['dsa', 'dsa_public.pem', 'dsa_private.pem']); + } else { + common.printSkipMessage('Skipping unsupported dsa test case'); + } + for (const [type, pub, priv] of unsupportedKeyTypes) { const pubKeyObj = crypto.createPublicKey( fixtures.readKey(pub, 'ascii')); const privKeyObj = crypto.createPrivateKey( @@ -102,7 +107,7 @@ if (hasOpenSSL(3, 5)) { } // DH keys also don't support raw formats - { + if (!process.features.openssl_is_boringssl) { const privKeyObj = crypto.createPrivateKey( fixtures.readKey('dh_private.pem', 'ascii')); assert.throws(() => privKeyObj.export({ format: 'raw-private' }), @@ -113,6 +118,8 @@ if (hasOpenSSL(3, 5)) { key: Buffer.alloc(32), format, asymmetricKeyType: 'dh', }), { code: 'ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS' }); } + } else { + common.printSkipMessage('Skipping unsupported dh test case'); } } @@ -268,7 +275,12 @@ if (hasOpenSSL(3, 5)) { assert.throws(() => ecPriv.export({ format: 'raw-seed' }), { code: 'ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS' }); - for (const type of ['ed25519', 'ed448', 'x25519', 'x448']) { + if (process.features.openssl_is_boringssl) { + common.printSkipMessage('Skipping unsupported ed448/x448 test cases'); + } + for (const type of process.features.openssl_is_boringssl ? + ['ed25519', 'x25519'] : + ['ed25519', 'ed448', 'x25519', 'x448']) { const priv = crypto.createPrivateKey( fixtures.readKey(`${type}_private.pem`, 'ascii')); assert.throws(() => priv.export({ format: 'raw-seed' }), @@ -436,7 +448,12 @@ if (hasOpenSSL(3, 5)) { // x25519, ed25519, x448, and ed448 cannot be used as 'ec' namedCurve values { - for (const type of ['ed25519', 'x25519', 'ed448', 'x448']) { + if (process.features.openssl_is_boringssl) { + common.printSkipMessage('Skipping unsupported ed448/x448 test cases'); + } + for (const type of process.features.openssl_is_boringssl ? + ['ed25519', 'x25519'] : + ['ed25519', 'x25519', 'ed448', 'x448']) { const priv = crypto.createPrivateKey( fixtures.readKey(`${type}_private.pem`, 'ascii')); const pub = crypto.createPublicKey( diff --git a/test/parallel/test-crypto-key-objects-to-crypto-key.js b/test/parallel/test-crypto-key-objects-to-crypto-key.js index 141e51d1ab74a4..54449329cb551a 100644 --- a/test/parallel/test-crypto-key-objects-to-crypto-key.js +++ b/test/parallel/test-crypto-key-objects-to-crypto-key.js @@ -26,9 +26,15 @@ function assertCryptoKey(cryptoKey, keyObject, algorithm, extractable, usages) { { for (const length of [128, 192, 256]) { const key = createSecretKey(randomBytes(length >> 3)); - const algorithms = ['AES-CTR', 'AES-CBC', 'AES-GCM', 'AES-KW']; + let algorithms = ['AES-CTR', 'AES-CBC', 'AES-GCM', 'AES-KW']; if (length === 256) algorithms.push('ChaCha20-Poly1305'); + + if (process.features.openssl_is_boringssl) { + algorithms = algorithms.filter((a) => a !== 'AES-KW' && a !== 'ChaCha20-Poly1305'); + common.printSkipMessage('Skipping unsupported AES-KW/ChaCha20-Poly1305 test cases'); + } + for (const algorithm of algorithms) { const usages = algorithm === 'AES-KW' ? ['wrapKey', 'unwrapKey'] : ['encrypt', 'decrypt']; for (const extractable of [true, false]) { @@ -97,7 +103,15 @@ function assertCryptoKey(cryptoKey, keyObject, algorithm, extractable, usages) { } { - for (const algorithm of ['Ed25519', 'Ed448', 'X25519', 'X448']) { + const algorithms = ['Ed25519', 'X25519']; + + if (!process.features.openssl_is_boringssl) { + algorithms.push('X448', 'Ed448'); + } else { + common.printSkipMessage('Skipping unsupported Ed448/X448 test cases'); + } + + for (const algorithm of algorithms) { const { publicKey, privateKey } = generateKeyPairSync(algorithm.toLowerCase()); assert.throws(() => { publicKey.toCryptoKey(algorithm === 'Ed25519' ? 'X25519' : 'Ed25519', true, []); diff --git a/test/parallel/test-crypto-key-objects.js b/test/parallel/test-crypto-key-objects.js index ce93de980946e5..7c82e4dd8b97ea 100644 --- a/test/parallel/test-crypto-key-objects.js +++ b/test/parallel/test-crypto-key-objects.js @@ -330,6 +330,12 @@ const privateDsa = fixtures.readKey('dsa_private_encrypted_1025.pem', createPrivateKey({ key: '' }); }, hasOpenSSL3 ? { message: 'error:1E08010C:DECODER routines::unsupported', + } : process.features.openssl_is_boringssl ? { + message: 'error:0900006e:PEM routines:OPENSSL_internal:NO_START_LINE', + code: 'ERR_OSSL_PEM_NO_START_LINE', + reason: 'NO_START_LINE', + library: 'PEM routines', + function: 'OPENSSL_internal', } : { message: 'error:0909006C:PEM routines:get_name:no start line', code: 'ERR_OSSL_PEM_NO_START_LINE', @@ -357,13 +363,16 @@ const privateDsa = fixtures.readKey('dsa_private_encrypted_1025.pem', }, hasOpenSSL3 ? { message: /error:1E08010C:DECODER routines::unsupported/, library: 'DECODER routines' + } : process.features.openssl_is_boringssl ? { + library: 'public key routines', + message: 'error:06000066:public key routines:OPENSSL_internal:DECODE_ERROR' } : { message: /asn1 encoding/, library: 'asn1 encoding routines' }); } -[ +for (const info of [ { private: fixtures.readKey('ed25519_private.pem', 'ascii'), public: fixtures.readKey('ed25519_public.pem', 'ascii'), keyType: 'ed25519', @@ -404,9 +413,14 @@ const privateDsa = fixtures.readKey('dsa_private_encrypted_1025.pem', 'S0jlSYJk', kty: 'OKP' } }, -].forEach((info) => { +]) { const keyType = info.keyType; + if (process.features.openssl_is_boringssl && keyType.endsWith('448')) { + common.printSkipMessage(`Skipping unsupported ${keyType} test case`); + continue; + } + { const key = createPrivateKey(info.private); assert.strictEqual(key.type, 'private'); @@ -471,7 +485,7 @@ const privateDsa = fixtures.readKey('dsa_private_encrypted_1025.pem', assert.deepStrictEqual( importedPub.export({ format: 'raw-public' }), rawPub); } -}); +} // Importing an OKP private JWK where x does not match d should fail. { @@ -518,7 +532,7 @@ const privateDsa = fixtures.readKey('dsa_private_encrypted_1025.pem', ); } -[ +for (const info of [ { private: fixtures.readKey('ec_p256_private.pem', 'ascii'), public: fixtures.readKey('ec_p256_public.pem', 'ascii'), keyType: 'ec', @@ -566,9 +580,14 @@ const privateDsa = fixtures.readKey('dsa_private_encrypted_1025.pem', y: 'Ad3flexBeAfXceNzRBH128kFbOWD6W41NjwKRqqIF26vmgW_8COldGKZjFkOSEASxPB' + 'cvA2iFJRUyQ3whC00j0Np' } }, -].forEach((info) => { +]) { const { keyType, namedCurve } = info; + if (process.features.openssl_is_boringssl && !getCurves().includes(namedCurve)) { + common.printSkipMessage(`Skipping unsupported ${keyType} test case`); + continue; + } + { const key = createPrivateKey(info.private); assert.strictEqual(key.type, 'private'); @@ -648,7 +667,7 @@ const privateDsa = fixtures.readKey('dsa_private_encrypted_1025.pem', assert.deepStrictEqual( importedPub.export({ format: 'raw-public' }), rawPub); } -}); +} // Importing an EC private JWK where x does not match d should fail. { @@ -726,7 +745,7 @@ const privateDsa = fixtures.readKey('dsa_private_encrypted_1025.pem', format: 'pem', passphrase: Buffer.alloc(1024, 'a') }), { - message: /bad decrypt/ + message: /bad decrypt|BAD_DECRYPT/ }); const publicKey = createPublicKey(publicDsa); @@ -750,7 +769,7 @@ const privateDsa = fixtures.readKey('dsa_private_encrypted_1025.pem', { code: 'ERR_CRYPTO_JWK_UNSUPPORTED_KEY_TYPE' }); } -{ +if (!process.features.openssl_is_boringssl) { // Test RSA-PSS. { // This key pair does not restrict the message digest algorithm or salt @@ -946,6 +965,8 @@ const privateDsa = fixtures.readKey('dsa_private_encrypted_1025.pem', } } } +} else { + common.printSkipMessage('Skipping unsupported RSA-PSS test case'); } { @@ -1045,7 +1066,7 @@ const privateDsa = fixtures.readKey('dsa_private_encrypted_1025.pem', { const first = generateKeyPairSync('ed25519'); - const second = generateKeyPairSync('ed448'); + const second = generateKeyPairSync('x25519'); assert(!first.publicKey.equals(second.publicKey)); assert(!first.publicKey.equals(second.privateKey)); diff --git a/test/parallel/test-crypto-keygen-async-dsa-key-object.js b/test/parallel/test-crypto-keygen-async-dsa-key-object.js index a3df136230d0f8..ea35facbdc7e20 100644 --- a/test/parallel/test-crypto-keygen-async-dsa-key-object.js +++ b/test/parallel/test-crypto-keygen-async-dsa-key-object.js @@ -4,6 +4,9 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); +if (process.features.openssl_is_boringssl) + common.skip('not supported by BoringSSL'); + const assert = require('assert'); const { generateKeyPair, diff --git a/test/parallel/test-crypto-keygen-async-dsa.js b/test/parallel/test-crypto-keygen-async-dsa.js index 41968d8cc23365..d7c857d35e214b 100644 --- a/test/parallel/test-crypto-keygen-async-dsa.js +++ b/test/parallel/test-crypto-keygen-async-dsa.js @@ -4,6 +4,9 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); +if (process.features.openssl_is_boringssl) + common.skip('not supported by BoringSSL'); + const assert = require('assert'); const { generateKeyPair, diff --git a/test/parallel/test-crypto-keygen-async-elliptic-curve-jwk-ec.js b/test/parallel/test-crypto-keygen-async-elliptic-curve-jwk-ec.js index bddb4aa2fbdcd6..b0945dcc83a2cd 100644 --- a/test/parallel/test-crypto-keygen-async-elliptic-curve-jwk-ec.js +++ b/test/parallel/test-crypto-keygen-async-elliptic-curve-jwk-ec.js @@ -11,7 +11,11 @@ const { // Test async elliptic curve key generation with 'jwk' encoding and named // curve. -['P-384', 'P-256', 'P-521', 'secp256k1'].forEach((curve) => { +for (const curve of ['P-384', 'P-256', 'P-521', 'secp256k1']) { + if (process.features.openssl_is_boringssl && curve === 'secp256k1') { + common.printSkipMessage(`Skipping unsupported ${curve} test case`); + continue; + } generateKeyPair('ec', { namedCurve: curve, publicKeyEncoding: { @@ -32,4 +36,4 @@ const { assert.strictEqual(publicKey.crv, curve); assert.strictEqual(publicKey.crv, privateKey.crv); })); -}); +}; diff --git a/test/parallel/test-crypto-keygen-async-elliptic-curve-jwk.js b/test/parallel/test-crypto-keygen-async-elliptic-curve-jwk.js index 5243edd8c825b7..731960b0d56a06 100644 --- a/test/parallel/test-crypto-keygen-async-elliptic-curve-jwk.js +++ b/test/parallel/test-crypto-keygen-async-elliptic-curve-jwk.js @@ -11,12 +11,11 @@ const { // Test async elliptic curve key generation with 'jwk' encoding. { - [ - 'ed25519', - 'ed448', - 'x25519', - 'x448', - ].forEach((type) => { + for (const type of ['ed25519', 'ed448', 'x25519', 'x448']) { + if (process.features.openssl_is_boringssl && type.endsWith('448')) { + common.printSkipMessage(`Skipping unsupported ${type} test case`); + continue; + } generateKeyPair(type, { publicKeyEncoding: { format: 'jwk' @@ -36,5 +35,5 @@ const { assert.strictEqual(publicKey.crv, expectedCrv); assert.strictEqual(publicKey.crv, privateKey.crv); })); - }); + } } diff --git a/test/parallel/test-crypto-keygen-async-explicit-elliptic-curve-encrypted-p256.js b/test/parallel/test-crypto-keygen-async-explicit-elliptic-curve-encrypted-p256.js index 55aa3831c4233b..246cbe5dd1ace1 100644 --- a/test/parallel/test-crypto-keygen-async-explicit-elliptic-curve-encrypted-p256.js +++ b/test/parallel/test-crypto-keygen-async-explicit-elliptic-curve-encrypted-p256.js @@ -4,6 +4,9 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); +if (process.features.openssl_is_boringssl) + common.skip('BoringSSL does not support paramEncoding: explicit'); + const assert = require('assert'); const { generateKeyPair, diff --git a/test/parallel/test-crypto-keygen-async-explicit-elliptic-curve-encrypted.js.js b/test/parallel/test-crypto-keygen-async-explicit-elliptic-curve-encrypted.js.js index 8a55d4338bc72f..c3b8ab6e8f5093 100644 --- a/test/parallel/test-crypto-keygen-async-explicit-elliptic-curve-encrypted.js.js +++ b/test/parallel/test-crypto-keygen-async-explicit-elliptic-curve-encrypted.js.js @@ -4,6 +4,9 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); +if (process.features.openssl_is_boringssl) + common.skip('BoringSSL does not support paramEncoding: explicit'); + const assert = require('assert'); const { generateKeyPair, diff --git a/test/parallel/test-crypto-keygen-async-explicit-elliptic-curve.js b/test/parallel/test-crypto-keygen-async-explicit-elliptic-curve.js index 46223f08d7445a..8084cdfc0b3bf1 100644 --- a/test/parallel/test-crypto-keygen-async-explicit-elliptic-curve.js +++ b/test/parallel/test-crypto-keygen-async-explicit-elliptic-curve.js @@ -4,6 +4,9 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); +if (process.features.openssl_is_boringssl) + common.skip('BoringSSL does not support paramEncoding: explicit'); + const assert = require('assert'); const { generateKeyPair, diff --git a/test/parallel/test-crypto-keygen-bit-length.js b/test/parallel/test-crypto-keygen-bit-length.js index 63a80659bb2f53..13234589a5d6de 100644 --- a/test/parallel/test-crypto-keygen-bit-length.js +++ b/test/parallel/test-crypto-keygen-bit-length.js @@ -4,6 +4,10 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); +if (process.features.openssl_is_boringssl) + common.skip('BoringSSL does not support arbitrary RSA modulus length ' + + 'or RSA-PSS/DSA key generation'); + const assert = require('assert'); const { generateKeyPair, diff --git a/test/parallel/test-crypto-keygen-dh-classic.js b/test/parallel/test-crypto-keygen-dh-classic.js index ecf5ce7863b8a4..44af7730126afe 100644 --- a/test/parallel/test-crypto-keygen-dh-classic.js +++ b/test/parallel/test-crypto-keygen-dh-classic.js @@ -4,6 +4,9 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); +if (process.features.openssl_is_boringssl) + common.skip('BoringSSL does not support DH key pair generation'); + const assert = require('assert'); const { generateKeyPair, diff --git a/test/parallel/test-crypto-keygen-eddsa.js b/test/parallel/test-crypto-keygen-eddsa.js index 5a097c2524f3ea..0a132235ea28ba 100644 --- a/test/parallel/test-crypto-keygen-eddsa.js +++ b/test/parallel/test-crypto-keygen-eddsa.js @@ -11,17 +11,19 @@ const { // Test EdDSA key generation. { - if (!/^1\.1\.0/.test(process.versions.openssl)) { - ['ed25519', 'ed448', 'x25519', 'x448'].forEach((keyType) => { - generateKeyPair(keyType, common.mustSucceed((publicKey, privateKey) => { - assert.strictEqual(publicKey.type, 'public'); - assert.strictEqual(publicKey.asymmetricKeyType, keyType); - assert.deepStrictEqual(publicKey.asymmetricKeyDetails, {}); + for (const keyType of ['ed25519', 'ed448', 'x25519', 'x448']) { + if (process.features.openssl_is_boringssl && keyType.endsWith('448')) { + common.printSkipMessage(`Skipping unsupported ${keyType} test case`); + continue; + } + generateKeyPair(keyType, common.mustSucceed((publicKey, privateKey) => { + assert.strictEqual(publicKey.type, 'public'); + assert.strictEqual(publicKey.asymmetricKeyType, keyType); + assert.deepStrictEqual(publicKey.asymmetricKeyDetails, {}); - assert.strictEqual(privateKey.type, 'private'); - assert.strictEqual(privateKey.asymmetricKeyType, keyType); - assert.deepStrictEqual(privateKey.asymmetricKeyDetails, {}); - })); - }); + assert.strictEqual(privateKey.type, 'private'); + assert.strictEqual(privateKey.asymmetricKeyType, keyType); + assert.deepStrictEqual(privateKey.asymmetricKeyDetails, {}); + })); } } diff --git a/test/parallel/test-crypto-keygen-invalid-parameter-encoding-dsa.js b/test/parallel/test-crypto-keygen-invalid-parameter-encoding-dsa.js index b5ff5dc2059c1b..9086e2e8a5f1ba 100644 --- a/test/parallel/test-crypto-keygen-invalid-parameter-encoding-dsa.js +++ b/test/parallel/test-crypto-keygen-invalid-parameter-encoding-dsa.js @@ -4,6 +4,9 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); +if (process.features.openssl_is_boringssl) + common.skip('BoringSSL does not support DSA key pair generation'); + const assert = require('assert'); const { diff --git a/test/parallel/test-crypto-keygen-no-rsassa-pss-params.js b/test/parallel/test-crypto-keygen-no-rsassa-pss-params.js index 97dafe1be3cbd0..559c6f0af05163 100644 --- a/test/parallel/test-crypto-keygen-no-rsassa-pss-params.js +++ b/test/parallel/test-crypto-keygen-no-rsassa-pss-params.js @@ -4,6 +4,9 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); +if (process.features.openssl_is_boringssl) + common.skip('BoringSSL does not support RSA-PSS key pair generation'); + const assert = require('assert'); const { generateKeyPair, diff --git a/test/parallel/test-crypto-keygen-raw.js b/test/parallel/test-crypto-keygen-raw.js index fd2971dc2c86cd..5b7abe3f72d9dd 100644 --- a/test/parallel/test-crypto-keygen-raw.js +++ b/test/parallel/test-crypto-keygen-raw.js @@ -158,12 +158,14 @@ const { hasOpenSSL } = require('../common/crypto'); } // Test error: raw with DSA. -{ +if (!process.features.openssl_is_boringssl) { assert.throws(() => generateKeyPairSync('dsa', { modulusLength: 2048, publicKeyEncoding: { format: 'raw-public' }, privateKeyEncoding: { format: 'raw-private' }, }), { code: 'ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS' }); +} else { + common.printSkipMessage(`Skipping unsupported dsa test case`); } // Test error: raw-private in publicKeyEncoding. diff --git a/test/parallel/test-crypto-keygen-rfc8017-9-1.js b/test/parallel/test-crypto-keygen-rfc8017-9-1.js index 7198be1c41343b..fbefb1b4f642b4 100644 --- a/test/parallel/test-crypto-keygen-rfc8017-9-1.js +++ b/test/parallel/test-crypto-keygen-rfc8017-9-1.js @@ -4,6 +4,9 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); +if (process.features.openssl_is_boringssl) + common.skip('BoringSSL does not support RSA-PSS key pair generation'); + const assert = require('assert'); const { generateKeyPair, diff --git a/test/parallel/test-crypto-keygen-rfc8017-a-2-3.js b/test/parallel/test-crypto-keygen-rfc8017-a-2-3.js index f87dcf749bf6d0..bc96d57ed0cd1b 100644 --- a/test/parallel/test-crypto-keygen-rfc8017-a-2-3.js +++ b/test/parallel/test-crypto-keygen-rfc8017-a-2-3.js @@ -4,6 +4,9 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); +if (process.features.openssl_is_boringssl) + common.skip('BoringSSL does not support RSA-PSS key pair generation'); + const assert = require('assert'); const { generateKeyPair, diff --git a/test/parallel/test-crypto-keygen-rsa-pss.js b/test/parallel/test-crypto-keygen-rsa-pss.js index 41ebec97a5d2dd..3ce0d40e8d1b2d 100644 --- a/test/parallel/test-crypto-keygen-rsa-pss.js +++ b/test/parallel/test-crypto-keygen-rsa-pss.js @@ -4,6 +4,9 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); +if (process.features.openssl_is_boringssl) + common.skip('BoringSSL does not support RSA-PSS key pair generation'); + const assert = require('assert'); const { constants, diff --git a/test/parallel/test-crypto-oneshot-hash-xof.js b/test/parallel/test-crypto-oneshot-hash-xof.js index 75cb4800ff1bd5..b4363c31592763 100644 --- a/test/parallel/test-crypto-oneshot-hash-xof.js +++ b/test/parallel/test-crypto-oneshot-hash-xof.js @@ -7,6 +7,10 @@ if (!common.hasCrypto) common.skip('missing crypto'); const assert = require('assert'); const crypto = require('crypto'); +if (process.features.openssl_is_boringssl) { + common.skip('BoringSSL does not support XOF hash functions'); +} + // Test XOF hash functions and the outputLength option. { // Default outputLengths. diff --git a/test/parallel/test-crypto-pqc-key-objects-ml-dsa.js b/test/parallel/test-crypto-pqc-key-objects-ml-dsa.js index 413adf48686ede..f18c555d4653d4 100644 --- a/test/parallel/test-crypto-pqc-key-objects-ml-dsa.js +++ b/test/parallel/test-crypto-pqc-key-objects-ml-dsa.js @@ -4,6 +4,10 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); +if (process.features.openssl_is_boringssl) { + common.skip('Skipping unsupported ML-DSA key tests'); +} + const { hasOpenSSL } = require('../common/crypto'); const assert = require('assert'); diff --git a/test/parallel/test-crypto-rsa-dsa.js b/test/parallel/test-crypto-rsa-dsa.js index 119bc3c2d20ea7..35ad673020778a 100644 --- a/test/parallel/test-crypto-rsa-dsa.js +++ b/test/parallel/test-crypto-rsa-dsa.js @@ -39,10 +39,19 @@ const openssl1DecryptError = { const decryptError = hasOpenSSL3 ? { message: 'error:1C800064:Provider routines::bad decrypt' } : - openssl1DecryptError; + process.features.openssl_is_boringssl ? { + message: 'error:1e000065:Cipher functions:OPENSSL_internal:BAD_DECRYPT', + code: 'ERR_OSSL_BAD_DECRYPT', + reason: 'BAD_DECRYPT', + function: 'OPENSSL_internal', + library: 'Cipher functions', + } : + openssl1DecryptError; const decryptPrivateKeyError = hasOpenSSL3 ? { message: 'error:1C800064:Provider routines::bad decrypt', +} : process.features.openssl_is_boringssl ? { + message: 'error:1e000065:Cipher functions:OPENSSL_internal:BAD_DECRYPT', } : openssl1DecryptError; function getBufferCopy(buf) { @@ -325,9 +334,14 @@ function test_rsa(padding, encryptOaepHash, decryptOaepHash) { } test_rsa('RSA_NO_PADDING'); -test_rsa('RSA_PKCS1_PADDING'); test_rsa('RSA_PKCS1_OAEP_PADDING'); +if (!process.features.openssl_is_boringssl) { + test_rsa('RSA_PKCS1_PADDING'); +} else { + common.printSkipMessage('Skipping unsupported RSA_PKCS1_PADDING test case'); +} + // Test OAEP with different hash functions. test_rsa('RSA_PKCS1_OAEP_PADDING', undefined, 'sha1'); test_rsa('RSA_PKCS1_OAEP_PADDING', 'sha1', undefined); @@ -489,7 +503,7 @@ assert.throws(() => { // // Test DSA signing and verification // -{ +if (!process.features.openssl_is_boringssl) { const input = 'I AM THE WALRUS'; // DSA signatures vary across runs so there is no static string to verify @@ -512,13 +526,15 @@ assert.throws(() => { verify2.update(input); assert.strictEqual(verify2.verify(dsaPubPem, signature2, 'hex'), true); +} else { + common.printSkipMessage('Skipping unsupported DSA test case'); } // // Test DSA signing and verification with PKCS#8 private key // -{ +if (!process.features.openssl_is_boringssl) { const input = 'I AM THE WALRUS'; // DSA signatures vary across runs so there is no static string to verify @@ -531,6 +547,8 @@ assert.throws(() => { verify.update(input); assert.strictEqual(verify.verify(dsaPubPem, signature, 'hex'), true); +} else { + common.printSkipMessage('Skipping unsupported DSA test case'); } @@ -547,7 +565,7 @@ const input = 'I AM THE WALRUS'; }, decryptPrivateKeyError); } -{ +if (!process.features.openssl_is_boringssl) { // DSA signatures vary across runs so there is no static string to verify // against. const sign = crypto.createSign('SHA1'); @@ -559,4 +577,6 @@ const input = 'I AM THE WALRUS'; verify.update(input); assert.strictEqual(verify.verify(dsaPubPem, signature, 'hex'), true); +} else { + common.printSkipMessage('Skipping unsupported DSA test case'); } diff --git a/test/parallel/test-crypto-scrypt.js b/test/parallel/test-crypto-scrypt.js index eafdfe392bde8e..5effc083cda11a 100644 --- a/test/parallel/test-crypto-scrypt.js +++ b/test/parallel/test-crypto-scrypt.js @@ -192,7 +192,9 @@ for (const options of incompatibleOptions) { for (const options of toobig) { const expected = { - message: /Invalid scrypt params:.*memory limit exceeded/, + message: process.features.openssl_is_boringssl ? + /Invalid scrypt params:.*(INVALID_PARAMETERS|MEMORY_LIMIT_EXCEEDED)/ : + /Invalid scrypt params:.*memory limit exceeded/, code: 'ERR_CRYPTO_INVALID_SCRYPT_PARAMS', }; assert.throws(() => crypto.scrypt('pass', 'salt', 1, options, () => {}), diff --git a/test/parallel/test-crypto-secure-heap.js b/test/parallel/test-crypto-secure-heap.js index c20b01a91a9840..3845f49a4748b8 100644 --- a/test/parallel/test-crypto-secure-heap.js +++ b/test/parallel/test-crypto-secure-heap.js @@ -13,6 +13,10 @@ if (common.isASan) { common.skip('ASan does not play well with secure heap allocations'); } +if (process.features.openssl_is_boringssl) { + common.skip('BoringSSL does not support secure heap'); +} + const assert = require('assert'); const { fork } = require('child_process'); const fixtures = require('../common/fixtures'); diff --git a/test/parallel/test-crypto-sign-verify.js b/test/parallel/test-crypto-sign-verify.js index ba30cb17dc32df..a33eeca328ce8d 100644 --- a/test/parallel/test-crypto-sign-verify.js +++ b/test/parallel/test-crypto-sign-verify.js @@ -68,7 +68,9 @@ const keySize = 2048; }); }, { message: hasOpenSSL(3) ? 'error:1C8000A5:Provider routines::illegal or unsupported padding mode' : - 'bye, bye, error stack' }); + process.features.openssl_is_boringssl ? + 'error:0600006d:public key routines:OPENSSL_internal:ILLEGAL_OR_UNSUPPORTED_PADDING_MODE' : + 'bye, bye, error stack' }); delete Object.prototype.opensslErrorStack; } @@ -347,6 +349,9 @@ assert.throws( }, hasOpenSSL(3) ? { code: 'ERR_OSSL_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE', message: /illegal or unsupported padding mode/, + } : process.features.openssl_is_boringssl ? { + code: 'ERR_OSSL_EVP_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE', + message: /ILLEGAL_OR_UNSUPPORTED_PADDING_MODE/, } : { code: 'ERR_OSSL_RSA_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE', message: /illegal or unsupported padding mode/, @@ -418,25 +423,32 @@ assert.throws( /Invalid digest/); } -[ +for (const pair of [ { private: fixtures.readKey('ed25519_private.pem', 'ascii'), public: fixtures.readKey('ed25519_public.pem', 'ascii'), + skip: false, algo: null, supportsContext: hasOpenSSL(3, 2), sigLen: 64, raw: true }, { private: fixtures.readKey('ed448_private.pem', 'ascii'), public: fixtures.readKey('ed448_public.pem', 'ascii'), + skip: process.features.openssl_is_boringssl, algo: null, supportsContext: hasOpenSSL(3, 2), sigLen: 114, raw: true }, { private: fixtures.readKey('rsa_private_2048.pem', 'ascii'), public: fixtures.readKey('rsa_public_2048.pem', 'ascii'), + skip: false, algo: 'sha1', sigLen: 256, raw: false }, -].forEach((pair) => { +]) { + if (pair.skip) { + common.printSkipMessage('Skipping unsupported test case'); + continue; + } const algo = pair.algo; { @@ -550,7 +562,7 @@ assert.throws( }, { message: 'Context parameter is unsupported' }); } } -}); +} // Ed25519ctx: Ed25519 with context string. if (hasOpenSSL(3, 2)) { @@ -618,6 +630,10 @@ if (hasOpenSSL(3, 2)) { const keys = [['ec-key.pem', 64], ['dsa_private_1025.pem', 40]]; for (const [file, length] of keys) { + if (process.features.openssl_is_boringssl && file.startsWith('dsa_')) { + common.printSkipMessage(`Skipping unsupported ${file} test case`); + continue; + } const privKey = fixtures.readKey(file); [ crypto.createSign('sha1').update(data).sign(privKey), @@ -752,7 +768,7 @@ if (hasOpenSSL(3, 2)) { })); } -{ +if (!process.features.openssl_is_boringssl) { // Test RSA-PSS. { // This key pair does not restrict the message digest algorithm or salt @@ -861,6 +877,8 @@ if (hasOpenSSL(3, 2)) { } } } +} else { + common.printSkipMessage('Skipping unsupported RSA-PSS test cases'); } // The sign function should not swallow OpenSSL errors. @@ -873,7 +891,7 @@ if (hasOpenSSL(3, 2)) { crypto.sign('sha512', 'message', privateKey); }, { code: 'ERR_OSSL_RSA_DIGEST_TOO_BIG_FOR_RSA_KEY', - message: /digest too big for rsa key/ + message: /digest too big for rsa key|DIGEST_TOO_BIG_FOR_RSA_KEY/ }); } @@ -898,9 +916,13 @@ if (hasOpenSSL(3, 2)) { { // Ed25519 and Ed448 must use the one-shot methods const keys = [{ privateKey: fixtures.readKey('ed25519_private.pem', 'ascii'), - publicKey: fixtures.readKey('ed25519_public.pem', 'ascii') }, - { privateKey: fixtures.readKey('ed448_private.pem', 'ascii'), - publicKey: fixtures.readKey('ed448_public.pem', 'ascii') }]; + publicKey: fixtures.readKey('ed25519_public.pem', 'ascii') }]; + if (!process.features.openssl_is_boringssl) { + keys.push({ privateKey: fixtures.readKey('ed448_private.pem', 'ascii'), + publicKey: fixtures.readKey('ed448_public.pem', 'ascii') }); + } else { + common.printSkipMessage('Skipping unsupported Ed448 test case'); + } for (const { publicKey, privateKey } of keys) { assert.throws(() => { @@ -915,7 +937,7 @@ if (hasOpenSSL(3, 2)) { } } -{ +if (!process.features.openssl_is_boringssl) { // Dh, x25519 and x448 should not be used for signing/verifying // https://github.com/nodejs/node/issues/53742 for (const algo of ['dh', 'x25519', 'x448']) { @@ -931,6 +953,8 @@ if (hasOpenSSL(3, 2)) { crypto.createVerify('SHA256').update('Test123').verify(publicKey, 'sig'); }, { code: 'ERR_OSSL_EVP_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE', message: /operation not supported for this keytype/ }); } +} else { + common.printSkipMessage('Skipping unsupported dh/x25519/x448 test cases'); } // Test that sign/verify error messages use correct property paths diff --git a/test/parallel/test-crypto.js b/test/parallel/test-crypto.js index d21a6bd3d98d6d..fbb065dd442876 100644 --- a/test/parallel/test-crypto.js +++ b/test/parallel/test-crypto.js @@ -145,8 +145,10 @@ assert(crypto.getHashes().includes('sha1')); assert(crypto.getHashes().includes('sha256')); assert(!crypto.getHashes().includes('SHA1')); assert(!crypto.getHashes().includes('SHA256')); -assert(crypto.getHashes().includes('RSA-SHA1')); -assert(!crypto.getHashes().includes('rsa-sha1')); +if (!process.features.openssl_is_boringssl) { + assert(crypto.getHashes().includes('RSA-SHA1')); + assert(!crypto.getHashes().includes('rsa-sha1')); +} validateList(crypto.getHashes()); // Make sure all of the hashes are supported by OpenSSL for (const algo of crypto.getHashes()) diff --git a/test/parallel/test-tls-dhparam-auto-boringssl.js b/test/parallel/test-tls-dhparam-auto-boringssl.js new file mode 100644 index 00000000000000..54f2190d1a947b --- /dev/null +++ b/test/parallel/test-tls-dhparam-auto-boringssl.js @@ -0,0 +1,19 @@ +'use strict'; +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); + +if (!process.features.openssl_is_boringssl) + common.skip('only applies to BoringSSL builds'); + +const assert = require('assert'); +const tls = require('tls'); + +// BoringSSL does not provide SSL_CTX_set_dh_auto, so requesting automatic +// DH parameter selection via `dhparam: 'auto'` must throw. +assert.throws(() => { + tls.createSecureContext({ dhparam: 'auto' }); +}, { + code: 'ERR_CRYPTO_UNSUPPORTED_OPERATION', + message: 'Automatic DH parameter selection is not supported', +}); diff --git a/test/parallel/test-webcrypto-export-import-cfrg.js b/test/parallel/test-webcrypto-export-import-cfrg.js index c6e3509a4362bc..b1732bf077416c 100644 --- a/test/parallel/test-webcrypto-export-import-cfrg.js +++ b/test/parallel/test-webcrypto-export-import-cfrg.js @@ -428,7 +428,7 @@ async function testImportRaw({ name, publicUsages }) { for (const [name, publicUsages, privateUsages] of [ ['Ed25519', ['verify'], ['sign']], - ['X448', [], ['deriveBits']], + ['X25519', [], ['deriveBits']], ]) { assert.rejects(subtle.importKey( 'spki', diff --git a/test/parallel/test-webcrypto-promise-prototype-pollution.mjs b/test/parallel/test-webcrypto-promise-prototype-pollution.mjs index b4fbedba5e3242..3ea0a961f41b90 100644 --- a/test/parallel/test-webcrypto-promise-prototype-pollution.mjs +++ b/test/parallel/test-webcrypto-promise-prototype-pollution.mjs @@ -59,17 +59,21 @@ await subtle.deriveKey( true, ['encrypt', 'decrypt']); -const wrappingKey = await subtle.generateKey( - { name: 'AES-KW', length: 256 }, true, ['wrapKey', 'unwrapKey']); +if (!process.features.openssl_is_boringssl) { + const wrappingKey = await subtle.generateKey( + { name: 'AES-KW', length: 256 }, true, ['wrapKey', 'unwrapKey']); -const keyToWrap = await subtle.generateKey( - { name: 'AES-CBC', length: 256 }, true, ['encrypt', 'decrypt']); + const keyToWrap = await subtle.generateKey( + { name: 'AES-CBC', length: 256 }, true, ['encrypt', 'decrypt']); -const wrapped = await subtle.wrapKey('raw', keyToWrap, wrappingKey, 'AES-KW'); + const wrapped = await subtle.wrapKey('raw', keyToWrap, wrappingKey, 'AES-KW'); -await subtle.unwrapKey( - 'raw', wrapped, wrappingKey, 'AES-KW', - { name: 'AES-CBC', length: 256 }, true, ['encrypt', 'decrypt']); + await subtle.unwrapKey( + 'raw', wrapped, wrappingKey, 'AES-KW', + { name: 'AES-CBC', length: 256 }, true, ['encrypt', 'decrypt']); +} else { + common.printSkipMessage('Skipping unsupported AES-KW test case'); +} const { privateKey } = await subtle.generateKey( { name: 'ECDSA', namedCurve: 'P-256' }, true, ['sign', 'verify']); diff --git a/test/parallel/test-webcrypto-wrap-unwrap.js b/test/parallel/test-webcrypto-wrap-unwrap.js index a0cbe2c324f786..8c57111daebca6 100644 --- a/test/parallel/test-webcrypto-wrap-unwrap.js +++ b/test/parallel/test-webcrypto-wrap-unwrap.js @@ -179,13 +179,6 @@ async function generateKeysToWrap() { usages: ['encrypt', 'decrypt'], pair: false, }, - { - algorithm: { - name: 'ChaCha20-Poly1305' - }, - usages: ['encrypt', 'decrypt'], - pair: false, - }, { algorithm: { name: 'HMAC', @@ -210,6 +203,18 @@ async function generateKeysToWrap() { common.printSkipMessage('Skipping unsupported AES-KW test case'); } + if (!process.features.openssl_is_boringssl) { + parameters.push({ + algorithm: { + name: 'ChaCha20-Poly1305' + }, + usages: ['encrypt', 'decrypt'], + pair: false, + }); + } else { + common.printSkipMessage('Skipping unsupported ChaCha20-Poly1305 test case'); + } + if (hasOpenSSL(3, 5)) { for (const name of ['ML-DSA-44', 'ML-DSA-65', 'ML-DSA-87']) { parameters.push({ diff --git a/test/pummel/test-crypto-dh-keys.js b/test/pummel/test-crypto-dh-keys.js index ba67bc5717af62..8aa1e30e354f95 100644 --- a/test/pummel/test-crypto-dh-keys.js +++ b/test/pummel/test-crypto-dh-keys.js @@ -33,11 +33,14 @@ if (common.isPi()) { const assert = require('assert'); const crypto = require('crypto'); -[ 'modp1', 'modp2', 'modp5', 'modp14', 'modp15', 'modp16', 'modp17' ] -.forEach((name) => { - // modp1 is 768 bits, FIPS requires >= 1024 - if (name === 'modp1' && crypto.getFips()) { - return; +for (const name of ['modp1', 'modp2', 'modp5', 'modp14', 'modp15', 'modp16', 'modp17']) { + // modp1 is 768 bits, FIPS requires >= 1024. + // BoringSSL does not support modp1 or modp2. + if ((name === 'modp1' && crypto.getFips()) || + (process.features.openssl_is_boringssl && + (name === 'modp1' || name === 'modp2'))) { + common.printSkipMessage(`Skipping unsupported ${name} test case`); + continue; } const group1 = crypto.getDiffieHellman(name); const group2 = crypto.getDiffieHellman(name); @@ -46,4 +49,4 @@ const crypto = require('crypto'); const key1 = group1.computeSecret(group2.getPublicKey()); const key2 = group2.computeSecret(group1.getPublicKey()); assert.deepStrictEqual(key1, key2); -}); +} diff --git a/test/pummel/test-webcrypto-derivebits-pbkdf2.js b/test/pummel/test-webcrypto-derivebits-pbkdf2.js index 7cbcafd020edf7..cbe64bff77505c 100644 --- a/test/pummel/test-webcrypto-derivebits-pbkdf2.js +++ b/test/pummel/test-webcrypto-derivebits-pbkdf2.js @@ -24,14 +24,21 @@ const kDerivedKeyTypes = [ ['AES-CTR', 256, undefined, 'encrypt', 'decrypt'], ['AES-GCM', 128, undefined, 'encrypt', 'decrypt'], ['AES-GCM', 256, undefined, 'encrypt', 'decrypt'], - ['AES-KW', 128, undefined, 'wrapKey', 'unwrapKey'], - ['AES-KW', 256, undefined, 'wrapKey', 'unwrapKey'], ['HMAC', 256, 'SHA-1', 'sign', 'verify'], ['HMAC', 256, 'SHA-256', 'sign', 'verify'], ['HMAC', 256, 'SHA-384', 'sign', 'verify'], ['HMAC', 256, 'SHA-512', 'sign', 'verify'], ]; +if (!process.features.openssl_is_boringssl) { + kDerivedKeyTypes.push( + ['AES-KW', 128, undefined, 'wrapKey', 'unwrapKey'], + ['AES-KW', 256, undefined, 'wrapKey', 'unwrapKey'], + ); +} else { + common.printSkipMessage('Skipping unsupported AES-KW test cases'); +} + const kPasswords = { short: '5040737377307264', long: '55736572732073686f756c64207069636b206c6f6' + From f64b968bac7c9eda95394539f761e0e9c9f5406b Mon Sep 17 00:00:00 2001 From: Anna Henningsen Date: Fri, 1 May 2026 14:40:29 +0200 Subject: [PATCH 037/168] src: use `unique_ptr` for ffi memory management MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Anna Henningsen PR-URL: https://github.com/nodejs/node/pull/63071 Reviewed-By: Juan José Arboleda Reviewed-By: Paolo Insogna Reviewed-By: Matteo Collina --- src/node_ffi.cc | 29 +++++++++++++---------------- 1 file changed, 13 insertions(+), 16 deletions(-) diff --git a/src/node_ffi.cc b/src/node_ffi.cc index 22aeb8fd22f108..67ab93b3a8234c 100644 --- a/src/node_ffi.cc +++ b/src/node_ffi.cc @@ -874,22 +874,22 @@ void DynamicLibrary::RegisterCallback(const FunctionCallbackInfo& args) { return; } - auto callback = new FFICallback{.owner = lib, - .env = env, - .thread_id = std::this_thread::get_id(), - .fn = Global(isolate, fn), - .closure = nullptr, - .ptr = nullptr, - .cif = {}, - .args = std::move(callback_args), - .return_type = return_type}; + auto callback = std::unique_ptr( + new FFICallback{.owner = lib, + .env = env, + .thread_id = std::this_thread::get_id(), + .fn = Global(isolate, fn), + .closure = nullptr, + .ptr = nullptr, + .cif = {}, + .args = std::move(callback_args), + .return_type = return_type}); callback->closure = static_cast( ffi_closure_alloc(sizeof(ffi_closure), &callback->ptr)); if (callback->closure == nullptr) { THROW_ERR_FFI_CALL_FAILED(env, "ffi_closure_alloc failed"); - delete callback; return; } @@ -914,7 +914,6 @@ void DynamicLibrary::RegisterCallback(const FunctionCallbackInfo& args) { } THROW_ERR_FFI_CALL_FAILED(env, msg); - delete callback; return; } @@ -938,14 +937,12 @@ void DynamicLibrary::RegisterCallback(const FunctionCallbackInfo& args) { } THROW_ERR_FFI_CALL_FAILED(env, msg); - delete callback; return; } - lib->callbacks_.emplace(callback->ptr, callback); - args.GetReturnValue().Set(BigInt::NewFromUnsigned( - isolate, - static_cast(reinterpret_cast(callback->ptr)))); + auto ret = static_cast(reinterpret_cast(callback->ptr)); + lib->callbacks_.emplace(callback->ptr, std::move(callback)); + args.GetReturnValue().Set(BigInt::NewFromUnsigned(isolate, ret)); } void DynamicLibrary::UnregisterCallback( From 10dd87b5cf102a13e8cca9715fc91b4f46c6545e Mon Sep 17 00:00:00 2001 From: Anna Henningsen Date: Fri, 1 May 2026 15:13:51 +0200 Subject: [PATCH 038/168] ffi: make `FFIFunctionInfo` a `BaseObject` subclass MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This brings the typical benefits of using `BaseObject`, such as a reduced risk of memory management pitfalls (e.g. accidental `v8::Global` recursive references) and diagnostic tracking. Signed-off-by: Anna Henningsen PR-URL: https://github.com/nodejs/node/pull/63071 Reviewed-By: Juan José Arboleda Reviewed-By: Paolo Insogna Reviewed-By: Matteo Collina --- src/node_ffi.cc | 81 +++++++++++++++++++++++++++++++------------------ src/node_ffi.h | 29 +++++++++++++++--- 2 files changed, 76 insertions(+), 34 deletions(-) diff --git a/src/node_ffi.cc b/src/node_ffi.cc index 67ab93b3a8234c..34f999b015123b 100644 --- a/src/node_ffi.cc +++ b/src/node_ffi.cc @@ -20,7 +20,6 @@ using v8::Boolean; using v8::Context; using v8::DontDelete; using v8::DontEnum; -using v8::External; using v8::Function; using v8::FunctionCallbackInfo; using v8::FunctionTemplate; @@ -39,11 +38,13 @@ using v8::ReadOnly; using v8::String; using v8::TryCatch; using v8::Value; -using v8::WeakCallbackInfo; -using v8::WeakCallbackType; namespace ffi { +void FFIFunctionInfo::MemoryInfo(MemoryTracker* tracker) const { + tracker->TrackField("sb_backing", sb_backing); +} + DynamicLibrary::DynamicLibrary(Environment* env, Local object) : BaseObject(env, object), lib_{}, handle_(nullptr), symbols_() { MakeWeak(); @@ -189,13 +190,44 @@ Maybe DynamicLibrary::PrepareFunction( return Just(PreparedFunction{fn, should_cache_symbol, should_cache_function}); } -void DynamicLibrary::CleanupFunctionInfo( - const WeakCallbackInfo& data) { - FFIFunctionInfo* info = data.GetParameter(); - info->fn.reset(); - info->self.Reset(); - info->library.Reset(); - delete info; +FFIFunctionInfo::FFIFunctionInfo(Environment* env, + Local object, + std::shared_ptr fn, + DynamicLibrary* library) + : BaseObject(env, object), fn(std::move(fn)) { + // Keep the DynamicLibrary instance alive as long as any of its functions are + // alive + object->SetInternalField(FFIFunctionInfo::kLibrary, library->object()); +} + +Local FFIFunctionInfo::GetConstructorTemplate( + IsolateData* isolate_data) { + Local tmpl = + isolate_data->ffi_function_constructor_template(); + if (tmpl.IsEmpty()) { + Isolate* isolate = isolate_data->isolate(); + tmpl = MakeLazilyInitializedJSTemplate(isolate_data, kInternalFieldCount); + Local classname = FIXED_ONE_BYTE_STRING(isolate, "FFIFunctionInfo"); + tmpl->SetClassName(classname); + auto instance = tmpl->InstanceTemplate(); + instance->SetInternalFieldCount(FFIFunctionInfo::kInternalFieldCount); + isolate_data->set_ffi_function_constructor_template(tmpl); + } + return tmpl; +} + +BaseObjectPtr FFIFunctionInfo::Create( + Environment* env, + std::shared_ptr fn, + DynamicLibrary* library) { + Local obj; + if (!GetConstructorTemplate(env->isolate_data()) + ->InstanceTemplate() + ->NewInstance(env->context()) + .ToLocal(&obj)) { + return nullptr; + } + return MakeWeakBaseObject(env, obj, std::move(fn), library); } MaybeLocal DynamicLibrary::CreateFunction( @@ -205,24 +237,18 @@ MaybeLocal DynamicLibrary::CreateFunction( Isolate* isolate = env->isolate(); Local context = env->context(); - // The info is held in a unique_ptr so early-return paths free it. Ownership - // moves to the weak callback via `release()` once `SetWeak` succeeds. - auto info = std::make_unique(); - info->fn = fn; + auto info = FFIFunctionInfo::Create(env, fn, this); DCHECK_EQ(fn->args.size(), fn->arg_type_names.size()); bool use_sb = IsSBEligibleSignature(*fn); bool has_ptr_args = use_sb && SignatureHasPointerArgs(*fn); - Local data = - External::New(isolate, info.get(), v8::kExternalPointerTypeTagDefault); - MaybeLocal maybe_ret = Function::New(context, use_sb ? DynamicLibrary::InvokeFunctionSB : DynamicLibrary::InvokeFunction, - data); + info->object()); Local ret; if (!maybe_ret.ToLocal(&ret)) { return MaybeLocal(); @@ -270,7 +296,8 @@ MaybeLocal DynamicLibrary::CreateFunction( // (strings, Buffers, ArrayBuffers, and ArrayBufferViews). if (has_ptr_args) { Local slow_fn; - if (!Function::New(context, DynamicLibrary::InvokeFunction, data) + if (!Function::New( + context, DynamicLibrary::InvokeFunction, info->object()) .ToLocal(&slow_fn)) { return MaybeLocal(); } @@ -313,12 +340,6 @@ MaybeLocal DynamicLibrary::CreateFunction( } } - info->self.Reset(isolate, ret); - info->library.Reset(isolate, object()); - info->self.SetWeak(info.release(), - DynamicLibrary::CleanupFunctionInfo, - WeakCallbackType::kParameter); - return ret; } @@ -375,8 +396,8 @@ void DynamicLibrary::Close(const FunctionCallbackInfo& args) { void DynamicLibrary::InvokeFunction(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args); - FFIFunctionInfo* info = static_cast( - args.Data().As()->Value(v8::kExternalPointerTypeTagDefault)); + FFIFunctionInfo* info = Unwrap(args.Data()); + CHECK_NOT_NULL(info); FFIFunction* fn = info->fn.get(); if (fn == nullptr || fn->closed || fn->ptr == nullptr) { @@ -444,8 +465,8 @@ void DynamicLibrary::InvokeFunction(const FunctionCallbackInfo& args) { void DynamicLibrary::InvokeFunctionSB(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args); - FFIFunctionInfo* info = - static_cast(args.Data().As()->Value()); + FFIFunctionInfo* info = Unwrap(args.Data()); + CHECK_NOT_NULL(info); FFIFunction* fn = info->fn.get(); if (fn == nullptr || fn->closed || fn->ptr == nullptr) { @@ -920,7 +941,7 @@ void DynamicLibrary::RegisterCallback(const FunctionCallbackInfo& args) { status = ffi_prep_closure_loc(callback->closure, &callback->cif, DynamicLibrary::InvokeCallback, - callback, + callback.get(), callback->ptr); if (status != FFI_OK) { const char* msg = "ffi_prep_closure_loc failed"; diff --git a/src/node_ffi.h b/src/node_ffi.h index 22d78a2ad4f35a..1626fd5fa0d756 100644 --- a/src/node_ffi.h +++ b/src/node_ffi.h @@ -29,12 +29,33 @@ struct FFIFunction { std::string return_type_name; }; -struct FFIFunctionInfo { +class FFIFunctionInfo final : public BaseObject { + public: + enum InternalFields { + kLibrary = BaseObject::kInternalFieldCount, + kInternalFieldCount + }; + + FFIFunctionInfo(Environment* env, + v8::Local object, + std::shared_ptr fn, + DynamicLibrary* library); + + void MemoryInfo(MemoryTracker* tracker) const override; + SET_MEMORY_INFO_NAME(FFIFunctionInfo) + SET_SELF_SIZE(FFIFunctionInfo) + + static BaseObjectPtr Create(Environment* env, + std::shared_ptr fn, + DynamicLibrary* library); + static v8::Local GetConstructorTemplate( + IsolateData* isolate_data); + + private: std::shared_ptr fn; - v8::Global self; std::shared_ptr sb_backing; - // Keep the owning DynamicLibrary alive while the generated function is alive. - v8::Global library; + + friend class DynamicLibrary; }; struct FFICallback { From 2ce788c095669b405c30bce8e1137993a76e7804 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Sun, 3 May 2026 22:08:32 +0000 Subject: [PATCH 039/168] meta: bump actions/upload-artifact from 7.0.0 to 7.0.1 Bumps [actions/upload-artifact](https://github.com/actions/upload-artifact) from 7.0.0 to 7.0.1. - [Release notes](https://github.com/actions/upload-artifact/releases) - [Commits](https://github.com/actions/upload-artifact/compare/v7...043fb46d1a93c77aae656e7c1c64a875d1fc6a0a) --- updated-dependencies: - dependency-name: actions/upload-artifact dependency-version: 7.0.1 dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] PR-URL: https://github.com/nodejs/node/pull/63072 Reviewed-By: Antoine du Hamel Reviewed-By: Luigi Pinca --- .github/workflows/test-shared.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/test-shared.yml b/.github/workflows/test-shared.yml index f9a2df843c5572..a9f18bfc6b6629 100644 --- a/.github/workflows/test-shared.yml +++ b/.github/workflows/test-shared.yml @@ -223,7 +223,7 @@ jobs: - name: Upload libv8 if: ${{ steps.cachix-check.outputs.ALREADY_CACHED != 'true' && steps.cachix-check.outputs.HAS_WRITE_TOKEN != 'true' }} id: upload - uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0 + uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 with: name: libv8 path: libv8 From 502a7ef513939e56b8ac1d7b6ee7603530795c13 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Sun, 3 May 2026 22:08:42 +0000 Subject: [PATCH 040/168] meta: bump Mozilla-Actions/sccache-action from 0.0.9 to 0.0.10 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bumps [Mozilla-Actions/sccache-action](https://github.com/mozilla-actions/sccache-action) from 0.0.9 to 0.0.10. - [Release notes](https://github.com/mozilla-actions/sccache-action/releases) - [Commits](https://github.com/mozilla-actions/sccache-action/compare/7d986dd989559c6ecdb630a3fd2557667be217ad...9e7fa8a12102821edf02ca5dbea1acd0f89a2696) --- updated-dependencies: - dependency-name: Mozilla-Actions/sccache-action dependency-version: 0.0.10 dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] PR-URL: https://github.com/nodejs/node/pull/63073 Reviewed-By: Michaël Zasso Reviewed-By: Luigi Pinca --- .github/workflows/build-tarball.yml | 2 +- .github/workflows/coverage-linux-without-intl.yml | 2 +- .github/workflows/coverage-linux.yml | 2 +- .github/workflows/test-internet.yml | 2 +- .github/workflows/test-linux.yml | 2 +- .github/workflows/test-macos.yml | 2 +- 6 files changed, 6 insertions(+), 6 deletions(-) diff --git a/.github/workflows/build-tarball.yml b/.github/workflows/build-tarball.yml index 63890ac8e50563..5b26bfba6c4479 100644 --- a/.github/workflows/build-tarball.yml +++ b/.github/workflows/build-tarball.yml @@ -121,7 +121,7 @@ jobs: allow-prereleases: true - name: Set up sccache if: github.base_ref == 'main' || github.ref_name == 'main' - uses: Mozilla-Actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9 + uses: Mozilla-Actions/sccache-action@9e7fa8a12102821edf02ca5dbea1acd0f89a2696 # v0.0.10 with: version: v0.12.0 - name: Environment Information diff --git a/.github/workflows/coverage-linux-without-intl.yml b/.github/workflows/coverage-linux-without-intl.yml index 6a94519eac5d5a..7336900a73c099 100644 --- a/.github/workflows/coverage-linux-without-intl.yml +++ b/.github/workflows/coverage-linux-without-intl.yml @@ -64,7 +64,7 @@ jobs: allow-prereleases: true - name: Set up sccache if: github.base_ref == 'main' || github.ref_name == 'main' - uses: Mozilla-Actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9 + uses: Mozilla-Actions/sccache-action@9e7fa8a12102821edf02ca5dbea1acd0f89a2696 # v0.0.10 with: version: v0.12.0 - name: Environment Information diff --git a/.github/workflows/coverage-linux.yml b/.github/workflows/coverage-linux.yml index 1d6ad69e8d9fd1..da798627d99a4b 100644 --- a/.github/workflows/coverage-linux.yml +++ b/.github/workflows/coverage-linux.yml @@ -64,7 +64,7 @@ jobs: allow-prereleases: true - name: Set up sccache if: github.base_ref == 'main' || github.ref_name == 'main' - uses: Mozilla-Actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9 + uses: Mozilla-Actions/sccache-action@9e7fa8a12102821edf02ca5dbea1acd0f89a2696 # v0.0.10 with: version: v0.12.0 - name: Environment Information diff --git a/.github/workflows/test-internet.yml b/.github/workflows/test-internet.yml index ebcff77ed90d7e..6471391171b0c5 100644 --- a/.github/workflows/test-internet.yml +++ b/.github/workflows/test-internet.yml @@ -61,7 +61,7 @@ jobs: allow-prereleases: true - name: Set up sccache if: github.base_ref == 'main' || github.ref_name == 'main' - uses: Mozilla-Actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9 + uses: Mozilla-Actions/sccache-action@9e7fa8a12102821edf02ca5dbea1acd0f89a2696 # v0.0.10 with: version: v0.12.0 - name: Environment Information diff --git a/.github/workflows/test-linux.yml b/.github/workflows/test-linux.yml index 5887a99eb8b991..7c1baf9890461e 100644 --- a/.github/workflows/test-linux.yml +++ b/.github/workflows/test-linux.yml @@ -77,7 +77,7 @@ jobs: allow-prereleases: true - name: Set up sccache if: github.base_ref == 'main' || github.ref_name == 'main' - uses: Mozilla-Actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9 + uses: Mozilla-Actions/sccache-action@9e7fa8a12102821edf02ca5dbea1acd0f89a2696 # v0.0.10 with: version: v0.12.0 - name: Environment Information diff --git a/.github/workflows/test-macos.yml b/.github/workflows/test-macos.yml index e227877f38a007..e17ac27020cc97 100644 --- a/.github/workflows/test-macos.yml +++ b/.github/workflows/test-macos.yml @@ -100,7 +100,7 @@ jobs: rustup --version - name: Set up sccache if: github.base_ref == 'main' || github.ref_name == 'main' - uses: Mozilla-Actions/sccache-action@7d986dd989559c6ecdb630a3fd2557667be217ad # v0.0.9 + uses: Mozilla-Actions/sccache-action@9e7fa8a12102821edf02ca5dbea1acd0f89a2696 # v0.0.10 with: version: v0.12.0 - name: Environment Information From bb26491933788f5fcb7d3b643b413e8862a89813 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Sun, 3 May 2026 22:08:51 +0000 Subject: [PATCH 041/168] meta: bump github/codeql-action from 4.35.1 to 4.35.3 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bumps [github/codeql-action](https://github.com/github/codeql-action) from 4.35.1 to 4.35.3. - [Release notes](https://github.com/github/codeql-action/releases) - [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md) - [Commits](https://github.com/github/codeql-action/compare/c10b8064de6f491fea524254123dbe5e09572f13...e46ed2cbd01164d986452f91f178727624ae40d7) --- updated-dependencies: - dependency-name: github/codeql-action dependency-version: 4.35.3 dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] PR-URL: https://github.com/nodejs/node/pull/63074 Reviewed-By: Ulises Gascón Reviewed-By: Colin Ihrig Reviewed-By: Luigi Pinca --- .github/workflows/codeql.yml | 6 +++--- .github/workflows/scorecard.yml | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml index 41666793e9f1eb..5ff9daaa630d2a 100644 --- a/.github/workflows/codeql.yml +++ b/.github/workflows/codeql.yml @@ -27,15 +27,15 @@ jobs: # Initializes the CodeQL tools for scanning. - name: Initialize CodeQL - uses: github/codeql-action/init@c10b8064de6f491fea524254123dbe5e09572f13 # v4.35.1 + uses: github/codeql-action/init@e46ed2cbd01164d986452f91f178727624ae40d7 # v4.35.3 with: languages: ${{ matrix.language }} config-file: ./.github/codeql-config.yml - name: Autobuild - uses: github/codeql-action/autobuild@c10b8064de6f491fea524254123dbe5e09572f13 # v4.35.1 + uses: github/codeql-action/autobuild@e46ed2cbd01164d986452f91f178727624ae40d7 # v4.35.3 - name: Perform CodeQL Analysis - uses: github/codeql-action/analyze@c10b8064de6f491fea524254123dbe5e09572f13 # v4.35.1 + uses: github/codeql-action/analyze@e46ed2cbd01164d986452f91f178727624ae40d7 # v4.35.3 with: category: /language:${{matrix.language}} diff --git a/.github/workflows/scorecard.yml b/.github/workflows/scorecard.yml index 84b8e448642884..07f05ecbbca57f 100644 --- a/.github/workflows/scorecard.yml +++ b/.github/workflows/scorecard.yml @@ -75,6 +75,6 @@ jobs: # Upload the results to GitHub's code scanning dashboard. - name: Upload to code-scanning - uses: github/codeql-action/upload-sarif@c10b8064de6f491fea524254123dbe5e09572f13 # v4.35.1 + uses: github/codeql-action/upload-sarif@e46ed2cbd01164d986452f91f178727624ae40d7 # v4.35.3 with: sarif_file: results.sarif From 25f80fb7647d2c22b26359f4a5945a8c2b7efff3 Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Fri, 24 Apr 2026 13:52:52 +0200 Subject: [PATCH 042/168] src: decouple KeyObject and CryptoKey and move CryptoKey to src Signed-off-by: Filip Skokan PR-URL: https://github.com/nodejs/node/pull/62924 Reviewed-By: Antoine du Hamel --- benchmark/crypto/webcrypto-sign.js | 97 ++++ benchmark/crypto/webcrypto-verify.js | 100 ++++ lib/eslint.config_partial.mjs | 4 + lib/internal/crypto/aes.js | 90 ++-- lib/internal/crypto/argon2.js | 8 +- lib/internal/crypto/cfrg.js | 74 ++- lib/internal/crypto/chacha20_poly1305.js | 55 +-- lib/internal/crypto/diffiehellman.js | 20 +- lib/internal/crypto/ec.js | 69 ++- lib/internal/crypto/hkdf.js | 15 +- lib/internal/crypto/keys.js | 460 +++++++++++------- lib/internal/crypto/mac.js | 85 +--- lib/internal/crypto/ml_dsa.js | 79 +-- lib/internal/crypto/ml_kem.js | 82 ++-- lib/internal/crypto/pbkdf2.js | 8 +- lib/internal/crypto/rsa.js | 81 ++- lib/internal/crypto/util.js | 122 +++-- lib/internal/crypto/webcrypto.js | 171 ++++--- lib/internal/crypto/webcrypto_util.js | 82 +++- lib/internal/crypto/webidl.js | 9 +- lib/internal/util/comparisons.js | 29 +- src/crypto/README.md | 26 +- src/crypto/crypto_ec.cc | 17 +- src/crypto/crypto_keys.cc | 264 ++++++++++ src/crypto/crypto_keys.h | 89 ++++ src/crypto/crypto_rsa.cc | 4 +- src/env_properties.h | 2 + src/node_crypto.cc | 1 + .../test-webcrypto-cryptokey-brand-check.js | 126 +++++ ...test-webcrypto-cryptokey-clone-transfer.js | 351 +++++++++++++ .../test-webcrypto-cryptokey-hidden-slots.js | 161 ++++++ ...test-webcrypto-cryptokey-no-own-symbols.js | 52 ++ .../test-webcrypto-derivebits-hkdf.js | 37 +- ...rypto-encrypt-decrypt-chacha20-poly1305.js | 1 + .../test-webcrypto-export-import-cfrg.js | 4 +- .../test-webcrypto-export-import-ec.js | 4 +- .../test-webcrypto-export-import-ml-dsa.js | 4 +- .../test-webcrypto-export-import-ml-kem.js | 4 +- .../test-webcrypto-export-import-rsa.js | 14 + .../test-webcrypto-internal-slots.mjs | 7 + 40 files changed, 2150 insertions(+), 758 deletions(-) create mode 100644 benchmark/crypto/webcrypto-sign.js create mode 100644 benchmark/crypto/webcrypto-verify.js create mode 100644 test/parallel/test-webcrypto-cryptokey-brand-check.js create mode 100644 test/parallel/test-webcrypto-cryptokey-clone-transfer.js create mode 100644 test/parallel/test-webcrypto-cryptokey-hidden-slots.js create mode 100644 test/parallel/test-webcrypto-cryptokey-no-own-symbols.js diff --git a/benchmark/crypto/webcrypto-sign.js b/benchmark/crypto/webcrypto-sign.js new file mode 100644 index 00000000000000..d298ec69eef437 --- /dev/null +++ b/benchmark/crypto/webcrypto-sign.js @@ -0,0 +1,97 @@ +'use strict'; + +const common = require('../common.js'); +const { hasOpenSSL } = require('../../test/common/crypto.js'); +const { subtle } = globalThis.crypto; + +const kAlgorithms = { + 'ec': { name: 'ECDSA', namedCurve: 'P-256' }, + 'rsassa-pkcs1-v1_5': { + name: 'RSASSA-PKCS1-v1_5', + modulusLength: 2048, + publicExponent: new Uint8Array([1, 0, 1]), + hash: 'SHA-256', + }, + 'rsa-pss': { + name: 'RSA-PSS', + modulusLength: 2048, + publicExponent: new Uint8Array([1, 0, 1]), + hash: 'SHA-256', + }, + 'ed25519': { name: 'Ed25519' }, +}; + +if (hasOpenSSL(3, 5)) { + kAlgorithms['ml-dsa-44'] = { name: 'ML-DSA-44' }; +} + +const kSignParams = { + 'ec': { name: 'ECDSA', hash: 'SHA-256' }, + 'rsassa-pkcs1-v1_5': { name: 'RSASSA-PKCS1-v1_5' }, + 'rsa-pss': { name: 'RSA-PSS', saltLength: 32 }, + 'ed25519': { name: 'Ed25519' }, + 'ml-dsa-44': { name: 'ML-DSA-44' }, +}; + +const data = globalThis.crypto.getRandomValues(new Uint8Array(256)); + +let keys; + +const bench = common.createBenchmark(main, { + keyType: Object.keys(kAlgorithms), + mode: ['serial', 'parallel'], + keyReuse: ['shared', 'unique'], + n: [1e3], +}, { + combinationFilter(p) { + // Unique only differs from shared when operations overlap (parallel); + // sequential calls have no contention so unique+serial adds no value. + if (p.keyReuse === 'unique') return p.mode === 'parallel'; + return true; + }, +}); + +async function measureSerial(n, signParams, sharedKey) { + bench.start(); + for (let i = 0; i < n; ++i) { + await subtle.sign(signParams, sharedKey || keys[i], data); + } + bench.end(n); +} + +async function measureParallel(n, signParams, sharedKey) { + const promises = new Array(n); + bench.start(); + for (let i = 0; i < n; ++i) { + promises[i] = subtle.sign(signParams, sharedKey || keys[i], data); + } + await Promise.all(promises); + bench.end(n); +} + +async function main({ n, mode, keyReuse, keyType }) { + const algorithm = kAlgorithms[keyType]; + const signParams = kSignParams[keyType]; + + if (!keys || keys.length !== n || keys[0].algorithm.name !== signParams.name) { + keys = new Array(n); + // Generate one key pair, then import its pkcs8 bytes n times to get + // distinct CryptoKey instances. + const kp = await subtle.generateKey(algorithm, true, ['sign', 'verify']); + const pkcs8 = await subtle.exportKey('pkcs8', kp.privateKey); + for (let i = 0; i < n; ++i) { + keys[i] = await subtle.importKey('pkcs8', pkcs8, algorithm, false, ['sign']); + } + } + + const sharedKey = keyReuse === 'shared' ? keys[0] : undefined; + + switch (mode) { + case 'serial': + await measureSerial(n, signParams, sharedKey); + break; + case 'parallel': + await measureParallel(n, signParams, sharedKey); + break; + } +} diff --git a/benchmark/crypto/webcrypto-verify.js b/benchmark/crypto/webcrypto-verify.js new file mode 100644 index 00000000000000..6b0d52cddc30d8 --- /dev/null +++ b/benchmark/crypto/webcrypto-verify.js @@ -0,0 +1,100 @@ +'use strict'; + +const common = require('../common.js'); +const { hasOpenSSL } = require('../../test/common/crypto.js'); +const { subtle } = globalThis.crypto; + +const kAlgorithms = { + 'ec': { name: 'ECDSA', namedCurve: 'P-256' }, + 'rsassa-pkcs1-v1_5': { + name: 'RSASSA-PKCS1-v1_5', + modulusLength: 2048, + publicExponent: new Uint8Array([1, 0, 1]), + hash: 'SHA-256', + }, + 'rsa-pss': { + name: 'RSA-PSS', + modulusLength: 2048, + publicExponent: new Uint8Array([1, 0, 1]), + hash: 'SHA-256', + }, + 'ed25519': { name: 'Ed25519' }, +}; + +if (hasOpenSSL(3, 5)) { + kAlgorithms['ml-dsa-44'] = { name: 'ML-DSA-44' }; +} + +const kSignParams = { + 'ec': { name: 'ECDSA', hash: 'SHA-256' }, + 'rsassa-pkcs1-v1_5': { name: 'RSASSA-PKCS1-v1_5' }, + 'rsa-pss': { name: 'RSA-PSS', saltLength: 32 }, + 'ed25519': { name: 'Ed25519' }, + 'ml-dsa-44': { name: 'ML-DSA-44' }, +}; + +const data = globalThis.crypto.getRandomValues(new Uint8Array(256)); + +let publicKeys; +let signature; + +const bench = common.createBenchmark(main, { + keyType: Object.keys(kAlgorithms), + mode: ['serial', 'parallel'], + keyReuse: ['shared', 'unique'], + n: [1e3], +}, { + combinationFilter(p) { + // Unique only differs from shared when operations overlap (parallel); + // sequential calls have no contention so unique+serial adds no value. + if (p.keyReuse === 'unique') return p.mode === 'parallel'; + return true; + }, +}); + +async function measureSerial(n, verifyParams, sharedKey) { + bench.start(); + for (let i = 0; i < n; ++i) { + await subtle.verify(verifyParams, sharedKey || publicKeys[i], signature, data); + } + bench.end(n); +} + +async function measureParallel(n, verifyParams, sharedKey) { + const promises = new Array(n); + bench.start(); + for (let i = 0; i < n; ++i) { + promises[i] = subtle.verify(verifyParams, sharedKey || publicKeys[i], signature, data); + } + await Promise.all(promises); + bench.end(n); +} + +async function main({ n, mode, keyReuse, keyType }) { + const algorithm = kAlgorithms[keyType]; + const verifyParams = kSignParams[keyType]; + + if (!publicKeys || publicKeys.length !== n || + publicKeys[0].algorithm.name !== verifyParams.name) { + publicKeys = new Array(n); + // Generate one key pair, then import its spki bytes n times to get + // distinct CryptoKey instances. + const kp = await subtle.generateKey(algorithm, true, ['sign', 'verify']); + const spki = await subtle.exportKey('spki', kp.publicKey); + for (let i = 0; i < n; ++i) { + publicKeys[i] = await subtle.importKey('spki', spki, algorithm, false, ['verify']); + } + signature = await subtle.sign(verifyParams, kp.privateKey, data); + } + + const sharedKey = keyReuse === 'shared' ? publicKeys[0] : undefined; + + switch (mode) { + case 'serial': + await measureSerial(n, verifyParams, sharedKey); + break; + case 'parallel': + await measureParallel(n, verifyParams, sharedKey); + break; + } +} diff --git a/lib/eslint.config_partial.mjs b/lib/eslint.config_partial.mjs index 48328ed678a0a8..61632a7ee447e6 100644 --- a/lib/eslint.config_partial.mjs +++ b/lib/eslint.config_partial.mjs @@ -71,6 +71,10 @@ export default [ selector: "CallExpression[callee.type='Identifier'][callee.name='ReflectApply'][arguments.2.type='ArrayExpression']", message: 'Use `FunctionPrototypeCall` to avoid creating an ad-hoc array', }, + { + selector: "VariableDeclarator[init.type='CallExpression'][init.callee.name='internalBinding'][init.arguments.0.value='crypto'] > ObjectPattern > Property[key.name='getCryptoKeySlots']", + message: "Use `const { getCryptoKeySlots } = require('internal/crypto/keys');` instead of destructuring it from `internalBinding('crypto')`.", + }, ], 'no-restricted-globals': [ 'error', diff --git a/lib/internal/crypto/aes.js b/lib/internal/crypto/aes.js index 0e6189b6df832c..123babf6fd570d 100644 --- a/lib/internal/crypto/aes.js +++ b/lib/internal/crypto/aes.js @@ -7,10 +7,7 @@ const { const { AESCipherJob, - KeyObjectHandle, kCryptoJobAsync, - kKeyFormatJWK, - kKeyTypeSecret, kKeyVariantAES_CTR_128, kKeyVariantAES_CBC_128, kKeyVariantAES_GCM_128, @@ -26,37 +23,32 @@ const { kKeyVariantAES_GCM_256, kKeyVariantAES_KW_256, kKeyVariantAES_OCB_256, + SecretKeyGenJob, } = internalBinding('crypto'); const { + getUsagesMask, hasAnyNotIn, jobPromise, kHandle, - kKeyObject, } = require('internal/crypto/util'); const { lazyDOMException, - promisify, } = require('internal/util'); const { InternalCryptoKey, - SecretKeyObject, - createSecretKey, - kAlgorithm, + getCryptoKeyAlgorithm, + getCryptoKeyHandle, } = require('internal/crypto/keys'); const { + importJwkSecretKey, + importSecretKey, validateJwk, } = require('internal/crypto/webcrypto_util'); -const { - generateKey: _generateKey, -} = require('internal/crypto/keygen'); - -const generateKey = promisify(_generateKey); - function getAlgorithmName(name, length) { switch (name) { case 'AES-CBC': return `A${length}CBC`; @@ -116,9 +108,9 @@ function asyncAesCtrCipher(mode, key, data, algorithm) { return jobPromise(() => new AESCipherJob( kCryptoJobAsync, mode, - key[kKeyObject][kHandle], + getCryptoKeyHandle(key), data, - getVariant('AES-CTR', key[kAlgorithm].length), + getVariant('AES-CTR', getCryptoKeyAlgorithm(key).length), algorithm.counter, algorithm.length)); } @@ -127,9 +119,9 @@ function asyncAesCbcCipher(mode, key, data, algorithm) { return jobPromise(() => new AESCipherJob( kCryptoJobAsync, mode, - key[kKeyObject][kHandle], + getCryptoKeyHandle(key), data, - getVariant('AES-CBC', key[kAlgorithm].length), + getVariant('AES-CBC', getCryptoKeyAlgorithm(key).length), algorithm.iv)); } @@ -137,9 +129,9 @@ function asyncAesKwCipher(mode, key, data) { return jobPromise(() => new AESCipherJob( kCryptoJobAsync, mode, - key[kKeyObject][kHandle], + getCryptoKeyHandle(key), data, - getVariant('AES-KW', key[kAlgorithm].length))); + getVariant('AES-KW', getCryptoKeyAlgorithm(key).length))); } function asyncAesGcmCipher(mode, key, data, algorithm) { @@ -149,9 +141,9 @@ function asyncAesGcmCipher(mode, key, data, algorithm) { return jobPromise(() => new AESCipherJob( kCryptoJobAsync, mode, - key[kKeyObject][kHandle], + getCryptoKeyHandle(key), data, - getVariant('AES-GCM', key[kAlgorithm].length), + getVariant('AES-GCM', getCryptoKeyAlgorithm(key).length), algorithm.iv, tagByteLength, algorithm.additionalData)); @@ -164,9 +156,9 @@ function asyncAesOcbCipher(mode, key, data, algorithm) { return jobPromise(() => new AESCipherJob( kCryptoJobAsync, mode, - key[kKeyObject][kHandle], + getCryptoKeyHandle(key), data, - getVariant('AES-OCB', key.algorithm.length), + getVariant('AES-OCB', getCryptoKeyAlgorithm(key).length), algorithm.iv, tagByteLength, algorithm.additionalData)); @@ -196,20 +188,12 @@ async function aesGenerateKey(algorithm, extractable, keyUsages) { 'SyntaxError'); } - let key; - try { - key = await generateKey('aes', { length }); - } catch (err) { - throw lazyDOMException( - 'The operation failed for an operation-specific reason' + - `[${err.message}]`, - { name: 'OperationError', cause: err }); - } + const handle = await jobPromise(() => new SecretKeyGenJob(kCryptoJobAsync, length)); return new InternalCryptoKey( - key, + handle, { name, length }, - usagesSet, + getUsagesMask(usagesSet), extractable); } @@ -231,12 +215,13 @@ function aesImportKey( 'SyntaxError'); } - let keyObject; + let handle; let length; switch (format) { case 'KeyObject': { - validateKeyLength(keyData.symmetricKeySize * 8); - keyObject = keyData; + length = keyData.symmetricKeySize * 8; + validateKeyLength(length); + handle = keyData[kHandle]; break; } case 'raw-secret': @@ -244,47 +229,32 @@ function aesImportKey( if (format === 'raw' && name === 'AES-OCB') { return undefined; } - validateKeyLength(keyData.byteLength * 8); - keyObject = createSecretKey(keyData); + length = keyData.byteLength * 8; + validateKeyLength(length); + handle = importSecretKey(keyData); break; } case 'jwk': { validateJwk(keyData, 'oct', extractable, usagesSet, 'enc'); - - const handle = new KeyObjectHandle(); - try { - handle.init(kKeyTypeSecret, keyData, kKeyFormatJWK, null, null); - } catch (err) { - throw lazyDOMException( - 'Invalid keyData', { name: 'DataError', cause: err }); - } - - ({ length } = handle.keyDetail({ })); + handle = importJwkSecretKey(keyData); + length = handle.getSymmetricKeySize() * 8; validateKeyLength(length); - if (keyData.alg !== undefined) { if (keyData.alg !== getAlgorithmName(algorithm.name, length)) throw lazyDOMException( 'JWK "alg" does not match the requested algorithm', 'DataError'); } - - keyObject = new SecretKeyObject(handle); break; } default: return undefined; } - if (length === undefined) { - ({ length } = keyObject[kHandle].keyDetail({ })); - validateKeyLength(length); - } - return new InternalCryptoKey( - keyObject, + handle, { name, length }, - usagesSet, + getUsagesMask(usagesSet), extractable); } diff --git a/lib/internal/crypto/argon2.js b/lib/internal/crypto/argon2.js index 1d2b8b7cac91e9..6110c55c16dfb8 100644 --- a/lib/internal/crypto/argon2.js +++ b/lib/internal/crypto/argon2.js @@ -24,9 +24,12 @@ const { promisify, } = require('internal/util'); +const { + getCryptoKeyHandle, +} = require('internal/crypto/keys'); + const { getArrayBufferOrView, - kKeyObject, } = require('internal/crypto/util'); const { @@ -216,7 +219,8 @@ async function argon2DeriveBits(algorithm, baseKey, length) { result = await argon2Promise( StringPrototypeToLowerCase(algorithm.name), { - message: baseKey[kKeyObject].export(), + // TODO(panva): call the job directly without needing to re-export the handle + message: getCryptoKeyHandle(baseKey).export(), nonce: algorithm.nonce, parallelism: algorithm.parallelism, tagLength: length / 8, diff --git a/lib/internal/crypto/cfrg.js b/lib/internal/crypto/cfrg.js index 039f5d8b6635e7..f3e3e008b629f3 100644 --- a/lib/internal/crypto/cfrg.js +++ b/lib/internal/crypto/cfrg.js @@ -16,28 +16,29 @@ const { kWebCryptoKeyFormatPKCS8, kWebCryptoKeyFormatRaw, kWebCryptoKeyFormatSPKI, + NidKeyPairGenJob, + EVP_PKEY_ED25519, + EVP_PKEY_ED448, + EVP_PKEY_X25519, + EVP_PKEY_X448, } = internalBinding('crypto'); const { + getUsagesMask, getUsagesUnion, hasAnyNotIn, jobPromise, kHandle, - kKeyObject, } = require('internal/crypto/util'); const { lazyDOMException, - promisify, } = require('internal/util'); const { - generateKeyPair: _generateKeyPair, -} = require('internal/crypto/keygen'); - -const { + getCryptoKeyHandle, + getCryptoKeyType, InternalCryptoKey, - kKeyType, } = require('internal/crypto/keys'); const { @@ -47,8 +48,6 @@ const { validateJwk, } = require('internal/crypto/webcrypto_util'); -const generateKeyPair = promisify(_generateKeyPair); - function verifyAcceptableCfrgKeyUse(name, isPublic, usages) { let checkSet; switch (name) { @@ -97,30 +96,23 @@ async function cfrgGenerateKey(algorithm, extractable, keyUsages) { } break; } - let genKeyType; + let nid; switch (name) { case 'Ed25519': - genKeyType = 'ed25519'; + nid = EVP_PKEY_ED25519; break; case 'Ed448': - genKeyType = 'ed448'; + nid = EVP_PKEY_ED448; break; case 'X25519': - genKeyType = 'x25519'; + nid = EVP_PKEY_X25519; break; case 'X448': - genKeyType = 'x448'; + nid = EVP_PKEY_X448; break; } - let keyPair; - try { - keyPair = await generateKeyPair(genKeyType); - } catch (err) { - throw lazyDOMException( - 'The operation failed for an operation-specific reason', - { name: 'OperationError', cause: err }); - } + const handles = await jobPromise(() => new NidKeyPairGenJob(kCryptoJobAsync, nid)); let publicUsages; let privateUsages; @@ -143,16 +135,16 @@ async function cfrgGenerateKey(algorithm, extractable, keyUsages) { const publicKey = new InternalCryptoKey( - keyPair.publicKey, + handles[0], keyAlgorithm, - publicUsages, + getUsagesMask(publicUsages), true); const privateKey = new InternalCryptoKey( - keyPair.privateKey, + handles[1], keyAlgorithm, - privateUsages, + getUsagesMask(privateUsages), extractable); return { __proto__: null, privateKey, publicKey }; @@ -162,17 +154,17 @@ function cfrgExportKey(key, format) { try { switch (format) { case kWebCryptoKeyFormatRaw: { - const handle = key[kKeyObject][kHandle]; + const handle = getCryptoKeyHandle(key); return TypedArrayPrototypeGetBuffer( - key[kKeyType] === 'private' ? handle.rawPrivateKey() : handle.rawPublicKey()); + getCryptoKeyType(key) === 'private' ? handle.rawPrivateKey() : handle.rawPublicKey()); } case kWebCryptoKeyFormatSPKI: { return TypedArrayPrototypeGetBuffer( - key[kKeyObject][kHandle].export(kKeyFormatDER, kWebCryptoKeyFormatSPKI)); + getCryptoKeyHandle(key).export(kKeyFormatDER, kWebCryptoKeyFormatSPKI)); } case kWebCryptoKeyFormatPKCS8: { return TypedArrayPrototypeGetBuffer( - key[kKeyObject][kHandle].export(kKeyFormatDER, kWebCryptoKeyFormatPKCS8, null, null)); + getCryptoKeyHandle(key).export(kKeyFormatDER, kWebCryptoKeyFormatPKCS8, null, null)); } default: return undefined; @@ -192,22 +184,22 @@ function cfrgImportKey( keyUsages) { const { name } = algorithm; - let keyObject; + let handle; const usagesSet = new SafeSet(keyUsages); switch (format) { case 'KeyObject': { verifyAcceptableCfrgKeyUse(name, keyData.type === 'public', usagesSet); - keyObject = keyData; + handle = keyData[kHandle]; break; } case 'spki': { verifyAcceptableCfrgKeyUse(name, true, usagesSet); - keyObject = importDerKey(keyData, true); + handle = importDerKey(keyData, true); break; } case 'pkcs8': { verifyAcceptableCfrgKeyUse(name, false, usagesSet); - keyObject = importDerKey(keyData, false); + handle = importDerKey(keyData, false); break; } case 'jwk': { @@ -226,26 +218,26 @@ function cfrgImportKey( const isPublic = keyData.d === undefined; verifyAcceptableCfrgKeyUse(name, isPublic, usagesSet); - keyObject = importJwkKey(isPublic, keyData); + handle = importJwkKey(isPublic, keyData); break; } case 'raw': { verifyAcceptableCfrgKeyUse(name, true, usagesSet); - keyObject = importRawKey(true, keyData, kKeyFormatRawPublic, name); + handle = importRawKey(true, keyData, kKeyFormatRawPublic, name); break; } default: return undefined; } - if (keyObject.asymmetricKeyType !== StringPrototypeToLowerCase(name)) { + if (handle.getAsymmetricKeyType() !== StringPrototypeToLowerCase(name)) { throw lazyDOMException('Invalid key type', 'DataError'); } return new InternalCryptoKey( - keyObject, + handle, { name }, - usagesSet, + getUsagesMask(usagesSet), extractable); } @@ -253,13 +245,13 @@ async function eddsaSignVerify(key, data, algorithm, signature) { const mode = signature === undefined ? kSignJobModeSign : kSignJobModeVerify; const type = mode === kSignJobModeSign ? 'private' : 'public'; - if (key[kKeyType] !== type) + if (getCryptoKeyType(key) !== type) throw lazyDOMException(`Key must be a ${type} key`, 'InvalidAccessError'); return await jobPromise(() => new SignJob( kCryptoJobAsync, mode, - key[kKeyObject][kHandle], + getCryptoKeyHandle(key), undefined, undefined, undefined, diff --git a/lib/internal/crypto/chacha20_poly1305.js b/lib/internal/crypto/chacha20_poly1305.js index fe2ba389d52c66..ca7ec501bf4a0c 100644 --- a/lib/internal/crypto/chacha20_poly1305.js +++ b/lib/internal/crypto/chacha20_poly1305.js @@ -6,40 +6,32 @@ const { const { ChaCha20Poly1305CipherJob, - KeyObjectHandle, + SecretKeyGenJob, kCryptoJobAsync, - kKeyFormatJWK, - kKeyTypeSecret, } = internalBinding('crypto'); const { + getUsagesMask, hasAnyNotIn, jobPromise, kHandle, - kKeyObject, } = require('internal/crypto/util'); const { lazyDOMException, - promisify, } = require('internal/util'); const { InternalCryptoKey, - SecretKeyObject, - createSecretKey, + getCryptoKeyHandle, } = require('internal/crypto/keys'); const { + importJwkSecretKey, + importSecretKey, validateJwk, } = require('internal/crypto/webcrypto_util'); -const { - randomBytes: _randomBytes, -} = require('internal/crypto/random'); - -const randomBytes = promisify(_randomBytes); - function validateKeyLength(length) { if (length !== 256) throw lazyDOMException('Invalid key length', 'DataError'); @@ -49,7 +41,7 @@ function c20pCipher(mode, key, data, algorithm) { return jobPromise(() => new ChaCha20Poly1305CipherJob( kCryptoJobAsync, mode, - key[kKeyObject][kHandle], + getCryptoKeyHandle(key), data, algorithm.iv, algorithm.additionalData)); @@ -67,20 +59,12 @@ async function c20pGenerateKey(algorithm, extractable, keyUsages) { 'SyntaxError'); } - let keyData; - try { - keyData = await randomBytes(32); - } catch (err) { - throw lazyDOMException( - 'The operation failed for an operation-specific reason' + - `[${err.message}]`, - { name: 'OperationError', cause: err }); - } + const handle = await jobPromise(() => new SecretKeyGenJob(kCryptoJobAsync, 256)); return new InternalCryptoKey( - createSecretKey(keyData), + handle, { name }, - usagesSet, + getUsagesMask(usagesSet), extractable); } @@ -100,26 +84,20 @@ function c20pImportKey( 'SyntaxError'); } - let keyObject; + let handle; switch (format) { case 'KeyObject': { - keyObject = keyData; + handle = keyData[kHandle]; break; } case 'raw-secret': { - keyObject = createSecretKey(keyData); + handle = importSecretKey(keyData); break; } case 'jwk': { validateJwk(keyData, 'oct', extractable, usagesSet, 'enc'); - const handle = new KeyObjectHandle(); - try { - handle.init(kKeyTypeSecret, keyData, kKeyFormatJWK, null, null); - } catch (err) { - throw lazyDOMException( - 'Invalid keyData', { name: 'DataError', cause: err }); - } + handle = importJwkSecretKey(keyData); if (keyData.alg !== undefined && keyData.alg !== 'C20P') { throw lazyDOMException( @@ -127,19 +105,18 @@ function c20pImportKey( 'DataError'); } - keyObject = new SecretKeyObject(handle); break; } default: return undefined; } - validateKeyLength(keyObject.symmetricKeySize * 8); + validateKeyLength(handle.getSymmetricKeySize() * 8); return new InternalCryptoKey( - keyObject, + handle, { name }, - usagesSet, + getUsagesMask(usagesSet), extractable); } diff --git a/lib/internal/crypto/diffiehellman.js b/lib/internal/crypto/diffiehellman.js index 24f9c5b36e710c..81006c34b34758 100644 --- a/lib/internal/crypto/diffiehellman.js +++ b/lib/internal/crypto/diffiehellman.js @@ -47,8 +47,9 @@ const { } = require('internal/util'); const { - kAlgorithm, - kKeyType, + getCryptoKeyAlgorithm, + getCryptoKeyHandle, + getCryptoKeyType, preparePrivateKey, preparePublicOrPrivateKey, } = require('internal/crypto/keys'); @@ -58,7 +59,6 @@ const { jobPromise, toBuf, kHandle, - kKeyObject, } = require('internal/crypto/util'); const { @@ -329,32 +329,34 @@ let masks; async function ecdhDeriveBits(algorithm, baseKey, length) { const { 'public': key } = algorithm; - if (baseKey[kKeyType] !== 'private') { + if (getCryptoKeyType(baseKey) !== 'private') { throw lazyDOMException( 'baseKey must be a private key', 'InvalidAccessError'); } - if (key[kAlgorithm].name !== baseKey[kAlgorithm].name) { + const keyAlgorithm = getCryptoKeyAlgorithm(key); + const baseKeyAlgorithm = getCryptoKeyAlgorithm(baseKey); + if (keyAlgorithm.name !== baseKeyAlgorithm.name) { throw lazyDOMException( 'The public and private keys must be of the same type', 'InvalidAccessError'); } if ( - key[kAlgorithm].name === 'ECDH' && - key[kAlgorithm].namedCurve !== baseKey[kAlgorithm].namedCurve + keyAlgorithm.name === 'ECDH' && + keyAlgorithm.namedCurve !== baseKeyAlgorithm.namedCurve ) { throw lazyDOMException('Named curve mismatch', 'InvalidAccessError'); } const bits = await jobPromise(() => new DHBitsJob( kCryptoJobAsync, - key[kKeyObject][kHandle], + getCryptoKeyHandle(key), undefined, undefined, undefined, undefined, - baseKey[kKeyObject][kHandle], + getCryptoKeyHandle(baseKey), undefined, undefined, undefined, diff --git a/lib/internal/crypto/ec.js b/lib/internal/crypto/ec.js index e9c72bc58918e8..e399071228e4e8 100644 --- a/lib/internal/crypto/ec.js +++ b/lib/internal/crypto/ec.js @@ -7,6 +7,7 @@ const { } = primordials; const { + EcKeyPairGenJob, KeyObjectHandle, SignJob, kCryptoJobAsync, @@ -28,28 +29,24 @@ const { } = internalBinding('constants'); const { + getUsagesMask, getUsagesUnion, hasAnyNotIn, jobPromise, normalizeHashName, kHandle, - kKeyObject, kNamedCurveAliases, } = require('internal/crypto/util'); const { lazyDOMException, - promisify, } = require('internal/util'); -const { - generateKeyPair: _generateKeyPair, -} = require('internal/crypto/keygen'); - const { InternalCryptoKey, - kAlgorithm, - kKeyType, + getCryptoKeyAlgorithm, + getCryptoKeyHandle, + getCryptoKeyType, } = require('internal/crypto/keys'); const { @@ -59,8 +56,6 @@ const { validateJwk, } = require('internal/crypto/webcrypto_util'); -const generateKeyPair = promisify(_generateKeyPair); - function verifyAcceptableEcKeyUse(name, isPublic, usages) { let checkSet; switch (name) { @@ -102,14 +97,8 @@ async function ecGenerateKey(algorithm, extractable, keyUsages) { // Fall through } - let keyPair; - try { - keyPair = await generateKeyPair('ec', { namedCurve }); - } catch (err) { - throw lazyDOMException( - 'The operation failed for an operation-specific reason', - { name: 'OperationError', cause: err }); - } + const handles = await jobPromise(() => new EcKeyPairGenJob( + kCryptoJobAsync, namedCurve)); let publicUsages; let privateUsages; @@ -128,16 +117,16 @@ async function ecGenerateKey(algorithm, extractable, keyUsages) { const publicKey = new InternalCryptoKey( - keyPair.publicKey, + handles[0], keyAlgorithm, - publicUsages, + getUsagesMask(publicUsages), true); const privateKey = new InternalCryptoKey( - keyPair.privateKey, + handles[1], keyAlgorithm, - privateUsages, + getUsagesMask(privateUsages), extractable); return { __proto__: null, publicKey, privateKey }; @@ -145,7 +134,7 @@ async function ecGenerateKey(algorithm, extractable, keyUsages) { function ecExportKey(key, format) { try { - const handle = key[kKeyObject][kHandle]; + const handle = getCryptoKeyHandle(key); switch (format) { case kWebCryptoKeyFormatRaw: { return TypedArrayPrototypeGetBuffer( @@ -161,13 +150,14 @@ function ecExportKey(key, format) { // P-384: 120 = 23 bytes of SPKI ASN.1 + 97-byte uncompressed point. // P-521: 158 = 25 bytes of SPKI ASN.1 + 133-byte uncompressed point. // Difference in initial SPKI ASN.1 is caused by OIDs and length encoding. + const { namedCurve } = getCryptoKeyAlgorithm(key); if (TypedArrayPrototypeGetByteLength(spki) !== { '__proto__': null, 'P-256': 91, 'P-384': 120, 'P-521': 158, - }[key[kAlgorithm].namedCurve]) { + }[namedCurve]) { const raw = handle.exportECPublicRaw(POINT_CONVERSION_UNCOMPRESSED); const tmp = new KeyObjectHandle(); tmp.init(kKeyTypePublic, raw, kKeyFormatRawPublic, - 'ec', null, key[kAlgorithm].namedCurve); + 'ec', null, namedCurve); spki = tmp.export(kKeyFormatDER, kWebCryptoKeyFormatSPKI); } return TypedArrayPrototypeGetBuffer(spki); @@ -195,22 +185,22 @@ function ecImportKey( ) { const { name, namedCurve } = algorithm; - let keyObject; + let handle; const usagesSet = new SafeSet(keyUsages); switch (format) { case 'KeyObject': { verifyAcceptableEcKeyUse(name, keyData.type === 'public', usagesSet); - keyObject = keyData; + handle = keyData[kHandle]; break; } case 'spki': { verifyAcceptableEcKeyUse(name, true, usagesSet); - keyObject = importDerKey(keyData, true); + handle = importDerKey(keyData, true); break; } case 'pkcs8': { verifyAcceptableEcKeyUse(name, false, usagesSet); - keyObject = importDerKey(keyData, false); + handle = importDerKey(keyData, false); break; } case 'jwk': { @@ -237,12 +227,12 @@ function ecImportKey( const isPublic = keyData.d === undefined; verifyAcceptableEcKeyUse(name, isPublic, usagesSet); - keyObject = importJwkKey(isPublic, keyData); + handle = importJwkKey(isPublic, keyData); break; } case 'raw': { verifyAcceptableEcKeyUse(name, true, usagesSet); - keyObject = importRawKey(true, keyData, kKeyFormatRawPublic, 'ec', namedCurve); + handle = importRawKey(true, keyData, kKeyFormatRawPublic, 'ec', namedCurve); break; } default: @@ -253,25 +243,22 @@ function ecImportKey( case 'ECDSA': // Fall through case 'ECDH': - if (keyObject.asymmetricKeyType !== 'ec') + if (handle.getAsymmetricKeyType() !== 'ec') throw lazyDOMException('Invalid key type', 'DataError'); break; } - if (!keyObject[kHandle].checkEcKeyData()) { + if (!handle.checkEcKeyData()) { throw lazyDOMException('Invalid keyData', 'DataError'); } - const { - namedCurve: checkNamedCurve, - } = keyObject[kHandle].keyDetail({}); - if (kNamedCurveAliases[namedCurve] !== checkNamedCurve) + if (kNamedCurveAliases[namedCurve] !== handle.keyDetail({}).namedCurve) throw lazyDOMException('Named curve mismatch', 'DataError'); return new InternalCryptoKey( - keyObject, + handle, { name, namedCurve }, - usagesSet, + getUsagesMask(usagesSet), extractable); } @@ -279,7 +266,7 @@ async function ecdsaSignVerify(key, data, { name, hash }, signature) { const mode = signature === undefined ? kSignJobModeSign : kSignJobModeVerify; const type = mode === kSignJobModeSign ? 'private' : 'public'; - if (key[kKeyType] !== type) + if (getCryptoKeyType(key) !== type) throw lazyDOMException(`Key must be a ${type} key`, 'InvalidAccessError'); const hashname = normalizeHashName(hash.name); @@ -287,7 +274,7 @@ async function ecdsaSignVerify(key, data, { name, hash }, signature) { return await jobPromise(() => new SignJob( kCryptoJobAsync, mode, - key[kKeyObject][kHandle], + getCryptoKeyHandle(key), undefined, undefined, undefined, diff --git a/lib/internal/crypto/hkdf.js b/lib/internal/crypto/hkdf.js index 1a5e9ccd06813e..4203e3ee21c701 100644 --- a/lib/internal/crypto/hkdf.js +++ b/lib/internal/crypto/hkdf.js @@ -20,20 +20,20 @@ const { const { kMaxLength } = require('buffer'); const { + jobPromise, normalizeHashName, toBuf, validateByteSource, - kKeyObject, } = require('internal/crypto/util'); const { createSecretKey, + getCryptoKeyHandle, isKeyObject, } = require('internal/crypto/keys'); const { lazyDOMException, - promisify, } = require('internal/util'); const { @@ -137,7 +137,6 @@ function hkdfSync(hash, key, salt, info, length) { return bits; } -const hkdfPromise = promisify(hkdf); function validateHkdfDeriveBitsLength(length) { if (length === null) throw lazyDOMException('length cannot be null', 'OperationError'); @@ -156,9 +155,13 @@ async function hkdfDeriveBits(algorithm, baseKey, length) { return new ArrayBuffer(0); try { - return await hkdfPromise( - normalizeHashName(hash.name), baseKey[kKeyObject], salt, info, length / 8, - ); + return await jobPromise(() => new HKDFJob( + kCryptoJobAsync, + normalizeHashName(hash.name), + getCryptoKeyHandle(baseKey), + salt, + info, + length / 8)); } catch (err) { throw lazyDOMException( 'The operation failed for an operation-specific reason', diff --git a/lib/internal/crypto/keys.js b/lib/internal/crypto/keys.js index 0e39e9a1640eaa..03ace95df21dca 100644 --- a/lib/internal/crypto/keys.js +++ b/lib/internal/crypto/keys.js @@ -1,7 +1,6 @@ 'use strict'; const { - ArrayFrom, ArrayPrototypeSlice, ObjectDefineProperties, ObjectDefineProperty, @@ -15,6 +14,9 @@ const { const { KeyObjectHandle, createNativeKeyObjectClass, + createCryptoKeyClass, + // eslint-disable-next-line no-restricted-syntax -- intended here + getCryptoKeySlots: nativeGetCryptoKeySlots, kKeyTypeSecret, kKeyTypePublic, kKeyTypePrivate, @@ -56,12 +58,13 @@ const { const { kHandle, - kKeyObject, getArrayBufferOrView, bigIntArrayToUnsignedBigInt, normalizeAlgorithm, hasAnyNotIn, - getSortedUsages, + getUsagesMask, + getUsagesFromMask, + hasUsage, } = require('internal/crypto/util'); const { @@ -69,12 +72,6 @@ const { isArrayBufferView, } = require('internal/util/types'); -const { - markTransferMode, - kClone, - kDeserialize, -} = require('internal/worker/js_transferable'); - const { customInspectSymbol: kInspect, getDeprecationWarningEmitter, @@ -84,12 +81,12 @@ const { const { inspect } = require('internal/util/inspect'); -const kAlgorithm = Symbol('kAlgorithm'); -const kExtractable = Symbol('kExtractable'); +// Module-local symbol used by KeyObject to store its `type` string +// ("secret"/"public"/"private"). It is also used by `isKeyObject` to +// distinguish KeyObject instances from other types. CryptoKey no longer +// uses any module-local symbol slots - its state lives in C++ internal +// fields on `NativeCryptoKey`. const kKeyType = Symbol('kKeyType'); -const kKeyUsages = Symbol('kKeyUsages'); -const kCachedAlgorithm = Symbol('kCachedAlgorithm'); -const kCachedKeyUsages = Symbol('kCachedKeyUsages'); const emitDEP0203 = getDeprecationWarningEmitter( 'DEP0203', @@ -101,7 +98,7 @@ const maybeEmitDEP0204 = getDeprecationWarningEmitter( 'Passing a non-extractable CryptoKey to KeyObject.from() is deprecated.', undefined, false, - (key) => !key[kExtractable], + (key) => !getCryptoKeyExtractable(key), ); // Key input contexts. @@ -155,7 +152,14 @@ const { if (!isCryptoKey(key)) throw new ERR_INVALID_ARG_TYPE('key', 'CryptoKey', key); maybeEmitDEP0204(key); - return key[kKeyObject]; + const handle = getCryptoKeyHandle(key); + switch (getCryptoKeyType(key)) { + /* eslint-disable no-use-before-define */ + case 'secret': return new SecretKeyObject(handle); + case 'public': return new PublicKeyObject(handle); + case 'private': return new PrivateKeyObject(handle); + /* eslint-enable no-use-before-define */ + } } equals(otherKeyObject) { @@ -252,9 +256,9 @@ const { throw lazyDOMException('Unrecognized algorithm name', 'NotSupportedError'); } - if (result[kKeyUsages].length === 0) { + if (getCryptoKeyUsagesMask(result) === 0) { throw lazyDOMException( - `Usages cannot be empty when importing a ${result.type} key.`, + `Usages cannot be empty when importing a ${getCryptoKeyType(result)} key.`, 'SyntaxError'); } @@ -347,9 +351,10 @@ const { throw lazyDOMException('Unrecognized algorithm name', 'NotSupportedError'); } - if (result.type === 'private' && result[kKeyUsages].length === 0) { + const resultType = getCryptoKeyType(result); + if (resultType === 'private' && getCryptoKeyUsagesMask(result) === 0) { throw lazyDOMException( - `Usages cannot be empty when importing a ${result.type} key.`, + `Usages cannot be empty when importing a ${resultType} key.`, 'SyntaxError'); } @@ -589,7 +594,7 @@ function parsePrivateKeyEncoding(enc, keyType, objName) { return parseKeyEncoding(enc, keyType, false, objName); } -function getKeyObjectHandle(key, ctx) { +function validateAsymmetricKeyType(type, ctx, key) { if (ctx === kCreatePrivate) { throw new ERR_INVALID_ARG_TYPE( 'key', @@ -598,16 +603,14 @@ function getKeyObjectHandle(key, ctx) { ); } - if (key.type !== 'private') { + if (type !== 'private') { if (ctx === kConsumePrivate || ctx === kCreatePublic) - throw new ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE(key.type, 'private'); - if (key.type !== 'public') { - throw new ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE(key.type, + throw new ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE(type, 'private'); + if (type !== 'public') { + throw new ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE(type, 'private or public'); } } - - return key[kHandle]; } function getKeyTypes(allowKeyObject, bufferOnly = false) { @@ -632,11 +635,13 @@ function getKeyTypes(allowKeyObject, bufferOnly = false) { function prepareAsymmetricKey(key, ctx, name = 'key') { if (isKeyObject(key)) { // Best case: A key object, as simple as that. - return { data: getKeyObjectHandle(key, ctx) }; + validateAsymmetricKeyType(key.type, ctx, key); + return { data: key[kHandle] }; } if (isCryptoKey(key)) { emitDEP0203(); - return { data: getKeyObjectHandle(key[kKeyObject], ctx) }; + validateAsymmetricKeyType(getCryptoKeyType(key), ctx, key); + return { data: getCryptoKeyHandle(key) }; } if (isStringOrBuffer(key)) { // Expect PEM by default, mostly for backward compatibility. @@ -648,11 +653,13 @@ function prepareAsymmetricKey(key, ctx, name = 'key') { // The 'key' property can be a KeyObject as well to allow specifying // additional options such as padding along with the key. if (isKeyObject(data)) { - return { data: getKeyObjectHandle(data, ctx) }; + validateAsymmetricKeyType(data.type, ctx, data); + return { data: data[kHandle] }; } if (isCryptoKey(data)) { emitDEP0203(); - return { data: getKeyObjectHandle(data[kKeyObject], ctx) }; + validateAsymmetricKeyType(getCryptoKeyType(data), ctx, data); + return { data: getCryptoKeyHandle(data) }; } if (format === 'jwk') { validateObject(data, `${name}.key`); @@ -717,9 +724,10 @@ function prepareSecretKey(key, encoding, bufferOnly = false) { } if (isCryptoKey(key)) { emitDEP0203(); - if (key[kKeyType] !== 'secret') - throw new ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE(key[kKeyType], 'secret'); - return key[kKeyObject][kHandle]; + const type = getCryptoKeyType(key); + if (type !== 'secret') + throw new ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE(type, 'secret'); + return getCryptoKeyHandle(key); } } if (typeof key !== 'string' && @@ -759,180 +767,248 @@ function createPrivateKey(key) { } function isKeyObject(obj) { - return obj != null && obj[kKeyType] !== undefined && obj[kKeyObject] === undefined; + return obj != null && obj[kKeyType] !== undefined; } -// Our implementation of CryptoKey is a simple wrapper around a KeyObject -// that adapts it to the standard interface. -// TODO(@jasnell): Embedder environments like electron may have issues -// here similar to other things like URL. A chromium provided CryptoKey -// will not be recognized as a Node.js CryptoKey, and vice versa. It -// would be fantastic if we could find a way of making those interop. -class CryptoKey { - constructor() { - throw new ERR_ILLEGAL_CONSTRUCTOR(); - } +// CryptoKey is a plain JS class whose prototype's [[Prototype]] is +// Object.prototype, as Web Crypto requires. Instance storage (type enum, +// extractable, algorithm, usages mask, and the KeyObject handle) lives +// on a C++ class, NativeCryptoKey, created by createCryptoKeyClass. +// InternalCryptoKey is the only constructor we expose to internal +// code; it extends NativeCryptoKey to get that storage and then has +// its prototype spliced so the chain visible to user code is: +// instance -> InternalCryptoKey.prototype +// -> CryptoKey.prototype +// -> Object.prototype +// +// All five internal slots are read from C++ in a single call via +// `getCryptoKeySlots`. The resulting array is cached in a private +// class field on `InternalCryptoKey` so that it is invisible to +// reflection (`Object.getOwnPropertySymbols` etc.) and leaves each +// CryptoKey's hidden class pristine. The `getCryptoKey{Type, +// Extractable,Algorithm,Usages,Handle}` helpers index into that +// array and convert native enums/masks back to Web Crypto strings. +// The public `algorithm` getter caches a cloned dictionary and the +// public `usages` getter caches a synthesized array (as Web Crypto +// requires repeat reads to return the same object so a consumer's +// mutation is visible next time). +let getSlots; // Populated by the createCryptoKeyClass callback below. + +const kSlotType = 0; +const kSlotExtractable = 1; +const kSlotAlgorithm = 2; +const kSlotUsagesMask = 3; +const kSlotHandle = 4; +const kSlotClonedAlgorithm = 5; +const kSlotClonedUsages = 6; +const kSlotUsages = 7; + +function cloneAlgorithm(raw) { + const cloned = { ...raw }; + if (cloned.hash !== undefined) cloned.hash = { ...cloned.hash }; + if (cloned.publicExponent !== undefined) + cloned.publicExponent = new Uint8Array(cloned.publicExponent); + return cloned; +} - [kInspect](depth, options) { - if (depth < 0) - return this; +const { + 0: CryptoKey, + 1: InternalCryptoKey, +} = createCryptoKeyClass((NativeCryptoKey) => { + class CryptoKey { + constructor() { + throw new ERR_ILLEGAL_CONSTRUCTOR(); + } - const opts = { - ...options, - depth: options.depth == null ? null : options.depth - 1, - }; + [kInspect](depth, options) { + if (depth < 0) + return this; - return `CryptoKey ${inspect({ - type: this[kKeyType], - extractable: this[kExtractable], - algorithm: this[kAlgorithm], - usages: this[kKeyUsages], - }, opts)}`; - } + const opts = { + ...options, + depth: options.depth == null ? null : options.depth - 1, + }; - get [kKeyType]() { - return this[kKeyObject].type; - } + return `CryptoKey ${inspect({ + type: getCryptoKeyType(this), + extractable: getCryptoKeyExtractable(this), + algorithm: getCryptoKeyAlgorithm(this), + usages: getCryptoKeyUsages(this), + }, opts)}`; + } - get type() { - if (!(this instanceof CryptoKey)) - throw new ERR_INVALID_THIS('CryptoKey'); - return this[kKeyType]; - } + get type() { + return getCryptoKeyType(this); + } + + get extractable() { + return getCryptoKeyExtractable(this); + } + + get algorithm() { + const slots = getSlots(this); + let cached = slots[kSlotClonedAlgorithm]; + if (cached === undefined) { + cached = cloneAlgorithm(slots[kSlotAlgorithm]); + slots[kSlotClonedAlgorithm] = cached; + } + return cached; + } - get extractable() { - if (!(this instanceof CryptoKey)) - throw new ERR_INVALID_THIS('CryptoKey'); - return this[kExtractable]; + get usages() { + const slots = getSlots(this); + let cached = slots[kSlotClonedUsages]; + if (cached === undefined) { + cached = ArrayPrototypeSlice(getCryptoKeyUsagesFromSlots(slots), 0); + slots[kSlotClonedUsages] = cached; + } + return cached; + } } - get algorithm() { - if (!(this instanceof CryptoKey)) - throw new ERR_INVALID_THIS('CryptoKey'); - if (!this[kCachedAlgorithm]) { - this[kCachedAlgorithm] ??= { ...this[kAlgorithm] }; - this[kCachedAlgorithm].hash &&= { ...this[kCachedAlgorithm].hash }; - this[kCachedAlgorithm].publicExponent &&= new Uint8Array(this[kCachedAlgorithm].publicExponent); + class InternalCryptoKey extends NativeCryptoKey { + #slots; + + static getSlots(key) { + if (!key || typeof key !== 'object') + throw new ERR_INVALID_THIS('CryptoKey'); + if (#slots in key) { + const cached = key.#slots; + if (cached !== undefined) return cached; + } + const slots = nativeGetCryptoKeySlots(key); + key.#slots = slots; + return slots; } - return this[kCachedAlgorithm]; } + getSlots = InternalCryptoKey.getSlots; + // Hide NativeCryptoKey from user code. + InternalCryptoKey.prototype.constructor = CryptoKey; + ObjectSetPrototypeOf(InternalCryptoKey.prototype, CryptoKey.prototype); + + ObjectDefineProperties(CryptoKey.prototype, { + type: kEnumerableProperty, + extractable: kEnumerableProperty, + algorithm: kEnumerableProperty, + usages: kEnumerableProperty, + [SymbolToStringTag]: { + __proto__: null, + configurable: true, + value: 'CryptoKey', + }, + }); + + return [CryptoKey, InternalCryptoKey]; +}); - get usages() { - if (!(this instanceof CryptoKey)) - throw new ERR_INVALID_THIS('CryptoKey'); - this[kCachedKeyUsages] ??= ArrayFrom(this[kKeyUsages]); - return this[kCachedKeyUsages]; +// The helpers below return a CryptoKey's internal slot value, +// populating the per-instance cache on first access via a single +// native call. The public `type` getter converts the native enum to +// the Web Crypto string. The `usages` helper converts the native usage +// mask to Web Crypto strings. The public `algorithm` / `usages` getters +// on `CryptoKey.prototype` cache their returned objects. + +/** + * Returns the value of a CryptoKey's `[[type]]` internal slot. + * @param {CryptoKey} key + * @returns {'secret' | 'public' | 'private'} + */ +function getCryptoKeyType(key) { + switch (getSlots(key)[kSlotType]) { + case kKeyTypeSecret: return 'secret'; + case kKeyTypePublic: return 'public'; + case kKeyTypePrivate: return 'private'; + default: { + const assert = require('internal/assert'); + assert.fail('Unreachable code'); + } } } -ObjectDefineProperties(CryptoKey.prototype, { - type: kEnumerableProperty, - extractable: kEnumerableProperty, - algorithm: kEnumerableProperty, - usages: kEnumerableProperty, - [SymbolToStringTag]: { - __proto__: null, - configurable: true, - value: 'CryptoKey', - }, -}); +/** + * Returns the value of a CryptoKey's `[[extractable]]` internal slot. + * @param {CryptoKey} key + * @returns {boolean} + */ +function getCryptoKeyExtractable(key) { + return getSlots(key)[kSlotExtractable]; +} /** - * @param {InternalCryptoKey} key - * @param {KeyObject} keyObject - * @param {object} algorithm - * @param {boolean} extractable - * @param {Set} keyUsages + * Returns the CryptoKey's `[[algorithm]]` internal slot, bypassing the + * public `algorithm` getter (which returns a cloned copy). + * @param {CryptoKey} key + * @returns {object} */ -function defineCryptoKeyProperties( - key, - keyObject, - algorithm, - extractable, - keyUsages, -) { - // Using symbol properties here currently instead of private - // properties because (for now) the performance penalty of - // private fields is still too high. - ObjectDefineProperties(key, { - [kKeyObject]: { - __proto__: null, - value: keyObject, - enumerable: false, - configurable: false, - writable: false, - }, - [kAlgorithm]: { - __proto__: null, - value: algorithm, - enumerable: false, - configurable: false, - writable: false, - }, - [kExtractable]: { - __proto__: null, - value: extractable, - enumerable: false, - configurable: false, - writable: false, - }, - [kKeyUsages]: { - __proto__: null, - value: keyUsages, - enumerable: false, - configurable: false, - writable: false, - }, - }); +function getCryptoKeyAlgorithm(key) { + return getSlots(key)[kSlotAlgorithm]; } -// All internal code must use new InternalCryptoKey to create -// CryptoKey instances. The CryptoKey class is exposed to end -// user code but is not permitted to be constructed directly. -// Using markTransferMode also allows the CryptoKey to be -// cloned to Workers. -class InternalCryptoKey { - constructor(keyObject, algorithm, keyUsages, extractable) { - markTransferMode(this, true, false); - // When constructed during transfer the properties get assigned - // in the kDeserialize call. - if (keyObject) { - defineCryptoKeyProperties( - this, - keyObject, - algorithm, - extractable, - getSortedUsages(new SafeSet(keyUsages)), - ); - } - } +/** + * Returns the CryptoKey's native `[[usages]]` mask. + * @param {CryptoKey} key + * @returns {number} + */ +function getCryptoKeyUsagesMask(key) { + return getSlots(key)[kSlotUsagesMask]; +} - [kClone]() { - const keyObject = this[kKeyObject]; - const algorithm = this[kAlgorithm]; - const extractable = this[kExtractable]; - const usages = this[kKeyUsages]; +/** + * Returns whether a CryptoKey's `[[usages]]` contains `usage`. + * @param {CryptoKey} key + * @param {string} usage + * @returns {boolean} + */ +function hasCryptoKeyUsage(key, usage) { + return hasUsage(getCryptoKeyUsagesMask(key), usage); +} - return { - data: { - keyObject, - algorithm, - usages, - extractable, - }, - deserializeInfo: 'internal/crypto/keys:InternalCryptoKey', - }; +/** + * Returns the CryptoKey's cached canonical usages array for internal + * consumers, expanding it from the native usage mask on first access. + * @param {Array} slots + * @returns {string[]} + */ +function getCryptoKeyUsagesFromSlots(slots) { + let usages = slots[kSlotUsages]; + if (usages === undefined) { + usages = getUsagesFromMask(slots[kSlotUsagesMask]); + slots[kSlotUsages] = usages; } + return usages; +} - [kDeserialize]({ keyObject, algorithm, usages, extractable }) { - defineCryptoKeyProperties(this, keyObject, algorithm, extractable, usages); - } +/** + * Returns the CryptoKey's `[[usages]]` internal slot, bypassing the + * public `usages` getter (which returns a cloned array). The internal + * array is expanded lazily from the native usage mask. + * @param {CryptoKey} key + * @returns {string[]} + */ +function getCryptoKeyUsages(key) { + return getCryptoKeyUsagesFromSlots(getSlots(key)); +} + +/** + * Returns the KeyObjectHandle wrapping the CryptoKey's underlying + * key material. + * @param {CryptoKey} key + * @returns {KeyObjectHandle} + */ +function getCryptoKeyHandle(key) { + return getSlots(key)[kSlotHandle]; } -InternalCryptoKey.prototype.constructor = CryptoKey; -ObjectSetPrototypeOf(InternalCryptoKey.prototype, CryptoKey.prototype); function isCryptoKey(obj) { - return obj != null && obj[kKeyObject] !== undefined; + if (obj == null || typeof obj !== 'object') + return false; + + try { + getSlots(obj); + return true; + } catch { + return false; + } } function importGenericSecretKey( @@ -953,22 +1029,27 @@ function importGenericSecretKey( 'SyntaxError'); } - let keyObject; + let handle; switch (format) { case 'KeyObject': { - keyObject = keyData; + handle = keyData[kHandle]; break; } case 'raw-secret': case 'raw': { - keyObject = createSecretKey(keyData); + handle = new KeyObjectHandle(); + handle.init(kKeyTypeSecret, keyData); break; } default: return undefined; } - return new InternalCryptoKey(keyObject, { name }, usagesSet, false); + return new InternalCryptoKey( + handle, + { name }, + getUsagesMask(usagesSet), + false); } module.exports = { @@ -992,9 +1073,12 @@ module.exports = { PrivateKeyObject, isKeyObject, isCryptoKey, + getCryptoKeyType, + getCryptoKeyExtractable, + getCryptoKeyAlgorithm, + getCryptoKeyUsages, + getCryptoKeyUsagesMask, + hasCryptoKeyUsage, + getCryptoKeyHandle, importGenericSecretKey, - kAlgorithm, - kExtractable, - kKeyType, - kKeyUsages, }; diff --git a/lib/internal/crypto/mac.js b/lib/internal/crypto/mac.js index 4331f95355ba23..6554e05a892ff4 100644 --- a/lib/internal/crypto/mac.js +++ b/lib/internal/crypto/mac.js @@ -7,53 +7,38 @@ const { const { HmacJob, - KeyObjectHandle, KmacJob, kCryptoJobAsync, - kKeyFormatJWK, - kKeyTypeSecret, kSignJobModeSign, kSignJobModeVerify, + SecretKeyGenJob, } = internalBinding('crypto'); const { getBlockSize, + getUsagesMask, hasAnyNotIn, jobPromise, normalizeHashName, kHandle, - kKeyObject, } = require('internal/crypto/util'); const { lazyDOMException, - promisify, } = require('internal/util'); -const { - generateKey: _generateKey, -} = require('internal/crypto/keygen'); - - -const { - randomBytes: _randomBytes, -} = require('internal/crypto/random'); - -const randomBytes = promisify(_randomBytes); - const { InternalCryptoKey, - SecretKeyObject, - createSecretKey, - kAlgorithm, + getCryptoKeyAlgorithm, + getCryptoKeyHandle, } = require('internal/crypto/keys'); const { + importJwkSecretKey, + importSecretKey, validateJwk, } = require('internal/crypto/webcrypto_util'); -const generateKey = promisify(_generateKey); - async function hmacGenerateKey(algorithm, extractable, keyUsages) { const { hash, @@ -68,19 +53,12 @@ async function hmacGenerateKey(algorithm, extractable, keyUsages) { 'SyntaxError'); } - let key; - try { - key = await generateKey('hmac', { length }); - } catch (err) { - throw lazyDOMException( - 'The operation failed for an operation-specific reason', - { name: 'OperationError', cause: err }); - } + const handle = await jobPromise(() => new SecretKeyGenJob(kCryptoJobAsync, length)); return new InternalCryptoKey( - key, + handle, { name, length, hash }, - usageSet, + getUsagesMask(usageSet), extractable); } @@ -101,20 +79,12 @@ async function kmacGenerateKey(algorithm, extractable, keyUsages) { 'SyntaxError'); } - let keyData; - try { - keyData = await randomBytes(length / 8); - } catch (err) { - throw lazyDOMException( - 'The operation failed for an operation-specific reason' + - `[${err.message}]`, - { name: 'OperationError', cause: err }); - } + const handle = await jobPromise(() => new SecretKeyGenJob(kCryptoJobAsync, length)); return new InternalCryptoKey( - createSecretKey(keyData), + handle, { name, length }, - usageSet, + getUsagesMask(usageSet), extractable); } @@ -132,10 +102,12 @@ function macImportKey( `Unsupported key usage for ${algorithm.name} key`, 'SyntaxError'); } - let keyObject; + let handle; + let length; switch (format) { case 'KeyObject': { - keyObject = keyData; + length = keyData.symmetricKeySize * 8; + handle = keyData[kHandle]; break; } case 'raw-secret': @@ -143,7 +115,8 @@ function macImportKey( if (format === 'raw' && !isHmac) { return undefined; } - keyObject = createSecretKey(keyData); + length = keyData.byteLength * 8; + handle = importSecretKey(keyData); break; } case 'jwk': { @@ -159,22 +132,14 @@ function macImportKey( 'DataError'); } - const handle = new KeyObjectHandle(); - try { - handle.init(kKeyTypeSecret, keyData, kKeyFormatJWK, null, null); - } catch (err) { - throw lazyDOMException( - 'Invalid keyData', { name: 'DataError', cause: err }); - } - keyObject = new SecretKeyObject(handle); + handle = importJwkSecretKey(keyData); + length = handle.getSymmetricKeySize() * 8; break; } default: return undefined; } - const { length } = keyObject[kHandle].keyDetail({}); - if (length === 0) throw lazyDOMException('Zero-length key is not supported', 'DataError'); @@ -193,9 +158,9 @@ function macImportKey( } return new InternalCryptoKey( - keyObject, + handle, algorithmObject, - usagesSet, + getUsagesMask(usagesSet), extractable); } @@ -204,8 +169,8 @@ function hmacSignVerify(key, data, algorithm, signature) { return jobPromise(() => new HmacJob( kCryptoJobAsync, mode, - normalizeHashName(key[kAlgorithm].hash.name), - key[kKeyObject][kHandle], + normalizeHashName(getCryptoKeyAlgorithm(key).hash.name), + getCryptoKeyHandle(key), data, signature)); } @@ -215,7 +180,7 @@ function kmacSignVerify(key, data, algorithm, signature) { return jobPromise(() => new KmacJob( kCryptoJobAsync, mode, - key[kKeyObject][kHandle], + getCryptoKeyHandle(key), algorithm.name, algorithm.customization, algorithm.outputLength / 8, diff --git a/lib/internal/crypto/ml_dsa.js b/lib/internal/crypto/ml_dsa.js index 283c695686a69a..173ef666c29736 100644 --- a/lib/internal/crypto/ml_dsa.js +++ b/lib/internal/crypto/ml_dsa.js @@ -18,28 +18,28 @@ const { kWebCryptoKeyFormatRaw, kWebCryptoKeyFormatPKCS8, kWebCryptoKeyFormatSPKI, + NidKeyPairGenJob, + EVP_PKEY_ML_DSA_44, + EVP_PKEY_ML_DSA_65, + EVP_PKEY_ML_DSA_87, } = internalBinding('crypto'); const { + getUsagesMask, getUsagesUnion, hasAnyNotIn, jobPromise, kHandle, - kKeyObject, } = require('internal/crypto/util'); const { lazyDOMException, - promisify, } = require('internal/util'); const { - generateKeyPair: _generateKeyPair, -} = require('internal/crypto/keygen'); - -const { + getCryptoKeyHandle, + getCryptoKeyType, InternalCryptoKey, - kKeyType, } = require('internal/crypto/keys'); const { @@ -49,8 +49,6 @@ const { validateJwk, } = require('internal/crypto/webcrypto_util'); -const generateKeyPair = promisify(_generateKeyPair); - function verifyAcceptableMlDsaKeyUse(name, isPublic, usages) { const checkSet = isPublic ? ['verify'] : ['sign']; if (hasAnyNotIn(usages, checkSet)) { @@ -70,32 +68,37 @@ async function mlDsaGenerateKey(algorithm, extractable, keyUsages) { 'SyntaxError'); } - let keyPair; - try { - keyPair = await generateKeyPair(name.toLowerCase()); - } catch (err) { - throw lazyDOMException( - 'The operation failed for an operation-specific reason', - { name: 'OperationError', cause: err }); + let nid; + switch (name) { + case 'ML-DSA-44': + nid = EVP_PKEY_ML_DSA_44; + break; + case 'ML-DSA-65': + nid = EVP_PKEY_ML_DSA_65; + break; + case 'ML-DSA-87': + nid = EVP_PKEY_ML_DSA_87; + break; } - const publicUsages = getUsagesUnion(usageSet, 'verify'); - const privateUsages = getUsagesUnion(usageSet, 'sign'); + const handles = await jobPromise(() => new NidKeyPairGenJob(kCryptoJobAsync, nid)); + const publicUsagesMask = getUsagesMask(getUsagesUnion(usageSet, 'verify')); + const privateUsagesMask = getUsagesMask(getUsagesUnion(usageSet, 'sign')); const keyAlgorithm = { name }; const publicKey = new InternalCryptoKey( - keyPair.publicKey, + handles[0], keyAlgorithm, - publicUsages, + publicUsagesMask, true); const privateKey = new InternalCryptoKey( - keyPair.privateKey, + handles[1], keyAlgorithm, - privateUsages, + privateUsagesMask, extractable); return { __proto__: null, privateKey, publicKey }; @@ -103,17 +106,19 @@ async function mlDsaGenerateKey(algorithm, extractable, keyUsages) { function mlDsaExportKey(key, format) { try { + const handle = getCryptoKeyHandle(key); switch (format) { case kWebCryptoKeyFormatRaw: { - const handle = key[kKeyObject][kHandle]; return TypedArrayPrototypeGetBuffer( - key[kKeyType] === 'private' ? handle.rawSeed() : handle.rawPublicKey()); + getCryptoKeyType(key) === 'private' ? handle.rawSeed() : handle.rawPublicKey()); } case kWebCryptoKeyFormatSPKI: { - return TypedArrayPrototypeGetBuffer(key[kKeyObject][kHandle].export(kKeyFormatDER, kWebCryptoKeyFormatSPKI)); + return TypedArrayPrototypeGetBuffer( + handle.export(kKeyFormatDER, kWebCryptoKeyFormatSPKI)); } case kWebCryptoKeyFormatPKCS8: { - const pkcs8 = key[kKeyObject][kHandle].export(kKeyFormatDER, kWebCryptoKeyFormatPKCS8, null, null); + const pkcs8 = handle.export( + kKeyFormatDER, kWebCryptoKeyFormatPKCS8, null, null); // Edge case only possible when user creates a seedless KeyObject // first and converts it with KeyObject.prototype.toCryptoKey. // 54 = 22 bytes of PKCS#8 ASN.1 + 32-byte seed. @@ -142,17 +147,17 @@ function mlDsaImportKey( keyUsages) { const { name } = algorithm; - let keyObject; + let handle; const usagesSet = new SafeSet(keyUsages); switch (format) { case 'KeyObject': { verifyAcceptableMlDsaKeyUse(name, keyData.type === 'public', usagesSet); - keyObject = keyData; + handle = keyData[kHandle]; break; } case 'spki': { verifyAcceptableMlDsaKeyUse(name, true, usagesSet); - keyObject = importDerKey(keyData, true); + handle = importDerKey(keyData, true); break; } case 'pkcs8': { @@ -170,7 +175,7 @@ function mlDsaImportKey( 'NotSupportedError'); } - keyObject = importDerKey(keyData, false); + handle = importDerKey(keyData, false); break; } case 'jwk': { @@ -182,28 +187,28 @@ function mlDsaImportKey( const isPublic = keyData.priv === undefined; verifyAcceptableMlDsaKeyUse(name, isPublic, usagesSet); - keyObject = importJwkKey(isPublic, keyData); + handle = importJwkKey(isPublic, keyData); break; } case 'raw-public': case 'raw-seed': { const isPublic = format === 'raw-public'; verifyAcceptableMlDsaKeyUse(name, isPublic, usagesSet); - keyObject = importRawKey(isPublic, keyData, isPublic ? kKeyFormatRawPublic : kKeyFormatRawSeed, name); + handle = importRawKey(isPublic, keyData, isPublic ? kKeyFormatRawPublic : kKeyFormatRawSeed, name); break; } default: return undefined; } - if (keyObject.asymmetricKeyType !== StringPrototypeToLowerCase(name)) { + if (handle.getAsymmetricKeyType() !== StringPrototypeToLowerCase(name)) { throw lazyDOMException('Invalid key type', 'DataError'); } return new InternalCryptoKey( - keyObject, + handle, { name }, - usagesSet, + getUsagesMask(usagesSet), extractable); } @@ -211,13 +216,13 @@ async function mlDsaSignVerify(key, data, algorithm, signature) { const mode = signature === undefined ? kSignJobModeSign : kSignJobModeVerify; const type = mode === kSignJobModeSign ? 'private' : 'public'; - if (key[kKeyType] !== type) + if (getCryptoKeyType(key) !== type) throw lazyDOMException(`Key must be a ${type} key`, 'InvalidAccessError'); return await jobPromise(() => new SignJob( kCryptoJobAsync, mode, - key[kKeyObject][kHandle], + getCryptoKeyHandle(key), undefined, undefined, undefined, diff --git a/lib/internal/crypto/ml_kem.js b/lib/internal/crypto/ml_kem.js index 4f1207a2c27fc2..67f5ddd0ff2499 100644 --- a/lib/internal/crypto/ml_kem.js +++ b/lib/internal/crypto/ml_kem.js @@ -18,27 +18,28 @@ const { kWebCryptoKeyFormatPKCS8, kWebCryptoKeyFormatRaw, kWebCryptoKeyFormatSPKI, + NidKeyPairGenJob, + EVP_PKEY_ML_KEM_512, + EVP_PKEY_ML_KEM_768, + EVP_PKEY_ML_KEM_1024, } = internalBinding('crypto'); const { + getUsagesMask, getUsagesUnion, hasAnyNotIn, + jobPromise, kHandle, - kKeyObject, } = require('internal/crypto/util'); const { lazyDOMException, - promisify, } = require('internal/util'); const { - generateKeyPair: _generateKeyPair, -} = require('internal/crypto/keygen'); - -const { + getCryptoKeyHandle, + getCryptoKeyType, InternalCryptoKey, - kKeyType, } = require('internal/crypto/keys'); const { @@ -48,8 +49,6 @@ const { validateJwk, } = require('internal/crypto/webcrypto_util'); -const generateKeyPair = promisify(_generateKeyPair); - async function mlKemGenerateKey(algorithm, extractable, keyUsages) { const { name } = algorithm; @@ -60,32 +59,33 @@ async function mlKemGenerateKey(algorithm, extractable, keyUsages) { 'SyntaxError'); } - let keyPair; - try { - keyPair = await generateKeyPair(name.toLowerCase()); - } catch (err) { - throw lazyDOMException( - 'The operation failed for an operation-specific reason', - { name: 'OperationError', cause: err }); - } + const nid = { + '__proto__': null, + 'ML-KEM-512': EVP_PKEY_ML_KEM_512, + 'ML-KEM-768': EVP_PKEY_ML_KEM_768, + 'ML-KEM-1024': EVP_PKEY_ML_KEM_1024, + }[name]; - const publicUsages = getUsagesUnion(usageSet, 'encapsulateKey', 'encapsulateBits'); - const privateUsages = getUsagesUnion(usageSet, 'decapsulateKey', 'decapsulateBits'); + const handles = await jobPromise(() => new NidKeyPairGenJob(kCryptoJobAsync, nid)); + const publicUsagesMask = getUsagesMask( + getUsagesUnion(usageSet, 'encapsulateKey', 'encapsulateBits')); + const privateUsagesMask = getUsagesMask( + getUsagesUnion(usageSet, 'decapsulateKey', 'decapsulateBits')); const keyAlgorithm = { name }; const publicKey = new InternalCryptoKey( - keyPair.publicKey, + handles[0], keyAlgorithm, - publicUsages, + publicUsagesMask, true); const privateKey = new InternalCryptoKey( - keyPair.privateKey, + handles[1], keyAlgorithm, - privateUsages, + privateUsagesMask, extractable); return { __proto__: null, privateKey, publicKey }; @@ -93,17 +93,19 @@ async function mlKemGenerateKey(algorithm, extractable, keyUsages) { function mlKemExportKey(key, format) { try { + const handle = getCryptoKeyHandle(key); switch (format) { case kWebCryptoKeyFormatRaw: { - const handle = key[kKeyObject][kHandle]; return TypedArrayPrototypeGetBuffer( - key[kKeyType] === 'private' ? handle.rawSeed() : handle.rawPublicKey()); + getCryptoKeyType(key) === 'private' ? handle.rawSeed() : handle.rawPublicKey()); } case kWebCryptoKeyFormatSPKI: { - return TypedArrayPrototypeGetBuffer(key[kKeyObject][kHandle].export(kKeyFormatDER, kWebCryptoKeyFormatSPKI)); + return TypedArrayPrototypeGetBuffer( + handle.export(kKeyFormatDER, kWebCryptoKeyFormatSPKI)); } case kWebCryptoKeyFormatPKCS8: { - const pkcs8 = key[kKeyObject][kHandle].export(kKeyFormatDER, kWebCryptoKeyFormatPKCS8, null, null); + const pkcs8 = handle.export( + kKeyFormatDER, kWebCryptoKeyFormatPKCS8, null, null); // Edge case only possible when user creates a seedless KeyObject // first and converts it with KeyObject.prototype.toCryptoKey. // 86 = 22 bytes of PKCS#8 ASN.1 + 64-byte seed. @@ -141,17 +143,17 @@ function mlKemImportKey( keyUsages) { const { name } = algorithm; - let keyObject; + let handle; const usagesSet = new SafeSet(keyUsages); switch (format) { case 'KeyObject': { verifyAcceptableMlKemKeyUse(name, keyData.type === 'public', usagesSet); - keyObject = keyData; + handle = keyData[kHandle]; break; } case 'spki': { verifyAcceptableMlKemKeyUse(name, true, usagesSet); - keyObject = importDerKey(keyData, true); + handle = importDerKey(keyData, true); break; } case 'pkcs8': { @@ -169,14 +171,14 @@ function mlKemImportKey( 'NotSupportedError'); } - keyObject = importDerKey(keyData, false); + handle = importDerKey(keyData, false); break; } case 'raw-public': case 'raw-seed': { const isPublic = format === 'raw-public'; verifyAcceptableMlKemKeyUse(name, isPublic, usagesSet); - keyObject = importRawKey(isPublic, keyData, isPublic ? kKeyFormatRawPublic : kKeyFormatRawPrivate, name); + handle = importRawKey(isPublic, keyData, isPublic ? kKeyFormatRawPublic : kKeyFormatRawPrivate, name); break; } case 'jwk': { @@ -188,26 +190,26 @@ function mlKemImportKey( const isPublic = keyData.priv === undefined; verifyAcceptableMlKemKeyUse(name, isPublic, usagesSet); - keyObject = importJwkKey(isPublic, keyData); + handle = importJwkKey(isPublic, keyData); break; } default: return undefined; } - if (keyObject.asymmetricKeyType !== StringPrototypeToLowerCase(name)) { + if (handle.getAsymmetricKeyType() !== StringPrototypeToLowerCase(name)) { throw lazyDOMException('Invalid key type', 'DataError'); } return new InternalCryptoKey( - keyObject, + handle, { name }, - usagesSet, + getUsagesMask(usagesSet), extractable); } function mlKemEncapsulate(encapsulationKey) { - if (encapsulationKey[kKeyType] !== 'public') { + if (getCryptoKeyType(encapsulationKey) !== 'public') { throw lazyDOMException(`Key must be a public key`, 'InvalidAccessError'); } @@ -215,7 +217,7 @@ function mlKemEncapsulate(encapsulationKey) { const job = new KEMEncapsulateJob( kCryptoJobAsync, - encapsulationKey[kKeyObject][kHandle], + getCryptoKeyHandle(encapsulationKey), undefined, undefined, undefined, @@ -241,7 +243,7 @@ function mlKemEncapsulate(encapsulationKey) { } function mlKemDecapsulate(decapsulationKey, ciphertext) { - if (decapsulationKey[kKeyType] !== 'private') { + if (getCryptoKeyType(decapsulationKey) !== 'private') { throw lazyDOMException(`Key must be a private key`, 'InvalidAccessError'); } @@ -249,7 +251,7 @@ function mlKemDecapsulate(decapsulationKey, ciphertext) { const job = new KEMDecapsulateJob( kCryptoJobAsync, - decapsulationKey[kKeyObject][kHandle], + getCryptoKeyHandle(decapsulationKey), undefined, undefined, undefined, diff --git a/lib/internal/crypto/pbkdf2.js b/lib/internal/crypto/pbkdf2.js index 2b11535edb3ec7..7f0fa0e1855efe 100644 --- a/lib/internal/crypto/pbkdf2.js +++ b/lib/internal/crypto/pbkdf2.js @@ -23,7 +23,6 @@ const { const { getArrayBufferOrView, normalizeHashName, - kKeyObject, } = require('internal/crypto/util'); const { @@ -31,6 +30,10 @@ const { promisify, } = require('internal/util'); +const { + getCryptoKeyHandle, +} = require('internal/crypto/keys'); + function pbkdf2(password, salt, iterations, keylen, digest, callback) { if (typeof digest === 'function') { callback = digest; @@ -113,8 +116,9 @@ async function pbkdf2DeriveBits(algorithm, baseKey, length) { let result; try { + // TODO(panva): call the job directly without needing to re-export the handle result = await pbkdf2Promise( - baseKey[kKeyObject].export(), salt, iterations, length / 8, normalizeHashName(hash.name), + getCryptoKeyHandle(baseKey).export(), salt, iterations, length / 8, normalizeHashName(hash.name), ); } catch (err) { throw lazyDOMException( diff --git a/lib/internal/crypto/rsa.js b/lib/internal/crypto/rsa.js index f6f1f09a294131..a019e70e0268b7 100644 --- a/lib/internal/crypto/rsa.js +++ b/lib/internal/crypto/rsa.js @@ -15,9 +15,11 @@ const { kSignJobModeSign, kSignJobModeVerify, kKeyVariantRSA_OAEP, + kKeyVariantRSA_SSA_PKCS1_v1_5, kWebCryptoCipherEncrypt, kWebCryptoKeyFormatPKCS8, kWebCryptoKeyFormatSPKI, + RsaKeyPairGenJob, RSA_PKCS1_PSS_PADDING, } = internalBinding('crypto'); @@ -28,24 +30,24 @@ const { const { bigIntArrayToUnsignedInt, getDigestSizeInBytes, + getUsagesMask, getUsagesUnion, hasAnyNotIn, jobPromise, normalizeHashName, validateMaxBufferLength, kHandle, - kKeyObject, } = require('internal/crypto/util'); const { lazyDOMException, - promisify, } = require('internal/util'); const { InternalCryptoKey, - kAlgorithm, - kKeyType, + getCryptoKeyAlgorithm, + getCryptoKeyHandle, + getCryptoKeyType, } = require('internal/crypto/keys'); const { @@ -54,12 +56,6 @@ const { validateJwk, } = require('internal/crypto/webcrypto_util'); -const { - generateKeyPair: _generateKeyPair, -} = require('internal/crypto/keygen'); - -const generateKeyPair = promisify(_generateKeyPair); - function verifyAcceptableRsaKeyUse(name, isPublic, usages) { let checkSet; switch (name) { @@ -92,7 +88,7 @@ async function rsaOaepCipher(mode, key, data, algorithm) { validateRsaOaepAlgorithm(algorithm); const type = mode === kWebCryptoCipherEncrypt ? 'public' : 'private'; - if (key[kKeyType] !== type) { + if (getCryptoKeyType(key) !== type) { throw lazyDOMException( 'The requested operation is not valid for the provided key', 'InvalidAccessError'); @@ -101,10 +97,10 @@ async function rsaOaepCipher(mode, key, data, algorithm) { return await jobPromise(() => new RSACipherJob( kCryptoJobAsync, mode, - key[kKeyObject][kHandle], + getCryptoKeyHandle(key), data, kKeyVariantRSA_OAEP, - normalizeHashName(key[kAlgorithm].hash.name), + normalizeHashName(getCryptoKeyAlgorithm(key).hash.name), algorithm.label)); } @@ -145,17 +141,11 @@ async function rsaKeyGenerate( } } - let keyPair; - try { - keyPair = await generateKeyPair('rsa', { - modulusLength, - publicExponent: publicExponentConverted, - }); - } catch (err) { - throw lazyDOMException( - 'The operation failed for an operation-specific reason', - { name: 'OperationError', cause: err }); - } + const handles = await jobPromise(() => new RsaKeyPairGenJob( + kCryptoJobAsync, + kKeyVariantRSA_SSA_PKCS1_v1_5, + modulusLength, + publicExponentConverted)); const keyAlgorithm = { name, @@ -181,16 +171,16 @@ async function rsaKeyGenerate( const publicKey = new InternalCryptoKey( - keyPair.publicKey, + handles[0], keyAlgorithm, - publicUsages, + getUsagesMask(publicUsages), true); const privateKey = new InternalCryptoKey( - keyPair.privateKey, + handles[1], keyAlgorithm, - privateUsages, + getUsagesMask(privateUsages), extractable); return { __proto__: null, publicKey, privateKey }; @@ -201,11 +191,11 @@ function rsaExportKey(key, format) { switch (format) { case kWebCryptoKeyFormatSPKI: { return TypedArrayPrototypeGetBuffer( - key[kKeyObject][kHandle].export(kKeyFormatDER, kWebCryptoKeyFormatSPKI)); + getCryptoKeyHandle(key).export(kKeyFormatDER, kWebCryptoKeyFormatSPKI)); } case kWebCryptoKeyFormatPKCS8: { return TypedArrayPrototypeGetBuffer( - key[kKeyObject][kHandle].export(kKeyFormatDER, kWebCryptoKeyFormatPKCS8, null, null)); + getCryptoKeyHandle(key).export(kKeyFormatDER, kWebCryptoKeyFormatPKCS8, null, null)); } default: return undefined; @@ -224,21 +214,21 @@ function rsaImportKey( extractable, keyUsages) { const usagesSet = new SafeSet(keyUsages); - let keyObject; + let handle; switch (format) { case 'KeyObject': { verifyAcceptableRsaKeyUse(algorithm.name, keyData.type === 'public', usagesSet); - keyObject = keyData; + handle = keyData[kHandle]; break; } case 'spki': { verifyAcceptableRsaKeyUse(algorithm.name, true, usagesSet); - keyObject = importDerKey(keyData, true); + handle = importDerKey(keyData, true); break; } case 'pkcs8': { verifyAcceptableRsaKeyUse(algorithm.name, false, usagesSet); - keyObject = importDerKey(keyData, false); + handle = importDerKey(keyData, false); break; } case 'jwk': { @@ -260,58 +250,59 @@ function rsaImportKey( const isPublic = keyData.d === undefined; verifyAcceptableRsaKeyUse(algorithm.name, isPublic, usagesSet); - keyObject = importJwkKey(isPublic, keyData); + handle = importJwkKey(isPublic, keyData); break; } default: return undefined; } - if (keyObject.asymmetricKeyType !== 'rsa') { + if (handle.getAsymmetricKeyType() !== 'rsa') { throw lazyDOMException('Invalid key type', 'DataError'); } const { modulusLength, publicExponent, - } = keyObject[kHandle].keyDetail({}); + } = handle.keyDetail({}); - return new InternalCryptoKey(keyObject, { + return new InternalCryptoKey(handle, { name: algorithm.name, modulusLength, publicExponent: new Uint8Array(publicExponent), hash: algorithm.hash, - }, usagesSet, extractable); + }, getUsagesMask(usagesSet), extractable); } async function rsaSignVerify(key, data, { saltLength }, signature) { const mode = signature === undefined ? kSignJobModeSign : kSignJobModeVerify; const type = mode === kSignJobModeSign ? 'private' : 'public'; - if (key[kKeyType] !== type) + if (getCryptoKeyType(key) !== type) throw lazyDOMException(`Key must be a ${type} key`, 'InvalidAccessError'); return await jobPromise(() => { - if (key[kAlgorithm].name === 'RSA-PSS') { + const algorithm = getCryptoKeyAlgorithm(key); + if (algorithm.name === 'RSA-PSS') { validateInt32( saltLength, 'algorithm.saltLength', 0, - MathCeil((key[kAlgorithm].modulusLength - 1) / 8) - getDigestSizeInBytes(key[kAlgorithm].hash.name) - 2); + MathCeil((algorithm.modulusLength - 1) / 8) - getDigestSizeInBytes(algorithm.hash.name) - 2); } return new SignJob( kCryptoJobAsync, signature === undefined ? kSignJobModeSign : kSignJobModeVerify, - key[kKeyObject][kHandle], + getCryptoKeyHandle(key), undefined, undefined, undefined, undefined, data, - normalizeHashName(key[kAlgorithm].hash.name), + normalizeHashName(algorithm.hash.name), saltLength, - key[kAlgorithm].name === 'RSA-PSS' ? RSA_PKCS1_PSS_PADDING : undefined, + algorithm.name === 'RSA-PSS' ? RSA_PKCS1_PSS_PADDING : undefined, undefined, undefined, signature); diff --git a/lib/internal/crypto/util.js b/lib/internal/crypto/util.js index 0240a82b058a6a..b743f3f93a149e 100644 --- a/lib/internal/crypto/util.js +++ b/lib/internal/crypto/util.js @@ -3,7 +3,6 @@ const { ArrayBufferIsView, ArrayBufferPrototypeGetByteLength, - ArrayFrom, ArrayPrototypeIncludes, ArrayPrototypePush, BigInt, @@ -94,7 +93,6 @@ const { } = require('internal/util/types'); const kHandle = Symbol('kHandle'); -const kKeyObject = Symbol('kKeyObject'); // This is here because many functions accepted binary strings without // any explicit encoding in older versions of node, and we don't want @@ -529,10 +527,10 @@ const simpleAlgorithmDictionaries = { TurboShakeParams: {}, }; -function validateMaxBufferLength(data, name) { - if (data.byteLength > kMaxBufferLength) { +function validateMaxBufferLength(data, name, max = kMaxBufferLength) { + if (data.byteLength > max) { throw lazyDOMException( - `${name} must be less than ${kMaxBufferLength + 1} bits`, + `${name} must be at most ${max} bytes`, 'OperationError'); } } @@ -719,6 +717,12 @@ function getStringOption(options, key) { return value; } +/** + * Returns the requested usages that are present in `usageSet`. + * @param {SafeSet} usageSet + * @param {...string} usages + * @returns {SafeSet} + */ function getUsagesUnion(usageSet, ...usages) { const newset = new SafeSet(); for (let n = 0; n < usages.length; n++) { @@ -728,28 +732,76 @@ function getUsagesUnion(usageSet, ...usages) { return newset; } -const kCanonicalUsageOrder = new SafeSet([ +// Must be at most 31 entries. +const kCanonicalUsageOrder = [ 'encrypt', 'decrypt', 'sign', 'verify', 'deriveKey', 'deriveBits', 'wrapKey', 'unwrapKey', 'encapsulateKey', 'encapsulateBits', 'decapsulateKey', 'decapsulateBits', -]); +]; + +const kUsageMasks = { + __proto__: null, +}; +const kUsageByMask = { + __proto__: null, +}; +// Derive both lookup tables from kCanonicalUsageOrder so adding a new +// usage only requires updating the canonical list above. The numeric +// mask uses the usage's canonical index as its bit position. +for (let n = 0; n < kCanonicalUsageOrder.length; n++) { + const usage = kCanonicalUsageOrder[n]; + const mask = 1 << n; + kUsageMasks[usage] = mask; + kUsageByMask[mask] = usage; +} /** - * Returns the usages from `usageSet` as an array in the canonical order - * defined by {@link kCanonicalUsageOrder}. + * Returns a bit mask representing the usages from `usageSet`. * @param {SafeSet} usageSet + * @returns {number} + */ +function getUsagesMask(usageSet) { + // No usages is a valid state for some public keys, represented by a + // zero mask. + if (usageSet.size === 0) return 0; + let mask = 0; + for (const usage of usageSet) { + mask |= kUsageMasks[usage]; + } + return mask; +} + +/** + * Returns whether `mask` contains `usage`. + * @param {number} mask + * @param {string} usage + * @returns {boolean} + */ +function hasUsage(mask, usage) { + return (mask & kUsageMasks[usage]) !== 0; +} + +/** + * Returns the usages represented by `mask` in canonical order. + * @param {number} mask * @returns {string[]} */ -function getSortedUsages(usageSet) { - if (usageSet.size <= 1) { - return ArrayFrom(usageSet); +function getUsagesFromMask(mask) { + // Short circuit most common cases, empty and single usage + // No usages is a valid state for some public keys + if (mask === 0) return []; + // A mask with exactly one bit set maps directly to one usage + if ((mask & (mask - 1)) === 0) { + return [kUsageByMask[mask]]; } + // Multiple usages need to be expanded in canonical order. const result = []; - for (const usage of kCanonicalUsageOrder) { - if (usageSet.has(usage)) ArrayPrototypePush(result, usage); + for (let n = 0; n < kCanonicalUsageOrder.length; n++) { + if (mask & (1 << n)) + ArrayPrototypePush(result, kCanonicalUsageOrder[n]); } return result; } @@ -791,36 +843,20 @@ function getDigestSizeInBytes(name) { } } -const kKeyOps = { - __proto__: null, - sign: 1, - verify: 2, - encrypt: 3, - decrypt: 4, - wrapKey: 5, - unwrapKey: 6, - deriveKey: 7, - deriveBits: 8, - encapsulateKey: 9, - encapsulateBits: 10, - decapsulateKey: 11, - decapsulateBits: 12, -}; - function validateKeyOps(keyOps, usagesSet) { if (keyOps === undefined) return; validateArray(keyOps, 'keyData.key_ops'); - let flags = 0; + let keyOpsMask = 0; for (let n = 0; n < keyOps.length; n++) { const op = keyOps[n]; - const op_flag = kKeyOps[op]; + const opMask = kUsageMasks[op]; // Skipping unknown key ops - if (op_flag === undefined) + if (opMask === undefined) continue; // Have we seen it already? if so, error - if (flags & (1 << op_flag)) + if (keyOpsMask & opMask) throw lazyDOMException('Duplicate key operation', 'DataError'); - flags |= (1 << op_flag); + keyOpsMask |= opMask; // TODO(@jasnell): RFC7517 section 4.3 strong recommends validating // key usage combinations. Specifically, it says that unrelated key @@ -828,12 +864,11 @@ function validateKeyOps(keyOps, usagesSet) { } if (usagesSet !== undefined) { - for (const use of usagesSet) { - if (!ArrayPrototypeIncludes(keyOps, use)) { - throw lazyDOMException( - 'Key operations and usage mismatch', - 'DataError'); - } + const usagesMask = getUsagesMask(usagesSet); + if ((keyOpsMask & usagesMask) !== usagesMask) { + throw lazyDOMException( + 'Key operations and usage mismatch', + 'DataError'); } } } @@ -856,7 +891,6 @@ module.exports = { getDataViewOrTypedArrayBuffer, getHashes, kHandle, - kKeyObject, setEngine, toBuf, @@ -874,7 +908,9 @@ module.exports = { getDigestSizeInBytes, getStringOption, getUsagesUnion, - getSortedUsages, + getUsagesMask, + getUsagesFromMask, + hasUsage, secureHeapUsed, getCachedHashId, getHashCache, diff --git a/lib/internal/crypto/webcrypto.js b/lib/internal/crypto/webcrypto.js index b0e143ce46ea60..150f489c541b8c 100644 --- a/lib/internal/crypto/webcrypto.js +++ b/lib/internal/crypto/webcrypto.js @@ -1,7 +1,7 @@ 'use strict'; const { - ArrayPrototypeIncludes, + ArrayPrototypeSlice, FunctionPrototypeCall, JSONParse, JSONStringify, @@ -35,11 +35,15 @@ const { const { createPublicKey, CryptoKey, + getCryptoKeyAlgorithm, + getCryptoKeyExtractable, + getCryptoKeyHandle, + getCryptoKeyType, + getCryptoKeyUsages, + getCryptoKeyUsagesMask, + hasCryptoKeyUsage, importGenericSecretKey, - kAlgorithm, - kKeyUsages, - kExtractable, - kKeyType, + PrivateKeyObject, } = require('internal/crypto/keys'); const { @@ -51,8 +55,6 @@ const { normalizeAlgorithm, normalizeHashName, validateMaxBufferLength, - kHandle, - kKeyObject, } = require('internal/crypto/util'); const { @@ -198,12 +200,15 @@ async function generateKey( throw lazyDOMException('Unrecognized algorithm name', 'NotSupportedError'); } - if ( - (resultType === 'CryptoKey' && - (result[kKeyType] === 'secret' || result[kKeyType] === 'private') && - result[kKeyUsages].length === 0) || - (resultType === 'CryptoKeyPair' && result.privateKey[kKeyUsages].length === 0) - ) { + if (resultType === 'CryptoKey') { + const type = getCryptoKeyType(result); + if ((type === 'secret' || type === 'private') && + getCryptoKeyUsagesMask(result) === 0) { + throw lazyDOMException( + 'Usages cannot be empty when creating a key.', + 'SyntaxError'); + } + } else if (getCryptoKeyUsagesMask(result.privateKey) === 0) { throw lazyDOMException( 'Usages cannot be empty when creating a key.', 'SyntaxError'); @@ -234,12 +239,12 @@ async function deriveBits(algorithm, baseKey, length = null) { } algorithm = normalizeAlgorithm(algorithm, 'deriveBits'); - if (!ArrayPrototypeIncludes(baseKey[kKeyUsages], 'deriveBits')) { + if (!hasCryptoKeyUsage(baseKey, 'deriveBits')) { throw lazyDOMException( 'baseKey does not have deriveBits usage', 'InvalidAccessError'); } - if (baseKey[kAlgorithm].name !== algorithm.name) + if (getCryptoKeyAlgorithm(baseKey).name !== algorithm.name) throw lazyDOMException('Key algorithm mismatch', 'InvalidAccessError'); switch (algorithm.name) { case 'X25519': @@ -339,12 +344,12 @@ async function deriveKey( algorithm = normalizeAlgorithm(algorithm, 'deriveBits'); derivedKeyAlgorithm = normalizeAlgorithm(derivedKeyAlgorithm, 'importKey'); - if (!ArrayPrototypeIncludes(baseKey[kKeyUsages], 'deriveKey')) { + if (!hasCryptoKeyUsage(baseKey, 'deriveKey')) { throw lazyDOMException( 'baseKey does not have deriveKey usage', 'InvalidAccessError'); } - if (baseKey[kAlgorithm].name !== algorithm.name) + if (getCryptoKeyAlgorithm(baseKey).name !== algorithm.name) throw lazyDOMException('Key algorithm mismatch', 'InvalidAccessError'); const length = getKeyLength(normalizeAlgorithm(arguments[2], 'get key length')); @@ -386,7 +391,7 @@ async function deriveKey( } async function exportKeySpki(key) { - switch (key[kAlgorithm].name) { + switch (getCryptoKeyAlgorithm(key).name) { case 'RSASSA-PKCS1-v1_5': // Fall through case 'RSA-PSS': @@ -428,7 +433,7 @@ async function exportKeySpki(key) { } async function exportKeyPkcs8(key) { - switch (key[kAlgorithm].name) { + switch (getCryptoKeyAlgorithm(key).name) { case 'RSASSA-PKCS1-v1_5': // Fall through case 'RSA-PSS': @@ -470,7 +475,7 @@ async function exportKeyPkcs8(key) { } async function exportKeyRawPublic(key, format) { - switch (key[kAlgorithm].name) { + switch (getCryptoKeyAlgorithm(key).name) { case 'ECDSA': // Fall through case 'ECDH': @@ -515,7 +520,7 @@ async function exportKeyRawPublic(key, format) { } async function exportKeyRawSeed(key) { - switch (key[kAlgorithm].name) { + switch (getCryptoKeyAlgorithm(key).name) { case 'ML-DSA-44': // Fall through case 'ML-DSA-65': @@ -536,7 +541,7 @@ async function exportKeyRawSeed(key) { } async function exportKeyRawSecret(key, format) { - switch (key[kAlgorithm].name) { + switch (getCryptoKeyAlgorithm(key).name) { case 'AES-CTR': // Fall through case 'AES-CBC': @@ -546,7 +551,7 @@ async function exportKeyRawSecret(key, format) { case 'AES-KW': // Fall through case 'HMAC': - return TypedArrayPrototypeGetBuffer(key[kKeyObject][kHandle].export()); + return TypedArrayPrototypeGetBuffer(getCryptoKeyHandle(key).export()); case 'AES-OCB': // Fall through case 'KMAC128': @@ -555,7 +560,7 @@ async function exportKeyRawSecret(key, format) { // Fall through case 'ChaCha20-Poly1305': if (format === 'raw-secret') { - return TypedArrayPrototypeGetBuffer(key[kKeyObject][kHandle].export()); + return TypedArrayPrototypeGetBuffer(getCryptoKeyHandle(key).export()); } return undefined; default: @@ -564,28 +569,29 @@ async function exportKeyRawSecret(key, format) { } async function exportKeyJWK(key) { + const algorithm = getCryptoKeyAlgorithm(key); const parameters = { - key_ops: key[kKeyUsages], - ext: key[kExtractable], + key_ops: ArrayPrototypeSlice(getCryptoKeyUsages(key), 0), + ext: getCryptoKeyExtractable(key), }; - switch (key[kAlgorithm].name) { + switch (algorithm.name) { case 'RSASSA-PKCS1-v1_5': { const alg = normalizeHashName( - key[kAlgorithm].hash.name, + algorithm.hash.name, normalizeHashName.kContextJwkRsa); if (alg) parameters.alg = alg; break; } case 'RSA-PSS': { const alg = normalizeHashName( - key[kAlgorithm].hash.name, + algorithm.hash.name, normalizeHashName.kContextJwkRsaPss); if (alg) parameters.alg = alg; break; } case 'RSA-OAEP': { const alg = normalizeHashName( - key[kAlgorithm].hash.name, + algorithm.hash.name, normalizeHashName.kContextJwkRsaOaep); if (alg) parameters.alg = alg; break; @@ -613,7 +619,7 @@ async function exportKeyJWK(key) { case 'Ed25519': // Fall through case 'Ed448': - parameters.alg = key[kAlgorithm].name; + parameters.alg = algorithm.name; break; case 'AES-CTR': // Fall through @@ -625,14 +631,14 @@ async function exportKeyJWK(key) { // Fall through case 'AES-KW': parameters.alg = require('internal/crypto/aes') - .getAlgorithmName(key[kAlgorithm].name, key[kAlgorithm].length); + .getAlgorithmName(algorithm.name, algorithm.length); break; case 'ChaCha20-Poly1305': parameters.alg = 'C20P'; break; case 'HMAC': { const alg = normalizeHashName( - key[kAlgorithm].hash.name, + algorithm.hash.name, normalizeHashName.kContextJwkHmac); if (alg) parameters.alg = alg; break; @@ -648,7 +654,7 @@ async function exportKeyJWK(key) { return undefined; } - return key[kKeyObject][kHandle].exportJwk(parameters, true); + return getCryptoKeyHandle(key).exportJwk(parameters, true); } async function exportKey(format, key) { @@ -666,26 +672,28 @@ async function exportKey(format, key) { context: '2nd argument', }); + const algorithm = getCryptoKeyAlgorithm(key); try { - normalizeAlgorithm(key[kAlgorithm], 'exportKey'); + normalizeAlgorithm(algorithm, 'exportKey'); } catch { throw lazyDOMException( - `${key[kAlgorithm].name} key export is not supported`, 'NotSupportedError'); + `${algorithm.name} key export is not supported`, 'NotSupportedError'); } - if (!key[kExtractable]) + if (!getCryptoKeyExtractable(key)) throw lazyDOMException('key is not extractable', 'InvalidAccessError'); + const type = getCryptoKeyType(key); let result; switch (format) { case 'spki': { - if (key[kKeyType] === 'public') { + if (type === 'public') { result = await exportKeySpki(key); } break; } case 'pkcs8': { - if (key[kKeyType] === 'private') { + if (type === 'private') { result = await exportKeyPkcs8(key); } break; @@ -695,27 +703,27 @@ async function exportKey(format, key) { break; } case 'raw-secret': { - if (key[kKeyType] === 'secret') { + if (type === 'secret') { result = await exportKeyRawSecret(key, format); } break; } case 'raw-public': { - if (key[kKeyType] === 'public') { + if (type === 'public') { result = await exportKeyRawPublic(key, format); } break; } case 'raw-seed': { - if (key[kKeyType] === 'private') { + if (type === 'private') { result = await exportKeyRawSeed(key); } break; } case 'raw': { - if (key[kKeyType] === 'secret') { + if (type === 'secret') { result = await exportKeyRawSecret(key, format); - } else if (key[kKeyType] === 'public') { + } else if (type === 'public') { result = await exportKeyRawPublic(key, format); } break; @@ -724,7 +732,7 @@ async function exportKey(format, key) { if (!result) { throw lazyDOMException( - `Unable to export ${key[kAlgorithm].name} ${key[kKeyType]} key using ${format} format`, + `Unable to export ${algorithm.name} ${type} key using ${format} format`, 'NotSupportedError'); } @@ -844,9 +852,10 @@ function importKeySync(format, keyData, algorithm, extractable, keyUsages) { 'NotSupportedError'); } - if ((result.type === 'secret' || result.type === 'private') && result[kKeyUsages].length === 0) { + const type = getCryptoKeyType(result); + if ((type === 'secret' || type === 'private') && getCryptoKeyUsagesMask(result) === 0) { throw lazyDOMException( - `Usages cannot be empty when importing a ${result.type} key.`, + `Usages cannot be empty when importing a ${type} key.`, 'SyntaxError'); } @@ -926,10 +935,10 @@ async function wrapKey(format, key, wrappingKey, algorithm) { algorithm = normalizeAlgorithm(algorithm, 'encrypt'); } - if (algorithm.name !== wrappingKey[kAlgorithm].name) + if (algorithm.name !== getCryptoKeyAlgorithm(wrappingKey).name) throw lazyDOMException('Key algorithm mismatch', 'InvalidAccessError'); - if (!ArrayPrototypeIncludes(wrappingKey[kKeyUsages], 'wrapKey')) + if (!hasCryptoKeyUsage(wrappingKey, 'wrapKey')) throw lazyDOMException( 'Unable to use this key to wrapKey', 'InvalidAccessError'); @@ -1011,10 +1020,10 @@ async function unwrapKey( unwrappedKeyAlgo = normalizeAlgorithm(unwrappedKeyAlgo, 'importKey'); - if (unwrapAlgo.name !== unwrappingKey[kAlgorithm].name) + if (unwrapAlgo.name !== getCryptoKeyAlgorithm(unwrappingKey).name) throw lazyDOMException('Key algorithm mismatch', 'InvalidAccessError'); - if (!ArrayPrototypeIncludes(unwrappingKey[kKeyUsages], 'unwrapKey')) + if (!hasCryptoKeyUsage(unwrappingKey, 'unwrapKey')) throw lazyDOMException( 'Unable to use this key to unwrapKey', 'InvalidAccessError'); @@ -1045,18 +1054,15 @@ async function unwrapKey( } async function signVerify(algorithm, key, data, signature) { - let usage = 'sign'; - if (signature !== undefined) { - usage = 'verify'; - } - algorithm = normalizeAlgorithm(algorithm, usage); + const op = signature !== undefined ? 'verify' : 'sign'; // This is also usage + algorithm = normalizeAlgorithm(algorithm, op); - if (algorithm.name !== key[kAlgorithm].name) + if (algorithm.name !== getCryptoKeyAlgorithm(key).name) throw lazyDOMException('Key algorithm mismatch', 'InvalidAccessError'); - if (!ArrayPrototypeIncludes(key[kKeyUsages], usage)) + if (!hasCryptoKeyUsage(key, op)) throw lazyDOMException( - `Unable to use this key to ${usage}`, 'InvalidAccessError'); + `Unable to use this key to ${op}`, 'InvalidAccessError'); switch (algorithm.name) { case 'RSA-PSS': @@ -1192,10 +1198,10 @@ async function encrypt(algorithm, key, data) { algorithm = normalizeAlgorithm(algorithm, 'encrypt'); - if (algorithm.name !== key[kAlgorithm].name) + if (algorithm.name !== getCryptoKeyAlgorithm(key).name) throw lazyDOMException('Key algorithm mismatch', 'InvalidAccessError'); - if (!ArrayPrototypeIncludes(key[kKeyUsages], 'encrypt')) + if (!hasCryptoKeyUsage(key, 'encrypt')) throw lazyDOMException( 'Unable to use this key to encrypt', 'InvalidAccessError'); @@ -1229,10 +1235,10 @@ async function decrypt(algorithm, key, data) { algorithm = normalizeAlgorithm(algorithm, 'decrypt'); - if (algorithm.name !== key[kAlgorithm].name) + if (algorithm.name !== getCryptoKeyAlgorithm(key).name) throw lazyDOMException('Key algorithm mismatch', 'InvalidAccessError'); - if (!ArrayPrototypeIncludes(key[kKeyUsages], 'decrypt')) + if (!hasCryptoKeyUsage(key, 'decrypt')) throw lazyDOMException( 'Unable to use this key to decrypt', 'InvalidAccessError'); @@ -1262,13 +1268,16 @@ async function getPublicKey(key, keyUsages) { context: '2nd argument', }); - if (key[kKeyType] !== 'private') + const type = getCryptoKeyType(key); + if (type !== 'private') throw lazyDOMException('key must be a private key', - key[kKeyType] === 'secret' ? 'NotSupportedError' : 'InvalidAccessError'); + type === 'secret' ? 'NotSupportedError' : 'InvalidAccessError'); - const keyObject = createPublicKey(key[kKeyObject]); - return keyObject.toCryptoKey(key[kAlgorithm], true, keyUsages); + // TODO(panva): this is by no means a hot path, but let's still follow up to get + // rid of this awkwardness + const keyObject = createPublicKey(new PrivateKeyObject(getCryptoKeyHandle(key))); + return keyObject.toCryptoKey(getCryptoKeyAlgorithm(key), true, keyUsages); } async function encapsulateBits(encapsulationAlgorithm, encapsulationKey) { @@ -1288,20 +1297,21 @@ async function encapsulateBits(encapsulationAlgorithm, encapsulationKey) { }); const normalizedEncapsulationAlgorithm = normalizeAlgorithm(encapsulationAlgorithm, 'encapsulate'); + const keyAlgorithm = getCryptoKeyAlgorithm(encapsulationKey); - if (normalizedEncapsulationAlgorithm.name !== encapsulationKey[kAlgorithm].name) { + if (normalizedEncapsulationAlgorithm.name !== keyAlgorithm.name) { throw lazyDOMException( 'key algorithm mismatch', 'InvalidAccessError'); } - if (!ArrayPrototypeIncludes(encapsulationKey[kKeyUsages], 'encapsulateBits')) { + if (!hasCryptoKeyUsage(encapsulationKey, 'encapsulateBits')) { throw lazyDOMException( 'encapsulationKey does not have encapsulateBits usage', 'InvalidAccessError'); } - switch (encapsulationKey[kAlgorithm].name) { + switch (keyAlgorithm.name) { case 'ML-KEM-512': case 'ML-KEM-768': case 'ML-KEM-1024': @@ -1342,21 +1352,22 @@ async function encapsulateKey(encapsulationAlgorithm, encapsulationKey, sharedKe const normalizedEncapsulationAlgorithm = normalizeAlgorithm(encapsulationAlgorithm, 'encapsulate'); const normalizedSharedKeyAlgorithm = normalizeAlgorithm(sharedKeyAlgorithm, 'importKey'); + const keyAlgorithm = getCryptoKeyAlgorithm(encapsulationKey); - if (normalizedEncapsulationAlgorithm.name !== encapsulationKey[kAlgorithm].name) { + if (normalizedEncapsulationAlgorithm.name !== keyAlgorithm.name) { throw lazyDOMException( 'key algorithm mismatch', 'InvalidAccessError'); } - if (!ArrayPrototypeIncludes(encapsulationKey[kKeyUsages], 'encapsulateKey')) { + if (!hasCryptoKeyUsage(encapsulationKey, 'encapsulateKey')) { throw lazyDOMException( 'encapsulationKey does not have encapsulateKey usage', 'InvalidAccessError'); } let encapsulateBits; - switch (encapsulationKey[kAlgorithm].name) { + switch (keyAlgorithm.name) { case 'ML-KEM-512': case 'ML-KEM-768': case 'ML-KEM-1024': @@ -1402,20 +1413,21 @@ async function decapsulateBits(decapsulationAlgorithm, decapsulationKey, ciphert }); const normalizedDecapsulationAlgorithm = normalizeAlgorithm(decapsulationAlgorithm, 'decapsulate'); + const keyAlgorithm = getCryptoKeyAlgorithm(decapsulationKey); - if (normalizedDecapsulationAlgorithm.name !== decapsulationKey[kAlgorithm].name) { + if (normalizedDecapsulationAlgorithm.name !== keyAlgorithm.name) { throw lazyDOMException( 'key algorithm mismatch', 'InvalidAccessError'); } - if (!ArrayPrototypeIncludes(decapsulationKey[kKeyUsages], 'decapsulateBits')) { + if (!hasCryptoKeyUsage(decapsulationKey, 'decapsulateBits')) { throw lazyDOMException( 'decapsulationKey does not have decapsulateBits usage', 'InvalidAccessError'); } - switch (decapsulationKey[kAlgorithm].name) { + switch (keyAlgorithm.name) { case 'ML-KEM-512': case 'ML-KEM-768': case 'ML-KEM-1024': @@ -1462,21 +1474,22 @@ async function decapsulateKey( const normalizedDecapsulationAlgorithm = normalizeAlgorithm(decapsulationAlgorithm, 'decapsulate'); const normalizedSharedKeyAlgorithm = normalizeAlgorithm(sharedKeyAlgorithm, 'importKey'); + const keyAlgorithm = getCryptoKeyAlgorithm(decapsulationKey); - if (normalizedDecapsulationAlgorithm.name !== decapsulationKey[kAlgorithm].name) { + if (normalizedDecapsulationAlgorithm.name !== keyAlgorithm.name) { throw lazyDOMException( 'key algorithm mismatch', 'InvalidAccessError'); } - if (!ArrayPrototypeIncludes(decapsulationKey[kKeyUsages], 'decapsulateKey')) { + if (!hasCryptoKeyUsage(decapsulationKey, 'decapsulateKey')) { throw lazyDOMException( 'decapsulationKey does not have decapsulateKey usage', 'InvalidAccessError'); } let decapsulatedBits; - switch (decapsulationKey[kAlgorithm].name) { + switch (keyAlgorithm.name) { case 'ML-KEM-512': case 'ML-KEM-768': case 'ML-KEM-1024': diff --git a/lib/internal/crypto/webcrypto_util.js b/lib/internal/crypto/webcrypto_util.js index db340fa620c35a..320bf0436de553 100644 --- a/lib/internal/crypto/webcrypto_util.js +++ b/lib/internal/crypto/webcrypto_util.js @@ -8,6 +8,7 @@ const { kKeyEncodingSPKI, kKeyTypePublic, kKeyTypePrivate, + kKeyTypeSecret, } = internalBinding('crypto'); const { @@ -18,11 +19,6 @@ const { lazyDOMException, } = require('internal/util'); -const { - PrivateKeyObject, - PublicKeyObject, -} = require('internal/crypto/keys'); - function importDerKey(keyData, isPublic) { const handle = new KeyObjectHandle(); const keyType = isPublic ? kKeyTypePublic : kKeyTypePrivate; @@ -33,16 +29,57 @@ function importDerKey(keyData, isPublic) { throw lazyDOMException( 'Invalid keyData', { name: 'DataError', cause: err }); } - return isPublic ? - new PublicKeyObject(handle) : - new PrivateKeyObject(handle); + return handle; } function validateJwk(keyData, kty, extractable, usagesSet, expectedUse) { - if (!keyData.kty) + if (typeof keyData.kty !== 'string') throw lazyDOMException('Invalid keyData', 'DataError'); if (keyData.kty !== kty) throw lazyDOMException('Invalid JWK "kty" Parameter', 'DataError'); + switch (kty) { + case 'RSA': + if (typeof keyData.n !== 'string' || + typeof keyData.e !== 'string' || + (keyData.d !== undefined && typeof keyData.d !== 'string')) + throw lazyDOMException('Invalid keyData', 'DataError'); + if (typeof keyData.d === 'string' && + (typeof keyData.p !== 'string' || + typeof keyData.q !== 'string' || + typeof keyData.dp !== 'string' || + typeof keyData.dq !== 'string' || + typeof keyData.qi !== 'string')) + throw lazyDOMException('Invalid keyData', 'DataError'); + break; + case 'EC': + if (typeof keyData.crv !== 'string' || + typeof keyData.x !== 'string' || + typeof keyData.y !== 'string' || + (keyData.d !== undefined && typeof keyData.d !== 'string')) + throw lazyDOMException('Invalid keyData', 'DataError'); + break; + case 'OKP': + if (typeof keyData.crv !== 'string' || + typeof keyData.x !== 'string' || + (keyData.d !== undefined && typeof keyData.d !== 'string')) + throw lazyDOMException('Invalid keyData', 'DataError'); + break; + case 'oct': + if (typeof keyData.k !== 'string') + throw lazyDOMException('Invalid keyData', 'DataError'); + break; + case 'AKP': + if (typeof keyData.alg !== 'string' || + typeof keyData.pub !== 'string' || + (keyData.priv !== undefined && typeof keyData.priv !== 'string')) + throw lazyDOMException('Invalid keyData', 'DataError'); + break; + default: { + // It is not possible to get here because all possible cases are handled above. + const assert = require('internal/assert'); + assert.fail('Unreachable code'); + } + } if (usagesSet.size > 0 && keyData.use !== undefined) { if (keyData.use !== expectedUse) throw lazyDOMException('Invalid JWK "use" Parameter', 'DataError'); @@ -66,9 +103,7 @@ function importJwkKey(isPublic, keyData) { throw lazyDOMException( 'Invalid keyData', { name: 'DataError', cause: err }); } - return isPublic ? - new PublicKeyObject(handle) : - new PrivateKeyObject(handle); + return handle; } function importRawKey(isPublic, keyData, format, name, namedCurve) { @@ -80,14 +115,31 @@ function importRawKey(isPublic, keyData, format, name, namedCurve) { throw lazyDOMException( 'Invalid keyData', { name: 'DataError', cause: err }); } - return isPublic ? - new PublicKeyObject(handle) : - new PrivateKeyObject(handle); + return handle; +} + +function importSecretKey(keyData) { + const handle = new KeyObjectHandle(); + handle.init(kKeyTypeSecret, keyData); + return handle; +} + +function importJwkSecretKey(keyData) { + const handle = new KeyObjectHandle(); + try { + handle.init(kKeyTypeSecret, keyData, kKeyFormatJWK, null, null); + } catch (err) { + throw lazyDOMException( + 'Invalid keyData', { name: 'DataError', cause: err }); + } + return handle; } module.exports = { importDerKey, importJwkKey, + importJwkSecretKey, importRawKey, + importSecretKey, validateJwk, }; diff --git a/lib/internal/crypto/webidl.js b/lib/internal/crypto/webidl.js index 0c14bd22d6a9ad..43f0906a3af902 100644 --- a/lib/internal/crypto/webidl.js +++ b/lib/internal/crypto/webidl.js @@ -43,6 +43,10 @@ const { setOwnProperty, } = require('internal/util'); const { CryptoKey } = require('internal/crypto/webcrypto'); +const { + getCryptoKeyAlgorithm, + getCryptoKeyType, +} = require('internal/crypto/keys'); const { validateMaxBufferLength, kNamedCurveAliases, @@ -563,6 +567,7 @@ converters.HkdfParams = createDictionaryConverter( { key: 'info', converter: converters.BufferSource, + validator: (V, dict) => validateMaxBufferLength(V, 'algorithm.info', 1024), required: true, }, ]); @@ -738,11 +743,11 @@ converters.EcdhKeyDeriveParams = createDictionaryConverter( key: 'public', converter: converters.CryptoKey, validator: (V, dict) => { - if (V.type !== 'public') + if (getCryptoKeyType(V) !== 'public') throw lazyDOMException( 'algorithm.public must be a public key', 'InvalidAccessError'); - if (StringPrototypeToLowerCase(V.algorithm.name) !== StringPrototypeToLowerCase(dict.name)) + if (StringPrototypeToLowerCase(getCryptoKeyAlgorithm(V).name) !== StringPrototypeToLowerCase(dict.name)) throw lazyDOMException( 'key algorithm mismatch', 'InvalidAccessError'); diff --git a/lib/internal/util/comparisons.js b/lib/internal/util/comparisons.js index 694bb570957cb3..2f21740fcb84bf 100644 --- a/lib/internal/util/comparisons.js +++ b/lib/internal/util/comparisons.js @@ -127,10 +127,11 @@ const { getOwnNonIndexProperties, } = internalBinding('util'); -let kKeyObject; -let kExtractable; -let kAlgorithm; -let kKeyUsages; +let getCryptoKeyHandle; +let getCryptoKeyType; +let getCryptoKeyExtractable; +let getCryptoKeyAlgorithm; +let getCryptoKeyUsagesMask; const kStrict = 2; const kStrictWithoutPrototypes = 3; @@ -413,15 +414,21 @@ function objectComparisonStart(val1, val2, mode, memos) { return false; } } else if (isCryptoKey(val1)) { - if (kKeyObject === undefined) { - kKeyObject = require('internal/crypto/util').kKeyObject; - ({ kExtractable, kAlgorithm, kKeyUsages } = require('internal/crypto/keys')); + if (getCryptoKeyHandle === undefined) { + ({ + getCryptoKeyHandle, + getCryptoKeyType, + getCryptoKeyExtractable, + getCryptoKeyAlgorithm, + getCryptoKeyUsagesMask, + } = require('internal/crypto/keys')); } if (!isCryptoKey(val2) || - val1[kExtractable] !== val2[kExtractable] || - !innerDeepEqual(val1[kAlgorithm], val2[kAlgorithm], mode, memos) || - !innerDeepEqual(val1[kKeyUsages], val2[kKeyUsages], mode, memos) || - !innerDeepEqual(val1[kKeyObject], val2[kKeyObject], mode, memos) + getCryptoKeyType(val1) !== getCryptoKeyType(val2) || + getCryptoKeyExtractable(val1) !== getCryptoKeyExtractable(val2) || + !innerDeepEqual(getCryptoKeyAlgorithm(val1), getCryptoKeyAlgorithm(val2), mode, memos) || + getCryptoKeyUsagesMask(val1) !== getCryptoKeyUsagesMask(val2) || + !getCryptoKeyHandle(val1).equals(getCryptoKeyHandle(val2)) ) { return false; } diff --git a/src/crypto/README.md b/src/crypto/README.md index 0a2a5d6f285f60..672b15c13d4962 100644 --- a/src/crypto/README.md +++ b/src/crypto/README.md @@ -149,24 +149,32 @@ core key objects. #### `KeyObjectData` `KeyObjectData` is an internal thread-safe structure used to wrap either -a `EVPKeyPointer` (for Public or Private keys) or a `ByteSource` containing -a Secret key. +an `EVPKeyPointer` (for Public or Private keys) or a `ByteSource` containing +a Secret key. It is the shared backing representation used by `KeyObject`, +`CryptoKey`, and native crypto jobs that operate on key material. #### `KeyObjectHandle` -The `KeyObjectHandle` provides the interface between the native C++ code -handling keys and the public JavaScript `KeyObject` API. +`KeyObjectHandle` is the JavaScript-visible C++ handle for a +`KeyObjectData`. It exposes operations that internal JavaScript uses to +initialize, inspect, compare, and export key material. Native code passes +`KeyObjectData` across threads and jobs; a `KeyObjectHandle` is created when +JavaScript needs access to those operations. #### `KeyObject` -A `KeyObject` is the public Node.js-specific API for keys. A single -`KeyObject` wraps exactly one `KeyObjectHandle`. +A `KeyObject` is the public Node.js-specific API for keys. It extends a +native `NativeKeyObject`, which stores `KeyObjectData` for structured +cloning, and it owns one `KeyObjectHandle` used by the JavaScript API +surface. #### `CryptoKey` -A `CryptoKey` is the Web Crypto API's alternative to `KeyObject`. In the -Node.js implementation, `CryptoKey` is a thin wrapper around the -`KeyObject` and it is largely possible to use them interchangeably. +A `CryptoKey` is the Web Crypto API key type. In the Node.js implementation, +public `CryptoKey` instances are backed by a native `NativeCryptoKey`, not by +a `KeyObject`. `NativeCryptoKey` stores the same `KeyObjectData` +representation as `KeyObject`, plus the Web Crypto internal slots +(`[[extractable]]`, `[[algorithm]]`, and `[[usages]]`). ### `CryptoJob` diff --git a/src/crypto/crypto_ec.cc b/src/crypto/crypto_ec.cc index 9cd50a421f8715..9355b7f7a6ca64 100644 --- a/src/crypto/crypto_ec.cc +++ b/src/crypto/crypto_ec.cc @@ -436,7 +436,6 @@ Maybe EcKeyGenTraits::AdditionalConfig( EcKeyPairGenConfig* params) { Environment* env = Environment::GetCurrent(args); CHECK(args[*offset]->IsString()); // curve name - CHECK(args[*offset + 1]->IsInt32()); // param encoding Utf8Value curve_name(env->isolate(), args[*offset]); params->params.curve_nid = Ec::GetCurveIdFromName(*curve_name); @@ -445,11 +444,17 @@ Maybe EcKeyGenTraits::AdditionalConfig( return Nothing(); } - params->params.param_encoding = args[*offset + 1].As()->Value(); - if (params->params.param_encoding != OPENSSL_EC_NAMED_CURVE && - params->params.param_encoding != OPENSSL_EC_EXPLICIT_CURVE) { - THROW_ERR_OUT_OF_RANGE(env, "Invalid param_encoding specified"); - return Nothing(); + // param encoding + if (args[*offset + 1]->IsNullOrUndefined()) { + params->params.param_encoding = OPENSSL_EC_NAMED_CURVE; + } else { + CHECK(args[*offset + 1]->IsInt32()); + params->params.param_encoding = args[*offset + 1].As()->Value(); + if (params->params.param_encoding != OPENSSL_EC_NAMED_CURVE && + params->params.param_encoding != OPENSSL_EC_EXPLICIT_CURVE) { + THROW_ERR_OUT_OF_RANGE(env, "Invalid param_encoding specified"); + return Nothing(); + } } *offset += 2; diff --git a/src/crypto/crypto_keys.cc b/src/crypto/crypto_keys.cc index 29a8b4513d64dc..92bb7dbb9714ce 100644 --- a/src/crypto/crypto_keys.cc +++ b/src/crypto/crypto_keys.cc @@ -1788,6 +1788,270 @@ std::unique_ptr NativeKeyObject::CloneForMessaging() return std::make_unique(handle_data_); } +void NativeCryptoKey::Initialize(Environment* env, Local target) { + SetMethod(env->context(), + target, + "createCryptoKeyClass", + NativeCryptoKey::CreateCryptoKeyClass); + SetMethod( + env->context(), target, "getCryptoKeySlots", NativeCryptoKey::GetSlots); +} + +void NativeCryptoKey::RegisterExternalReferences( + ExternalReferenceRegistry* registry) { + registry->Register(NativeCryptoKey::CreateCryptoKeyClass); + registry->Register(NativeCryptoKey::GetSlots); + registry->Register(NativeCryptoKey::New); +} + +namespace { +// Verifies that `value` is a `NativeCryptoKey` by checking whether it +// was constructed from the Environment's `NativeCryptoKey` template. +bool IsNativeCryptoKey(Environment* env, Local value) { + auto t = env->crypto_cryptokey_constructor_template(); + return !t.IsEmpty() && t->HasInstance(value); +} +} // namespace + +bool NativeCryptoKey::HasInstance(Environment* env, Local value) { + return IsNativeCryptoKey(env, value); +} + +void NativeCryptoKey::New(const FunctionCallbackInfo& args) { + Environment* env = Environment::GetCurrent(args); + CHECK_EQ(args.Length(), 4); + // args[0] is a KeyObjectHandle; we keep its KeyObjectData directly. + // args[1] is the algorithm dictionary object. + // args[2] is the usages mask. + // args[3] is the extractable boolean. + // + // args[1] is undefined only when called from + // CryptoKeyTransferData::Deserialize for a partially-initialized + // CryptoKey: algorithm/usages mask/extractable get filled in afterwards + // by FinalizeTransferRead before any JS can see the object. + // + // This constructor is not exposed to user JS - the public CryptoKey + // class throws from its constructor and InternalCryptoKey is kept + // in a module-closure. + CHECK(KeyObjectHandle::HasInstance(env, args[0])); + KeyObjectHandle* handle = Unwrap(args[0].As()); + CHECK_NOT_NULL(handle); + + auto* native = new NativeCryptoKey(env, args.This(), handle->Data()); + + if (!args[1]->IsUndefined()) { + CHECK(args[1]->IsObject()); + CHECK(args[2]->IsUint32()); + CHECK(args[3]->IsBoolean()); + args.This()->SetInternalField(kAlgorithmField, args[1]); + native->usages_mask_ = args[2].As()->Value(); + native->extractable_ = args[3]->IsTrue(); + } +} + +void NativeCryptoKey::CreateCryptoKeyClass( + const FunctionCallbackInfo& args) { + Environment* env = Environment::GetCurrent(args); + Isolate* isolate = env->isolate(); + + CHECK_EQ(args.Length(), 1); + Local callback = args[0]; + CHECK(callback->IsFunction()); + + Local t = + NewFunctionTemplate(isolate, NativeCryptoKey::New); + t->InstanceTemplate()->SetInternalFieldCount( + NativeCryptoKey::kInternalFieldCount); + CHECK(env->crypto_cryptokey_constructor_template().IsEmpty()); + env->set_crypto_cryptokey_constructor_template(t); + + Local ctor; + if (!t->GetFunction(env->context()).ToLocal(&ctor)) return; + + Local recv = Undefined(env->isolate()); + Local ret_v; + if (!callback.As() + ->Call(env->context(), recv, 1, &ctor) + .ToLocal(&ret_v)) { + return; + } + Local ret = ret_v.As(); + Local internal_ctor_v; + if (!ret->Get(env->context(), 1).ToLocal(&internal_ctor_v)) return; + CHECK(env->crypto_internal_cryptokey_constructor().IsEmpty()); + env->set_crypto_internal_cryptokey_constructor( + internal_ctor_v.As()); + args.GetReturnValue().Set(ret); +} + +// Returns all of the key's internal slot values as a single Array: +// [type enum, extractable, algorithm, usages mask, handle]. JS-side helpers +// call this once per key to prime a per-instance cache, so subsequent +// reads don't need to cross into C++ at all. +void NativeCryptoKey::GetSlots(const FunctionCallbackInfo& args) { + Environment* env = Environment::GetCurrent(args); + CHECK_EQ(args.Length(), 1); + if (!HasInstance(env, args[0])) { + THROW_ERR_INVALID_THIS(env, "Value of \"this\" must be of type CryptoKey"); + return; + } + Local obj = args[0].As(); + NativeCryptoKey* native = Unwrap(obj); + + Local handle; + if (!KeyObjectHandle::Create(env, native->handle_data_).ToLocal(&handle)) { + return; + } + + Local algorithm = obj->GetInternalField(kAlgorithmField).As(); + CHECK(algorithm->IsObject()); + Isolate* isolate = env->isolate(); + Local slots[] = { + Uint32::NewFromUnsigned(isolate, native->handle_data_.GetKeyType()), + v8::Boolean::New(isolate, native->extractable_), + algorithm, + Uint32::NewFromUnsigned(isolate, native->usages_mask_), + handle, + }; + args.GetReturnValue().Set(Array::New(isolate, slots, arraysize(slots))); +} + +BaseObject::TransferMode NativeCryptoKey::GetTransferMode() const { + return BaseObject::TransferMode::kCloneable; +} + +std::unique_ptr NativeCryptoKey::CloneForMessaging() + const { + Isolate* isolate = env()->isolate(); + Local obj = object(); + Local algorithm_v = obj->GetInternalField(kAlgorithmField).As(); + CHECK(algorithm_v->IsObject()); + v8::Global algorithm_copy(isolate, algorithm_v.As()); + return std::make_unique( + handle_data_, std::move(algorithm_copy), usages_mask_, extractable_); +} + +Maybe NativeCryptoKey::FinalizeTransferRead( + Local context, v8::ValueDeserializer* deserializer) { + Local bundle_v; + if (!deserializer->ReadValue(context).ToLocal(&bundle_v)) { + return Nothing(); + } + CHECK(bundle_v->IsObject()); + Local bundle = bundle_v.As(); + Isolate* isolate = env()->isolate(); + Local obj = object(); + + // The partially-initialized object produced by + // CryptoKeyTransferData::Deserialize should not have algorithm set yet. + CHECK(obj->GetInternalField(kAlgorithmField).As()->IsUndefined()); + + Local algorithm_v; + if (!bundle->Get(context, FIXED_ONE_BYTE_STRING(isolate, "algorithm")) + .ToLocal(&algorithm_v)) { + return Nothing(); + } + CHECK(algorithm_v->IsObject()); + obj->SetInternalField(kAlgorithmField, algorithm_v); + + Local usages_v; + if (!bundle->Get(context, FIXED_ONE_BYTE_STRING(isolate, "usages")) + .ToLocal(&usages_v)) { + return Nothing(); + } + CHECK(usages_v->IsUint32()); + usages_mask_ = usages_v.As()->Value(); + + Local extractable_v; + if (!bundle->Get(context, FIXED_ONE_BYTE_STRING(isolate, "extractable")) + .ToLocal(&extractable_v)) { + return Nothing(); + } + CHECK(extractable_v->IsBoolean()); + extractable_ = extractable_v->IsTrue(); + + return v8::JustVoid(); +} + +Maybe NativeCryptoKey::CryptoKeyTransferData::FinalizeTransferWrite( + Local context, v8::ValueSerializer* serializer) { + Isolate* isolate = Isolate::GetCurrent(); + CHECK(!algorithm_.IsEmpty()); + Local bundle = Object::New(isolate); + Local algorithm_v = PersistentToLocal::Strong(algorithm_); + if (bundle + ->Set( + context, FIXED_ONE_BYTE_STRING(isolate, "algorithm"), algorithm_v) + .IsNothing() || + bundle + ->Set(context, + FIXED_ONE_BYTE_STRING(isolate, "usages"), + Uint32::NewFromUnsigned(isolate, usages_mask_)) + .IsNothing() || + bundle + ->Set(context, + FIXED_ONE_BYTE_STRING(isolate, "extractable"), + v8::Boolean::New(isolate, extractable_)) + .IsNothing()) { + return Nothing(); + } + auto ret = serializer->WriteValue(context, bundle); + algorithm_.Reset(); + return ret; +} + +BaseObjectPtr NativeCryptoKey::CryptoKeyTransferData::Deserialize( + Environment* env, + Local context, + std::unique_ptr self) { + if (context != env->context()) { + THROW_ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE(env); + return {}; + } + + // Reconstruct the KeyObjectHandle for the transferred KeyObjectData. + Local handle; + if (!KeyObjectHandle::Create(env, data_).ToLocal(&handle)) return {}; + + // Make sure internal/crypto/keys has been loaded so that the + // CryptoKey constructor is registered with the Environment. + Isolate* isolate = env->isolate(); + Local arg = FIXED_ONE_BYTE_STRING(isolate, "internal/crypto/keys"); + if (env->builtin_module_require() + ->Call(context, Null(isolate), 1, &arg) + .IsEmpty()) { + return {}; + } + + // Construct a partially-initialized InternalCryptoKey; algorithm, + // usages mask and extractable are filled in via FinalizeTransferRead. + Local cryptokey_ctor = env->crypto_internal_cryptokey_constructor(); + CHECK(!cryptokey_ctor.IsEmpty()); + Local ctor_args[] = { + handle, + Undefined(isolate), + Undefined(isolate), + Undefined(isolate), + }; + Local cryptokey; + if (!cryptokey_ctor->NewInstance(context, 4, ctor_args).ToLocal(&cryptokey)) { + return {}; + } + + return BaseObjectPtr( + Unwrap(cryptokey.As())); +} + +void NativeCryptoKey::MemoryInfo(MemoryTracker* tracker) const { + tracker->TrackField("handle_data", handle_data_); +} + +void NativeCryptoKey::CryptoKeyTransferData::MemoryInfo( + MemoryTracker* tracker) const { + tracker->TrackField("data", data_); + tracker->TrackField("algorithm", algorithm_); +} + namespace Keys { void Initialize(Environment* env, Local target) { target->Set(env->context(), diff --git a/src/crypto/crypto_keys.h b/src/crypto/crypto_keys.h index 237a45ec955beb..bab640138e909d 100644 --- a/src/crypto/crypto_keys.h +++ b/src/crypto/crypto_keys.h @@ -13,6 +13,7 @@ #include +#include #include #include @@ -233,6 +234,94 @@ class NativeKeyObject : public BaseObject { KeyObjectData handle_data_; }; +// NativeCryptoKey is the native base class for the Web Crypto +// `CryptoKey`. It holds the internal slots - `[[type]]` as an enum, +// `[[extractable]]`, `[[algorithm]]`, `[[usages]]` as a mask, and the +// underlying KeyObjectData. The public `type`, `extractable`, +// `algorithm`, and `usages` accessors on `CryptoKey.prototype` are +// user-configurable per Web IDL, so internal consumers read these +// values directly from the C++ side via a single `GetSlots` call +// which returns all slots at once; JS primes a per-instance cache +// from that result. +class NativeCryptoKey : public BaseObject { + public: + enum InternalFields { + kAlgorithmField = BaseObject::kInternalFieldCount, + kInternalFieldCount, + }; + + static void Initialize(Environment* env, v8::Local target); + static void RegisterExternalReferences(ExternalReferenceRegistry* registry); + + static void New(const v8::FunctionCallbackInfo& args); + static void CreateCryptoKeyClass( + const v8::FunctionCallbackInfo& args); + + // True if `value` is a real NativeCryptoKey instance. Uses the + // FunctionTemplate stored on the Environment as a brand check. + // Used by `GetSlots` to validate its receiver. + static bool HasInstance(Environment* env, v8::Local value); + + // Returns [type, extractable, algorithm, usages mask, handle] in one call + // so JS can prime a per-instance cache on first access. + static void GetSlots(const v8::FunctionCallbackInfo& args); + + void MemoryInfo(MemoryTracker* tracker) const override; + SET_MEMORY_INFO_NAME(NativeCryptoKey) + SET_SELF_SIZE(NativeCryptoKey) + + class CryptoKeyTransferData : public worker::TransferData { + public: + CryptoKeyTransferData(const KeyObjectData& data, + v8::Global&& algorithm, + uint32_t usages_mask, + bool extractable) + : data_(data.addRef()), + algorithm_(std::move(algorithm)), + usages_mask_(usages_mask), + extractable_(extractable) {} + + BaseObjectPtr Deserialize( + Environment* env, + v8::Local context, + std::unique_ptr self) override; + + v8::Maybe FinalizeTransferWrite( + v8::Local context, + v8::ValueSerializer* serializer) override; + + void MemoryInfo(MemoryTracker* tracker) const override; + SET_MEMORY_INFO_NAME(CryptoKeyTransferData) + SET_SELF_SIZE(CryptoKeyTransferData) + + private: + KeyObjectData data_; + v8::Global algorithm_; + uint32_t usages_mask_; + bool extractable_; + }; + + BaseObject::TransferMode GetTransferMode() const override; + std::unique_ptr CloneForMessaging() const override; + v8::Maybe FinalizeTransferRead( + v8::Local context, + v8::ValueDeserializer* deserializer) override; + + const KeyObjectData& handle_data() const { return handle_data_; } + + private: + NativeCryptoKey(Environment* env, + v8::Local wrap, + const KeyObjectData& handle_data) + : BaseObject(env, wrap), handle_data_(handle_data.addRef()) { + MakeWeak(); + } + + KeyObjectData handle_data_; + uint32_t usages_mask_ = 0; + bool extractable_ = false; +}; + enum WebCryptoKeyFormat { kWebCryptoKeyFormatRaw, kWebCryptoKeyFormatPKCS8, diff --git a/src/crypto/crypto_rsa.cc b/src/crypto/crypto_rsa.cc index 38122d14efe2e6..e722f87b23fcbe 100644 --- a/src/crypto/crypto_rsa.cc +++ b/src/crypto/crypto_rsa.cc @@ -128,9 +128,9 @@ Maybe RsaKeyGenTraits::AdditionalConfig( static_cast(args[*offset].As()->Value()); CHECK_IMPLIES(params->params.variant != kKeyVariantRSA_PSS, - args.Length() == 10); + static_cast(args.Length()) >= *offset + 3); CHECK_IMPLIES(params->params.variant == kKeyVariantRSA_PSS, - args.Length() == 13); + static_cast(args.Length()) >= *offset + 6); params->params.modulus_bits = args[*offset + 1].As()->Value(); params->params.exponent = args[*offset + 2].As()->Value(); diff --git a/src/env_properties.h b/src/env_properties.h index 0fc7b2b66179e4..60a5d75708ac85 100644 --- a/src/env_properties.h +++ b/src/env_properties.h @@ -407,6 +407,7 @@ V(contextify_global_template, v8::ObjectTemplate) \ V(contextify_wrapper_template, v8::ObjectTemplate) \ V(cpu_usage_template, v8::DictionaryTemplate) \ + V(crypto_cryptokey_constructor_template, v8::FunctionTemplate) \ V(crypto_key_object_handle_constructor, v8::FunctionTemplate) \ V(env_proxy_template, v8::ObjectTemplate) \ V(env_proxy_ctor_template, v8::FunctionTemplate) \ @@ -481,6 +482,7 @@ V(async_hooks_init_function, v8::Function) \ V(async_hooks_promise_resolve_function, v8::Function) \ V(buffer_prototype_object, v8::Object) \ + V(crypto_internal_cryptokey_constructor, v8::Function) \ V(crypto_key_object_private_constructor, v8::Function) \ V(crypto_key_object_public_constructor, v8::Function) \ V(crypto_key_object_secret_constructor, v8::Function) \ diff --git a/src/node_crypto.cc b/src/node_crypto.cc index 84375f9a737675..c0869f40e0410d 100644 --- a/src/node_crypto.cc +++ b/src/node_crypto.cc @@ -48,6 +48,7 @@ namespace crypto { V(Hmac) \ V(Keygen) \ V(Keys) \ + V(NativeCryptoKey) \ V(NativeKeyObject) \ V(PBKDF2Job) \ V(Random) \ diff --git a/test/parallel/test-webcrypto-cryptokey-brand-check.js b/test/parallel/test-webcrypto-cryptokey-brand-check.js new file mode 100644 index 00000000000000..5b5c0386693865 --- /dev/null +++ b/test/parallel/test-webcrypto-cryptokey-brand-check.js @@ -0,0 +1,126 @@ +'use strict'; + +// The four CryptoKey prototype getters (`type`, `extractable`, +// `algorithm`, `usages`) are user-configurable per Web IDL, so they +// can be invoked with an arbitrary `this`. The native callbacks that +// implement them must brand-check their receiver and throw cleanly +// (ERR_INVALID_THIS) rather than crashing the process or returning +// garbage. This test exercises four progressively more hostile +// receiver shapes, including subverting `instanceof` via +// `Symbol.hasInstance`, to make sure the C++ brand check holds. +// +// It also verifies that `util.types.isCryptoKey()` cannot be fooled +// by prototype spoofing. + +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); + +const assert = require('node:assert'); +const { types: { isCryptoKey } } = require('node:util'); +const { subtle } = globalThis.crypto; + +(async () => { + const key = await subtle.generateKey( + { name: 'HMAC', hash: 'SHA-256' }, + true, + ['sign'], + ); + + const CryptoKey = key.constructor; + + // Capture the underlying prototype getters once, so that subsequent + // tampering with `CryptoKey.prototype` cannot affect what we call. + const getters = { + type: Object.getOwnPropertyDescriptor(CryptoKey.prototype, 'type').get, + extractable: + Object.getOwnPropertyDescriptor(CryptoKey.prototype, 'extractable').get, + algorithm: + Object.getOwnPropertyDescriptor(CryptoKey.prototype, 'algorithm').get, + usages: + Object.getOwnPropertyDescriptor(CryptoKey.prototype, 'usages').get, + }; + + // Sanity: each getter works on a real CryptoKey. + Object.entries(getters).forEach(([name, getter]) => { + assert.notStrictEqual(getter.call(key), undefined, `baseline ${name}`); + }); + assert.strictEqual(isCryptoKey(key), true); + + const invalidThis = { code: 'ERR_INVALID_THIS', name: 'TypeError' }; + + // Plain object receiver. + Object.entries(getters).forEach(([, getter]) => { + assert.throws(() => getter.call({}), invalidThis); + }); + + // Null-prototype object receiver. + Object.entries(getters).forEach(([, getter]) => { + assert.throws(() => getter.call({ __proto__: null }), invalidThis); + }); + + // Primitive receiver. + Object.entries(getters).forEach(([, getter]) => { + assert.throws(() => getter.call(1), invalidThis); + }); + + // Null. + Object.entries(getters).forEach(([, getter]) => { + // eslint-disable-next-line no-useless-call + assert.throws(() => getter.call(null), invalidThis); + }); + + // Undefined. + Object.entries(getters).forEach(([, getter]) => { + assert.throws(() => getter.call(), invalidThis); + }); + + // Function + Object.entries(getters).forEach(([, getter]) => { + assert.throws(() => getter.call(function() {}), invalidThis); + }); + + // Prototype spoofing with InternalCryptoKey.prototype must not pass + // util.types.isCryptoKey(). + const spoofed = {}; + Object.setPrototypeOf(spoofed, Object.getPrototypeOf(key)); + assert.strictEqual(spoofed instanceof CryptoKey, true); + assert.strictEqual(isCryptoKey(spoofed), false); + await assert.rejects( + subtle.sign('HMAC', spoofed, Buffer.from('payload')), + invalidThis); + await assert.rejects( + subtle.exportKey('jwk', spoofed), + invalidThis); + + // Subvert `instanceof CryptoKey` via Symbol.hasInstance, then + // invoke the native getters on a forged object. The C++ tag + // check must reject the receiver even though `instanceof` + // reports true. + Object.defineProperty(CryptoKey, Symbol.hasInstance, { + configurable: true, + value: () => true, + }); + const fake = { foo: 'bar' }; + assert.strictEqual(fake instanceof CryptoKey, true); + assert.strictEqual(isCryptoKey(fake), false); + Object.entries(getters).forEach(([, getter]) => { + assert.throws(() => getter.call(fake), invalidThis); + }); + + // Subverted `instanceof` plus a real BaseObject of a different + // kind (a Buffer) as the receiver. Without the C++ tag check + // this would type-confuse `Unwrap`. + const buf = Buffer.alloc(16); + assert.strictEqual(buf instanceof CryptoKey, true); + assert.strictEqual(isCryptoKey(buf), false); + Object.entries(getters).forEach(([, getter]) => { + assert.throws(() => getter.call(buf), invalidThis); + }); + + // The real CryptoKey continues to work after all of the above. + assert.strictEqual(getters.type.call(key), 'secret'); + assert.strictEqual(getters.extractable.call(key), true); + assert.strictEqual(getters.algorithm.call(key).name, 'HMAC'); + assert.deepStrictEqual(getters.usages.call(key), ['sign']); +})().then(common.mustCall()); diff --git a/test/parallel/test-webcrypto-cryptokey-clone-transfer.js b/test/parallel/test-webcrypto-cryptokey-clone-transfer.js new file mode 100644 index 00000000000000..4983e1c0bda308 --- /dev/null +++ b/test/parallel/test-webcrypto-cryptokey-clone-transfer.js @@ -0,0 +1,351 @@ +'use strict'; + +// Tests that CryptoKey instances can be structured-cloned (same-realm +// via `structuredClone`, cross-realm via `MessagePort.postMessage` and +// `Worker.postMessage`) and that the clones: +// 1. preserve all of [[type]], [[extractable]], [[algorithm]], +// [[usages]] internal slots (as observed through both the public +// accessors and the custom util.inspect output), +// 2. are usable in cryptographic operations (sign/verify/encrypt/ +// decrypt/exportKey) and produce the same output as the original, +// 3. can themselves be cloned again (round-trip), and +// 4. work for secret, public, and private keys and for both +// extractable and non-extractable keys. + +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); + +const assert = require('node:assert'); +const { inspect } = require('node:util'); +const { once } = require('node:events'); +const { Worker, MessageChannel } = require('node:worker_threads'); +const { subtle } = globalThis.crypto; + +function assertNoOwnReflection(key) { + assert.deepStrictEqual(Object.getOwnPropertySymbols(key), []); + assert.deepStrictEqual(Object.getOwnPropertyNames(key), []); + assert.deepStrictEqual(Reflect.ownKeys(key), []); +} + +function describeKey(key) { + const algorithm = { ...key.algorithm }; + if (algorithm.hash !== undefined) + algorithm.hash = { ...algorithm.hash }; + if (algorithm.publicExponent !== undefined) + algorithm.publicExponent = Array.from(algorithm.publicExponent); + return { + type: key.type, + extractable: key.extractable, + algorithm, + usages: [...key.usages].sort(), + }; +} + +function assertSameCryptoKey(a, b) { + assert.notStrictEqual(a, b); + assert.strictEqual(a.type, b.type); + assert.strictEqual(a.extractable, b.extractable); + assert.deepStrictEqual(a.algorithm, b.algorithm); + assert.deepStrictEqual([...a.usages].sort(), [...b.usages].sort()); + assertNoOwnReflection(a); + assertNoOwnReflection(b); + // util.inspect reads native internal slots directly, so a clone's + // rendered form must match the original's. + assert.strictEqual(inspect(a, { depth: 4 }), inspect(b, { depth: 4 })); + // assert.deepStrictEqual on CryptoKey objects goes through the + // dedicated isCryptoKey branch in comparisons.js; a clone must be + // deep-equal to its source. + assert.deepStrictEqual(a, b); +} + +async function roundTripViaMessageChannel(key) { + const { port1, port2 } = new MessageChannel(); + port1.postMessage(key); + const [received] = await once(port2, 'message'); + port1.close(); + port2.close(); + return received; +} + +async function checkHmacKey(original) { + const data = Buffer.from('some data to sign'); + + const cloned = structuredClone(original); + assertSameCryptoKey(original, cloned); + + const viaPort = await roundTripViaMessageChannel(original); + assertSameCryptoKey(original, viaPort); + + // Round-trip: clone a clone. + const clonedAgain = structuredClone(viaPort); + assertSameCryptoKey(original, clonedAgain); + const viaPortAgain = await roundTripViaMessageChannel(cloned); + assertSameCryptoKey(original, viaPortAgain); + + // Signatures produced by every copy must match. + const sigs = await Promise.all( + [original, cloned, viaPort, clonedAgain, viaPortAgain].map( + (k) => subtle.sign('HMAC', k, data), + ), + ); + for (let i = 1; i < sigs.length; i++) { + assert.deepStrictEqual(Buffer.from(sigs[0]), Buffer.from(sigs[i])); + } + + // Each copy must verify a signature produced by any other copy. + for (const verifier of [original, cloned, viaPort, clonedAgain]) { + for (const sig of sigs) { + assert.strictEqual( + await subtle.verify('HMAC', verifier, sig, data), true); + } + } + + // Exported JWK must match byte-for-byte when extractable. + if (original.extractable) { + const jwks = await Promise.all( + [original, cloned, viaPort, clonedAgain].map( + (k) => subtle.exportKey('jwk', k), + ), + ); + for (let i = 1; i < jwks.length; i++) { + assert.deepStrictEqual(jwks[0], jwks[i]); + } + } else { + // Non-extractable keys must refuse export on every copy. + for (const k of [cloned, viaPort, clonedAgain]) { + await assert.rejects(subtle.exportKey('jwk', k), + { name: 'InvalidAccessError' }); + } + } +} + +async function checkAsymmetricKeyPair({ publicKey, privateKey }) { + const data = Buffer.from('payload'); + + for (const original of [publicKey, privateKey]) { + const cloned = structuredClone(original); + assertSameCryptoKey(original, cloned); + const viaPort = await roundTripViaMessageChannel(original); + assertSameCryptoKey(original, viaPort); + const clonedAgain = structuredClone(viaPort); + assertSameCryptoKey(original, clonedAgain); + } + + // Sign with the original private key, verify with every cloned public key. + const signature = await subtle.sign( + { name: 'ECDSA', hash: 'SHA-256' }, privateKey, data); + const publicClones = [ + publicKey, + structuredClone(publicKey), + await roundTripViaMessageChannel(publicKey), + structuredClone(await roundTripViaMessageChannel(publicKey)), + ]; + for (const pub of publicClones) { + assert.strictEqual( + await subtle.verify({ name: 'ECDSA', hash: 'SHA-256' }, + pub, signature, data), + true); + } + + // Sign with every cloned private key, verify with the original public key. + const privateClones = [ + structuredClone(privateKey), + await roundTripViaMessageChannel(privateKey), + structuredClone(await roundTripViaMessageChannel(privateKey)), + ]; + for (const priv of privateClones) { + const sig = await subtle.sign( + { name: 'ECDSA', hash: 'SHA-256' }, priv, data); + assert.strictEqual( + await subtle.verify({ name: 'ECDSA', hash: 'SHA-256' }, + publicKey, sig, data), + true); + } +} + +async function checkTransferToWorker(key) { + // A one-shot worker that receives a key, asserts its properties, + // signs with it, and echoes the key back together with the signature. + const worker = new Worker(` + 'use strict'; + const { parentPort } = require('node:worker_threads'); + const { subtle } = globalThis.crypto; + parentPort.once('message', async ({ key, expected }) => { + try { + if (key.type !== expected.type || + key.extractable !== expected.extractable || + key.algorithm.name !== expected.algorithm.name || + key.algorithm.hash?.name !== expected.algorithm.hash?.name) { + throw new Error('slot mismatch in worker'); + } + const sig = await subtle.sign('HMAC', key, Buffer.from('wdata')); + // Echo the key back so the parent can verify round-trip. + parentPort.postMessage({ key, sig: Buffer.from(sig) }); + } catch (err) { + parentPort.postMessage({ error: err.message }); + } + }); + `, { eval: true }); + + worker.postMessage({ + key, + expected: { + type: key.type, + extractable: key.extractable, + algorithm: { + name: key.algorithm.name, + hash: key.algorithm.hash ? { name: key.algorithm.hash.name } : undefined, + }, + }, + }); + const [msg] = await once(worker, 'message'); + await worker.terminate(); + + assert.strictEqual(msg.error, undefined, msg.error); + // The key echoed back from the worker must itself be a fully-formed + // CryptoKey with all slots preserved. + assertSameCryptoKey(key, msg.key); + // The signature produced inside the worker must verify against the + // parent-side key. + assert.strictEqual( + await subtle.verify('HMAC', key, msg.sig, Buffer.from('wdata')), + true); +} + +async function checkRsaPssTransferToWorker({ publicKey, privateKey }) { + const data = Buffer.from('rsa-pss worker payload'); + const algorithm = { name: 'RSA-PSS', saltLength: 32 }; + const parentSignature = Buffer.from( + await subtle.sign(algorithm, privateKey, data)); + + const worker = new Worker(` + 'use strict'; + const assert = require('node:assert'); + const { parentPort } = require('node:worker_threads'); + const { subtle } = globalThis.crypto; + + ${describeKey} + + parentPort.once('message', async (message) => { + try { + const { + publicKey, + privateKey, + expectedPublic, + expectedPrivate, + signature, + data, + } = message; + assert.deepStrictEqual(describeKey(publicKey), expectedPublic); + assert.deepStrictEqual(describeKey(privateKey), expectedPrivate); + + const algorithm = { name: 'RSA-PSS', saltLength: 32 }; + const verified = await subtle.verify( + algorithm, publicKey, signature, data); + const workerSignature = Buffer.from( + await subtle.sign(algorithm, privateKey, data)); + + parentPort.postMessage({ + publicKey, + privateKey, + verified, + signature: workerSignature, + }); + } catch (err) { + parentPort.postMessage({ error: err.stack || err.message }); + } + }); + `, { eval: true }); + + worker.postMessage({ + publicKey, + privateKey, + expectedPublic: describeKey(publicKey), + expectedPrivate: describeKey(privateKey), + signature: parentSignature, + data, + }); + const [msg] = await once(worker, 'message'); + await worker.terminate(); + + assert.strictEqual(msg.error, undefined, msg.error); + assert.strictEqual(msg.verified, true); + assertSameCryptoKey(publicKey, msg.publicKey); + assertSameCryptoKey(privateKey, msg.privateKey); + assert.strictEqual( + await subtle.verify(algorithm, publicKey, msg.signature, data), + true); +} + +(async () => { + // Extractable HMAC (secret) + const hmacExtractable = await subtle.importKey( + 'raw', + Buffer.from( + '000102030405060708090a0b0c0d0e0f' + + '101112131415161718191a1b1c1d1e1f', 'hex'), + { name: 'HMAC', hash: 'SHA-256' }, + true, + ['sign', 'verify']); + await checkHmacKey(hmacExtractable); + await checkTransferToWorker(hmacExtractable); + + // Non-extractable HMAC (secret) + const hmacNonExtractable = await subtle.generateKey( + { name: 'HMAC', hash: 'SHA-384' }, + false, + ['sign', 'verify']); + await checkHmacKey(hmacNonExtractable); + await checkTransferToWorker(hmacNonExtractable); + + // AES-GCM secret key + { + const key = await subtle.generateKey( + { name: 'AES-GCM', length: 256 }, true, ['encrypt', 'decrypt']); + const cloned = structuredClone(key); + assertSameCryptoKey(key, cloned); + const viaPort = await roundTripViaMessageChannel(key); + assertSameCryptoKey(key, viaPort); + const clonedAgain = structuredClone(viaPort); + assertSameCryptoKey(key, clonedAgain); + + const iv = globalThis.crypto.getRandomValues(new Uint8Array(12)); + const plaintext = Buffer.from('secret payload'); + const ciphertext = await subtle.encrypt( + { name: 'AES-GCM', iv }, key, plaintext); + // Decrypt with every clone. + for (const k of [cloned, viaPort, clonedAgain]) { + const decrypted = await subtle.decrypt( + { name: 'AES-GCM', iv }, k, ciphertext); + assert.deepStrictEqual(Buffer.from(decrypted), plaintext); + } + } + + // ECDSA keypair (public extractable, private non-extractable) + const ecKeypair = await subtle.generateKey( + { name: 'ECDSA', namedCurve: 'P-256' }, + false, + ['sign', 'verify']); + await checkAsymmetricKeyPair(ecKeypair); + + // ECDSA with extractable private key (covers the extractable-private path) + const ecKeypairExtractable = await subtle.generateKey( + { name: 'ECDSA', namedCurve: 'P-384' }, + true, + ['sign', 'verify']); + await checkAsymmetricKeyPair(ecKeypairExtractable); + + // RSA-PSS keypair through a Worker (covers public/private native key + // handles and cloning of the publicExponent algorithm member). + const rsaPssKeypair = await subtle.generateKey( + { + name: 'RSA-PSS', + modulusLength: 2048, + publicExponent: new Uint8Array([1, 0, 1]), + hash: 'SHA-256', + }, + false, + ['sign', 'verify']); + await checkRsaPssTransferToWorker(rsaPssKeypair); +})().then(common.mustCall()); diff --git a/test/parallel/test-webcrypto-cryptokey-hidden-slots.js b/test/parallel/test-webcrypto-cryptokey-hidden-slots.js new file mode 100644 index 00000000000000..4e042fef697d67 --- /dev/null +++ b/test/parallel/test-webcrypto-cryptokey-hidden-slots.js @@ -0,0 +1,161 @@ +'use strict'; + +// CryptoKey prototype getters (`type`, `extractable`, +// `algorithm`, `usages`) are configurable in the Web Crypto IDL and +// can therefore be replaced by user code. Internal consumers of those +// attributes, and the custom inspect output, must NOT go through the +// public prototype getters, they must read the underlying native +// internal slots directly. This test mutates the prototype getters +// (and mutates the per-instance `algorithm`/`usages` caches returned +// by those getters) and asserts that: +// +// 1. util.inspect() shows the real internal values, unaffected by +// the replacement getters. +// 2. Internal Web Crypto and Node.js crypto bridge operations that +// receive the mutated CryptoKey still succeed and observe the real +// internal state, not the replaced one. + +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); + +const assert = require('node:assert'); +const { + createHmac, + KeyObject, + sign: cryptoSign, + verify: cryptoVerify, +} = require('node:crypto'); +const { inspect } = require('node:util'); +const { subtle } = globalThis.crypto; + +common.expectWarning({ + DeprecationWarning: { + DEP0203: 'Passing a CryptoKey to node:crypto functions is deprecated.', + }, +}); + +(async () => { + const key = await subtle.generateKey( + { name: 'HMAC', hash: 'SHA-256' }, + true, + ['sign', 'verify'], + ); + const { publicKey: ecPublicKey, privateKey: ecPrivateKey } = + await subtle.generateKey( + { name: 'ECDSA', namedCurve: 'P-256' }, + false, + ['sign', 'verify'], + ); + + // Snapshot the real values BEFORE tampering. + const realType = key.type; + const realExtractable = key.extractable; + const realAlgorithm = { ...key.algorithm, hash: { ...key.algorithm.hash } }; + const realUsages = [...key.usages]; + + // 1) Replace all four prototype getters. + let proto = Object.getPrototypeOf(key); + while (proto && !Object.getOwnPropertyDescriptor(proto, 'type')) { + proto = Object.getPrototypeOf(proto); + } + assert.ok(proto, 'could not find CryptoKey.prototype'); + const forgedDescriptors = { + type: { + configurable: true, + enumerable: true, + get() { return 'FORGED-TYPE'; }, + }, + extractable: { + configurable: true, + enumerable: true, + get() { return 'FORGED-EXTRACTABLE'; }, + }, + algorithm: { + configurable: true, + enumerable: true, + get() { return { name: 'FORGED-ALGORITHM', hash: { name: 'FORGED-HASH' } }; }, + }, + usages: { + configurable: true, + enumerable: true, + get() { return ['forged-usage']; }, + }, + }; + const originalDescriptors = {}; + for (const [name, descriptor] of Object.entries(forgedDescriptors)) { + originalDescriptors[name] = Object.getOwnPropertyDescriptor(proto, name); + Object.defineProperty(proto, name, descriptor); + } + + try { + // Confirm the forgeries are in effect from user-code perspective. + assert.strictEqual(key.type, 'FORGED-TYPE'); + assert.strictEqual(key.extractable, 'FORGED-EXTRACTABLE'); + assert.strictEqual(key.algorithm.name, 'FORGED-ALGORITHM'); + assert.deepStrictEqual(key.usages, ['forged-usage']); + + // 2) util.inspect() must not be influenced by the forged getters, + // it must read the real internal slots directly. + const rendered = inspect(key, { depth: 4 }); + assert.match(rendered, /type: 'secret'/); + assert.match(rendered, /extractable: true/); + assert.match(rendered, /name: 'HMAC'/); + assert.match(rendered, /name: 'SHA-256'/); + assert.match(rendered, /'sign'/); + assert.match(rendered, /'verify'/); + assert.doesNotMatch(rendered, /FORGED/); + + // 3) Internal consumers that receive this CryptoKey must see the + // real internal slots. exportKey('jwk') reads [[type]], + // [[extractable]], [[algorithm]], and [[usages]]; if any + // went through the user-visible getter the call would either + // throw or produce forged output. + const jwk = await subtle.exportKey('jwk', key); + assert.strictEqual(jwk.kty, 'oct'); + assert.strictEqual(jwk.alg, 'HS256'); + assert.strictEqual(jwk.ext, true); + assert.deepStrictEqual(jwk.key_ops.sort(), ['sign', 'verify']); + + // 4) The Node.js crypto bridge must also read the real native + // slots directly, both for KeyObject.from() and for deprecated + // direct CryptoKey consumption. + const keyObject = KeyObject.from(key); + assert.strictEqual(keyObject.type, 'secret'); + assert.deepStrictEqual(keyObject.export(), Buffer.from(jwk.k, 'base64url')); + + const payload = Buffer.from('payload'); + const digest = createHmac('sha256', key).update(payload).digest('hex'); + const expectedDigest = + createHmac('sha256', keyObject).update(payload).digest('hex'); + assert.strictEqual(digest, expectedDigest); + + const signature = cryptoSign('sha256', payload, ecPrivateKey); + assert.strictEqual( + cryptoVerify('sha256', payload, ecPublicKey, signature), + true); + + // 5) Importing back from the exported JWK must yield an equivalent + // key, i.e. the real algorithm and usages round-trip. + const reimported = await subtle.importKey('jwk', jwk, + { name: 'HMAC', hash: 'SHA-256' }, + true, ['sign', 'verify']); + // Reimported's prototype is the same mutated prototype, so we must + // also inspect() the reimported key to check real slots. + const rerendered = inspect(reimported, { depth: 4 }); + assert.match(rerendered, /type: 'secret'/); + assert.match(rerendered, /name: 'HMAC'/); + assert.doesNotMatch(rerendered, /FORGED/); + } finally { + // Restore the original getters so subsequent tests are unaffected. + for (const [name, descriptor] of Object.entries(originalDescriptors)) { + Object.defineProperty(proto, name, descriptor); + } + } + + // After restoration, the real values come back through the public API. + assert.strictEqual(key.type, realType); + assert.strictEqual(key.extractable, realExtractable); + assert.deepStrictEqual(key.algorithm, realAlgorithm); + assert.deepStrictEqual(key.usages, realUsages); +})().then(common.mustCall()); diff --git a/test/parallel/test-webcrypto-cryptokey-no-own-symbols.js b/test/parallel/test-webcrypto-cryptokey-no-own-symbols.js new file mode 100644 index 00000000000000..44e3413d17ca3b --- /dev/null +++ b/test/parallel/test-webcrypto-cryptokey-no-own-symbols.js @@ -0,0 +1,52 @@ +'use strict'; + +// CryptoKey instances must not expose any own Symbol-keyed properties +// to user code. The internal slots backing the public getters are +// kept in native internal fields, with JS-side caches in private fields, +// so that reflection APIs such as Object.getOwnPropertySymbols() and +// Reflect.ownKeys() cannot enumerate them, even after the public getters +// have been invoked and their per-instance caches populated. + +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); + +const assert = require('node:assert'); +const { subtle } = globalThis.crypto; + +(async () => { + const keys = [ + await subtle.generateKey( + { name: 'HMAC', hash: 'SHA-256' }, true, ['sign', 'verify']), + (await subtle.generateKey( + { name: 'ECDSA', namedCurve: 'P-256' }, true, ['sign', 'verify'])).privateKey, + (await subtle.generateKey( + { name: 'RSA-PSS', modulusLength: 2048, + publicExponent: new Uint8Array([1, 0, 1]), hash: 'SHA-256' }, + true, ['sign', 'verify'])).publicKey, + await subtle.generateKey( + { name: 'AES-GCM', length: 128 }, true, ['encrypt', 'decrypt']), + ]; + + for (const key of keys) { + // Touch every public getter so any lazy per-instance caching would + // materialise now. + /* eslint-disable no-unused-expressions */ + key.type; + key.extractable; + key.algorithm; + key.usages; + // Read the getters a second time to exercise the cache-hit path. + key.algorithm; + key.usages; + /* eslint-enable no-unused-expressions */ + + assert.deepStrictEqual( + Object.getOwnPropertySymbols(key), [], + `CryptoKey has own Symbol properties: ${ + Object.getOwnPropertySymbols(key).map(String).join(', ')}`, + ); + assert.deepStrictEqual(Object.getOwnPropertyNames(key), []); + assert.deepStrictEqual(Reflect.ownKeys(key), []); + } +})().then(common.mustCall()); diff --git a/test/parallel/test-webcrypto-derivebits-hkdf.js b/test/parallel/test-webcrypto-derivebits-hkdf.js index 2759223e76a060..689eaeb38fd66f 100644 --- a/test/parallel/test-webcrypto-derivebits-hkdf.js +++ b/test/parallel/test-webcrypto-derivebits-hkdf.js @@ -628,16 +628,27 @@ async function testWrongKeyType( })().then(common.mustCall()); // https://github.com/w3c/webcrypto/pull/380 -{ - crypto.subtle.importKey('raw', new Uint8Array(0), 'HKDF', false, ['deriveBits']).then((key) => { - return crypto.subtle.deriveBits({ - name: 'HKDF', - hash: { name: 'SHA-256' }, - info: new Uint8Array(0), - salt: new Uint8Array(0), - }, key, 0); - }).then((bits) => { - assert.deepStrictEqual(bits, new ArrayBuffer(0)); - }) - .then(common.mustCall()); -} +(async function() { + const key = await crypto.subtle.importKey('raw', new Uint8Array(0), 'HKDF', false, ['deriveBits']); + const bits = await crypto.subtle.deriveBits({ + name: 'HKDF', + hash: { name: 'SHA-256' }, + info: new Uint8Array(0), + salt: new Uint8Array(0), + }, key, 0); + assert.deepStrictEqual(bits, new ArrayBuffer(0)); +})().then(common.mustCall()); + +// OpenSSL limits info to 1024 bytes +(async function() { + const key = await crypto.subtle.importKey('raw', new Uint8Array(0), 'HKDF', false, ['deriveBits']); + await assert.rejects(crypto.subtle.deriveBits({ + name: 'HKDF', + hash: { name: 'SHA-256' }, + info: new Uint8Array(1025), + salt: new Uint8Array(0), + }, key, 0), { + name: 'OperationError', + message: 'algorithm.info must be at most 1024 bytes', + }); +})().then(common.mustCall()); diff --git a/test/parallel/test-webcrypto-encrypt-decrypt-chacha20-poly1305.js b/test/parallel/test-webcrypto-encrypt-decrypt-chacha20-poly1305.js index 0825027a7c3c02..0f930a356712ed 100644 --- a/test/parallel/test-webcrypto-encrypt-decrypt-chacha20-poly1305.js +++ b/test/parallel/test-webcrypto-encrypt-decrypt-chacha20-poly1305.js @@ -220,6 +220,7 @@ async function testDecrypt({ keyBuffer, algorithm, result }) { // JWK error conditions const jwkTests = [ + [{ kty: 'oct' }, /Invalid keyData/], [{ k: baseJwk.k }, /Invalid keyData/], [{ ...baseJwk, kty: 'RSA' }, /Invalid JWK "kty" Parameter/], [{ ...baseJwk, use: 'sig' }, /Invalid JWK "use" Parameter/], diff --git a/test/parallel/test-webcrypto-export-import-cfrg.js b/test/parallel/test-webcrypto-export-import-cfrg.js index b1732bf077416c..14f475fc1779bb 100644 --- a/test/parallel/test-webcrypto-export-import-cfrg.js +++ b/test/parallel/test-webcrypto-export-import-cfrg.js @@ -355,7 +355,7 @@ async function testImportJwk({ name, publicUsages, privateUsages }, extractable) { name }, extractable, publicUsages), - { message: 'JWK "crv" Parameter and algorithm name mismatch' }); + { message: crv ? 'JWK "crv" Parameter and algorithm name mismatch' : 'Invalid keyData' }); await assert.rejects( subtle.importKey( @@ -364,7 +364,7 @@ async function testImportJwk({ name, publicUsages, privateUsages }, extractable) { name }, extractable, privateUsages), - { message: 'JWK "crv" Parameter and algorithm name mismatch' }); + { message: crv ? 'JWK "crv" Parameter and algorithm name mismatch' : 'Invalid keyData' }); } await assert.rejects( diff --git a/test/parallel/test-webcrypto-export-import-ec.js b/test/parallel/test-webcrypto-export-import-ec.js index 98d0d7d3342ccb..f6157bff2b69d6 100644 --- a/test/parallel/test-webcrypto-export-import-ec.js +++ b/test/parallel/test-webcrypto-export-import-ec.js @@ -322,7 +322,7 @@ async function testImportJwk( { name, namedCurve }, extractable, publicUsages), - { message: 'JWK "crv" does not match the requested algorithm' }); + { message: crv ? 'JWK "crv" does not match the requested algorithm' : 'Invalid keyData' }); await assert.rejects( subtle.importKey( @@ -331,7 +331,7 @@ async function testImportJwk( { name, namedCurve }, extractable, privateUsages), - { message: 'JWK "crv" does not match the requested algorithm' }); + { message: crv ? 'JWK "crv" does not match the requested algorithm' : 'Invalid keyData' }); } await assert.rejects( diff --git a/test/parallel/test-webcrypto-export-import-ml-dsa.js b/test/parallel/test-webcrypto-export-import-ml-dsa.js index 7030c452003c63..63766a7b377c77 100644 --- a/test/parallel/test-webcrypto-export-import-ml-dsa.js +++ b/test/parallel/test-webcrypto-export-import-ml-dsa.js @@ -347,7 +347,7 @@ async function testImportJwk({ name, publicUsages, privateUsages }, extractable) { name }, extractable, publicUsages), - { message: 'JWK "alg" Parameter and algorithm name mismatch' }); + { message: alg ? 'JWK "alg" Parameter and algorithm name mismatch' : 'Invalid keyData' }); await assert.rejects( subtle.importKey( @@ -356,7 +356,7 @@ async function testImportJwk({ name, publicUsages, privateUsages }, extractable) { name }, extractable, privateUsages), - { message: 'JWK "alg" Parameter and algorithm name mismatch' }); + { message: alg ? 'JWK "alg" Parameter and algorithm name mismatch' : 'Invalid keyData' }); } await assert.rejects( diff --git a/test/parallel/test-webcrypto-export-import-ml-kem.js b/test/parallel/test-webcrypto-export-import-ml-kem.js index 1da0218f258e3c..332d88d93f69d1 100644 --- a/test/parallel/test-webcrypto-export-import-ml-kem.js +++ b/test/parallel/test-webcrypto-export-import-ml-kem.js @@ -423,7 +423,7 @@ async function testImportJwk({ name, publicUsages, privateUsages }, extractable) { name }, extractable, publicUsages), - { message: 'JWK "alg" Parameter and algorithm name mismatch' }); + { message: alg ? 'JWK "alg" Parameter and algorithm name mismatch' : 'Invalid keyData' }); await assert.rejects( subtle.importKey( @@ -432,7 +432,7 @@ async function testImportJwk({ name, publicUsages, privateUsages }, extractable) { name }, extractable, privateUsages), - { message: 'JWK "alg" Parameter and algorithm name mismatch' }); + { message: alg ? 'JWK "alg" Parameter and algorithm name mismatch' : 'Invalid keyData' }); } await assert.rejects( diff --git a/test/parallel/test-webcrypto-export-import-rsa.js b/test/parallel/test-webcrypto-export-import-rsa.js index e542365f52ded5..8808fcbe6b1fd7 100644 --- a/test/parallel/test-webcrypto-export-import-rsa.js +++ b/test/parallel/test-webcrypto-export-import-rsa.js @@ -600,6 +600,20 @@ async function testImportJwk( extractable, publicUsages), { name: 'DataError', message: 'Invalid keyData' }); + + for (const field of ['p', 'q', 'dp', 'dq', 'qi']) { + const jwkMissingCrtField = { ...jwk }; + delete jwkMissingCrtField[field]; + await assert.rejects( + subtle.importKey( + 'jwk', + jwkMissingCrtField, + { name, hash }, + extractable, + privateUsages), + { name: 'DataError', message: 'Invalid keyData' }, + `missing private JWK CRT field ${field}`); + } } // combinations to test diff --git a/test/parallel/test-webcrypto-internal-slots.mjs b/test/parallel/test-webcrypto-internal-slots.mjs index 9b824167ba4553..935cd732bacb30 100644 --- a/test/parallel/test-webcrypto-internal-slots.mjs +++ b/test/parallel/test-webcrypto-internal-slots.mjs @@ -18,4 +18,11 @@ assert.ok(kp.publicKey.usages.includes('foo')); assert.ok(util.inspect(kp.publicKey).includes("algorithm: { name: 'Ed25519' }")); assert.ok(util.inspect(kp.publicKey).includes("usages: [ 'verify' ]")); +const jwk = await subtle.exportKey('jwk', kp.publicKey); +assert.deepStrictEqual(jwk.key_ops, ['verify']); +jwk.key_ops.push('foo'); +assert.ok(!util.inspect(kp.publicKey).includes('foo')); +assert.deepStrictEqual((await subtle.exportKey('jwk', kp.publicKey)).key_ops, + ['verify']); + await subtle.sign('Ed25519', kp.privateKey, Buffer.alloc(32)); From 59272da055883898bd40b9dcac57b98aae6e1a1b Mon Sep 17 00:00:00 2001 From: Marco Ippolito Date: Mon, 4 May 2026 08:39:18 +0200 Subject: [PATCH 043/168] src: swap dotenv and config file parsing order Signed-off-by: Marco Ippolito PR-URL: https://github.com/nodejs/node/pull/63035 Reviewed-By: Ethan Arrowood Reviewed-By: Matteo Collina --- doc/api/cli.md | 8 ++++---- src/node.cc | 7 +++++-- src/node_dotenv.cc | 2 +- test/parallel/test-config-file.js | 8 ++++---- 4 files changed, 14 insertions(+), 11 deletions(-) diff --git a/doc/api/cli.md b/doc/api/cli.md index e979ec95c4259d..b5428453787e4a 100644 --- a/doc/api/cli.md +++ b/doc/api/cli.md @@ -1143,12 +1143,12 @@ node --import amaro/strip --watch-path=src --watch-preserve-output --test-isolat The priority in configuration is as follows: 1. NODE\_OPTIONS and command-line options -2. Configuration file -3. Dotenv NODE\_OPTIONS +2. Dotenv NODE\_OPTIONS +3. Configuration file Values in the configuration file will not override the values in the environment -variables and command-line options, but will override the values in the `NODE_OPTIONS` -env file parsed by the `--env-file` flag. +variables, command-line options, or the `NODE_OPTIONS` env file parsed by the +`--env-file` flag. Keys cannot be duplicated within the same or different namespaces. diff --git a/src/node.cc b/src/node.cc index 92d0402b7dfbaf..4ba019ddca05f4 100644 --- a/src/node.cc +++ b/src/node.cc @@ -870,6 +870,7 @@ static ExitCode InitializeNodeWithArgsInternal( HandleEnvOptions(per_process::cli_options->per_isolate->per_env); std::string node_options; + std::string node_options_from_dotenv; auto env_files = node::Dotenv::GetDataFromArgs(*argv); if (!env_files.empty()) { @@ -896,7 +897,8 @@ static ExitCode InitializeNodeWithArgsInternal( } } - per_process::dotenv_file.AssignNodeOptionsIfAvailable(&node_options); + per_process::dotenv_file.AssignNodeOptionsIfAvailable( + &node_options_from_dotenv); } std::string node_options_from_config; @@ -932,9 +934,10 @@ static ExitCode InitializeNodeWithArgsInternal( errors->emplace_back("The number of NODE_OPTIONS doesn't match " "the number of flags in the config file"); } - node_options += node_options_from_config; } + node_options = node_options_from_config + node_options_from_dotenv; + #if !defined(NODE_WITHOUT_NODE_OPTIONS) bool should_parse_node_options = !(flags & ProcessInitializationFlags::kDisableNodeOptionsEnv); diff --git a/src/node_dotenv.cc b/src/node_dotenv.cc index e1940904d1c039..e42eb3c9deaf7b 100644 --- a/src/node_dotenv.cc +++ b/src/node_dotenv.cc @@ -356,7 +356,7 @@ void Dotenv::AssignNodeOptionsIfAvailable(std::string* node_options) const { auto match = store_.find("NODE_OPTIONS"); if (match != store_.end()) { - *node_options = match->second; + *node_options = " " + match->second; } } diff --git a/test/parallel/test-config-file.js b/test/parallel/test-config-file.js index dc70242855de65..3c88c16395d53b 100644 --- a/test/parallel/test-config-file.js +++ b/test/parallel/test-config-file.js @@ -86,16 +86,16 @@ test('should throw an error when a flag is declared twice', async () => { assert.strictEqual(result.code, 9); }); -test('should override env-file', onlyWithAmaroAndNodeOptions, async () => { +test('should not override env-file', onlyWithAmaroAndNodeOptions, async () => { const result = await spawnPromisified(process.execPath, [ '--no-warnings', `--experimental-config-file=${fixtures.path('rc/strip-types.json')}`, '--env-file', fixtures.path('dotenv/node-options-no-tranform.env'), fixtures.path('typescript/ts/test-typescript.ts'), ]); - assert.strictEqual(result.stderr, ''); - assert.match(result.stdout, /Hello, TypeScript!/); - assert.strictEqual(result.code, 0); + assert.match(result.stderr, /SyntaxError/); + assert.strictEqual(result.stdout, ''); + assert.strictEqual(result.code, 1); }); test('should not override NODE_OPTIONS', onlyWithAmaro, async () => { From 9390c810d1885aca677b1d0d2b661a77e787aa94 Mon Sep 17 00:00:00 2001 From: Ali Hassan <24819103+thisalihassan@users.noreply.github.com> Date: Mon, 4 May 2026 14:30:42 +0500 Subject: [PATCH 044/168] lib: reject SharedArrayBuffer in Blob constructor per spec MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Ali Hassan PR-URL: https://github.com/nodejs/node/pull/63046 Refs: https://github.com/nodejs/node/issues/59688 Refs: https://github.com/nodejs/node/pull/62632 Reviewed-By: Antoine du Hamel Reviewed-By: René Reviewed-By: Yagiz Nizipli Reviewed-By: Matteo Collina --- lib/internal/blob.js | 10 ++++++-- ...test-webapi-sharedarraybuffer-rejection.js | 24 +++++++++++++++++++ 2 files changed, 32 insertions(+), 2 deletions(-) diff --git a/lib/internal/blob.js b/lib/internal/blob.js index 5059b651f467ca..0e901d416e0430 100644 --- a/lib/internal/blob.js +++ b/lib/internal/blob.js @@ -127,9 +127,12 @@ function getSource(source, endings) { } const sourcesConverter = createSequenceConverter((source, opts = kEmptyObject) => { - if (isBlob(source) || isAnyArrayBuffer(source) || isArrayBufferView(source)) { + if (isBlob(source)) { return source; } + if (isAnyArrayBuffer(source) || isArrayBufferView(source)) { + return converters.BufferSource(source, opts); + } return converters.DOMString(source, opts); }); @@ -149,7 +152,10 @@ class Blob { constructor(sources = [], options) { markTransferMode(this, true, false); - const sources_ = sourcesConverter(sources); + const sources_ = sourcesConverter(sources, { + __proto__: null, + context: 'sources', + }); validateDictionary(options, 'options'); let { diff --git a/test/parallel/test-webapi-sharedarraybuffer-rejection.js b/test/parallel/test-webapi-sharedarraybuffer-rejection.js index c5503dfc0a1b2d..744c929753c285 100644 --- a/test/parallel/test-webapi-sharedarraybuffer-rejection.js +++ b/test/parallel/test-webapi-sharedarraybuffer-rejection.js @@ -3,6 +3,7 @@ const common = require('../common'); const assert = require('assert'); const test = require('node:test'); +const { Blob } = require('buffer'); const { ReadableStream } = require('stream/web'); const sab = new SharedArrayBuffer(8); @@ -98,6 +99,29 @@ test('ReadableByteStreamController.enqueue() rejects SAB-backed DataView', async reader.releaseLock(); }); +// -- Blob -- + +test('Blob rejects SharedArrayBuffer part', () => { + assert.throws( + () => new Blob([sab]), + { code: 'ERR_INVALID_ARG_TYPE' }, + ); +}); + +test('Blob rejects SAB-backed Uint8Array part', () => { + assert.throws( + () => new Blob([sabView]), + { code: 'ERR_INVALID_ARG_TYPE' }, + ); +}); + +test('Blob rejects SAB-backed DataView part', () => { + assert.throws( + () => new Blob([sabDataView]), + { code: 'ERR_INVALID_ARG_TYPE' }, + ); +}); + // -- SharedWebIDL converters -- const { converters } = require('internal/webidl'); From f4c50a8d710350175e4c9aed1dace6fb6bbee883 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ren=C3=A9?= Date: Mon, 4 May 2026 11:22:57 +0100 Subject: [PATCH 045/168] build: remove armv6 from experimental platforms MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Renegade334 PR-URL: https://github.com/nodejs/node/pull/63063 Reviewed-By: Yagiz Nizipli Reviewed-By: Paolo Insogna Reviewed-By: Michaël Zasso Reviewed-By: Luigi Pinca Reviewed-By: Marco Ippolito Reviewed-By: Rafael Gonzaga --- BUILDING.md | 1 - configure.py | 8 +------- 2 files changed, 1 insertion(+), 8 deletions(-) diff --git a/BUILDING.md b/BUILDING.md index 2cb15c812acf3b..632833c2a66697 100644 --- a/BUILDING.md +++ b/BUILDING.md @@ -111,7 +111,6 @@ platforms. This is true regardless of entries in the table below. | GNU/Linux | x86 | kernel >= 3.10, glibc >= 2.17 | Experimental | Downgraded as of Node.js 10 | | GNU/Linux | arm64 | kernel >= 4.18[^1], glibc >= 2.28 | Tier 1 | e.g. Ubuntu 20.04, Debian 10, RHEL 8 | | GNU/Linux | armv7 | kernel >= 4.18[^1], glibc >= 2.28 | Experimental | Downgraded as of Node.js 24 | -| GNU/Linux | armv6 | kernel >= 4.14, glibc >= 2.24 | Experimental | Downgraded as of Node.js 12 | | GNU/Linux | ppc64le >=power9 | kernel >= 4.18[^1], glibc >= 2.28 | Tier 2 | e.g. Ubuntu 20.04, RHEL 8 | | GNU/Linux | s390x >=z14 | kernel >= 4.18[^1], glibc >= 2.28 | Tier 2 | e.g. RHEL 8 | | GNU/Linux | loong64 | kernel >= 5.19, glibc >= 2.36 | Experimental | | diff --git a/configure.py b/configure.py index ffdd538bf71834..7b82e0c5e86e7d 100755 --- a/configure.py +++ b/configure.py @@ -1669,12 +1669,6 @@ def is_arch_armv7(): return cc_macros_cache.get('__ARM_ARCH') == '7' -def is_arch_armv6(): - """Check for ARMv6 instructions""" - cc_macros_cache = cc_macros() - return cc_macros_cache.get('__ARM_ARCH') == '6' - - def is_arm_hard_float_abi(): """Check for hardfloat or softfloat eabi on ARM""" # GCC versions 4.6 and above define __ARM_PCS or __ARM_PCS_VFP to specify @@ -1758,7 +1752,7 @@ def configure_arm(o): arm_fpu = 'vfpv3' o['variables']['arm_version'] = '7' else: - o['variables']['arm_version'] = '6' if is_arch_armv6() else 'default' + o['variables']['arm_version'] = 'default' o['variables']['arm_thumb'] = 0 # -marm o['variables']['arm_float_abi'] = arm_float_abi From 6110b2a49f6b46dbe53669a025d9105fc87523eb Mon Sep 17 00:00:00 2001 From: Mike McCready <66998419+MikeMcC399@users.noreply.github.com> Date: Mon, 4 May 2026 16:33:44 +0200 Subject: [PATCH 046/168] tools: update gr2m/create-or-update-pull-request-action to v1.10.1 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mike McCready <66998419+MikeMcC399@users.noreply.github.com> PR-URL: https://github.com/nodejs/node/pull/63065 Fixes: https://github.com/nodejs/node/issues/62990 Reviewed-By: Luigi Pinca Reviewed-By: René --- .github/workflows/find-inactive-collaborators.yml | 2 +- .github/workflows/find-inactive-tsc.yml | 2 +- .github/workflows/license-builder.yml | 2 +- .github/workflows/timezone-update.yml | 3 ++- .github/workflows/update-openssl.yml | 4 ++-- .github/workflows/update-wpt.yml | 2 +- 6 files changed, 8 insertions(+), 7 deletions(-) diff --git a/.github/workflows/find-inactive-collaborators.yml b/.github/workflows/find-inactive-collaborators.yml index 1453cb24520da1..ba9ce0c2e18826 100644 --- a/.github/workflows/find-inactive-collaborators.yml +++ b/.github/workflows/find-inactive-collaborators.yml @@ -33,7 +33,7 @@ jobs: run: tools/find-inactive-collaborators.mjs - name: Open pull request - uses: gr2m/create-or-update-pull-request-action@77596e3166f328b24613f7082ab30bf2d93079d5 + uses: gr2m/create-or-update-pull-request-action@b65137ca591da0b9f43bad7b24df13050ea45d1b # v1.10.1 # Creates a PR or update the Action's existing PR, or # no-op if the base branch is already up-to-date. env: diff --git a/.github/workflows/find-inactive-tsc.yml b/.github/workflows/find-inactive-tsc.yml index b3e6d7e2c733ca..eb09e4e94a8ad4 100644 --- a/.github/workflows/find-inactive-tsc.yml +++ b/.github/workflows/find-inactive-tsc.yml @@ -42,7 +42,7 @@ jobs: run: tools/find-inactive-tsc.mjs >> $GITHUB_ENV - name: Open pull request - uses: gr2m/create-or-update-pull-request-action@77596e3166f328b24613f7082ab30bf2d93079d5 + uses: gr2m/create-or-update-pull-request-action@b65137ca591da0b9f43bad7b24df13050ea45d1b # v1.10.1 # Creates a PR or update the Action's existing PR, or # no-op if the base branch is already up-to-date. env: diff --git a/.github/workflows/license-builder.yml b/.github/workflows/license-builder.yml index 08ff3c7b014af0..83b7cea221b0f5 100644 --- a/.github/workflows/license-builder.yml +++ b/.github/workflows/license-builder.yml @@ -21,7 +21,7 @@ jobs: with: persist-credentials: false - run: ./tools/license-builder.sh # Run the license builder tool - - uses: gr2m/create-or-update-pull-request-action@86ec1766034c8173518f61d2075cc2a173fb8c97 # v1.9.4 + - uses: gr2m/create-or-update-pull-request-action@b65137ca591da0b9f43bad7b24df13050ea45d1b # v1.10.1 # Creates a PR or update the Action's existing PR, or # no-op if the base branch is already up-to-date. env: diff --git a/.github/workflows/timezone-update.yml b/.github/workflows/timezone-update.yml index 4063115182c442..5e90d16c1b1dd4 100644 --- a/.github/workflows/timezone-update.yml +++ b/.github/workflows/timezone-update.yml @@ -51,7 +51,8 @@ jobs: - name: Open Pull Request if: ${{ env.new_version != env.current_version }} - uses: gr2m/create-or-update-pull-request-action@77596e3166f328b24613f7082ab30bf2d93079d5 # Create a PR or update the Action's existing PR + # Create a PR or update the Action's existing PR + uses: gr2m/create-or-update-pull-request-action@b65137ca591da0b9f43bad7b24df13050ea45d1b # v1.10.1 env: GITHUB_TOKEN: ${{ secrets.GH_USER_TOKEN }} with: diff --git a/.github/workflows/update-openssl.yml b/.github/workflows/update-openssl.yml index 95ae8887a2e62c..b93e37e7f4b3bc 100644 --- a/.github/workflows/update-openssl.yml +++ b/.github/workflows/update-openssl.yml @@ -28,7 +28,7 @@ jobs: GITHUB_TOKEN: ${{ secrets.GH_USER_TOKEN }} - name: Create PR with first commit if: env.NEW_VERSION - uses: gr2m/create-or-update-pull-request-action@77596e3166f328b24613f7082ab30bf2d93079d5 + uses: gr2m/create-or-update-pull-request-action@b65137ca591da0b9f43bad7b24df13050ea45d1b # v1.10.1 # Creates a PR with the new OpenSSL source code committed env: GITHUB_TOKEN: ${{ secrets.GH_USER_TOKEN }} @@ -51,7 +51,7 @@ jobs: - name: Add second commit # Adds a second commit to the PR with the generated platform-dependent files if: env.NEW_VERSION - uses: gr2m/create-or-update-pull-request-action@77596e3166f328b24613f7082ab30bf2d93079d5 + uses: gr2m/create-or-update-pull-request-action@b65137ca591da0b9f43bad7b24df13050ea45d1b # v1.10.1 env: GITHUB_TOKEN: ${{ secrets.GH_USER_TOKEN }} with: diff --git a/.github/workflows/update-wpt.yml b/.github/workflows/update-wpt.yml index 85a3115848135f..7e9a6a30fe64d9 100644 --- a/.github/workflows/update-wpt.yml +++ b/.github/workflows/update-wpt.yml @@ -68,7 +68,7 @@ jobs: SUBSYSTEM: ${{ matrix.subsystem }} - name: Open or update PR for the subsystem update - uses: gr2m/create-or-update-pull-request-action@77596e3166f328b24613f7082ab30bf2d93079d5 + uses: gr2m/create-or-update-pull-request-action@b65137ca591da0b9f43bad7b24df13050ea45d1b # v1.10.1 with: # The create-or-update-pull-request-action matches the branch name by prefix, # which is why we need to add the -wpt suffix. If we dont do that, we risk matching wrong PRs, From 69121abfe28165ecb67a54f2f8de13a1bb884800 Mon Sep 17 00:00:00 2001 From: Vas Sudanagunta Date: Mon, 4 May 2026 10:33:56 -0400 Subject: [PATCH 047/168] doc: remove typo comma from man page MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit It was accidentally added by commit 5d494effc15fe22f64324cfaf530a0a3bab233a4 Signed-off-by: vassudanagunta PR-URL: https://github.com/nodejs/node/pull/63080 Reviewed-By: Chemi Atlow Reviewed-By: Luigi Pinca Reviewed-By: Ulises Gascón --- doc/node.1 | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/node.1 b/doc/node.1 index 2b1ee8d5f31679..6604a480f7be29 100644 --- a/doc/node.1 +++ b/doc/node.1 @@ -38,7 +38,7 @@ .Op Ar arguments ... . .Nm node -.Cm inspect, +.Cm inspect .Op Ar | Fl e Ar string | Ar : .Ar ... . From ff101999ed4838a74211d464dee8c0ed207be4dc Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Mon, 4 May 2026 17:21:45 +0200 Subject: [PATCH 048/168] lib: refactor internal webidl converters MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Rework lib/internal/webidl.js into a documented shared converter module that follows the Web IDL conversion algorithms more closely. Improvements: - Add documented converters and helper factories for primitive values, dictionaries, enums, sequences, interfaces, required arguments, integers, `Uint8Array`, and `BufferSource`. - Move WebCrypto onto the shared converters, while keeping compatibility wrappers for its existing `BufferSource` and `BigInteger` behavior. - Use shared converters from Blob, Performance, Web Locks, and structured clone option handling. - Add benchmarks for `ConvertToInt` and WebCrypto Web IDL converter hot paths. - Add focused tests for core converters, WebCrypto converters, integer conversion, and buffer source behavior. Fixes: - Make the shared `BufferSource` and `Uint8Array` converters reject resizable `ArrayBuffer` and growable `SharedArrayBuffer` backing stores unless explicitly allowed. WebCrypto preserves its legacy resizable backing-store behavior through compatibility wrappers until a semver-major follow-up can opt in to the stricter behavior. - Use Web IDL `ToNumber` and `ToString` behavior for BigInt, Symbol, and object primitive conversion. - Use exact BigInt modulo for 64-bit `ConvertToInt` wrapping and document the final Number approximation behavior. - Normalize mathematical modulo results to `+0` where Web IDL requires it. - Process inherited dictionaries in least-derived to most-derived order, sorting members only within each dictionary level. - Use `IteratorComplete` truthiness for sequence conversion. - Cover detached buffers, resizable-backed views, growable-backed views, cross-realm buffer sources, mutation-after-call behavior, inherited dictionary member order, and sequence iterator completion behavior. Signed-off-by: Filip Skokan PR-URL: https://github.com/nodejs/node/pull/62979 Reviewed-By: Сковорода Никита Андреевич Reviewed-By: Matteo Collina --- benchmark/misc/webcrypto-webidl.js | 109 ++ benchmark/misc/webidl-convert-to-int.js | 82 ++ lib/internal/blob.js | 13 +- lib/internal/crypto/webidl.js | 1101 +++++++--------- lib/internal/locks.js | 2 +- lib/internal/perf/performance.js | 8 +- lib/internal/webidl.js | 1121 +++++++++++++---- lib/internal/worker/js_transferable.js | 1 + .../webcrypto/supports-modern-algorithms.mjs | 29 +- test/parallel/test-abortsignal-any.mjs | 2 +- test/parallel/test-blob.js | 16 + .../test-internal-webidl-buffer-source.js | 212 +++- .../test-internal-webidl-converttoint.js | 382 +++++- test/parallel/test-internal-webidl.js | 616 +++++++++ ...st-performance-resourcetimingbuffersize.js | 13 + test/parallel/test-structuredClone-global.js | 2 +- ...test-webapi-sharedarraybuffer-rejection.js | 21 +- test/parallel/test-webcrypto-webidl.js | 146 ++- 18 files changed, 2813 insertions(+), 1063 deletions(-) create mode 100644 benchmark/misc/webcrypto-webidl.js create mode 100644 benchmark/misc/webidl-convert-to-int.js create mode 100644 test/parallel/test-internal-webidl.js diff --git a/benchmark/misc/webcrypto-webidl.js b/benchmark/misc/webcrypto-webidl.js new file mode 100644 index 00000000000000..0f6275ed09517c --- /dev/null +++ b/benchmark/misc/webcrypto-webidl.js @@ -0,0 +1,109 @@ +'use strict'; + +const common = require('../common.js'); + +const bench = common.createBenchmark(main, { + op: [ + 'normalizeAlgorithm-string', + 'normalizeAlgorithm-dict', + 'webidl-dict', + 'webidl-algorithm-identifier-string', + 'webidl-algorithm-identifier-object', + 'webidl-dict-enforce-range', + 'webidl-dict-ensure-sha', + 'webidl-dict-null', + ], + n: [1e6], +}, { flags: ['--expose-internals'] }); + +function main({ n, op }) { + const { normalizeAlgorithm } = require('internal/crypto/util'); + + switch (op) { + case 'normalizeAlgorithm-string': { + // String shortcut + null dictionary (cheapest path). + bench.start(); + for (let i = 0; i < n; i++) + normalizeAlgorithm('SHA-256', 'digest'); + bench.end(n); + break; + } + case 'normalizeAlgorithm-dict': { + // Object input with a dictionary type and no BufferSource members. + const alg = { name: 'ECDSA', hash: 'SHA-256' }; + bench.start(); + for (let i = 0; i < n; i++) + normalizeAlgorithm(alg, 'sign'); + bench.end(n); + break; + } + case 'webidl-dict': { + // WebIDL dictionary converter in isolation. + const webidl = require('internal/crypto/webidl'); + const input = { name: 'AES-GCM', iv: new Uint8Array(12) }; + const opts = { prefix: 'test', context: 'test' }; + bench.start(); + for (let i = 0; i < n; i++) + webidl.converters.AeadParams(input, opts); + bench.end(n); + break; + } + case 'webidl-algorithm-identifier-string': { + // Exercises converters.AlgorithmIdentifier string path. + const webidl = require('internal/crypto/webidl'); + const opts = { prefix: 'test', context: 'test' }; + bench.start(); + for (let i = 0; i < n; i++) + webidl.converters.AlgorithmIdentifier('SHA-256', opts); + bench.end(n); + break; + } + case 'webidl-algorithm-identifier-object': { + // Exercises converters.AlgorithmIdentifier object path. + const webidl = require('internal/crypto/webidl'); + const input = { name: 'SHA-256' }; + const opts = { prefix: 'test', context: 'test' }; + bench.start(); + for (let i = 0; i < n; i++) + webidl.converters.AlgorithmIdentifier(input, opts); + bench.end(n); + break; + } + case 'webidl-dict-enforce-range': { + // Exercises [EnforceRange] integer dictionary members. + const webidl = require('internal/crypto/webidl'); + const input = { + name: 'RSASSA-PKCS1-v1_5', + modulusLength: 2048, + publicExponent: new Uint8Array([1, 0, 1]), + }; + const opts = { prefix: 'test', context: 'test' }; + bench.start(); + for (let i = 0; i < n; i++) + webidl.converters.RsaKeyGenParams(input, opts); + bench.end(n); + break; + } + case 'webidl-dict-ensure-sha': { + // Exercises ensureSHA on a hash member. + const webidl = require('internal/crypto/webidl'); + const input = { name: 'RSASSA-PKCS1-v1_5', hash: 'SHA-256' }; + const opts = { prefix: 'test', context: 'test' }; + bench.start(); + for (let i = 0; i < n; i++) + webidl.converters.RsaHashedImportParams(input, opts); + bench.end(n); + break; + } + case 'webidl-dict-null': { + // Exercises the null/undefined path in createDictionaryConverter(). + const webidl = require('internal/crypto/webidl'); + const opts = { prefix: 'test', context: 'test' }; + bench.start(); + for (let i = 0; i < n; i++) + webidl.converters.JsonWebKey(undefined, opts); + bench.end(n); + break; + } + } +} diff --git a/benchmark/misc/webidl-convert-to-int.js b/benchmark/misc/webidl-convert-to-int.js new file mode 100644 index 00000000000000..52245ee3b6a1a5 --- /dev/null +++ b/benchmark/misc/webidl-convert-to-int.js @@ -0,0 +1,82 @@ +'use strict'; + +const assert = require('assert'); +const common = require('../common.js'); + +const bench = common.createBenchmark(main, { + converter: [ + 'byte', + 'octet', + 'unsigned short', + 'unsigned long', + 'long long', + ], + input: [ + 'integer', + 'fractional', + 'wrap', + 'clamp', + 'enforce-range', + 'object', + ], + n: [1e6], +}, { flags: ['--expose-internals'] }); + +function getConverter(converter) { + switch (converter) { + case 'byte': + return { bitLength: 8, signedness: 'signed' }; + case 'octet': + return { bitLength: 8 }; + case 'unsigned short': + return { bitLength: 16 }; + case 'unsigned long': + return { bitLength: 32 }; + case 'long long': + return { bitLength: 64, signedness: 'signed' }; + default: + throw new Error(`Unsupported converter: ${converter}`); + } +} + +function getInput(input) { + switch (input) { + case 'integer': + return { value: 7 }; + case 'fractional': + return { value: 7.9 }; + case 'wrap': + return { value: 2 ** 63 + 2 ** 11 }; + case 'clamp': + return { value: 300.8, options: { clamp: true } }; + case 'enforce-range': + return { value: 7.9, options: { enforceRange: true } }; + case 'object': + return { + value: { + valueOf() { return 7; }, + }, + }; + default: + throw new Error(`Unsupported input: ${input}`); + } +} + +function main({ n, converter, input }) { + const { convertToInt } = require('internal/webidl'); + const { bitLength, signedness } = getConverter(converter); + const { value, options } = getInput(input); + + let noDead; + bench.start(); + if (options === undefined) { + for (let i = 0; i < n; i++) + noDead = convertToInt(value, bitLength, signedness); + } else { + for (let i = 0; i < n; i++) + noDead = convertToInt(value, bitLength, signedness, options); + } + bench.end(n); + + assert.strictEqual(typeof noDead, 'number'); +} diff --git a/lib/internal/blob.js b/lib/internal/blob.js index 0e901d416e0430..7eb3341076aec5 100644 --- a/lib/internal/blob.js +++ b/lib/internal/blob.js @@ -54,7 +54,6 @@ const { const { inspect } = require('internal/util/inspect'); const { converters, - convertToInt, createSequenceConverter, } = require('internal/webidl'); @@ -251,10 +250,14 @@ class Blob { if (!isBlob(this)) throw new ERR_INVALID_THIS('Blob'); - // Coerce values to int - const opts = { __proto__: null, signed: true }; - start = convertToInt('start', start, 64, opts); - end = convertToInt('end', end, 64, opts); + start = converters['long long']( + start, + { __proto__: null, context: 'start' }, + ); + end = converters['long long']( + end, + { __proto__: null, context: 'end' }, + ); if (start < 0) { start = MathMax(this[kLength] + start, 0); diff --git a/lib/internal/crypto/webidl.js b/lib/internal/crypto/webidl.js index 43f0906a3af902..a87edcb411d08e 100644 --- a/lib/internal/crypto/webidl.js +++ b/lib/internal/crypto/webidl.js @@ -1,46 +1,17 @@ 'use strict'; -// Adapted from the following sources -// - https://github.com/jsdom/webidl-conversions -// Copyright Domenic Denicola. Licensed under BSD-2-Clause License. -// Original license at https://github.com/jsdom/webidl-conversions/blob/master/LICENSE.md. -// - https://github.com/denoland/deno -// Copyright Deno authors. Licensed under MIT License. -// Original license at https://github.com/denoland/deno/blob/main/LICENSE.md. -// Changes include using primordials and stripping the code down to only what -// WebCryptoAPI needs. - const { - ArrayBufferIsView, ArrayPrototypeIncludes, - ArrayPrototypePush, - ArrayPrototypeSort, MathPow, - MathTrunc, - Number, - NumberIsFinite, NumberParseInt, ObjectPrototypeHasOwnProperty, - ObjectPrototypeIsPrototypeOf, - SafeArrayIterator, - String, StringPrototypeStartsWith, StringPrototypeToLowerCase, - TypedArrayPrototypeGetBuffer, - TypedArrayPrototypeGetSymbolToStringTag, } = primordials; -const { - converters: sharedConverters, - makeException, - createEnumConverter, - createSequenceConverter, -} = require('internal/webidl'); - const { lazyDOMException, kEmptyObject, - setOwnProperty, } = require('internal/util'); const { CryptoKey } = require('internal/crypto/webcrypto'); const { @@ -51,55 +22,15 @@ const { validateMaxBufferLength, kNamedCurveAliases, } = require('internal/crypto/util'); -const { isSharedArrayBuffer } = require('internal/util/types'); - -// https://tc39.es/ecma262/#sec-tonumber -function toNumber(value, opts = kEmptyObject) { - switch (typeof value) { - case 'number': - return value; - case 'bigint': - throw makeException( - 'is a BigInt and cannot be converted to a number.', - opts); - case 'symbol': - throw makeException( - 'is a Symbol and cannot be converted to a number.', - opts); - default: - return Number(value); - } -} - -function type(V) { - if (V === null) - return 'Null'; - - switch (typeof V) { - case 'undefined': - return 'Undefined'; - case 'boolean': - return 'Boolean'; - case 'number': - return 'Number'; - case 'string': - return 'String'; - case 'symbol': - return 'Symbol'; - case 'bigint': - return 'BigInt'; - case 'object': // Fall through - case 'function': // Fall through - default: - // Per ES spec, typeof returns an implementation-defined value that is not - // any of the existing ones for uncallable non-standard exotic objects. - // Yet Type() which the Web IDL spec depends on returns Object for such - // cases. So treat the default case as an object. - return 'Object'; - } -} - -const integerPart = MathTrunc; +const { + converters: webidl, + createDictionaryConverter, + createEnumConverter, + createInterfaceConverter, + createSequenceConverter, + requiredArguments, + type, +} = require('internal/webidl'); function validateByteLength(buf, name, target) { if (buf.byteLength !== target) { @@ -123,79 +54,7 @@ function namedCurveValidator(V, dict) { 'NotSupportedError'); } -// This was updated to only consider bitlength up to 32 used by WebCryptoAPI -function createIntegerConversion(bitLength) { - const lowerBound = 0; - const upperBound = MathPow(2, bitLength) - 1; - - const twoToTheBitLength = MathPow(2, bitLength); - - return (V, opts = kEmptyObject) => { - let x = toNumber(V, opts); - - if (opts.enforceRange) { - if (!NumberIsFinite(x)) { - throw makeException( - 'is not a finite number.', - opts); - } - - x = integerPart(x); - - if (x < lowerBound || x > upperBound) { - throw makeException( - `is outside the expected range of ${lowerBound} to ${upperBound}.`, - { __proto__: null, ...opts, code: 'ERR_OUT_OF_RANGE' }, - ); - } - - return x; - } - - if (!NumberIsFinite(x) || x === 0) { - return 0; - } - - x = integerPart(x); - - if (x >= lowerBound && x <= upperBound) { - return x; - } - - x = x % twoToTheBitLength; - - return x; - }; -} - -const converters = {}; - -converters.boolean = (val) => !!val; -converters.octet = createIntegerConversion(8); -converters['unsigned short'] = createIntegerConversion(16); -converters['unsigned long'] = createIntegerConversion(32); - -converters.DOMString = function(V, opts = kEmptyObject) { - if (typeof V === 'string') { - return V; - } else if (typeof V === 'symbol') { - throw makeException( - 'is a Symbol and cannot be converted to a string.', - opts); - } - - return String(V); -}; - -converters.object = (V, opts) => { - if (type(V) !== 'Object') { - throw makeException( - 'is not an object.', - opts); - } - - return V; -}; +const converters = { __proto__: null, ...webidl }; /** * @param {string | object} V - The hash algorithm identifier (string or object). @@ -209,117 +68,6 @@ function ensureSHA(V, label) { `Only SHA hashes are supported in ${label}`, 'NotSupportedError'); } -converters.Uint8Array = (V, opts = kEmptyObject) => { - if (!ArrayBufferIsView(V) || - TypedArrayPrototypeGetSymbolToStringTag(V) !== 'Uint8Array') { - throw makeException( - 'is not an Uint8Array object.', - opts); - } - if (isSharedArrayBuffer(TypedArrayPrototypeGetBuffer(V))) { - throw makeException( - 'is a view on a SharedArrayBuffer, which is not allowed.', - opts); - } - - return V; -}; - -converters.BufferSource = sharedConverters.BufferSource; - -converters['sequence'] = createSequenceConverter( - converters.DOMString); - -function requiredArguments(length, required, opts = kEmptyObject) { - if (length < required) { - throw makeException( - `${required} argument${ - required === 1 ? '' : 's' - } required, but only ${length} present.`, - { __proto__: null, ...opts, context: '', code: 'ERR_MISSING_ARGS' }); - } -} - -function createDictionaryConverter(name, dictionaries) { - let hasRequiredKey = false; - const allMembers = []; - for (let i = 0; i < dictionaries.length; i++) { - const member = dictionaries[i]; - if (member.required) { - hasRequiredKey = true; - } - ArrayPrototypePush(allMembers, member); - } - ArrayPrototypeSort(allMembers, (a, b) => { - if (a.key === b.key) { - return 0; - } - return a.key < b.key ? -1 : 1; - }); - - return function(V, opts = kEmptyObject) { - const typeV = type(V); - switch (typeV) { - case 'Undefined': - case 'Null': - case 'Object': - break; - default: - throw makeException( - 'can not be converted to a dictionary', - opts); - } - const esDict = V; - const idlDict = {}; - - // Fast path null and undefined. - if (V == null && !hasRequiredKey) { - return idlDict; - } - - for (const member of new SafeArrayIterator(allMembers)) { - const key = member.key; - - let esMemberValue; - if (typeV === 'Undefined' || typeV === 'Null') { - esMemberValue = undefined; - } else { - esMemberValue = esDict[key]; - } - - if (esMemberValue !== undefined) { - const context = `'${key}' of '${name}'${ - opts.context ? ` (${opts.context})` : '' - }`; - const idlMemberValue = member.converter(esMemberValue, { - __proto__: null, - ...opts, - context, - }); - member.validator?.(idlMemberValue, esDict); - setOwnProperty(idlDict, key, idlMemberValue); - } else if (member.required) { - throw makeException( - `can not be converted to '${name}' because '${key}' is required in '${name}'.`, - { __proto__: null, ...opts, code: 'ERR_MISSING_OPTION' }); - } - } - - return idlDict; - }; -} - -function createInterfaceConverter(name, prototype) { - return (V, opts) => { - if (!ObjectPrototypeIsPrototypeOf(prototype, V)) { - throw makeException( - `is not of type ${name}.`, - opts); - } - return V; - }; -} - converters.AlgorithmIdentifier = (V, opts) => { // Union for (object or DOMString) if (type(V) === 'Object') { @@ -369,10 +117,29 @@ const dictAlgorithm = [ converters.Algorithm = createDictionaryConverter( 'Algorithm', dictAlgorithm); -converters.BigInteger = converters.Uint8Array; +// TODO(panva): Reject resizable backing stores in a semver-major with: +// converters.BigInteger = webidl.Uint8Array; +converters.BigInteger = (V, opts = kEmptyObject) => { + return webidl.Uint8Array(V, { + __proto__: null, + ...opts, + allowResizable: true, + allowShared: false, + }); +}; + +// TODO(panva): Reject resizable backing stores in a semver-major by +// removing this altogether. +converters.BufferSource = (V, opts = kEmptyObject) => { + return webidl.BufferSource(V, { + __proto__: null, + ...opts, + allowResizable: opts.allowResizable === undefined ? + true : opts.allowResizable, + }); +}; const dictRsaKeyGenParams = [ - ...new SafeArrayIterator(dictAlgorithm), { key: 'modulusLength', converter: (V, opts) => @@ -387,64 +154,78 @@ const dictRsaKeyGenParams = [ ]; converters.RsaKeyGenParams = createDictionaryConverter( - 'RsaKeyGenParams', dictRsaKeyGenParams); + 'RsaKeyGenParams', [ + dictAlgorithm, + dictRsaKeyGenParams, + ]); converters.RsaHashedKeyGenParams = createDictionaryConverter( 'RsaHashedKeyGenParams', [ - ...new SafeArrayIterator(dictRsaKeyGenParams), - { - key: 'hash', - converter: converters.HashAlgorithmIdentifier, - validator: (V, dict) => ensureSHA(V, 'RsaHashedKeyGenParams'), - required: true, - }, + dictAlgorithm, + dictRsaKeyGenParams, + [ + { + key: 'hash', + converter: converters.HashAlgorithmIdentifier, + validator: (V, dict) => ensureSHA(V, 'RsaHashedKeyGenParams'), + required: true, + }, + ], ]); converters.RsaHashedImportParams = createDictionaryConverter( 'RsaHashedImportParams', [ - ...new SafeArrayIterator(dictAlgorithm), - { - key: 'hash', - converter: converters.HashAlgorithmIdentifier, - validator: (V, dict) => ensureSHA(V, 'RsaHashedImportParams'), - required: true, - }, + dictAlgorithm, + [ + { + key: 'hash', + converter: converters.HashAlgorithmIdentifier, + validator: (V, dict) => ensureSHA(V, 'RsaHashedImportParams'), + required: true, + }, + ], ]); converters.NamedCurve = converters.DOMString; converters.EcKeyImportParams = createDictionaryConverter( 'EcKeyImportParams', [ - ...new SafeArrayIterator(dictAlgorithm), - { - key: 'namedCurve', - converter: converters.NamedCurve, - validator: namedCurveValidator, - required: true, - }, + dictAlgorithm, + [ + { + key: 'namedCurve', + converter: converters.NamedCurve, + validator: namedCurveValidator, + required: true, + }, + ], ]); converters.EcKeyGenParams = createDictionaryConverter( 'EcKeyGenParams', [ - ...new SafeArrayIterator(dictAlgorithm), - { - key: 'namedCurve', - converter: converters.NamedCurve, - validator: namedCurveValidator, - required: true, - }, + dictAlgorithm, + [ + { + key: 'namedCurve', + converter: converters.NamedCurve, + validator: namedCurveValidator, + required: true, + }, + ], ]); converters.AesKeyGenParams = createDictionaryConverter( 'AesKeyGenParams', [ - ...new SafeArrayIterator(dictAlgorithm), - { - key: 'length', - converter: (V, opts) => - converters['unsigned short'](V, { ...opts, enforceRange: true }), - validator: AESLengthValidator, - required: true, - }, + dictAlgorithm, + [ + { + key: 'length', + converter: (V, opts) => + converters['unsigned short'](V, { ...opts, enforceRange: true }), + validator: AESLengthValidator, + required: true, + }, + ], ]); function validateZeroLength(parameterName) { @@ -458,51 +239,59 @@ function validateZeroLength(parameterName) { converters.RsaPssParams = createDictionaryConverter( 'RsaPssParams', [ - ...new SafeArrayIterator(dictAlgorithm), - { - key: 'saltLength', - converter: (V, opts) => - converters['unsigned long'](V, { ...opts, enforceRange: true }), - required: true, - }, + dictAlgorithm, + [ + { + key: 'saltLength', + converter: (V, opts) => + converters['unsigned long'](V, { ...opts, enforceRange: true }), + required: true, + }, + ], ]); converters.RsaOaepParams = createDictionaryConverter( 'RsaOaepParams', [ - ...new SafeArrayIterator(dictAlgorithm), - { - key: 'label', - converter: converters.BufferSource, - }, + dictAlgorithm, + [ + { + key: 'label', + converter: converters.BufferSource, + }, + ], ]); converters.EcdsaParams = createDictionaryConverter( 'EcdsaParams', [ - ...new SafeArrayIterator(dictAlgorithm), - { - key: 'hash', - converter: converters.HashAlgorithmIdentifier, - validator: (V, dict) => ensureSHA(V, 'EcdsaParams'), - required: true, - }, - ]); - -for (const { 0: name, 1: zeroError } of [['HmacKeyGenParams', 'OperationError'], ['HmacImportParams', 'DataError']]) { - converters[name] = createDictionaryConverter( - name, [ - ...new SafeArrayIterator(dictAlgorithm), + dictAlgorithm, + [ { key: 'hash', converter: converters.HashAlgorithmIdentifier, - validator: (V, dict) => ensureSHA(V, name), + validator: (V, dict) => ensureSHA(V, 'EcdsaParams'), required: true, }, - { - key: 'length', - converter: (V, opts) => - converters['unsigned long'](V, { ...opts, enforceRange: true }), - validator: validateMacKeyLength(`${name}.length`, zeroError), - }, + ], + ]); + +for (const { 0: name, 1: zeroError } of [['HmacKeyGenParams', 'OperationError'], ['HmacImportParams', 'DataError']]) { + converters[name] = createDictionaryConverter( + name, [ + dictAlgorithm, + [ + { + key: 'hash', + converter: converters.HashAlgorithmIdentifier, + validator: (V, dict) => ensureSHA(V, name), + required: true, + }, + { + key: 'length', + converter: (V, opts) => + converters['unsigned long'](V, { ...opts, enforceRange: true }), + validator: validateMacKeyLength(`${name}.length`, zeroError), + }, + ], ]); } @@ -541,196 +330,210 @@ converters.JsonWebKey = createDictionaryConverter( simpleDomStringKey('dp'), simpleDomStringKey('dq'), simpleDomStringKey('qi'), - simpleDomStringKey('pub'), - simpleDomStringKey('priv'), { key: 'oth', converter: converters['sequence'], }, simpleDomStringKey('k'), + simpleDomStringKey('pub'), + simpleDomStringKey('priv'), ]); converters.HkdfParams = createDictionaryConverter( 'HkdfParams', [ - ...new SafeArrayIterator(dictAlgorithm), - { - key: 'hash', - converter: converters.HashAlgorithmIdentifier, - validator: (V, dict) => ensureSHA(V, 'HkdfParams'), - required: true, - }, - { - key: 'salt', - converter: converters.BufferSource, - required: true, - }, - { - key: 'info', - converter: converters.BufferSource, - validator: (V, dict) => validateMaxBufferLength(V, 'algorithm.info', 1024), - required: true, - }, + dictAlgorithm, + [ + { + key: 'hash', + converter: converters.HashAlgorithmIdentifier, + validator: (V, dict) => ensureSHA(V, 'HkdfParams'), + required: true, + }, + { + key: 'salt', + converter: converters.BufferSource, + required: true, + }, + { + key: 'info', + converter: converters.BufferSource, + validator: (V, dict) => validateMaxBufferLength(V, 'algorithm.info', 1024), + required: true, + }, + ], ]); converters.CShakeParams = createDictionaryConverter( 'CShakeParams', [ - ...new SafeArrayIterator(dictAlgorithm), - { - key: 'outputLength', - converter: (V, opts) => - converters['unsigned long'](V, { ...opts, enforceRange: true }), - validator: (V, opts) => { - // The Web Crypto spec allows for SHAKE output length that are not multiples of - // 8. We don't. - if (V % 8) - throw lazyDOMException('Unsupported CShakeParams outputLength', 'NotSupportedError'); - }, - required: true, - }, - { - key: 'functionName', - converter: converters.BufferSource, - validator: validateZeroLength('CShakeParams.functionName'), - }, - { - key: 'customization', - converter: converters.BufferSource, - validator: validateZeroLength('CShakeParams.customization'), - }, + dictAlgorithm, + [ + { + key: 'outputLength', + converter: (V, opts) => + converters['unsigned long'](V, { ...opts, enforceRange: true }), + validator: (V, opts) => { + // The Web Crypto spec allows for SHAKE output length that are not multiples of + // 8. We don't. + if (V % 8) + throw lazyDOMException('Unsupported CShakeParams outputLength', 'NotSupportedError'); + }, + required: true, + }, + { + key: 'functionName', + converter: converters.BufferSource, + validator: validateZeroLength('CShakeParams.functionName'), + }, + { + key: 'customization', + converter: converters.BufferSource, + validator: validateZeroLength('CShakeParams.customization'), + }, + ], ]); converters.Pbkdf2Params = createDictionaryConverter( 'Pbkdf2Params', [ - ...new SafeArrayIterator(dictAlgorithm), - { - key: 'hash', - converter: converters.HashAlgorithmIdentifier, - validator: (V, dict) => ensureSHA(V, 'Pbkdf2Params'), - required: true, - }, - { - key: 'iterations', - converter: (V, opts) => - converters['unsigned long'](V, { ...opts, enforceRange: true }), - validator: (V, dict) => { - if (V === 0) - throw lazyDOMException('iterations cannot be zero', 'OperationError'); - }, - required: true, - }, - { - key: 'salt', - converter: converters.BufferSource, - required: true, - }, + dictAlgorithm, + [ + { + key: 'salt', + converter: converters.BufferSource, + required: true, + }, + { + key: 'iterations', + converter: (V, opts) => + converters['unsigned long'](V, { ...opts, enforceRange: true }), + validator: (V, dict) => { + if (V === 0) + throw lazyDOMException('iterations cannot be zero', 'OperationError'); + }, + required: true, + }, + { + key: 'hash', + converter: converters.HashAlgorithmIdentifier, + validator: (V, dict) => ensureSHA(V, 'Pbkdf2Params'), + required: true, + }, + ], ]); converters.AesDerivedKeyParams = createDictionaryConverter( 'AesDerivedKeyParams', [ - ...new SafeArrayIterator(dictAlgorithm), - { - key: 'length', - converter: (V, opts) => - converters['unsigned short'](V, { ...opts, enforceRange: true }), - validator: AESLengthValidator, - required: true, - }, + dictAlgorithm, + [ + { + key: 'length', + converter: (V, opts) => + converters['unsigned short'](V, { ...opts, enforceRange: true }), + validator: AESLengthValidator, + required: true, + }, + ], ]); converters.AesCbcParams = createDictionaryConverter( 'AesCbcParams', [ - ...new SafeArrayIterator(dictAlgorithm), - { - key: 'iv', - converter: converters.BufferSource, - validator: (V, dict) => validateByteLength(V, 'algorithm.iv', 16), - required: true, - }, + dictAlgorithm, + [ + { + key: 'iv', + converter: converters.BufferSource, + validator: (V, dict) => validateByteLength(V, 'algorithm.iv', 16), + required: true, + }, + ], ]); converters.AeadParams = createDictionaryConverter( 'AeadParams', [ - ...new SafeArrayIterator(dictAlgorithm), - { - key: 'iv', - converter: converters.BufferSource, - validator: (V, dict) => { - switch (StringPrototypeToLowerCase(dict.name)) { - case 'chacha20-poly1305': - validateByteLength(V, 'algorithm.iv', 12); - break; - case 'aes-gcm': - validateMaxBufferLength(V, 'algorithm.iv'); - break; - case 'aes-ocb': - if (V.byteLength > 15) { - throw lazyDOMException( - 'AES-OCB algorithm.iv must be no more than 15 bytes', - 'OperationError'); - } - break; - } - }, - required: true, - }, - { - key: 'tagLength', - converter: (V, opts) => - converters.octet(V, { ...opts, enforceRange: true }), - validator: (V, dict) => { - switch (StringPrototypeToLowerCase(dict.name)) { - case 'chacha20-poly1305': - if (V !== 128) { - throw lazyDOMException( - `${V} is not a valid ChaCha20-Poly1305 tag length`, - 'OperationError'); - } - break; - case 'aes-gcm': - if (!ArrayPrototypeIncludes([32, 64, 96, 104, 112, 120, 128], V)) { - throw lazyDOMException( - `${V} is not a valid AES-GCM tag length`, - 'OperationError'); - } - break; - case 'aes-ocb': - if (!ArrayPrototypeIncludes([64, 96, 128], V)) { - throw lazyDOMException( - `${V} is not a valid AES-OCB tag length`, - 'OperationError'); - } - break; - } + dictAlgorithm, + [ + { + key: 'iv', + converter: converters.BufferSource, + validator: (V, dict) => { + switch (StringPrototypeToLowerCase(dict.name)) { + case 'chacha20-poly1305': + validateByteLength(V, 'algorithm.iv', 12); + break; + case 'aes-gcm': + validateMaxBufferLength(V, 'algorithm.iv'); + break; + case 'aes-ocb': + if (V.byteLength > 15) { + throw lazyDOMException( + 'AES-OCB algorithm.iv must be no more than 15 bytes', + 'OperationError'); + } + break; + } + }, + required: true, }, - }, - { - key: 'additionalData', - converter: converters.BufferSource, - validator: (V, dict) => validateMaxBufferLength(V, 'algorithm.additionalData'), - }, + { + key: 'additionalData', + converter: converters.BufferSource, + validator: (V, dict) => validateMaxBufferLength(V, 'algorithm.additionalData'), + }, + { + key: 'tagLength', + converter: (V, opts) => + converters.octet(V, { ...opts, enforceRange: true }), + validator: (V, dict) => { + switch (StringPrototypeToLowerCase(dict.name)) { + case 'chacha20-poly1305': + if (V !== 128) { + throw lazyDOMException( + `${V} is not a valid ChaCha20-Poly1305 tag length`, + 'OperationError'); + } + break; + case 'aes-gcm': + if (!ArrayPrototypeIncludes([32, 64, 96, 104, 112, 120, 128], V)) { + throw lazyDOMException( + `${V} is not a valid AES-GCM tag length`, + 'OperationError'); + } + break; + case 'aes-ocb': + if (!ArrayPrototypeIncludes([64, 96, 128], V)) { + throw lazyDOMException( + `${V} is not a valid AES-OCB tag length`, + 'OperationError'); + } + break; + } + }, + }, + ], ]); converters.AesCtrParams = createDictionaryConverter( 'AesCtrParams', [ - ...new SafeArrayIterator(dictAlgorithm), - { - key: 'counter', - converter: converters.BufferSource, - validator: (V, dict) => validateByteLength(V, 'algorithm.counter', 16), - required: true, - }, - { - key: 'length', - converter: (V, opts) => - converters.octet(V, { ...opts, enforceRange: true }), - validator: (V, dict) => { - if (V === 0 || V > 128) - throw lazyDOMException( - 'AES-CTR algorithm.length must be between 1 and 128', - 'OperationError'); - }, - required: true, - }, + dictAlgorithm, + [ + { + key: 'counter', + converter: converters.BufferSource, + validator: (V, dict) => validateByteLength(V, 'algorithm.counter', 16), + required: true, + }, + { + key: 'length', + converter: (V, opts) => + converters.octet(V, { ...opts, enforceRange: true }), + validator: (V, dict) => { + if (V === 0 || V > 128) + throw lazyDOMException( + 'AES-CTR algorithm.length must be between 1 and 128', + 'OperationError'); + }, + required: true, + }, + ], ]); converters.CryptoKey = createInterfaceConverter( @@ -738,104 +541,120 @@ converters.CryptoKey = createInterfaceConverter( converters.EcdhKeyDeriveParams = createDictionaryConverter( 'EcdhKeyDeriveParams', [ - ...new SafeArrayIterator(dictAlgorithm), - { - key: 'public', - converter: converters.CryptoKey, - validator: (V, dict) => { - if (getCryptoKeyType(V) !== 'public') - throw lazyDOMException( - 'algorithm.public must be a public key', 'InvalidAccessError'); - - if (StringPrototypeToLowerCase(getCryptoKeyAlgorithm(V).name) !== StringPrototypeToLowerCase(dict.name)) - throw lazyDOMException( - 'key algorithm mismatch', - 'InvalidAccessError'); - }, - required: true, - }, + dictAlgorithm, + [ + { + key: 'public', + converter: converters.CryptoKey, + validator: (V, dict) => { + if (getCryptoKeyType(V) !== 'public') + throw lazyDOMException( + 'algorithm.public must be a public key', 'InvalidAccessError'); + + if (StringPrototypeToLowerCase(getCryptoKeyAlgorithm(V).name) !== StringPrototypeToLowerCase(dict.name)) + throw lazyDOMException( + 'key algorithm mismatch', + 'InvalidAccessError'); + }, + required: true, + }, + ], ]); converters.ContextParams = createDictionaryConverter( 'ContextParams', [ - ...new SafeArrayIterator(dictAlgorithm), - { - key: 'context', - converter: converters.BufferSource, - validator(V, dict) { - let { 0: major, 1: minor } = process.versions.openssl.split('.'); - major = NumberParseInt(major, 10); - minor = NumberParseInt(minor, 10); - if (major > 3 || (major === 3 && minor >= 2)) { - this.validator = undefined; - } else { - this.validator = validateZeroLength('ContextParams.context'); - this.validator(V, dict); - } + dictAlgorithm, + [ + { + key: 'context', + converter: converters.BufferSource, + validator(V, dict) { + let { 0: major, 1: minor } = process.versions.openssl.split('.'); + major = NumberParseInt(major, 10); + minor = NumberParseInt(minor, 10); + if (major > 3 || (major === 3 && minor >= 2)) { + this.validator = undefined; + } else { + this.validator = validateZeroLength('ContextParams.context'); + this.validator(V, dict); + } + }, }, - }, + ], ]); converters.Argon2Params = createDictionaryConverter( 'Argon2Params', [ - ...new SafeArrayIterator(dictAlgorithm), - { - key: 'nonce', - converter: converters.BufferSource, - required: true, - }, - { - key: 'parallelism', - converter: (V, opts) => - converters['unsigned long'](V, { ...opts, enforceRange: true }), - validator: (V, dict) => { - if (V === 0 || V > MathPow(2, 24) - 1) { - throw lazyDOMException( - 'parallelism must be > 0 and < 16777215', - 'OperationError'); - } - }, - required: true, - }, - { - key: 'memory', - converter: (V, opts) => - converters['unsigned long'](V, { ...opts, enforceRange: true }), - validator: (V, dict) => { - if (V < 8 * dict.parallelism) { - throw lazyDOMException( - 'memory must be at least 8 times the degree of parallelism', - 'OperationError'); - } - }, - required: true, - }, - { - key: 'passes', - converter: (V, opts) => - converters['unsigned long'](V, { ...opts, enforceRange: true }), - required: true, - }, - { - key: 'version', - converter: (V, opts) => - converters.octet(V, { ...opts, enforceRange: true }), - validator: (V, dict) => { - if (V !== 0x13) { - throw lazyDOMException( - `${V} is not a valid Argon2 version`, - 'OperationError'); - } + dictAlgorithm, + [ + { + key: 'nonce', + converter: converters.BufferSource, + validator: (V) => { + if (V.byteLength < 8) { + throw lazyDOMException('nonce must be at least 8 bytes', 'OperationError'); + } + }, + required: true, }, - }, - { - key: 'secretValue', - converter: converters.BufferSource, - }, - { - key: 'associatedData', - converter: converters.BufferSource, - }, + { + key: 'parallelism', + converter: (V, opts) => + converters['unsigned long'](V, { ...opts, enforceRange: true }), + validator: (V, dict) => { + if (V === 0 || V > MathPow(2, 24) - 1) { + throw lazyDOMException( + 'parallelism must be > 0 and <= 16777215', + 'OperationError'); + } + }, + required: true, + }, + { + key: 'memory', + converter: (V, opts) => + converters['unsigned long'](V, { ...opts, enforceRange: true }), + validator: (V, dict) => { + if (V < 8 * dict.parallelism) { + throw lazyDOMException( + 'memory must be at least 8 times the degree of parallelism', + 'OperationError'); + } + }, + required: true, + }, + { + key: 'passes', + converter: (V, opts) => + converters['unsigned long'](V, { ...opts, enforceRange: true }), + validator: (V) => { + if (V === 0) { + throw lazyDOMException('passes must be > 0', 'OperationError'); + } + }, + required: true, + }, + { + key: 'version', + converter: (V, opts) => + converters.octet(V, { ...opts, enforceRange: true }), + validator: (V, dict) => { + if (V !== 0x13) { + throw lazyDOMException( + `${V} is not a valid Argon2 version`, + 'OperationError'); + } + }, + }, + { + key: 'secretValue', + converter: converters.BufferSource, + }, + { + key: 'associatedData', + converter: converters.BufferSource, + }, + ], ]); function validateMacKeyLength(parameterName, zeroError) { @@ -852,80 +671,88 @@ function validateMacKeyLength(parameterName, zeroError) { for (const { 0: name, 1: zeroError } of [['KmacKeyGenParams', 'OperationError'], ['KmacImportParams', 'DataError']]) { converters[name] = createDictionaryConverter( name, [ - ...new SafeArrayIterator(dictAlgorithm), - { - key: 'length', - converter: (V, opts) => - converters['unsigned long'](V, { ...opts, enforceRange: true }), - validator: validateMacKeyLength(`${name}.length`, zeroError), - }, + dictAlgorithm, + [ + { + key: 'length', + converter: (V, opts) => + converters['unsigned long'](V, { ...opts, enforceRange: true }), + validator: validateMacKeyLength(`${name}.length`, zeroError), + }, + ], ]); } converters.KmacParams = createDictionaryConverter( 'KmacParams', [ - ...new SafeArrayIterator(dictAlgorithm), - { - key: 'outputLength', - converter: (V, opts) => - converters['unsigned long'](V, { ...opts, enforceRange: true }), - validator: (V, opts) => { - // The Web Crypto spec allows for KMAC output length that are not multiples of 8. We don't. - if (V % 8) - throw lazyDOMException('Unsupported KmacParams outputLength', 'NotSupportedError'); - }, - required: true, - }, - { - key: 'customization', - converter: converters.BufferSource, - }, + dictAlgorithm, + [ + { + key: 'outputLength', + converter: (V, opts) => + converters['unsigned long'](V, { ...opts, enforceRange: true }), + validator: (V, opts) => { + // The Web Crypto spec allows for KMAC output length that are not multiples of 8. We don't. + if (V % 8) + throw lazyDOMException('Unsupported KmacParams outputLength', 'NotSupportedError'); + }, + required: true, + }, + { + key: 'customization', + converter: converters.BufferSource, + }, + ], ]); converters.KangarooTwelveParams = createDictionaryConverter( 'KangarooTwelveParams', [ - ...new SafeArrayIterator(dictAlgorithm), - { - key: 'outputLength', - converter: (V, opts) => - converters['unsigned long'](V, { ...opts, enforceRange: true }), - validator: (V, opts) => { - if (V === 0 || V % 8) - throw lazyDOMException('Invalid KangarooTwelveParams outputLength', 'OperationError'); - }, - required: true, - }, - { - key: 'customization', - converter: converters.BufferSource, - }, + dictAlgorithm, + [ + { + key: 'outputLength', + converter: (V, opts) => + converters['unsigned long'](V, { ...opts, enforceRange: true }), + validator: (V, opts) => { + if (V === 0 || V % 8) + throw lazyDOMException('Invalid KangarooTwelveParams outputLength', 'OperationError'); + }, + required: true, + }, + { + key: 'customization', + converter: converters.BufferSource, + }, + ], ]); converters.TurboShakeParams = createDictionaryConverter( 'TurboShakeParams', [ - ...new SafeArrayIterator(dictAlgorithm), - { - key: 'outputLength', - converter: (V, opts) => - converters['unsigned long'](V, { ...opts, enforceRange: true }), - validator: (V, opts) => { - if (V === 0 || V % 8) - throw lazyDOMException('Invalid TurboShakeParams outputLength', 'OperationError'); - }, - required: true, - }, - { - key: 'domainSeparation', - converter: (V, opts) => - converters.octet(V, { ...opts, enforceRange: true }), - validator: (V) => { - if (V < 0x01 || V > 0x7F) { - throw lazyDOMException( - 'TurboShakeParams.domainSeparation must be in range 0x01-0x7f', - 'OperationError'); - } + dictAlgorithm, + [ + { + key: 'outputLength', + converter: (V, opts) => + converters['unsigned long'](V, { ...opts, enforceRange: true }), + validator: (V, opts) => { + if (V === 0 || V % 8) + throw lazyDOMException('Invalid TurboShakeParams outputLength', 'OperationError'); + }, + required: true, }, - }, + { + key: 'domainSeparation', + converter: (V, opts) => + converters.octet(V, { ...opts, enforceRange: true }), + validator: (V) => { + if (V < 0x01 || V > 0x7F) { + throw lazyDOMException( + 'TurboShakeParams.domainSeparation must be in range 0x01-0x7f', + 'OperationError'); + } + }, + }, + ], ]); module.exports = { diff --git a/lib/internal/locks.js b/lib/internal/locks.js index 05000e933f0b55..817159c06e281a 100644 --- a/lib/internal/locks.js +++ b/lib/internal/locks.js @@ -43,7 +43,7 @@ const kConstructLock = Symbol('kConstructLock'); const kConstructLockManager = Symbol('kConstructLockManager'); // WebIDL dictionary LockOptions -const convertLockOptions = createDictionaryConverter([ +const convertLockOptions = createDictionaryConverter('LockOptions', [ { key: 'mode', converter: createEnumConverter('LockMode', [ diff --git a/lib/internal/perf/performance.js b/lib/internal/perf/performance.js index ef2b5a55dd7c44..a12be66333d4f9 100644 --- a/lib/internal/perf/performance.js +++ b/lib/internal/perf/performance.js @@ -44,7 +44,7 @@ const timerify = require('internal/perf/timerify'); const { customInspectSymbol: kInspect, kEnumerableProperty, kEmptyObject } = require('internal/util'); const { inspect } = require('util'); const { validateThisInternalField } = require('internal/validators'); -const { convertToInt } = require('internal/webidl'); +const { converters } = require('internal/webidl'); const kPerformanceBrand = Symbol('performance'); @@ -144,8 +144,10 @@ class Performance extends EventTarget { if (arguments.length === 0) { throw new ERR_MISSING_ARGS('maxSize'); } - // unsigned long - maxSize = convertToInt('maxSize', maxSize, 32); + maxSize = converters['unsigned long']( + maxSize, + { __proto__: null, context: 'maxSize' }, + ); return setResourceTimingBufferSize(maxSize); } diff --git a/lib/internal/webidl.js b/lib/internal/webidl.js index 36bde94013d1a8..f727ea84a40535 100644 --- a/lib/internal/webidl.js +++ b/lib/internal/webidl.js @@ -2,98 +2,186 @@ const { ArrayBufferIsView, - ArrayBufferPrototypeGetByteLength, + ArrayBufferPrototypeGetResizable, + ArrayIsArray, ArrayPrototypePush, ArrayPrototypeToSorted, + BigInt, DataViewPrototypeGetBuffer, + FunctionPrototypeCall, MathAbs, MathMax, MathMin, MathPow, MathSign, MathTrunc, + Number, + NumberIsFinite, NumberIsNaN, NumberMAX_SAFE_INTEGER, NumberMIN_SAFE_INTEGER, - ObjectAssign, ObjectPrototypeIsPrototypeOf, + SafeArrayIterator, SafeSet, String, - Symbol, SymbolIterator, TypeError, TypedArrayPrototypeGetBuffer, + TypedArrayPrototypeGetSymbolToStringTag, } = primordials; +const { kEmptyObject, setOwnProperty } = require('internal/util'); const { - codes: { - ERR_INVALID_ARG_TYPE, - ERR_INVALID_ARG_VALUE, - }, -} = require('internal/errors'); -const { kEmptyObject } = require('internal/util'); -const { - isArrayBuffer, + isSharedArrayBuffer, isTypedArray, } = require('internal/util/types'); +const BIGINT_2_63 = 1n << 63n; +const BIGINT_2_64 = 1n << 64n; + const converters = { __proto__: null }; -const UNDEFINED = Symbol('undefined'); -const BOOLEAN = Symbol('boolean'); -const STRING = Symbol('string'); -const SYMBOL = Symbol('symbol'); -const NUMBER = Symbol('number'); -const BIGINT = Symbol('bigint'); -const NULL = Symbol('null'); -const OBJECT = Symbol('object'); +/** + * @typedef {object} ConversionOptions + * @property {string} [prefix] Message prefix for operation failures. + * @property {string} [context] Message context for the converted value. + * @property {string} [code] Node.js error code to assign to TypeError. + * @property {boolean} [enforceRange] Web IDL [EnforceRange] attribute. + * @property {boolean} [clamp] Web IDL [Clamp] attribute. + * @property {boolean} [allowShared] Web IDL [AllowShared] attribute for + * buffer view types. + * @property {boolean} [allowResizable] Web IDL [AllowResizable] attribute. + */ /** - * @see https://webidl.spec.whatwg.org/#es-any - * @param {any} V + * @callback Converter + * @param {any} V JavaScript value to convert to an IDL value. + * @param {ConversionOptions} [options] Conversion options. * @returns {any} */ -converters.any = (V) => { - return V; -}; -converters.object = (V, opts = kEmptyObject) => { - if (type(V) !== OBJECT) { - throw makeException( - 'is not an object', - kEmptyObject, - ); +/** + * @callback DictionaryMemberValidator + * @param {any} idlMemberValue Converted IDL member value. + * @param {object} jsDict Original JavaScript dictionary object. + * @returns {void} + */ + +/** + * @typedef {object} DictionaryMember + * @property {string} key Dictionary member identifier. + * @property {Converter} converter Converter for the member type. + * @property {boolean} [required] Whether the member is required. + * @property {() => any} [defaultValue] Function returning the default value. + * @property {DictionaryMemberValidator} [validator] Optional Node.js + * extension point invoked after conversion and before storing the member. + * This is for early semantic validation of known unsupported IDL values, + * especially in Web Crypto, where SubtleCrypto.supports() needs to answer + * from normalized dictionaries without running the requested operation. + */ + +/** + * Creates a TypeError with a Node.js error code. + * @param {string} message Error message. + * @param {string} code Node.js error code to assign. + * @returns {TypeError} + */ +function codedTypeError(message, code) { + // eslint-disable-next-line no-restricted-syntax + const err = new TypeError(message); + setOwnProperty(err, 'code', code); + return err; +} + +/** + * Creates the exception thrown by Web IDL converters. + * @param {string} message Unprefixed conversion failure message. + * @param {ConversionOptions} [options] Conversion options. + * @returns {TypeError} + */ +function makeException(message, options = kEmptyObject) { + const prefix = options.prefix ? options.prefix + ': ' : ''; + const context = options.context?.length === 0 ? + '' : (options.context ?? 'Value') + ' '; + return codedTypeError( + `${prefix}${context}${message}`, + options.code || 'ERR_INVALID_ARG_TYPE', + ); +} + +/** + * Returns the ECMAScript specification type of a JavaScript value. + * @see https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values + * @param {any} V JavaScript value. + * @returns {'Undefined'|'Null'|'Boolean'|'String'|'Symbol'|'Number'|'BigInt'|'Object'} + */ +function type(V) { + // ECMA-262 6.1: map JavaScript values to language type names. + switch (typeof V) { + case 'undefined': + return 'Undefined'; + case 'boolean': + return 'Boolean'; + case 'string': + return 'String'; + case 'symbol': + return 'Symbol'; + case 'number': + return 'Number'; + case 'bigint': + return 'BigInt'; + case 'object': + case 'function': + default: + // ECMA-262 6.1.2: null is its own language type. + // ECMA-262 6.1.7: functions are Object values. + if (V === null) { + return 'Null'; + } + return 'Object'; } - return V; -}; +} -// https://webidl.spec.whatwg.org/#abstract-opdef-integerpart -const integerPart = MathTrunc; +/** + * Returns IntegerPart(n). + * @see https://webidl.spec.whatwg.org/#abstract-opdef-integerpart + * @param {number} n Numeric value. + * @returns {number} + */ +function integerPart(n) { + // Web IDL IntegerPart steps 1-3: floor(abs(n)), restore the sign, + // and choose +0 rather than -0. + const integer = MathTrunc(n); + return integer === 0 ? 0 : integer; +} -/* eslint-disable node-core/non-ascii-character */ -// Round x to the nearest integer, choosing the even integer if it lies halfway -// between two, and choosing +0 rather than -0. -// This is different from Math.round, which rounds to the next integer in the -// direction of +∞ when the fraction portion is exactly 0.5. -/* eslint-enable node-core/non-ascii-character */ +/** + * Rounds to the nearest integer, choosing the even integer on ties. + * @param {number} x Numeric value. + * @returns {number} + */ function evenRound(x) { - // Convert -0 to +0. - const i = integerPart(x) + 0; - const reminder = MathAbs(x % 1); - const sign = MathSign(i); - if (reminder === 0.5) { + // Web IDL ConvertToInt step 7.2: round to the nearest integer, + // choosing the even integer on ties and +0 rather than -0. + const i = integerPart(x); + const remainder = MathAbs(x % 1); + const sign = MathSign(x); + if (remainder === 0.5) { return i % 2 === 0 ? i : i + sign; } - const r = reminder < 0.5 ? i : i + sign; - // Convert -0 to +0. + const r = remainder < 0.5 ? i : i + sign; if (r === 0) { return 0; } return r; } +/** + * Returns 2 to the power of the given exponent. + * @param {number} exponent Non-negative integer exponent. + * @returns {number} + */ function pow2(exponent) { - // << operates on 32 bit signed integers. if (exponent < 31) { return 1 << exponent; } @@ -106,354 +194,877 @@ function pow2(exponent) { return MathPow(2, exponent); } -// https://tc39.es/ecma262/#eqn-modulo -// The notation “x modulo y” computes a value k of the same sign as y. +/** + * Returns x modulo y for Web IDL ConvertToInt step 10. + * + * This is intentionally not a general modulo helper. ConvertToInt only calls + * it with a positive power-of-two modulus, and the implementation assumes + * that. It converts JavaScript remainder into mathematical modulo and + * normalizes -0 to +0. + * @param {number} x Dividend. + * @param {number} y Positive divisor. + * @returns {number} + */ function modulo(x, y) { + // Web IDL ConvertToInt step 10 uses mathematical modulo. const r = x % y; - // Convert -0 to +0. if (r === 0) { return 0; } - return r; + return r > 0 ? r : r + y; +} + +/** + * Returns x modulo y for Web IDL ConvertToInt step 10. + * + * This is intentionally not a general modulo helper. ConvertToInt only calls + * it with a positive power-of-two modulus, and the implementation assumes + * that. BigInt has no -0, but this mirrors modulo()'s mathematical modulo + * behavior for the 64-bit path. + * @param {bigint} x Dividend. + * @param {bigint} y Positive divisor. + * @returns {bigint} + */ +function bigIntModulo(x, y) { + // Web IDL ConvertToInt step 10 uses mathematical modulo. + const r = x % y; + return r >= 0n ? r : r + y; } -// https://webidl.spec.whatwg.org/#abstract-opdef-converttoint -function convertToInt(name, value, bitLength, options = kEmptyObject) { - const { signed = false, enforceRange = false, clamp = false } = options; +/** + * Returns ToNumber(V). + * @see https://tc39.es/ecma262/#sec-tonumber + * @param {any} V JavaScript value. + * @param {ConversionOptions} [options] Conversion options. + * @returns {number} + */ +function toNumber(V, options = kEmptyObject) { + if (typeof V === 'bigint') { + // ECMA-262 ToNumber step 2: BigInt values throw. + throw makeException( + 'is a BigInt and cannot be converted to a number.', + options); + } + if (typeof V === 'symbol') { + // ECMA-262 ToNumber step 2: Symbol values throw. + throw makeException( + 'is a Symbol and cannot be converted to a number.', + options); + } + // Unary plus performs ToNumber, including ToPrimitive(V, number) for + // objects. Number(V) is not equivalent because it converts BigInt values, + // including BigInt values produced by ToPrimitive. + // Abrupt completions and native TypeErrors propagate unchanged. This is an + // intentional diagnostics tradeoff: decorating object conversion failures + // would require maintaining local ECMA-262 ToPrimitive and + // OrdinaryToPrimitive implementations. + return +V; +} + +/** + * Returns ToString(V). + * @see https://tc39.es/ecma262/#sec-tostring + * @param {any} V JavaScript value. + * @param {ConversionOptions} [options] Conversion options. + * @returns {string} + */ +function toString(V, options = kEmptyObject) { + if (typeof V === 'symbol') { + // ECMA-262 ToString step 2: Symbol values throw. + throw makeException( + 'is a Symbol and cannot be converted to a string.', + options); + } + + // The String function performs ToString for all non-Symbol primitives and + // objects, including ToPrimitive(V, string). String concatenation is not + // equivalent because it uses ToPrimitive(V, default). Abrupt completions + // and native TypeErrors propagate unchanged. This is an intentional + // diagnostics tradeoff: decorating object conversion failures would require + // maintaining local ECMA-262 ToPrimitive and OrdinaryToPrimitive + // implementations. + return String(V); +} + +/** + * Converts a JavaScript value to a Web IDL integer value. + * @see https://webidl.spec.whatwg.org/#abstract-opdef-converttoint + * @param {any} V JavaScript value. + * @param {number} bitLength Integer bit length. + * @param {'signed'|'unsigned'} [signedness] Integer signedness. + * @param {ConversionOptions} [options] Conversion options. + * @returns {number} + */ +function convertToInt( + V, + bitLength, + signedness = 'unsigned', + options = kEmptyObject, +) { + const signed = signedness === 'signed'; let upperBound; let lowerBound; - // 1. If bitLength is 64, then: + + // Web IDL ConvertToInt steps 1-3: determine lower/upper bounds. if (bitLength === 64) { - // 1.1. Let upperBound be 2^53 − 1. + // Steps 1.1-1.3 set upperBound to 2^53 - 1 and lowerBound to 0 + // for unsigned, or -2^53 + 1 for signed. This ensures 64-bit + // integer types associated with [EnforceRange] or [Clamp] are + // representable in JavaScript's Number type as unambiguous integers. upperBound = NumberMAX_SAFE_INTEGER; - // 1.2. If signedness is "unsigned", then let lowerBound be 0. - // 1.3. Otherwise let lowerBound be −2^53 + 1. - lowerBound = !signed ? 0 : NumberMIN_SAFE_INTEGER; + lowerBound = signed ? NumberMIN_SAFE_INTEGER : 0; } else if (!signed) { - // 2. Otherwise, if signedness is "unsigned", then: - // 2.1. Let lowerBound be 0. - // 2.2. Let upperBound be 2^bitLength − 1. + // Spell out the common Web IDL integer sizes so hot converters avoid + // recomputing powers of two on every call. lowerBound = 0; - upperBound = pow2(bitLength) - 1; + if (bitLength === 8) { + upperBound = 0xff; + } else if (bitLength === 16) { + upperBound = 0xffff; + } else if (bitLength === 32) { + upperBound = 0xffff_ffff; + } else { + upperBound = pow2(bitLength) - 1; + } + } else if (bitLength === 8) { + // Signed 8/16/32-bit conversions are mostly exercised through direct + // convertToInt() calls, but keep their common bounds cheap too. + lowerBound = -0x80; + upperBound = 0x7f; + } else if (bitLength === 16) { + lowerBound = -0x8000; + upperBound = 0x7fff; + } else if (bitLength === 32) { + lowerBound = -0x8000_0000; + upperBound = 0x7fff_ffff; } else { - // 3. Otherwise: - // 3.1. Let lowerBound be -2^(bitLength − 1). - // 3.2. Let upperBound be 2^(bitLength − 1) − 1. lowerBound = -pow2(bitLength - 1); upperBound = pow2(bitLength - 1) - 1; } - // 4. Let x be ? ToNumber(V). - let x = +value; - // 5. If x is −0, then set x to +0. + // Common case: primitive Number values that already fit the Web IDL + // range and have no fractional part are returned unchanged by every + // ConvertToInt path, except that -0 must become +0. This skips the + // generic ToNumber and option handling without skipping observable + // object coercion. + let x; + if (typeof V === 'number') { + // For primitive Numbers, in-range non-[Clamp] conversion is either + // identity or IntegerPart(V). This keeps the default and [EnforceRange] + // paths out of the generic ToNumber/options flow. + if (V >= lowerBound && V <= upperBound) { + const integer = MathTrunc(V); + if (integer === V) { + return V === 0 ? 0 : V; + } + if (options !== kEmptyObject && options.clamp) { + return evenRound(V); + } + return integer === 0 ? 0 : integer; + } + if (options !== kEmptyObject && options.enforceRange) { + // Keep [EnforceRange] ahead of [Clamp] without falling through to + // the shared check, which would observe options.enforceRange again. + if (!NumberIsFinite(V)) { + throw makeException( + 'is not a finite number.', + options); + } + + const integer = integerPart(V); + if (integer < lowerBound || integer > upperBound) { + throw makeException( + `is outside the expected range of ${lowerBound} to ${upperBound}.`, + { __proto__: null, ...options, code: 'ERR_OUT_OF_RANGE' }); + } + + return integer; + } + if (options !== kEmptyObject && options.clamp && !NumberIsNaN(V)) { + // Out-of-range [Clamp] returns one of the already-computed bounds. + if (V <= lowerBound) { + return lowerBound === 0 ? 0 : lowerBound; + } + if (V >= upperBound) { + return upperBound === 0 ? 0 : upperBound; + } + } + x = V; + } else { + // Step 4: convert V with ECMA-262 ToNumber. + x = toNumber(V, options); + } + // Step 5: normalize -0 to +0. if (x === 0) { x = 0; } - // 6. If the conversion is to an IDL type associated with the [EnforceRange] - // extended attribute, then: - if (enforceRange) { - // 6.1. If x is NaN, +∞, or −∞, then throw a TypeError. - if (NumberIsNaN(x) || x === Infinity || x === -Infinity) { - throw new ERR_INVALID_ARG_VALUE(name, x); + // Step 6: [EnforceRange] rejects non-finite and out-of-range values. + if (options.enforceRange) { + // Step 6.1: reject NaN and infinities. + if (!NumberIsFinite(x)) { + throw makeException( + 'is not a finite number.', + options); } - // 6.2. Set x to IntegerPart(x). + + // Step 6.2: truncate to IntegerPart(x). x = integerPart(x); - // 6.3. If x < lowerBound or x > upperBound, then throw a TypeError. + // Steps 6.3-6.4: reject out-of-range values, otherwise return. if (x < lowerBound || x > upperBound) { - throw new ERR_INVALID_ARG_VALUE(name, x); + throw makeException( + `is outside the expected range of ${lowerBound} to ${upperBound}.`, + { __proto__: null, ...options, code: 'ERR_OUT_OF_RANGE' }); } - // 6.4. Return x. return x; } - // 7. If x is not NaN and the conversion is to an IDL type associated with - // the [Clamp] extended attribute, then: - if (clamp && !NumberIsNaN(x)) { - // 7.1. Set x to min(max(x, lowerBound), upperBound). + // Step 7: [Clamp] clamps, rounds, and returns non-NaN values. + if (options.clamp && !NumberIsNaN(x)) { + // Step 7.1: clamp x into the supported bounds. x = MathMin(MathMax(x, lowerBound), upperBound); + // Steps 7.2-7.3: round ties to even and return. + return evenRound(x); + } - // 7.2. Round x to the nearest integer, choosing the even integer if it - // lies halfway between two, and choosing +0 rather than −0. - x = evenRound(x); + // Step 8: NaN, +0, -0, and infinities become +0. + if (!NumberIsFinite(x) || x === 0) { + return 0; + } + + // Step 9: truncate to IntegerPart(x). + x = integerPart(x); - // 7.3. Return x. + // Steps 10-12 are an identity for values already in the step 1-3 + // bounds. For 64-bit conversions this only skips the safe-integer + // subset; values outside it still need exact BigInt modulo and the + // final Number approximation. + if (x >= lowerBound && x <= upperBound) { return x; } - // 8. If x is NaN, +0, +∞, or −∞, then return +0. - if (NumberIsNaN(x) || x === 0 || x === Infinity || x === -Infinity) { - return 0; + if (bitLength === 64) { + // Steps 10-12 still wrap over the full 2^64 IDL integer range. + // BigInt keeps x modulo 2^64 and the signed high-bit adjustment exact + // before this helper returns the JavaScript binding result. + let xBigInt = BigInt(x); + xBigInt = bigIntModulo(xBigInt, BIGINT_2_64); + + // For long long and unsigned long long values outside the safe-integer + // range, Web IDL says the JS Number value represents the closest numeric + // value, choosing the value with an even significand if there are two + // equally close values. Number(BigInt) performs that final approximation. + + // Step 11: wrap into the signed range when the high bit is set. + if (signed && xBigInt >= BIGINT_2_63) { + return Number(xBigInt - BIGINT_2_64); + } + + // Step 12: return the unsigned value. + return Number(xBigInt); } - // 9. Set x to IntegerPart(x). - x = integerPart(x); + // For 8/16/32-bit conversions, bitwise operators perform the same + // power-of-two wrapping as Web IDL step 10 for finite integer Numbers. + // The shifts narrow the unsigned value into the signed range when needed. + if (bitLength === 8) { + return signed ? (x << 24) >> 24 : x & 0xff; + } + if (bitLength === 16) { + return signed ? (x << 16) >> 16 : x & 0xffff; + } + if (bitLength === 32) { + return signed ? x | 0 : x >>> 0; + } - // 10. Set x to x modulo 2^bitLength. - x = modulo(x, pow2(bitLength)); + // Step 10: reduce modulo 2^bitLength. + const twoToTheBitLength = pow2(bitLength); + x = modulo(x, twoToTheBitLength); - // 11. If signedness is "signed" and x ≥ 2^(bitLength − 1), then return x − - // 2^bitLength. + // Step 11: wrap into the signed range when the high bit is set. if (signed && x >= pow2(bitLength - 1)) { - return x - pow2(bitLength); + return x - twoToTheBitLength; } - // 12. Otherwise, return x. + // Step 12: return the unsigned value. return x; } /** - * @see https://webidl.spec.whatwg.org/#es-DOMString - * @param {any} V - * @returns {string} + * Creates a converter for a Web IDL integer type. + * @param {number} bitLength Integer bit length. + * @param {'signed'|'unsigned'} [signedness] Integer signedness. + * @returns {Converter} */ -converters.DOMString = function DOMString(V) { - if (typeof V === 'symbol') { - throw new ERR_INVALID_ARG_VALUE('value', V); - } +function createIntegerConverter(bitLength, signedness = 'unsigned') { + return (V, options = kEmptyObject) => { + // Integer conversion step 1 calls ConvertToInt; step 2 returns + // the IDL value with the same numeric value. + return convertToInt(V, bitLength, signedness, options); + }; +} - return String(V); +/** + * Converts a JavaScript value to the IDL boolean type. + * @see https://webidl.spec.whatwg.org/#es-boolean + * @param {any} V JavaScript value. + * @returns {boolean} + */ +converters.boolean = (V) => { + // Web IDL boolean steps 1-2: ToBoolean(V), then return the same + // truth value as an IDL boolean. + return !!V; }; -converters['sequence'] = createSequenceConverter(converters.object); +/** + * Converts a JavaScript value to the IDL object type. + * @see https://webidl.spec.whatwg.org/#es-object + * @param {any} V JavaScript value. + * @param {ConversionOptions} [options] Conversion options. + * @returns {object|Function} + */ +converters.object = (V, options = kEmptyObject) => { + // Web IDL object step 1: throw unless V is an ECMA-262 Object. + if (type(V) !== 'Object') { + throw makeException( + 'is not an object.', + options, + ); + } + // Step 2: return a reference to the same object. + return V; +}; -function codedTypeError(message, errorProperties = kEmptyObject) { - // eslint-disable-next-line no-restricted-syntax - const err = new TypeError(message); - ObjectAssign(err, errorProperties); - return err; -} +/** + * Converts a JavaScript value to the IDL octet type. + * @see https://webidl.spec.whatwg.org/#es-octet + * @type {Converter} + */ +converters.octet = createIntegerConverter(8); -function makeException(message, opts = kEmptyObject) { - const prefix = opts.prefix ? opts.prefix + ': ' : ''; - const context = opts.context?.length === 0 ? - '' : (opts.context ?? 'Value') + ' '; - return codedTypeError( - `${prefix}${context}${message}`, - { code: opts.code || 'ERR_INVALID_ARG_TYPE' }, - ); +/** + * Converts a JavaScript value to the IDL unsigned short type. + * @see https://webidl.spec.whatwg.org/#es-unsigned-short + * @type {Converter} + */ +converters['unsigned short'] = createIntegerConverter(16); + +/** + * Converts a JavaScript value to the IDL unsigned long type. + * @see https://webidl.spec.whatwg.org/#es-unsigned-long + * @type {Converter} + */ +converters['unsigned long'] = createIntegerConverter(32); + +/** + * Converts a JavaScript value to the IDL long long type. + * @see https://webidl.spec.whatwg.org/#es-long-long + * @type {Converter} + */ +converters['long long'] = createIntegerConverter(64, 'signed'); + +/** + * Converts a JavaScript value to the IDL DOMString type. + * @see https://webidl.spec.whatwg.org/#es-DOMString + * @param {any} V JavaScript value. + * @param {ConversionOptions} [options] Conversion options. + * @returns {string} + */ +converters.DOMString = function DOMString(V, options = kEmptyObject) { + // Step 1 only applies to [LegacyNullToEmptyString], which this core + // converter does not implement. Steps 2-3 apply ToString(V) and + // return a DOMString with the same code units. + return toString(V, options); +}; + +/** + * Throws when a Web IDL operation receives too few arguments. + * @param {number} length Actual argument count. + * @param {number} required Required argument count. + * @param {ConversionOptions} [options] Conversion options. + * @returns {void} + */ +function requiredArguments(length, required, options = kEmptyObject) { + if (length < required) { + throw makeException( + `${required} argument${ + required === 1 ? '' : 's' + } required, but only ${length} present.`, + { __proto__: null, ...options, context: '', code: 'ERR_MISSING_ARGS' }); + } } +/** + * Creates a converter for a Web IDL enum type. + * @see https://webidl.spec.whatwg.org/#es-enumeration + * @param {string} name Enum identifier. + * @param {string[]} values Enum values. + * @returns {Converter} + */ function createEnumConverter(name, values) { - const E = new SafeSet(values); + const E = new SafeSet(new SafeArrayIterator(values)); - return function(V, opts = kEmptyObject) { - const S = String(V); + return function(V, options = kEmptyObject) { + // Web IDL enumeration step 1: convert V with ToString. + const S = toString(V, options); + // Step 2: throw unless S is one of the enumeration values. if (!E.has(S)) { throw makeException( - `value '${S}' is not a valid enum value of type ${name}.`, - { __proto__: null, ...opts, code: 'ERR_INVALID_ARG_VALUE' }); + `'${S}' is not a valid enum value of type ${name}.`, + { __proto__: null, ...options, code: 'ERR_INVALID_ARG_VALUE' }); } + // Step 3: return the matching enumeration value. return S; }; } -// https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values -function type(V) { - switch (typeof V) { - case 'undefined': - return UNDEFINED; - case 'boolean': - return BOOLEAN; - case 'number': - return NUMBER; - case 'string': - return STRING; - case 'symbol': - return SYMBOL; - case 'bigint': - return BIGINT; - case 'object': // Fall through - case 'function': // Fall through - default: - if (V === null) { - return NULL; - } - // Per ES spec, typeof returns an implementation-defined value that is not - // any of the existing ones for uncallable non-standard exotic objects. - // Yet Type() which the Web IDL spec depends on returns Object for such - // cases. So treat the default case as an object. - return OBJECT; - } +/** + * Returns the context used when converting a dictionary member. + * @param {string} key Dictionary member identifier. + * @param {ConversionOptions} options Conversion options. + * @returns {string} + */ +function dictionaryMemberContext(key, options) { + return options.context ? `${key} in ${options.context}` : key; } -// https://webidl.spec.whatwg.org/#js-dictionary -function createDictionaryConverter(members) { - // The spec requires us to operate the members of a dictionary in - // lexicographical order. We are doing this in the outer scope to - // reduce the overhead that could happen in the returned function. - const sortedMembers = ArrayPrototypeToSorted(members, (a, b) => { +/** + * Returns the context used when converting a sequence element. + * @param {number} index Sequence element index. + * @param {ConversionOptions} options Conversion options. + * @returns {string} + */ +function sequenceElementContext(index, options) { + return `${options.context ?? 'Value'}[${index}]`; +} + +/** + * Returns the message used for a missing required dictionary member. + * @param {string} dictionaryName Dictionary identifier. + * @param {string} key Dictionary member identifier. + * @returns {string} + */ +function missingDictionaryMemberMessage(dictionaryName, key) { + return `cannot be converted to '${dictionaryName}' because ` + + `'${key}' is required in '${dictionaryName}'.`; +} + +/** + * Creates a converter for a Web IDL dictionary type. + * @see https://webidl.spec.whatwg.org/#js-dictionary + * @param {string} dictionaryName Dictionary identifier. + * @param {DictionaryMember[]|DictionaryMember[][]} members Dictionary members, + * either for a single dictionary or grouped from least-derived to + * most-derived dictionary. + * @returns {Converter} + */ +function createDictionaryConverter( + dictionaryName, + members, +) { + const compareMembers = (a, b) => { if (a.key === b.key) { return 0; } return a.key < b.key ? -1 : 1; - }); + }; + + const dictionaries = ArrayIsArray(members[0]) ? members : [members]; + const sortedDictionaries = []; + + // Web IDL dictionary conversion steps 3-4 process inherited dictionaries + // from least-derived to most-derived and sort only within each dictionary. + // Callers with inheritance pass one member array per dictionary level. + for (let i = 0; i < dictionaries.length; i++) { + ArrayPrototypePush( + sortedDictionaries, + ArrayPrototypeToSorted(dictionaries[i], compareMembers), + ); + } - return function( - V, - opts = kEmptyObject, - ) { - if (V != null && type(V) !== OBJECT) { + return function(jsDict, options = kEmptyObject) { + // Step 1: reject non-object, non-null, non-undefined values. + if (jsDict != null && type(jsDict) !== 'Object') { throw makeException( 'cannot be converted to a dictionary', - opts, + options, ); } + // Step 2: create the IDL dictionary value. const idlDict = { __proto__: null }; - for (let i = 0; i < sortedMembers.length; i++) { - const member = sortedMembers[i]; - const key = member.key; - let jsMemberValue; - if (V == null) { - jsMemberValue = undefined; - } else { - jsMemberValue = V[key]; - } - if (jsMemberValue !== undefined) { - const memberContext = opts.context ? `${key} in ${opts.context}` : `${key}`; - const converter = member.converter; - const idlMemberValue = converter( - jsMemberValue, - { - __proto__: null, - prefix: opts.prefix, - context: memberContext, - }, - ); - idlDict[key] = idlMemberValue; - } else if (typeof member.defaultValue === 'function') { - const idlMemberValue = member.defaultValue(); - idlDict[key] = idlMemberValue; - } else if (member.required) { - throw makeException( - `cannot be converted because of the missing '${key}'`, - opts, - ); + // Steps 3-4: iterate each dictionary level, then its sorted members. + for (let i = 0; i < sortedDictionaries.length; i++) { + const sortedMembers = sortedDictionaries[i]; + for (let j = 0; j < sortedMembers.length; j++) { + const member = sortedMembers[j]; + // Step 4.1.1: get the dictionary member identifier. + const key = member.key; + // Steps 4.1.2-4.1.3: read the JavaScript member value. + const jsMemberValue = jsDict == null ? undefined : jsDict[key]; + + // Step 4.1.4: convert and store present member values. + if (jsMemberValue !== undefined) { + const converter = member.converter; + // Step 4.1.4.1: convert the JavaScript value to IDL. + const idlMemberValue = converter( + jsMemberValue, + { + __proto__: null, + ...options, + context: dictionaryMemberContext(key, options), + }, + ); + // Validators are a Node.js extension after conversion. They let + // consumers reject known unsupported values while dictionary + // conversion still has precise member context. Web Crypto uses this + // so SubtleCrypto.supports() can make accurate decisions from + // normalized dictionaries instead of probing by running operations. + member.validator?.(idlMemberValue, jsDict); + // Step 4.1.4.2: set idlDict[key] to the IDL value. + idlDict[key] = idlMemberValue; + } else if (typeof member.defaultValue === 'function') { + // Step 4.1.5: store the member default value. + idlDict[key] = member.defaultValue(); + } else if (member.required) { + // Step 4.1.6: required missing members throw. + throw makeException( + missingDictionaryMemberMessage(dictionaryName, key), + { __proto__: null, ...options, code: 'ERR_MISSING_OPTION' }); + } } } + // Step 5: return the IDL dictionary. return idlDict; }; } -// https://webidl.spec.whatwg.org/#es-sequence +/** + * Creates a converter for a Web IDL sequence type. + * @see https://webidl.spec.whatwg.org/#es-sequence + * @param {Converter} converter Element converter. + * @returns {Converter} + */ function createSequenceConverter(converter) { - return function(V, opts = kEmptyObject) { - if (type(V) !== OBJECT) { + return function(V, options = kEmptyObject) { + // Web IDL sequence conversion step 1: require an ECMA-262 Object. + if (type(V) !== 'Object') { throw makeException( - 'can not be converted to sequence.', - opts); + 'cannot be converted to sequence.', + options); } - const iter = V?.[SymbolIterator]?.(); - if (iter === undefined) { + + // Step 2: GetMethod(V, %Symbol.iterator%). + const method = V[SymbolIterator]; + // Step 3: throw if the iterator method is undefined, null, or not callable. + if (typeof method !== 'function') { throw makeException( - 'can not be converted to sequence.', - opts); + 'cannot be converted to sequence.', + options); } - const array = []; + + // Step 4 and create-sequence step 1: get the iterator record. + const iterator = FunctionPrototypeCall(method, V); + const nextMethod = iterator?.next; + if (typeof nextMethod !== 'function') { + throw makeException( + 'cannot be converted to sequence.', + options); + } + + // Create-sequence step 2: initialize i to 0. + const idlSequence = []; while (true) { - const res = iter?.next?.(); - if (res === undefined) { + // Step 3.1: IteratorStepValue(iteratorRecord). + const next = FunctionPrototypeCall(nextMethod, iterator); + if (type(next) !== 'Object') { throw makeException( - 'can not be converted to sequence.', - opts); + 'cannot be converted to sequence.', + options); } - if (res.done === true) break; - const val = converter(res.value, { + // Step 3.2: IteratorComplete applies ToBoolean(done). + if (next.done) { + break; + } + // Step 3.3: convert next to an IDL value of type T. + const idlValue = converter(next.value, { __proto__: null, - ...opts, - context: `${opts.context}[${array.length}]`, + ...options, + context: sequenceElementContext(idlSequence.length, options), }); - ArrayPrototypePush(array, val); - }; - return array; + // Step 3.4: store the value and advance i. + ArrayPrototypePush(idlSequence, idlValue); + } + return idlSequence; }; } -// https://webidl.spec.whatwg.org/#js-interface -function createInterfaceConverter(name, I) { - return (V, opts = kEmptyObject) => { - // 1. If V implements I, then return the IDL interface type value that - // represents a reference to that platform object. - if (ObjectPrototypeIsPrototypeOf(I, V)) return V; - // 2. Throw a TypeError. - throw new ERR_INVALID_ARG_TYPE( - typeof opts.context === 'string' ? opts.context : 'value', name, V, - ); +/** + * Creates a converter for a Web IDL interface type. + * @see https://webidl.spec.whatwg.org/#js-interface + * @param {string} name Interface identifier. + * @param {object} prototype Interface prototype object. + * @returns {Converter} + */ +function createInterfaceConverter(name, prototype) { + return (V, options = kEmptyObject) => { + // Web IDL interface conversion step 1: return V if it implements I. + if (ObjectPrototypeIsPrototypeOf(prototype, V)) { + return V; + } + // Step 2: otherwise throw. + throw makeException( + `is not of type ${name}.`, + options); }; } -// Returns the [[ViewedArrayBuffer]] of an ArrayBufferView without leaving JS. +/** + * Returns the ArrayBuffer or SharedArrayBuffer viewed by a typed array or + * DataView. + * @param {ArrayBufferView} V TypedArray or DataView. + * @returns {ArrayBuffer|SharedArrayBuffer} + */ function getViewedArrayBuffer(V) { + // Buffer view conversion steps read V.[[ViewedArrayBuffer]]. return isTypedArray(V) ? TypedArrayPrototypeGetBuffer(V) : DataViewPrototypeGetBuffer(V); } -// Returns `true` if `buffer` is a `SharedArrayBuffer`. Uses a brand check via -// the `ArrayBuffer.prototype.byteLength` getter, which succeeds only on real -// (non-shared) ArrayBuffers and throws on SharedArrayBuffers — independent -// of the receiver's prototype chain. -function isSharedArrayBufferBacking(buffer) { +/** + * Validates [AllowShared] and [AllowResizable] backing-store constraints. + * @param {ArrayBuffer|SharedArrayBuffer} buffer Backing buffer. + * @param {ConversionOptions} options Conversion options. + * @returns {void} + */ +function validateBufferSourceBacking(buffer, options) { + let resizable; try { - ArrayBufferPrototypeGetByteLength(buffer); - return false; + // ArrayBuffer.prototype.resizable is an ArrayBuffer brand check and the + // [AllowResizable] value we need. For SharedArrayBuffer-backed views it + // throws, which lets this path avoid a separate IsSharedArrayBuffer check. + // BufferSource has separate inline logic because [AllowShared] cannot be + // used with that typedef. + resizable = ArrayBufferPrototypeGetResizable(buffer); } catch { - return true; + // ArrayBufferView conversion step 2: reject SharedArrayBuffer + // backing stores unless [AllowShared] is present. + if (!options.allowShared) { + throw makeException( + 'is a view on a SharedArrayBuffer, which is not allowed.', + options); + } + // Step 3: reject non-fixed SharedArrayBuffer backing stores unless + // [AllowResizable] is present. + validateAllowGrowableSharedArrayBuffer(buffer, options); + return; + } + + // ArrayBuffer conversion step 3 and ArrayBufferView conversion step 3: + // reject non-fixed ArrayBuffer backing stores unless [AllowResizable] + // is present. + validateAllowResizableArrayBuffer(resizable, options); +} + +/** + * Validates the [AllowResizable] constraint for growable SharedArrayBuffer. + * @param {SharedArrayBuffer} buffer SharedArrayBuffer backing buffer. + * @param {ConversionOptions} options Conversion options. + * @returns {void} + */ +function validateAllowGrowableSharedArrayBuffer(buffer, options) { + // SharedArrayBuffer and ArrayBufferView conversion step 3: + // IsFixedLengthArrayBuffer(buffer) must be true without [AllowResizable]. + // Do not use a primordial getter here. When this module is included in the + // startup snapshot, an early-captured SharedArrayBuffer.prototype.growable + // getter does not detect growable buffers created after deserialization. + // Lazily capturing the getter would work, but it would observe the runtime + // prototype at first comparison, so it would not be an actual primordial. + if (!options.allowResizable && buffer.growable) { + throw makeException( + 'is backed by a growable SharedArrayBuffer, which is not allowed.', + options); } } -// https://webidl.spec.whatwg.org/#ArrayBufferView -converters.ArrayBufferView = (V, opts = kEmptyObject) => { - if (!ArrayBufferIsView(V)) { +/** + * Validates the [AllowResizable] constraint for resizable ArrayBuffer. + * @param {boolean} resizable ArrayBuffer [[ArrayBufferResizable]] value. + * @param {ConversionOptions} options Conversion options. + * @returns {void} + */ +function validateAllowResizableArrayBuffer(resizable, options) { + // ArrayBuffer and ArrayBufferView conversion step 3: + // IsFixedLengthArrayBuffer(buffer) must be true without [AllowResizable]. + // Read [[ArrayBufferResizable]] first so fixed buffers skip the options + // property lookup on this hot path. + if (resizable && !options.allowResizable) { throw makeException( - 'is not an ArrayBufferView.', - opts); + 'is backed by a resizable ArrayBuffer, which is not allowed.', + options); } - if (isSharedArrayBufferBacking(getViewedArrayBuffer(V))) { +} + +/** + * Converts a JavaScript value to the IDL Uint8Array type. + * @param {any} V JavaScript value. + * @param {ConversionOptions} [options] Conversion options. + * @returns {Uint8Array} + */ +converters.Uint8Array = (V, options = kEmptyObject) => { + // Typed array conversion steps 1-2: T is Uint8Array, and V must + // have [[TypedArrayName]] equal to "Uint8Array". + if (!ArrayBufferIsView(V) || + TypedArrayPrototypeGetSymbolToStringTag(V) !== 'Uint8Array') { throw makeException( - 'is a view on a SharedArrayBuffer, which is not allowed.', - opts); + 'is not an Uint8Array object.', + options); } + // Steps 3-4: validate [AllowShared] and [AllowResizable]. + validateBufferSourceBacking(TypedArrayPrototypeGetBuffer(V), options); + // Step 5: return a reference to the same object. return V; }; -// https://webidl.spec.whatwg.org/#BufferSource -converters.BufferSource = (V, opts = kEmptyObject) => { +/** + * Converts a JavaScript value to the IDL BufferSource typedef. + * @see https://webidl.spec.whatwg.org/#BufferSource + * @param {any} V JavaScript value. + * @param {ConversionOptions} [options] Conversion options. + * @returns {ArrayBuffer|ArrayBufferView} + */ +converters.BufferSource = (V, options = kEmptyObject) => { + // BufferSource is a typedef for (ArrayBufferView or ArrayBuffer). + // [AllowShared] cannot be used with BufferSource because the ArrayBuffer + // union branch does not support it. Use AllowSharedBufferSource instead. if (ArrayBufferIsView(V)) { - if (isSharedArrayBufferBacking(getViewedArrayBuffer(V))) { + const buffer = getViewedArrayBuffer(V); + // ArrayBufferView conversion steps 2-4: validate the viewed buffer + // and return a reference to the same view. + // Keep this logic inline instead of calling validateBufferSourceBacking(). + // BufferSource conversion is hot, and this avoids a helper call while still + // using a primordial getter for the backing-buffer internal-slot check. + // Unlike validateBufferSourceBacking(), this intentionally ignores + // options.allowShared because [AllowShared] cannot be used with + // BufferSource. + let resizable; + try { + // ArrayBuffer.prototype.resizable is both the ArrayBuffer brand check + // and the step 3 value. It throws for SharedArrayBuffer, which lets this + // path reject SAB-backed views without an extra byteLength getter call. + resizable = ArrayBufferPrototypeGetResizable(buffer); + } catch { throw makeException( 'is a view on a SharedArrayBuffer, which is not allowed.', - opts); + options); + } + if (resizable && !options.allowResizable) { + throw makeException( + 'is backed by a resizable ArrayBuffer, which is not allowed.', + options); } - return V; } - if (!isArrayBuffer(V)) { + // ArrayBuffer conversion steps 1-2: require a non-shared ArrayBuffer. + // Use the primordial resizable getter as both the ArrayBuffer brand check + // and the step 3 value. This avoids isArrayBuffer(V) followed by another + // getter call, and rejects SharedArrayBuffer on this union branch. + let resizable; + try { + resizable = ArrayBufferPrototypeGetResizable(V); + } catch { throw makeException( 'is not instance of ArrayBuffer, Buffer, TypedArray, or DataView.', - opts); + options); } + // ArrayBuffer conversion step 3: validate [AllowResizable]. + // ArrayBufferPrototypeGetResizable(V) already excluded SharedArrayBuffer, + // so no [AllowShared] validation is needed on this branch. + if (resizable && !options.allowResizable) { + throw makeException( + 'is backed by a resizable ArrayBuffer, which is not allowed.', + options); + } + + // Step 4: return a reference to the same ArrayBuffer. return V; }; +/** + * Converts a JavaScript value to the IDL AllowSharedBufferSource typedef. + * @see https://webidl.spec.whatwg.org/#AllowSharedBufferSource + * @param {any} V JavaScript value. + * @param {ConversionOptions} [options] Conversion options. + * @returns {ArrayBuffer|SharedArrayBuffer|ArrayBufferView} + */ +converters.AllowSharedBufferSource = (V, options = kEmptyObject) => { + // AllowSharedBufferSource is a typedef for + // (ArrayBuffer or SharedArrayBuffer or [AllowShared] ArrayBufferView). + // The union branches are disjoint, so this keeps the hot view path first. + if (ArrayBufferIsView(V)) { + const buffer = getViewedArrayBuffer(V); + let resizable; + try { + resizable = ArrayBufferPrototypeGetResizable(buffer); + } catch { + validateAllowGrowableSharedArrayBuffer(buffer, options); + return V; + } + validateAllowResizableArrayBuffer(resizable, options); + return V; + } + + let resizable; + try { + resizable = ArrayBufferPrototypeGetResizable(V); + } catch { + if (isSharedArrayBuffer(V)) { + validateAllowGrowableSharedArrayBuffer(V, options); + return V; + } + throw makeException( + 'is not instance of ArrayBuffer, SharedArrayBuffer, Buffer, ' + + 'TypedArray, or DataView.', + options); + } + + validateAllowResizableArrayBuffer(resizable, options); + return V; +}; + +/** + * Converts a JavaScript value to the IDL sequence type. + * @see https://webidl.spec.whatwg.org/#es-sequence + * @type {Converter} + */ +converters['sequence'] = + createSequenceConverter(converters.DOMString); + +/** + * Converts a JavaScript value to the IDL sequence type. + * @see https://webidl.spec.whatwg.org/#es-sequence + * @type {Converter} + */ +converters['sequence'] = + createSequenceConverter(converters.object); + module.exports = { - type, converters, convertToInt, + createDictionaryConverter, createEnumConverter, createInterfaceConverter, createSequenceConverter, - createDictionaryConverter, - evenRound, - makeException, + requiredArguments, + type, }; diff --git a/lib/internal/worker/js_transferable.js b/lib/internal/worker/js_transferable.js index 6acc0a3b19a3cc..0ae80d9a728725 100644 --- a/lib/internal/worker/js_transferable.js +++ b/lib/internal/worker/js_transferable.js @@ -100,6 +100,7 @@ function markTransferMode(obj, cloneable = false, transferable = false) { webidl.converters.StructuredSerializeOptions = webidl .createDictionaryConverter( + 'StructuredSerializeOptions', [ { key: 'transfer', diff --git a/test/fixtures/webcrypto/supports-modern-algorithms.mjs b/test/fixtures/webcrypto/supports-modern-algorithms.mjs index 62b90daf7b0463..0572107e9f492e 100644 --- a/test/fixtures/webcrypto/supports-modern-algorithms.mjs +++ b/test/fixtures/webcrypto/supports-modern-algorithms.mjs @@ -168,19 +168,22 @@ export const vectors = { 'Argon2id'], ], 'deriveBits': [ - [argon2, { name: 'Argon2d', nonce: Buffer.alloc(0), parallelism: 1, memory: 8, passes: 1 }, 32], - [argon2, { name: 'Argon2d', nonce: Buffer.alloc(0), parallelism: 2, memory: 16, passes: 1 }, 32], - [argon2, { name: 'Argon2d', nonce: Buffer.alloc(0), parallelism: 1, memory: 8, passes: 1, secretValue: Buffer.alloc(0) }, 32], - [argon2, { name: 'Argon2d', nonce: Buffer.alloc(0), parallelism: 1, memory: 8, passes: 1, associatedData: Buffer.alloc(0) }, 32], - [argon2, { name: 'Argon2d', nonce: Buffer.alloc(0), parallelism: 1, memory: 8, passes: 1, version: 0x13 }, 32], - [false, { name: 'Argon2d', nonce: Buffer.alloc(0), parallelism: 1, memory: 8, passes: 1, version: 0x14 }, 32], - [false, { name: 'Argon2d', nonce: Buffer.alloc(0), parallelism: 1, memory: 7, passes: 1 }, 32], - [false, { name: 'Argon2d', nonce: Buffer.alloc(0), parallelism: 2, memory: 15, passes: 1 }, 32], - [false, { name: 'Argon2d', nonce: Buffer.alloc(0), parallelism: 1, memory: 8, passes: 1 }, null], - [false, { name: 'Argon2d', nonce: Buffer.alloc(0), parallelism: 1, memory: 8, passes: 1 }, 24], - [false, { name: 'Argon2d', nonce: Buffer.alloc(0), parallelism: 1, memory: 8, passes: 1 }, 31], - [false, { name: 'Argon2d', nonce: Buffer.alloc(0), parallelism: 0, memory: 8, passes: 1 }, 32], - [false, { name: 'Argon2d', nonce: Buffer.alloc(0), parallelism: 16777215, memory: 8, passes: 1 }, 32], + [argon2, { name: 'Argon2d', nonce: Buffer.alloc(8), parallelism: 1, memory: 8, passes: 1 }, 32], + [false, { name: 'Argon2d', nonce: Buffer.alloc(8), parallelism: 1, memory: 8, passes: 0 }, 32], + [false, { name: 'Argon2d', nonce: Buffer.alloc(7), parallelism: 1, memory: 8, passes: 1 }, 32], + [argon2, { name: 'Argon2d', nonce: Buffer.alloc(8), parallelism: 1, memory: 8, passes: 1 }, 32], + [argon2, { name: 'Argon2d', nonce: Buffer.alloc(8), parallelism: 2, memory: 16, passes: 1 }, 32], + [argon2, { name: 'Argon2d', nonce: Buffer.alloc(8), parallelism: 1, memory: 8, passes: 1, secretValue: Buffer.alloc(0) }, 32], + [argon2, { name: 'Argon2d', nonce: Buffer.alloc(8), parallelism: 1, memory: 8, passes: 1, associatedData: Buffer.alloc(0) }, 32], + [argon2, { name: 'Argon2d', nonce: Buffer.alloc(8), parallelism: 1, memory: 8, passes: 1, version: 0x13 }, 32], + [false, { name: 'Argon2d', nonce: Buffer.alloc(8), parallelism: 1, memory: 8, passes: 1, version: 0x14 }, 32], + [false, { name: 'Argon2d', nonce: Buffer.alloc(8), parallelism: 1, memory: 7, passes: 1 }, 32], + [false, { name: 'Argon2d', nonce: Buffer.alloc(8), parallelism: 2, memory: 15, passes: 1 }, 32], + [false, { name: 'Argon2d', nonce: Buffer.alloc(8), parallelism: 1, memory: 8, passes: 1 }, null], + [false, { name: 'Argon2d', nonce: Buffer.alloc(8), parallelism: 1, memory: 8, passes: 1 }, 24], + [false, { name: 'Argon2d', nonce: Buffer.alloc(8), parallelism: 1, memory: 8, passes: 1 }, 31], + [false, { name: 'Argon2d', nonce: Buffer.alloc(8), parallelism: 0, memory: 8, passes: 1 }, 32], + [false, { name: 'Argon2d', nonce: Buffer.alloc(8), parallelism: 16777215, memory: 8, passes: 1 }, 32], ], 'encrypt': [ [chacha, { name: 'ChaCha20-Poly1305', iv: Buffer.alloc(12) }], diff --git a/test/parallel/test-abortsignal-any.mjs b/test/parallel/test-abortsignal-any.mjs index 19b5569c4779d1..ff5226055b866c 100644 --- a/test/parallel/test-abortsignal-any.mjs +++ b/test/parallel/test-abortsignal-any.mjs @@ -16,7 +16,7 @@ describe('AbortSignal.any()', { concurrency: !process.env.TEST_PARALLEL }, () => () => AbortSignal.any([AbortSignal.abort(), undefined]), { code: 'ERR_INVALID_ARG_TYPE', - message: 'The "signals[1]" argument must be an instance of AbortSignal. Received undefined' + message: 'signals[1] is not of type AbortSignal.', }, ); }); diff --git a/test/parallel/test-blob.js b/test/parallel/test-blob.js index 8ce1c53012ddcc..dd74b244420f2a 100644 --- a/test/parallel/test-blob.js +++ b/test/parallel/test-blob.js @@ -157,6 +157,22 @@ assert.throws(() => new Blob({}), { assert.strictEqual(b.type, ''); } +{ + const b = new Blob(['hello']); + + assert.throws(() => b.slice(1n), { + name: 'TypeError', + code: 'ERR_INVALID_ARG_TYPE', + message: 'start is a BigInt and cannot be converted to a number.', + }); + + assert.throws(() => b.slice(0, Symbol()), { + name: 'TypeError', + code: 'ERR_INVALID_ARG_TYPE', + message: 'end is a Symbol and cannot be converted to a number.', + }); +} + { const b = new Blob([Buffer.from('hello'), Buffer.from('world')]); const mc = new MessageChannel(); diff --git a/test/parallel/test-internal-webidl-buffer-source.js b/test/parallel/test-internal-webidl-buffer-source.js index 2fb529edcde1b7..9e522d7d7b8a6e 100644 --- a/test/parallel/test-internal-webidl-buffer-source.js +++ b/test/parallel/test-internal-webidl-buffer-source.js @@ -4,6 +4,7 @@ require('../common'); const assert = require('assert'); const { test } = require('node:test'); +const vm = require('vm'); const { converters } = require('internal/webidl'); @@ -15,6 +16,18 @@ const TYPED_ARRAY_CTORS = [ BigInt64Array, BigUint64Array, ]; +function createGrowableSharedArrayBufferView(Ctor) { + const buffer = createGrowableSharedArrayBuffer(); + const view = new Ctor(buffer); + return view; +} + +function createGrowableSharedArrayBuffer() { + const buffer = new SharedArrayBuffer(0, { maxByteLength: 1 }); + assert.strictEqual(buffer.growable, true); + return buffer; +} + test('BufferSource accepts ArrayBuffer', () => { const ab = new ArrayBuffer(8); assert.strictEqual(converters.BufferSource(ab), ab); @@ -37,6 +50,28 @@ test('BufferSource accepts DataView', () => { assert.strictEqual(converters.BufferSource(dv), dv); }); +test('BufferSource accepts cross-realm buffer sources', () => { + const context = vm.createContext(); + + { + const ab = vm.runInContext('new ArrayBuffer(0)', context); + assert.strictEqual(converters.BufferSource(ab), ab); + } + + { + const dv = vm.runInContext('new DataView(new ArrayBuffer(0))', context); + assert.strictEqual(converters.BufferSource(dv), dv); + } + + for (const Ctor of TYPED_ARRAY_CTORS) { + const ta = vm.runInContext( + `new ${Ctor.name}(new ArrayBuffer(0))`, + context, + ); + assert.strictEqual(converters.BufferSource(ta), ta); + } +}); + test('BufferSource accepts ArrayBuffer subclass instance', () => { class MyAB extends ArrayBuffer {} const sub = new MyAB(8); @@ -74,6 +109,10 @@ test('BufferSource rejects SAB-backed TypedArray', () => { () => converters.BufferSource(view), { code: 'ERR_INVALID_ARG_TYPE' }, ); + assert.throws( + () => converters.BufferSource(view, { allowShared: true }), + { code: 'ERR_INVALID_ARG_TYPE' }, + ); }); test('BufferSource rejects SAB-backed DataView', () => { @@ -82,6 +121,10 @@ test('BufferSource rejects SAB-backed DataView', () => { () => converters.BufferSource(dv), { code: 'ERR_INVALID_ARG_TYPE' }, ); + assert.throws( + () => converters.BufferSource(dv, { allowShared: true }), + { code: 'ERR_INVALID_ARG_TYPE' }, + ); }); test('BufferSource rejects SAB view whose buffer prototype was reassigned', () => { @@ -101,107 +144,154 @@ test('BufferSource accepts a detached ArrayBuffer', () => { assert.strictEqual(converters.BufferSource(ab), ab); }); -test('BufferSource rejects objects with a forged @@toStringTag', () => { - const fake = { [Symbol.toStringTag]: 'Uint8Array' }; +test('BufferSource rejects resizable ArrayBuffer by default', () => { + const ab = new ArrayBuffer(0, { maxByteLength: 1 }); assert.throws( - () => converters.BufferSource(fake), + () => converters.BufferSource(ab), { code: 'ERR_INVALID_ARG_TYPE' }, ); }); -for (const value of [null, undefined, 0, 1, 1n, '', 'x', true, Symbol('s'), [], - {}, () => {}]) { - test(`BufferSource rejects ${typeof value} ${String(value)}`, () => { +test('BufferSource handles resizable-backed views with explicit options', () => { + for (const Ctor of [DataView, ...TYPED_ARRAY_CTORS]) { + { + const view = new Ctor(new ArrayBuffer(0, { maxByteLength: 1 })); + assert.throws( + () => converters.BufferSource(view), + { code: 'ERR_INVALID_ARG_TYPE' }, + ); + } + + { + const view = new Ctor(new ArrayBuffer(0, { maxByteLength: 1 })); + assert.throws( + () => converters.BufferSource(view, { allowResizable: false }), + { code: 'ERR_INVALID_ARG_TYPE' }, + ); + } + + { + const view = new Ctor(new ArrayBuffer(0, { maxByteLength: 1 })); + assert.strictEqual(converters.BufferSource(view, { + allowResizable: true, + }), view); + } + } +}); + +test('BufferSource rejects SAB-backed views with explicit options', () => { + for (const Ctor of [DataView, ...TYPED_ARRAY_CTORS]) { + const view = createGrowableSharedArrayBufferView(Ctor); assert.throws( - () => converters.BufferSource(value), + () => converters.BufferSource(view, { + allowShared: true, + allowResizable: true, + }), { code: 'ERR_INVALID_ARG_TYPE' }, ); - }); -} - -test('ArrayBufferView accepts all TypedArray kinds', () => { - for (const Ctor of TYPED_ARRAY_CTORS) { - const ta = new Ctor(4); - assert.strictEqual(converters.ArrayBufferView(ta), ta); } }); -test('ArrayBufferView accepts DataView', () => { - const dv = new DataView(new ArrayBuffer(8)); - assert.strictEqual(converters.ArrayBufferView(dv), dv); -}); +test('AllowSharedBufferSource accepts ArrayBuffer and SharedArrayBuffer', () => { + const ab = new ArrayBuffer(8); + const sab = new SharedArrayBuffer(8); -test('ArrayBufferView accepts TypedArray subclass instance', () => { - class MyU8 extends Uint8Array {} - const sub = new MyU8(4); - assert.strictEqual(converters.ArrayBufferView(sub), sub); + assert.strictEqual(converters.AllowSharedBufferSource(ab), ab); + assert.strictEqual(converters.AllowSharedBufferSource(sab), sab); }); -test('ArrayBufferView accepts TypedArray with null prototype', () => { - const ta = new Uint8Array(4); - Object.setPrototypeOf(ta, null); - assert.strictEqual(converters.ArrayBufferView(ta), ta); -}); +test('AllowSharedBufferSource accepts cross-realm buffers', () => { + const context = vm.createContext(); + const ab = vm.runInContext('new ArrayBuffer(0)', context); + const sab = vm.runInContext('new SharedArrayBuffer(0)', context); -test('ArrayBufferView accepts DataView with null prototype', () => { - const dv = new DataView(new ArrayBuffer(4)); - Object.setPrototypeOf(dv, null); - assert.strictEqual(converters.ArrayBufferView(dv), dv); + assert.strictEqual(converters.AllowSharedBufferSource(ab), ab); + assert.strictEqual(converters.AllowSharedBufferSource(sab), sab); }); -test('ArrayBufferView rejects raw ArrayBuffer', () => { - assert.throws( - () => converters.ArrayBufferView(new ArrayBuffer(4)), - { code: 'ERR_INVALID_ARG_TYPE' }, - ); -}); +test('AllowSharedBufferSource accepts ArrayBuffer and SharedArrayBuffer views', () => { + const abView = new Uint8Array(new ArrayBuffer(8)); + const sabView = new Uint8Array(new SharedArrayBuffer(8)); + const abDataView = new DataView(new ArrayBuffer(8)); + const sabDataView = new DataView(new SharedArrayBuffer(8)); -test('ArrayBufferView rejects raw SharedArrayBuffer', () => { - assert.throws( - () => converters.ArrayBufferView(new SharedArrayBuffer(4)), - { code: 'ERR_INVALID_ARG_TYPE' }, - ); + assert.strictEqual(converters.AllowSharedBufferSource(abView), abView); + assert.strictEqual(converters.AllowSharedBufferSource(sabView), sabView); + assert.strictEqual( + converters.AllowSharedBufferSource(abDataView), abDataView); + assert.strictEqual( + converters.AllowSharedBufferSource(sabDataView), sabDataView); }); -test('ArrayBufferView rejects SAB-backed TypedArray', () => { - const view = new Uint8Array(new SharedArrayBuffer(4)); - assert.throws( - () => converters.ArrayBufferView(view), - { code: 'ERR_INVALID_ARG_TYPE' }, - ); -}); +test('AllowSharedBufferSource handles resizable buffers with explicit options', () => { + const ab = new ArrayBuffer(0, { maxByteLength: 1 }); + const views = [new Uint8Array(ab), new DataView(ab)]; -test('ArrayBufferView rejects SAB-backed DataView', () => { - const dv = new DataView(new SharedArrayBuffer(4)); assert.throws( - () => converters.ArrayBufferView(dv), + () => converters.AllowSharedBufferSource(ab), { code: 'ERR_INVALID_ARG_TYPE' }, ); + for (const view of views) { + assert.throws( + () => converters.AllowSharedBufferSource(view), + { code: 'ERR_INVALID_ARG_TYPE' }, + ); + } + assert.strictEqual(converters.AllowSharedBufferSource(ab, { + allowResizable: true, + }), ab); + for (const view of views) { + assert.strictEqual(converters.AllowSharedBufferSource(view, { + allowResizable: true, + }), view); + } }); -test('ArrayBufferView rejects SAB view whose buffer prototype was reassigned', () => { - const sab = new SharedArrayBuffer(4); - Object.setPrototypeOf(sab, ArrayBuffer.prototype); - const view = new Uint8Array(sab); +test('AllowSharedBufferSource handles growable shared buffers with explicit ' + + 'options', () => { + const sab = createGrowableSharedArrayBuffer(); + const views = [new Uint8Array(sab), new DataView(sab)]; + assert.throws( - () => converters.ArrayBufferView(view), + () => converters.AllowSharedBufferSource(sab), { code: 'ERR_INVALID_ARG_TYPE' }, ); + for (const view of views) { + assert.throws( + () => converters.AllowSharedBufferSource(view), + { code: 'ERR_INVALID_ARG_TYPE' }, + ); + } + assert.strictEqual(converters.AllowSharedBufferSource(sab, { + allowResizable: true, + }), sab); + for (const view of views) { + assert.strictEqual(converters.AllowSharedBufferSource(view, { + allowResizable: true, + }), view); + } }); -test('ArrayBufferView rejects objects with a forged @@toStringTag', () => { +test('BufferSource rejects objects with a forged @@toStringTag', () => { const fake = { [Symbol.toStringTag]: 'Uint8Array' }; assert.throws( - () => converters.ArrayBufferView(fake), + () => converters.BufferSource(fake), { code: 'ERR_INVALID_ARG_TYPE' }, ); }); for (const value of [null, undefined, 0, 1, 1n, '', 'x', true, Symbol('s'), [], {}, () => {}]) { - test(`ArrayBufferView rejects ${typeof value} ${String(value)}`, () => { + test(`BufferSource rejects ${typeof value} ${String(value)}`, () => { + assert.throws( + () => converters.BufferSource(value), + { code: 'ERR_INVALID_ARG_TYPE' }, + ); + }); + + test(`AllowSharedBufferSource rejects ${typeof value} ${String(value)}`, () => { assert.throws( - () => converters.ArrayBufferView(value), + () => converters.AllowSharedBufferSource(value), { code: 'ERR_INVALID_ARG_TYPE' }, ); }); diff --git a/test/parallel/test-internal-webidl-converttoint.js b/test/parallel/test-internal-webidl-converttoint.js index 7e7c024387a0ec..4c2032dc8354d1 100644 --- a/test/parallel/test-internal-webidl-converttoint.js +++ b/test/parallel/test-internal-webidl-converttoint.js @@ -3,56 +3,360 @@ require('../common'); const assert = require('assert'); -const { convertToInt, evenRound } = require('internal/webidl'); +const { convertToInt } = require('internal/webidl'); -assert.strictEqual(evenRound(-0.5), 0); -assert.strictEqual(evenRound(0.5), 0); -assert.strictEqual(evenRound(-1.5), -2); -assert.strictEqual(evenRound(1.5), 2); -assert.strictEqual(evenRound(3.4), 3); -assert.strictEqual(evenRound(4.6), 5); -assert.strictEqual(evenRound(5), 5); -assert.strictEqual(evenRound(6), 6); +function assertPlainTypeError(fn) { + assert.throws(fn, (err) => { + assert(err instanceof TypeError); + assert.strictEqual(err.name, 'TypeError'); + assert.strictEqual(err.code, undefined); + return true; + }); +} + +function assertSameError(fn, expected) { + assert.throws(fn, (err) => { + assert.strictEqual(err, expected); + return true; + }); +} // https://webidl.spec.whatwg.org/#abstract-opdef-converttoint -assert.strictEqual(convertToInt('x', 0, 64), 0); -assert.strictEqual(convertToInt('x', 1, 64), 1); -assert.strictEqual(convertToInt('x', -0.5, 64), 0); -assert.strictEqual(convertToInt('x', -0.5, 64, { signed: true }), 0); -assert.strictEqual(convertToInt('x', -1.5, 64, { signed: true }), -1); +const two63 = 2 ** 63; +const two64 = 2 ** 64; + +assert.strictEqual(convertToInt(0, 64), 0); +assert.strictEqual(convertToInt(1, 64), 1); +assert.strictEqual(convertToInt(-0.5, 64), 0); +assert.strictEqual(convertToInt(-0.5, 64, 'signed'), 0); +assert.strictEqual(convertToInt(-1.5, 64, 'signed'), -1); +assert.strictEqual(convertToInt(2 ** 12 + 1, 12), 1); +assert.strictEqual(convertToInt(-1, 12), 2 ** 12 - 1); +assert.strictEqual(convertToInt(2 ** 11, 12, 'signed'), -(2 ** 11)); +assert.strictEqual(convertToInt(-1, 12, 'signed'), -1); + +{ + const options = { + get enforceRange() { + throw new Error('enforceRange should not be read'); + }, + get clamp() { + throw new Error('clamp should not be read'); + }, + }; + + assert.strictEqual(convertToInt(7, 8, 'unsigned', options), 7); +} + +{ + const opts = { + __proto__: null, + prefix: 'Prefix', + context: 'Context', + }; + + assert.throws(() => convertToInt(1n, 8, 'unsigned', opts), { + name: 'TypeError', + code: 'ERR_INVALID_ARG_TYPE', + message: 'Prefix: Context is a BigInt and cannot be converted ' + + 'to a number.', + }); + + assert.throws(() => convertToInt(Symbol(), 8, 'unsigned', opts), { + name: 'TypeError', + code: 'ERR_INVALID_ARG_TYPE', + message: 'Prefix: Context is a Symbol and cannot be converted ' + + 'to a number.', + }); + + for (const value of [ + Object(1n), + { valueOf() { return 1n; } }, + { valueOf() { return {}; }, toString() { return 1n; } }, + { [Symbol.toPrimitive]() { return 1n; } }, + Object(Symbol()), + { valueOf() { return Symbol(); } }, + { valueOf() { return {}; }, toString() { return Symbol(); } }, + { [Symbol.toPrimitive]() { return Symbol(); } }, + ]) { + assertPlainTypeError(() => convertToInt(value, 8, 'unsigned', opts)); + } + + assert.strictEqual(convertToInt({ + valueOf() { return {}; }, + toString() { return 7; }, + }, 8), 7); + + { + const value = Object(1n); + value.valueOf = () => 7; + assert.strictEqual(convertToInt(value, 8), 7); + } + + { + const calls = []; + const value = { + [Symbol.toPrimitive](hint) { + calls.push(hint); + return '7'; + }, + valueOf() { + calls.push('valueOf'); + return 1; + }, + toString() { + calls.push('toString'); + return '1'; + }, + }; + + assert.strictEqual(convertToInt(value, 8), 7); + assert.deepStrictEqual(calls, ['number']); + } + + for (const { value, expected } of [ + { + value: { + [Symbol.toPrimitive]: undefined, + valueOf() { return 8; }, + }, + expected: 8, + }, + { + value: { + [Symbol.toPrimitive]: null, + valueOf() { return 9; }, + }, + expected: 9, + }, + ]) { + assert.strictEqual(convertToInt(value, 8), expected); + } + + { + const calls = []; + const value = { + valueOf: 1, + toString() { + calls.push('toString'); + return '10'; + }, + }; + + assert.strictEqual(convertToInt(value, 8), 10); + assert.deepStrictEqual(calls, ['toString']); + } + + { + const calls = []; + const value = { + valueOf() { + calls.push('valueOf'); + return {}; + }, + toString() { + calls.push('toString'); + return '11'; + }, + }; + + assert.strictEqual(convertToInt(value, 8), 11); + assert.deepStrictEqual(calls, ['valueOf', 'toString']); + } + + for (const value of [ + { [Symbol.toPrimitive]: 1 }, + { [Symbol.toPrimitive]() { return {}; } }, + { + valueOf() { return {}; }, + toString() { return {}; }, + }, + ]) { + assertPlainTypeError(() => convertToInt(value, 8, 'unsigned', opts)); + } + + { + const sentinel = new TypeError('sentinel'); + assertSameError(() => convertToInt({ + get [Symbol.toPrimitive]() { + throw sentinel; + }, + }, 8), sentinel); + } + + { + const sentinel = new TypeError('sentinel'); + assertSameError(() => convertToInt({ + get valueOf() { + throw sentinel; + }, + toString() { + return 1; + }, + }, 8), sentinel); + } + + { + const sentinel = new TypeError('sentinel'); + assertSameError(() => convertToInt({ + valueOf() { + throw sentinel; + }, + toString() { + return 1; + }, + }, 8), sentinel); + } +} // EnforceRange -const OutOfRangeValues = [ NaN, Infinity, -Infinity, 2 ** 53, -(2 ** 53) ]; -for (const value of OutOfRangeValues) { - assert.throws(() => convertToInt('x', value, 64, { enforceRange: true }), { +const nonFiniteValues = [NaN, Infinity, -Infinity]; +for (const value of nonFiniteValues) { + assert.throws(() => convertToInt(value, 64, 'unsigned', { + enforceRange: true, + }), { name: 'TypeError', - code: 'ERR_INVALID_ARG_VALUE', + code: 'ERR_INVALID_ARG_TYPE', }); } +assert.strictEqual(convertToInt(-0.8, 64, 'unsigned', { + enforceRange: true, +}), 0); +assert.strictEqual(convertToInt(-0.8, 64, 'signed', { + enforceRange: true, +}), 0); +assert.strictEqual(convertToInt(Number.MAX_SAFE_INTEGER, 64, 'signed', { + enforceRange: true, +}), Number.MAX_SAFE_INTEGER); +assert.strictEqual(convertToInt(Number.MIN_SAFE_INTEGER, 64, 'signed', { + enforceRange: true, +}), Number.MIN_SAFE_INTEGER); +assert.strictEqual(convertToInt(-0.5, 8, 'unsigned', { + enforceRange: true, +}), 0); +assert.strictEqual(convertToInt(255.5, 8, 'unsigned', { + enforceRange: true, +}), 255); + +const outOfRangeValues = [2 ** 53, -(2 ** 53)]; +for (const value of outOfRangeValues) { + assert.throws(() => convertToInt(value, 64, 'unsigned', { + enforceRange: true, + }), { + name: 'TypeError', + code: 'ERR_OUT_OF_RANGE', + }); +} +assert.throws(() => convertToInt(Number.MAX_SAFE_INTEGER + 1, 64, 'signed', { + enforceRange: true, +}), { + name: 'TypeError', + code: 'ERR_OUT_OF_RANGE', +}); +assert.throws(() => convertToInt(Number.MIN_SAFE_INTEGER - 1, 64, 'signed', { + enforceRange: true, +}), { + name: 'TypeError', + code: 'ERR_OUT_OF_RANGE', +}); +assert.throws(() => convertToInt(256, 8, 'unsigned', { + enforceRange: true, +}), { + name: 'TypeError', + code: 'ERR_OUT_OF_RANGE', +}); + +{ + const calls = []; + const options = { + get enforceRange() { + calls.push('enforceRange'); + return false; + }, + get clamp() { + calls.push('clamp'); + return true; + }, + }; + + assert.strictEqual(convertToInt(256, 8, 'unsigned', options), 255); + assert.deepStrictEqual(calls, ['enforceRange', 'clamp']); +} + +{ + const calls = []; + const options = { + get enforceRange() { + calls.push('enforceRange'); + return false; + }, + get clamp() { + calls.push('clamp'); + return true; + }, + }; + + assert.strictEqual(convertToInt({ valueOf: () => 2.5 }, 8, 'unsigned', options), 2); + assert.deepStrictEqual(calls, ['enforceRange', 'clamp']); +} + // Out of range: clamp -assert.strictEqual(convertToInt('x', NaN, 64, { clamp: true }), 0); -assert.strictEqual(convertToInt('x', Infinity, 64, { clamp: true }), Number.MAX_SAFE_INTEGER); -assert.strictEqual(convertToInt('x', -Infinity, 64, { clamp: true }), 0); -assert.strictEqual(convertToInt('x', -Infinity, 64, { signed: true, clamp: true }), Number.MIN_SAFE_INTEGER); -assert.strictEqual(convertToInt('x', 0x1_0000_0000, 32, { clamp: true }), 0xFFFF_FFFF); -assert.strictEqual(convertToInt('x', 0xFFFF_FFFF, 32, { clamp: true }), 0xFFFF_FFFF); -assert.strictEqual(convertToInt('x', 0x8000_0000, 32, { clamp: true, signed: true }), 0x7FFF_FFFF); -assert.strictEqual(convertToInt('x', 0xFFFF_FFFF, 32, { clamp: true, signed: true }), 0x7FFF_FFFF); -assert.strictEqual(convertToInt('x', 0.5, 64, { clamp: true }), 0); -assert.strictEqual(convertToInt('x', 1.5, 64, { clamp: true }), 2); -assert.strictEqual(convertToInt('x', -0.5, 64, { clamp: true }), 0); -assert.strictEqual(convertToInt('x', -0.5, 64, { signed: true, clamp: true }), 0); -assert.strictEqual(convertToInt('x', -1.5, 64, { signed: true, clamp: true }), -2); +assert.strictEqual(convertToInt(NaN, 64, 'unsigned', { clamp: true }), 0); +assert.strictEqual(convertToInt(Infinity, 64, 'unsigned', { clamp: true }), Number.MAX_SAFE_INTEGER); +assert.strictEqual(convertToInt(-Infinity, 64, 'unsigned', { clamp: true }), 0); +assert.strictEqual(convertToInt(-Infinity, 64, 'signed', { clamp: true }), Number.MIN_SAFE_INTEGER); +assert.strictEqual(convertToInt(0x1_0000, 16, 'unsigned', { clamp: true }), 0xFFFF); +assert.strictEqual(convertToInt(0x1_0000_0000, 32, 'unsigned', { clamp: true }), 0xFFFF_FFFF); +assert.strictEqual(convertToInt(0xFFFF_FFFF, 32, 'unsigned', { clamp: true }), 0xFFFF_FFFF); +assert.strictEqual(convertToInt(0x8000, 16, 'signed', { clamp: true }), 0x7FFF); +assert.strictEqual(convertToInt(-0x8001, 16, 'signed', { clamp: true }), -0x8000); +assert.strictEqual(convertToInt(0x8000_0000, 32, 'signed', { clamp: true }), 0x7FFF_FFFF); +assert.strictEqual(convertToInt(0xFFFF_FFFF, 32, 'signed', { clamp: true }), 0x7FFF_FFFF); +assert.strictEqual(convertToInt(0.5, 64, 'unsigned', { clamp: true }), 0); +assert.strictEqual(convertToInt(0.8, 64, 'unsigned', { clamp: true }), 1); +assert.strictEqual(convertToInt(1.5, 64, 'unsigned', { clamp: true }), 2); +assert.strictEqual(convertToInt(-0.5, 64, 'unsigned', { clamp: true }), 0); +assert.strictEqual(convertToInt(-0.5, 64, 'signed', { clamp: true }), 0); +assert.strictEqual(convertToInt(-0.8, 64, 'signed', { clamp: true }), -1); +assert.strictEqual(convertToInt(-1.5, 64, 'signed', { clamp: true }), -2); // Out of range, step 8. -assert.strictEqual(convertToInt('x', NaN, 64), 0); -assert.strictEqual(convertToInt('x', Infinity, 64), 0); -assert.strictEqual(convertToInt('x', -Infinity, 64), 0); -assert.strictEqual(convertToInt('x', 0x1_0000_0000, 32), 0); -assert.strictEqual(convertToInt('x', 0x1_0000_0001, 32), 1); -assert.strictEqual(convertToInt('x', 0xFFFF_FFFF, 32), 0xFFFF_FFFF); +assert.strictEqual(convertToInt(NaN, 64), 0); +assert.strictEqual(convertToInt(Infinity, 64), 0); +assert.strictEqual(convertToInt(-Infinity, 64), 0); +assert.strictEqual(convertToInt(-3, 8), 253); +assert.strictEqual(convertToInt(-3, 8), new Uint8Array([-3])[0]); +assert.strictEqual(convertToInt(0x1_0000, 16), 0); +assert.strictEqual(convertToInt(0x1_0001, 16), 1); +assert.strictEqual(convertToInt(-1, 16), 0xFFFF); +assert.strictEqual(convertToInt(-1, 16), new Uint16Array([-1])[0]); +assert.strictEqual(convertToInt(0x1_0000_0000, 32), 0); +assert.strictEqual(convertToInt(0x1_0000_0001, 32), 1); +assert.strictEqual(convertToInt(0xFFFF_FFFF, 32), 0xFFFF_FFFF); +assert.strictEqual(convertToInt(-1, 32), 0xFFFF_FFFF); +assert.strictEqual(convertToInt(-1, 32), new Uint32Array([-1])[0]); +assert.strictEqual(convertToInt(-8192, 64), 2 ** 64 - 8192); +assert.strictEqual(convertToInt(two63, 64), two63); +assert.strictEqual(convertToInt(two64, 64), 0); +assert.strictEqual(convertToInt(two64 + 8192, 64), 8192); +assert.strictEqual(convertToInt(-(two64 + 2 ** 12), 64), + two64 - 2 ** 12); // Out of range, step 11. -assert.strictEqual(convertToInt('x', 0x8000_0000, 32, { signed: true }), -0x8000_0000); -assert.strictEqual(convertToInt('x', 0xFFF_FFFF, 32, { signed: true }), 0xFFF_FFFF); +assert.strictEqual(convertToInt(0x8000, 16, 'signed'), -0x8000); +assert.strictEqual(convertToInt(0xFFFF, 16, 'signed'), -1); +assert.strictEqual(convertToInt(-0x8001, 16, 'signed'), 0x7FFF); +assert.strictEqual(convertToInt(-0x8001, 16, 'signed'), new Int16Array([-0x8001])[0]); +assert.strictEqual(convertToInt(0x8000_0000, 32, 'signed'), -0x8000_0000); +assert.strictEqual(convertToInt(0xFFF_FFFF, 32, 'signed'), 0xFFF_FFFF); +assert.strictEqual(convertToInt(-200, 8, 'signed'), 56); +assert.strictEqual(convertToInt(-200, 8, 'signed'), new Int8Array([-200])[0]); +assert.strictEqual(convertToInt(-8192, 64, 'signed'), -8192); +assert.strictEqual(convertToInt(-8193, 64, 'signed'), -8193); +assert.strictEqual(convertToInt(two63, 64, 'signed'), -two63); +assert.strictEqual(convertToInt(two63 + 2 ** 11, 64, 'signed'), + -two63 + 2 ** 11); +assert.strictEqual(convertToInt(two64 + 8192, 64, 'signed'), 8192); +assert.strictEqual(convertToInt(-(two64 + 2 ** 12), 64, 'signed'), + -(2 ** 12)); diff --git a/test/parallel/test-internal-webidl.js b/test/parallel/test-internal-webidl.js new file mode 100644 index 00000000000000..bd08648549be78 --- /dev/null +++ b/test/parallel/test-internal-webidl.js @@ -0,0 +1,616 @@ +// Flags: --expose-internals +'use strict'; + +require('../common'); +const assert = require('assert'); +const vm = require('vm'); +const webidl = require('internal/webidl'); + +const { converters } = webidl; +const opts = { + __proto__: null, + prefix: 'Prefix', + context: 'Context', +}; +function createGrowableSharedArrayBufferView() { + const buffer = new SharedArrayBuffer(4, { maxByteLength: 8 }); + const view = new Uint8Array(buffer); + assert.strictEqual(view.buffer.growable, true); + return view; +} + +function assertInvalidArgType(fn) { + assert.throws(fn, { + name: 'TypeError', + code: 'ERR_INVALID_ARG_TYPE', + }); +} + +function assertPlainTypeError(fn) { + assert.throws(fn, (err) => { + assert(err instanceof TypeError); + assert.strictEqual(err.name, 'TypeError'); + assert.strictEqual(err.code, undefined); + return true; + }); +} + +function assertSameError(fn, expected) { + assert.throws(fn, (err) => { + assert.strictEqual(err, expected); + return true; + }); +} + +assert.strictEqual(webidl.type(undefined), 'Undefined'); +assert.strictEqual(webidl.type(null), 'Null'); +assert.strictEqual(webidl.type(false), 'Boolean'); +assert.strictEqual(webidl.type(''), 'String'); +assert.strictEqual(webidl.type(Symbol()), 'Symbol'); +assert.strictEqual(webidl.type(0), 'Number'); +assert.strictEqual(webidl.type(0n), 'BigInt'); +assert.strictEqual(webidl.type({}), 'Object'); +assert.strictEqual(webidl.type(function fn() {}), 'Object'); + +assert.strictEqual(converters.boolean(0), false); +assert.strictEqual(converters.boolean('false'), true); +{ + function fn() {} + assert.strictEqual(converters.object(fn), fn); +} +assert.throws(() => converters.object(null, opts), { + name: 'TypeError', + code: 'ERR_INVALID_ARG_TYPE', + message: 'Prefix: Context is not an object.', +}); + +assert.strictEqual(converters.DOMString(null), 'null'); +assert.throws(() => converters.DOMString(Symbol(), opts), { + name: 'TypeError', + code: 'ERR_INVALID_ARG_TYPE', + message: 'Prefix: Context is a Symbol and cannot be converted to a string.', +}); + +for (const value of [ + Object(Symbol()), + { toString() { return Symbol(); } }, + { toString() { return {}; }, valueOf() { return Symbol(); } }, + { [Symbol.toPrimitive]() { return Symbol(); } }, +]) { + assertPlainTypeError(() => converters.DOMString(value, opts)); +} +assert.strictEqual(converters.DOMString(1n), '1'); +assert.strictEqual(converters.DOMString(Object(1n)), '1'); +assert.strictEqual(converters.DOMString({ + toString() { return {}; }, + valueOf() { return 1n; }, +}), '1'); +assert.strictEqual(converters.DOMString({ + [Symbol.toPrimitive]() { return 1n; }, +}), '1'); +{ + const value = Object(Symbol()); + Object.defineProperty(value, Symbol.toPrimitive, { + __proto__: null, + value() { return 'symbol object'; }, + }); + assert.strictEqual(converters.DOMString(value), 'symbol object'); +} + +{ + const calls = []; + const value = { + [Symbol.toPrimitive](hint) { + calls.push(hint); + return 7; + }, + toString() { + calls.push('toString'); + return '1'; + }, + valueOf() { + calls.push('valueOf'); + return 1; + }, + }; + + assert.strictEqual(converters.DOMString(value), '7'); + assert.deepStrictEqual(calls, ['string']); +} + +for (const { value, expected } of [ + { + value: { + [Symbol.toPrimitive]: undefined, + toString() { return 'eight'; }, + }, + expected: 'eight', + }, + { + value: { + [Symbol.toPrimitive]: null, + toString() { return 'nine'; }, + }, + expected: 'nine', + }, +]) { + assert.strictEqual(converters.DOMString(value), expected); +} + +{ + const calls = []; + const value = { + toString: 1, + valueOf() { + calls.push('valueOf'); + return 10; + }, + }; + + assert.strictEqual(converters.DOMString(value), '10'); + assert.deepStrictEqual(calls, ['valueOf']); +} + +{ + const calls = []; + const value = { + toString() { + calls.push('toString'); + return {}; + }, + valueOf() { + calls.push('valueOf'); + return 11; + }, + }; + + assert.strictEqual(converters.DOMString(value), '11'); + assert.deepStrictEqual(calls, ['toString', 'valueOf']); +} + +for (const value of [ + { [Symbol.toPrimitive]: 1 }, + { [Symbol.toPrimitive]() { return {}; } }, + { + toString() { return {}; }, + valueOf() { return {}; }, + }, +]) { + assertPlainTypeError(() => converters.DOMString(value, opts)); +} + +{ + const sentinel = new TypeError('sentinel'); + assertSameError(() => converters.DOMString({ + get [Symbol.toPrimitive]() { + throw sentinel; + }, + }), sentinel); +} + +{ + const sentinel = new TypeError('sentinel'); + assertSameError(() => converters.DOMString({ + get toString() { + throw sentinel; + }, + valueOf() { + return 1; + }, + }), sentinel); +} + +{ + const sentinel = new TypeError('sentinel'); + assertSameError(() => converters.DOMString({ + toString() { + throw sentinel; + }, + valueOf() { + return 1; + }, + }), sentinel); +} + +{ + assert.strictEqual(converters.octet(-1), 255); + assert.strictEqual(converters['unsigned short'](-1), 0xFFFF); + assert.strictEqual(converters['unsigned long'](-1), 0xFFFF_FFFF); + assert.strictEqual(converters['long long'](-1), -1); + assert.strictEqual(converters.octet(2.5, { + __proto__: null, + clamp: true, + }), 2); + assert.throws(() => converters.octet(256, { + __proto__: null, + ...opts, + enforceRange: true, + }), { + name: 'TypeError', + code: 'ERR_OUT_OF_RANGE', + message: 'Prefix: Context is outside the expected range of 0 to 255.', + }); +} + +{ + const converter = webidl.createEnumConverter('Example', ['one', 'two']); + + assert.strictEqual(converter('one'), 'one'); + assert.throws(() => converter(Symbol(), opts), { + name: 'TypeError', + code: 'ERR_INVALID_ARG_TYPE', + message: 'Prefix: Context is a Symbol and cannot be converted to a string.', + }); + assert.throws(() => converter('three', opts), { + name: 'TypeError', + code: 'ERR_INVALID_ARG_VALUE', + message: "Prefix: Context 'three' is not a valid enum value " + + 'of type Example.', + }); +} + +assert.throws(() => webidl.requiredArguments(1, 2, opts), { + name: 'TypeError', + code: 'ERR_MISSING_ARGS', + message: 'Prefix: 2 arguments required, but only 1 present.', +}); + +{ + const ab = new ArrayBuffer(8, { maxByteLength: 16 }); + const view = new Uint8Array(ab); + const dataView = new DataView(ab); + + assert.strictEqual(ab.resizable, true); + assertInvalidArgType(() => converters.BufferSource(ab)); + assertInvalidArgType(() => converters.BufferSource(view)); + assertInvalidArgType(() => converters.BufferSource(dataView)); + assertInvalidArgType(() => converters.Uint8Array(view)); + + const disallowResizable = { + __proto__: null, + allowResizable: false, + }; + assertInvalidArgType(() => converters.BufferSource(ab, disallowResizable)); + assertInvalidArgType(() => converters.BufferSource(view, disallowResizable)); + assertInvalidArgType(() => converters.BufferSource(dataView, + disallowResizable)); + + const allowResizable = { + __proto__: null, + allowResizable: true, + }; + assert.strictEqual(converters.BufferSource(ab, allowResizable), ab); + assert.strictEqual(converters.BufferSource(view, allowResizable), view); + assert.strictEqual(converters.BufferSource(dataView, allowResizable), + dataView); + assert.strictEqual(converters.Uint8Array(view, allowResizable), view); +} + +{ + const ab = new ArrayBuffer(8); + const view = new Uint8Array(ab); + const dataView = new DataView(ab); + + structuredClone(ab, { transfer: [ab] }); + assert.strictEqual(ab.detached, true); + assert.strictEqual(converters.BufferSource(ab), ab); + assert.strictEqual(converters.BufferSource(view), view); + assert.strictEqual(converters.BufferSource(dataView), dataView); +} + +{ + const ab = new ArrayBuffer(8, { maxByteLength: 16 }); + const view = new Uint8Array(ab); + const dataView = new DataView(ab); + const allowResizable = { + __proto__: null, + allowResizable: true, + }; + + structuredClone(ab, { transfer: [ab] }); + assert.strictEqual(ab.detached, true); + assert.strictEqual(ab.resizable, true); + assertInvalidArgType(() => converters.BufferSource(ab)); + assertInvalidArgType(() => converters.BufferSource(view)); + assertInvalidArgType(() => converters.BufferSource(dataView)); + assertInvalidArgType(() => converters.Uint8Array(view)); + + const disallowResizable = { + __proto__: null, + allowResizable: false, + }; + assertInvalidArgType(() => converters.BufferSource(ab, disallowResizable)); + assertInvalidArgType(() => converters.BufferSource(view, disallowResizable)); + assertInvalidArgType(() => converters.BufferSource(dataView, + disallowResizable)); + + assert.strictEqual(converters.BufferSource(ab, allowResizable), ab); + assert.strictEqual(converters.BufferSource(view, allowResizable), view); + assert.strictEqual(converters.BufferSource(dataView, allowResizable), + dataView); + assert.strictEqual(converters.Uint8Array(view, allowResizable), view); +} + +{ + const ab = new ArrayBuffer(8, { maxByteLength: 16 }); + const view = new Uint8Array(ab); + + assert.strictEqual(converters.BufferSource(ab, { + __proto__: null, + allowResizable: true, + }), ab); + assert.strictEqual(converters.BufferSource(view, { + __proto__: null, + allowResizable: true, + }), view); + + ab.resize(4); + assert.strictEqual(ab.byteLength, 4); + assert.strictEqual(view.byteLength, 4); + + ab.resize(12); + assert.strictEqual(ab.byteLength, 12); + assert.strictEqual(view.byteLength, 12); +} + +{ + const converter = webidl.createDictionaryConverter('Example', [ + { + key: 'value', + converter: converters.DOMString, + required: true, + }, + ]); + + const idlDict = converter({ value: 1 }); + assert.deepStrictEqual(idlDict, { __proto__: null, value: '1' }); + + assert.throws(() => converter({}, opts), { + name: 'TypeError', + code: 'ERR_MISSING_OPTION', + message: "Prefix: Context cannot be converted to 'Example' because " + + "'value' is required in 'Example'.", + }); +} + +{ + const calls = []; + const converter = webidl.createDictionaryConverter('Derived', [ + [ + { + key: 'zBase', + converter(value) { + calls.push(`base z:${value}`); + return value; + }, + }, + { + key: 'aBase', + converter(value) { + calls.push(`base a:${value}`); + return value; + }, + }, + ], + [ + { + key: 'zDerived', + converter(value) { + calls.push(`derived z:${value}`); + return value; + }, + }, + { + key: 'aDerived', + converter(value) { + calls.push(`derived a:${value}`); + return value; + }, + }, + ], + ]); + + assert.deepStrictEqual(converter({ + zBase: 1, + aBase: 2, + zDerived: 3, + aDerived: 4, + }), { + __proto__: null, + aBase: 2, + zBase: 1, + aDerived: 4, + zDerived: 3, + }); + assert.deepStrictEqual(calls, [ + 'base a:2', + 'base z:1', + 'derived a:4', + 'derived z:3', + ]); +} + +{ + const converter = webidl.createDictionaryConverter('Example', [ + { + key: 'same', + converter(value) { + return `first:${value}`; + }, + }, + { + key: 'same', + converter(value) { + return `second:${value}`; + }, + }, + ]); + + assert.deepStrictEqual(converter({ same: 1 }), { + __proto__: null, + same: 'second:1', + }); +} + +{ + const converter = converters['sequence']; + assert.deepStrictEqual(converter([1, 2]), ['1', '2']); + + assert.throws(() => converter([Symbol()]), { + name: 'TypeError', + code: 'ERR_INVALID_ARG_TYPE', + message: 'Value[0] is a Symbol and cannot be converted to a string.', + }); + + assert.throws(() => converter({ [Symbol.iterator]: 1 }, opts), { + name: 'TypeError', + code: 'ERR_INVALID_ARG_TYPE', + message: 'Prefix: Context cannot be converted to sequence.', + }); + + assert.throws(() => converter({ + [Symbol.iterator]() { + return {}; + }, + }, opts), { + name: 'TypeError', + code: 'ERR_INVALID_ARG_TYPE', + message: 'Prefix: Context cannot be converted to sequence.', + }); + + assert.throws(() => converter({ + [Symbol.iterator]() { + return { + next() { + return null; + }, + }; + }, + }, opts), { + name: 'TypeError', + code: 'ERR_INVALID_ARG_TYPE', + message: 'Prefix: Context cannot be converted to sequence.', + }); + + assert.throws(() => converter([Symbol()], opts), { + name: 'TypeError', + code: 'ERR_INVALID_ARG_TYPE', + message: 'Prefix: Context[0] is a Symbol and cannot be converted ' + + 'to a string.', + }); + + assert.deepStrictEqual(converter({ + [Symbol.iterator]() { + return { + next() { + return { done: 1, value: Symbol() }; + }, + }; + }, + }), []); +} + +{ + class Example {} + const converter = webidl.createInterfaceConverter( + 'Example', + Example.prototype); + const example = new Example(); + + assert.strictEqual(converter(example), example); + assert.throws(() => converter({}, opts), { + name: 'TypeError', + code: 'ERR_INVALID_ARG_TYPE', + message: 'Prefix: Context is not of type Example.', + }); +} + +{ + const context = vm.createContext(); + const view = vm.runInContext( + 'new Uint8Array(new ArrayBuffer(0))', + context, + ); + assert.strictEqual(converters.Uint8Array(view), view); + + for (const value of [ + new ArrayBuffer(0), + new SharedArrayBuffer(0), + new DataView(new ArrayBuffer(0)), + new Int8Array(0), + Object.create(Uint8Array.prototype, { + [Symbol.toStringTag]: { value: 'Uint8Array' }, + }), + ]) { + assertInvalidArgType(() => converters.Uint8Array(value)); + } +} + +{ + const sab = new SharedArrayBuffer(4); + const view = new Uint8Array(sab); + + assertInvalidArgType(() => converters.BufferSource(sab)); + assertInvalidArgType(() => converters.BufferSource(view)); + assertInvalidArgType(() => converters.Uint8Array(view)); + + const allowShared = { + __proto__: null, + allowShared: true, + }; + assertInvalidArgType(() => converters.BufferSource(sab, allowShared)); + assertInvalidArgType(() => converters.BufferSource(view, allowShared)); + assert.strictEqual(converters.AllowSharedBufferSource(sab), sab); + assert.strictEqual(converters.AllowSharedBufferSource(view), view); + assert.strictEqual(converters.Uint8Array(view, allowShared), view); + + const growableView = createGrowableSharedArrayBufferView(); + + assertInvalidArgType(() => converters.BufferSource(growableView, { + __proto__: null, + allowShared: true, + allowResizable: true, + })); + assert.throws(() => converters.AllowSharedBufferSource(growableView.buffer, { + __proto__: null, + ...opts, + }), { + name: 'TypeError', + code: 'ERR_INVALID_ARG_TYPE', + message: 'Prefix: Context is backed by a growable ' + + 'SharedArrayBuffer, which is not allowed.', + }); + assert.throws(() => converters.AllowSharedBufferSource(growableView, { + __proto__: null, + ...opts, + allowResizable: false, + }), { + name: 'TypeError', + code: 'ERR_INVALID_ARG_TYPE', + message: 'Prefix: Context is backed by a growable ' + + 'SharedArrayBuffer, which is not allowed.', + }); + assert.throws(() => converters.Uint8Array(growableView, { + __proto__: null, + ...opts, + allowShared: true, + }), { + name: 'TypeError', + code: 'ERR_INVALID_ARG_TYPE', + message: 'Prefix: Context is backed by a growable ' + + 'SharedArrayBuffer, which is not allowed.', + }); + assert.strictEqual(converters.AllowSharedBufferSource(growableView.buffer, { + __proto__: null, + allowResizable: true, + }), growableView.buffer); + assert.strictEqual(converters.AllowSharedBufferSource(growableView, { + __proto__: null, + allowResizable: true, + }), growableView); + assert.strictEqual(converters.Uint8Array(growableView, { + __proto__: null, + allowShared: true, + allowResizable: true, + }), growableView); +} diff --git a/test/parallel/test-performance-resourcetimingbuffersize.js b/test/parallel/test-performance-resourcetimingbuffersize.js index c9c84dc9416f68..f01a31cc4403f6 100644 --- a/test/parallel/test-performance-resourcetimingbuffersize.js +++ b/test/parallel/test-performance-resourcetimingbuffersize.js @@ -37,6 +37,19 @@ async function main() { globalThis, cacheMode, ]; + + assert.throws(() => performance.setResourceTimingBufferSize(1n), { + name: 'TypeError', + code: 'ERR_INVALID_ARG_TYPE', + message: 'maxSize is a BigInt and cannot be converted to a number.', + }); + + assert.throws(() => performance.setResourceTimingBufferSize(Symbol()), { + name: 'TypeError', + code: 'ERR_INVALID_ARG_TYPE', + message: 'maxSize is a Symbol and cannot be converted to a number.', + }); + // Invalid buffer size values are converted to 0. const invalidValues = [ null, undefined, true, false, -1, 0.5, Infinity, NaN, '', 'foo', {}, [], () => {} ]; for (const value of invalidValues) { diff --git a/test/parallel/test-structuredClone-global.js b/test/parallel/test-structuredClone-global.js index e6b63c382b39b1..09e36ad47940ea 100644 --- a/test/parallel/test-structuredClone-global.js +++ b/test/parallel/test-structuredClone-global.js @@ -6,7 +6,7 @@ const assert = require('assert'); const prefix = "Failed to execute 'structuredClone'"; const key = 'transfer'; const context = 'Options'; -const memberConverterError = `${prefix}: ${key} in ${context} can not be converted to sequence.`; +const memberConverterError = `${prefix}: ${key} in ${context} cannot be converted to sequence.`; const dictionaryConverterError = `${prefix}: ${context} cannot be converted to a dictionary`; assert.throws(() => structuredClone(), { code: 'ERR_MISSING_ARGS' }); diff --git a/test/parallel/test-webapi-sharedarraybuffer-rejection.js b/test/parallel/test-webapi-sharedarraybuffer-rejection.js index 744c929753c285..09277c014b45c7 100644 --- a/test/parallel/test-webapi-sharedarraybuffer-rejection.js +++ b/test/parallel/test-webapi-sharedarraybuffer-rejection.js @@ -157,33 +157,28 @@ test('webidl converters.BufferSource accepts regular TypedArray', () => { assert.strictEqual(converters.BufferSource(ta), ta); }); -test('webidl converters.ArrayBufferView rejects SAB-backed Uint8Array', () => { +test('webidl converters.Uint8Array rejects SAB-backed Uint8Array', () => { assert.throws( - () => converters.ArrayBufferView(sabView), + () => converters.Uint8Array(sabView), { code: 'ERR_INVALID_ARG_TYPE' }, ); }); -test('webidl converters.ArrayBufferView rejects SAB-backed DataView', () => { +test('webidl converters.Uint8Array rejects DataView', () => { assert.throws( - () => converters.ArrayBufferView(sabDataView), + () => converters.Uint8Array(sabDataView), { code: 'ERR_INVALID_ARG_TYPE' }, ); }); -test('webidl converters.ArrayBufferView rejects non-view', () => { +test('webidl converters.Uint8Array rejects non-view', () => { assert.throws( - () => converters.ArrayBufferView('not a view'), + () => converters.Uint8Array('not a view'), { code: 'ERR_INVALID_ARG_TYPE' }, ); }); -test('webidl converters.ArrayBufferView accepts regular Uint8Array', () => { +test('webidl converters.Uint8Array accepts regular Uint8Array', () => { const ta = new Uint8Array(4); - assert.strictEqual(converters.ArrayBufferView(ta), ta); -}); - -test('webidl converters.ArrayBufferView accepts regular DataView', () => { - const dv = new DataView(new ArrayBuffer(4)); - assert.strictEqual(converters.ArrayBufferView(dv), dv); + assert.strictEqual(converters.Uint8Array(ta), ta); }); diff --git a/test/parallel/test-webcrypto-webidl.js b/test/parallel/test-webcrypto-webidl.js index 99386176c4d6ef..0f8f57ad6fb6a1 100644 --- a/test/parallel/test-webcrypto-webidl.js +++ b/test/parallel/test-webcrypto-webidl.js @@ -16,6 +16,21 @@ const prefix = "Failed to execute 'fn' on 'interface'"; const context = '1st argument'; const opts = { prefix, context }; +function asIdlDictionary(value) { + return { __proto__: null, ...value }; +} + +function assertIdlDictionary(actual, expected) { + assert.deepStrictEqual(actual, asIdlDictionary(expected)); +} + +function assertJsonWebKey(actual, expected) { + const idlDictionary = asIdlDictionary(expected); + if (idlDictionary.oth !== undefined) + idlDictionary.oth = idlDictionary.oth.map(asIdlDictionary); + assert.deepStrictEqual(actual, idlDictionary); +} + // Required arguments.length { assert.throws(() => webidl.requiredArguments(0, 3, { prefix }), { @@ -158,6 +173,14 @@ const opts = { prefix, context }; code: 'ERR_INVALID_ARG_TYPE', message: `${prefix}: ${context} is a view on a SharedArrayBuffer, which is not allowed.` }); + + { + const resizable = new ArrayBuffer(8, { maxByteLength: 16 }); + const view = new Uint8Array(resizable); + + // TODO(panva): Reject resizable backing stores in a semver-major + assert.deepStrictEqual(converters.BigInteger(view), view); + } } // BufferSource @@ -194,6 +217,39 @@ const opts = { prefix, context }; code: 'ERR_INVALID_ARG_TYPE', message: `${prefix}: ${context} is a view on a SharedArrayBuffer, which is not allowed.` }); + + { + const resizable = new ArrayBuffer(8, { maxByteLength: 16 }); + const view = new Uint8Array(resizable); + const dataView = new DataView(resizable); + + // TODO(panva): Reject resizable backing stores in a semver-major by + // removing the crypto/webidl BufferSource override. + assert.deepStrictEqual(converters.BufferSource(resizable), resizable); + assert.deepStrictEqual(converters.BufferSource(view), view); + assert.deepStrictEqual(converters.BufferSource(dataView), dataView); + const resizableError = { + name: 'TypeError', + code: 'ERR_INVALID_ARG_TYPE', + message: `${prefix}: ${context} is backed by a resizable ` + + 'ArrayBuffer, which is not allowed.', + }; + assert.throws(() => converters.BufferSource(resizable, { + __proto__: null, + ...opts, + allowResizable: false, + }), resizableError); + assert.throws(() => converters.BufferSource(view, { + __proto__: null, + ...opts, + allowResizable: false, + }), resizableError); + assert.throws(() => converters.BufferSource(dataView, { + __proto__: null, + ...opts, + allowResizable: false, + }), resizableError); + } } // CryptoKey @@ -231,8 +287,8 @@ const opts = { prefix, context }; { oth: [] }, { oth: [{ r: '', d: '', t: '' }] }, ]) { - assert.deepStrictEqual(converters.JsonWebKey(good), good); - assert.deepStrictEqual(converters.JsonWebKey({ ...good, filtered: 'out' }), good); + assertJsonWebKey(converters.JsonWebKey(good), good); + assertJsonWebKey(converters.JsonWebKey({ ...good, filtered: 'out' }), good); } } @@ -255,7 +311,7 @@ const opts = { prefix, context }; assert.throws(() => converters.KeyFormat(bad, opts), { name: 'TypeError', code: 'ERR_INVALID_ARG_VALUE', - message: `${prefix}: ${context} value '${bad}' is not a valid enum value of type KeyFormat.`, + message: `${prefix}: ${context} '${bad}' is not a valid enum value of type KeyFormat.`, }); } } @@ -283,7 +339,7 @@ const opts = { prefix, context }; assert.throws(() => converters.KeyUsage(bad, opts), { name: 'TypeError', code: 'ERR_INVALID_ARG_VALUE', - message: `${prefix}: ${context} value '${bad}' is not a valid enum value of type KeyUsage.`, + message: `${prefix}: ${context} '${bad}' is not a valid enum value of type KeyUsage.`, }); } } @@ -291,12 +347,12 @@ const opts = { prefix, context }; // Algorithm { const good = { name: 'RSA-PSS' }; - assert.deepStrictEqual(converters.Algorithm({ ...good, filtered: 'out' }, opts), good); + assertIdlDictionary(converters.Algorithm({ ...good, filtered: 'out' }, opts), good); assert.throws(() => converters.Algorithm({}, opts), { name: 'TypeError', code: 'ERR_MISSING_OPTION', - message: `${prefix}: ${context} can not be converted to 'Algorithm' because 'name' is required in 'Algorithm'.`, + message: `${prefix}: ${context} cannot be converted to 'Algorithm' because 'name' is required in 'Algorithm'.`, }); } @@ -316,12 +372,12 @@ const opts = { prefix, context }; publicExponent: new Uint8Array([1, 0, 1]), }, ]) { - assert.deepStrictEqual(converters.RsaHashedKeyGenParams({ ...good, filtered: 'out' }, opts), good); + assertIdlDictionary(converters.RsaHashedKeyGenParams({ ...good, filtered: 'out' }, opts), good); for (const required of ['hash', 'publicExponent', 'modulusLength']) { assert.throws(() => converters.RsaHashedKeyGenParams({ ...good, [required]: undefined }, opts), { name: 'TypeError', code: 'ERR_MISSING_OPTION', - message: `${prefix}: ${context} can not be converted to 'RsaHashedKeyGenParams' because '${required}' is required in 'RsaHashedKeyGenParams'.`, + message: `${prefix}: ${context} cannot be converted to 'RsaHashedKeyGenParams' because '${required}' is required in 'RsaHashedKeyGenParams'.`, }); } } @@ -333,11 +389,11 @@ const opts = { prefix, context }; { name: 'RSA-OAEP', hash: { name: 'SHA-1' } }, { name: 'RSA-OAEP', hash: 'SHA-1' }, ]) { - assert.deepStrictEqual(converters.RsaHashedImportParams({ ...good, filtered: 'out' }, opts), good); + assertIdlDictionary(converters.RsaHashedImportParams({ ...good, filtered: 'out' }, opts), good); assert.throws(() => converters.RsaHashedImportParams({ ...good, hash: undefined }, opts), { name: 'TypeError', code: 'ERR_MISSING_OPTION', - message: `${prefix}: ${context} can not be converted to 'RsaHashedImportParams' because 'hash' is required in 'RsaHashedImportParams'.`, + message: `${prefix}: ${context} cannot be converted to 'RsaHashedImportParams' because 'hash' is required in 'RsaHashedImportParams'.`, }); } } @@ -345,19 +401,19 @@ const opts = { prefix, context }; // RsaPssParams { const good = { name: 'RSA-PSS', saltLength: 20 }; - assert.deepStrictEqual(converters.RsaPssParams({ ...good, filtered: 'out' }, opts), good); + assertIdlDictionary(converters.RsaPssParams({ ...good, filtered: 'out' }, opts), good); assert.throws(() => converters.RsaPssParams({ ...good, saltLength: undefined }, opts), { name: 'TypeError', code: 'ERR_MISSING_OPTION', - message: `${prefix}: ${context} can not be converted to 'RsaPssParams' because 'saltLength' is required in 'RsaPssParams'.`, + message: `${prefix}: ${context} cannot be converted to 'RsaPssParams' because 'saltLength' is required in 'RsaPssParams'.`, }); } // RsaOaepParams { for (const good of [{ name: 'RSA-OAEP' }, { name: 'RSA-OAEP', label: Buffer.alloc(0) }]) { - assert.deepStrictEqual(converters.RsaOaepParams({ ...good, filtered: 'out' }, opts), good); + assertIdlDictionary(converters.RsaOaepParams({ ...good, filtered: 'out' }, opts), good); } } @@ -367,12 +423,12 @@ const opts = { prefix, context }; const { [name]: converter } = converters; const good = { name: 'ECDSA', namedCurve: 'P-256' }; - assert.deepStrictEqual(converter({ ...good, filtered: 'out' }, opts), good); + assertIdlDictionary(converter({ ...good, filtered: 'out' }, opts), good); assert.throws(() => converter({ ...good, namedCurve: undefined }, opts), { name: 'TypeError', code: 'ERR_MISSING_OPTION', - message: `${prefix}: ${context} can not be converted to '${name}' because 'namedCurve' is required in '${name}'.`, + message: `${prefix}: ${context} cannot be converted to '${name}' because 'namedCurve' is required in '${name}'.`, }); } } @@ -383,11 +439,11 @@ const opts = { prefix, context }; { name: 'ECDSA', hash: { name: 'SHA-1' } }, { name: 'ECDSA', hash: 'SHA-1' }, ]) { - assert.deepStrictEqual(converters.EcdsaParams({ ...good, filtered: 'out' }, opts), good); + assertIdlDictionary(converters.EcdsaParams({ ...good, filtered: 'out' }, opts), good); assert.throws(() => converters.EcdsaParams({ ...good, hash: undefined }, opts), { name: 'TypeError', code: 'ERR_MISSING_OPTION', - message: `${prefix}: ${context} can not be converted to 'EcdsaParams' because 'hash' is required in 'EcdsaParams'.`, + message: `${prefix}: ${context} cannot be converted to 'EcdsaParams' because 'hash' is required in 'EcdsaParams'.`, }); } } @@ -403,11 +459,11 @@ const opts = { prefix, context }; { name: 'HMAC', hash: 'SHA-1' }, { name: 'HMAC', hash: 'SHA-1', length: 32 }, ]) { - assert.deepStrictEqual(converter({ ...good, filtered: 'out' }, opts), good); + assertIdlDictionary(converter({ ...good, filtered: 'out' }, opts), good); assert.throws(() => converter({ ...good, hash: undefined }, opts), { name: 'TypeError', code: 'ERR_MISSING_OPTION', - message: `${prefix}: ${context} can not be converted to '${name}' because 'hash' is required in '${name}'.`, + message: `${prefix}: ${context} cannot be converted to '${name}' because 'hash' is required in '${name}'.`, }); } } @@ -419,12 +475,12 @@ const opts = { prefix, context }; const { [name]: converter } = converters; const good = { name: 'AES-CBC', length: 128 }; - assert.deepStrictEqual(converter({ ...good, filtered: 'out' }, opts), good); + assertIdlDictionary(converter({ ...good, filtered: 'out' }, opts), good); assert.throws(() => converter({ ...good, length: undefined }, opts), { name: 'TypeError', code: 'ERR_MISSING_OPTION', - message: `${prefix}: ${context} can not be converted to '${name}' because 'length' is required in '${name}'.`, + message: `${prefix}: ${context} cannot be converted to '${name}' because 'length' is required in '${name}'.`, }); } } @@ -435,12 +491,12 @@ const opts = { prefix, context }; { name: 'HKDF', hash: { name: 'SHA-1' }, salt: Buffer.alloc(0), info: Buffer.alloc(0) }, { name: 'HKDF', hash: 'SHA-1', salt: Buffer.alloc(0), info: Buffer.alloc(0) }, ]) { - assert.deepStrictEqual(converters.HkdfParams({ ...good, filtered: 'out' }, opts), good); + assertIdlDictionary(converters.HkdfParams({ ...good, filtered: 'out' }, opts), good); for (const required of ['hash', 'salt', 'info']) { assert.throws(() => converters.HkdfParams({ ...good, [required]: undefined }, opts), { name: 'TypeError', code: 'ERR_MISSING_OPTION', - message: `${prefix}: ${context} can not be converted to 'HkdfParams' because '${required}' is required in 'HkdfParams'.`, + message: `${prefix}: ${context} cannot be converted to 'HkdfParams' because '${required}' is required in 'HkdfParams'.`, }); } } @@ -452,12 +508,12 @@ const opts = { prefix, context }; { name: 'PBKDF2', hash: { name: 'SHA-1' }, iterations: 5, salt: Buffer.alloc(0) }, { name: 'PBKDF2', hash: 'SHA-1', iterations: 5, salt: Buffer.alloc(0) }, ]) { - assert.deepStrictEqual(converters.Pbkdf2Params({ ...good, filtered: 'out' }, opts), good); + assertIdlDictionary(converters.Pbkdf2Params({ ...good, filtered: 'out' }, opts), good); for (const required of ['hash', 'iterations', 'salt']) { assert.throws(() => converters.Pbkdf2Params({ ...good, [required]: undefined }, opts), { name: 'TypeError', code: 'ERR_MISSING_OPTION', - message: `${prefix}: ${context} can not be converted to 'Pbkdf2Params' because '${required}' is required in 'Pbkdf2Params'.`, + message: `${prefix}: ${context} cannot be converted to 'Pbkdf2Params' because '${required}' is required in 'Pbkdf2Params'.`, }); } } @@ -466,12 +522,12 @@ const opts = { prefix, context }; // AesCbcParams { const good = { name: 'AES-CBC', iv: Buffer.alloc(16) }; - assert.deepStrictEqual(converters.AesCbcParams({ ...good, filtered: 'out' }, opts), good); + assertIdlDictionary(converters.AesCbcParams({ ...good, filtered: 'out' }, opts), good); assert.throws(() => converters.AesCbcParams({ ...good, iv: undefined }, opts), { name: 'TypeError', code: 'ERR_MISSING_OPTION', - message: `${prefix}: ${context} can not be converted to 'AesCbcParams' because 'iv' is required in 'AesCbcParams'.`, + message: `${prefix}: ${context} cannot be converted to 'AesCbcParams' because 'iv' is required in 'AesCbcParams'.`, }); } @@ -482,12 +538,12 @@ const opts = { prefix, context }; { name: 'AES-GCM', iv: Buffer.alloc(0), tagLength: 64 }, { name: 'AES-GCM', iv: Buffer.alloc(0), tagLength: 64, additionalData: Buffer.alloc(0) }, ]) { - assert.deepStrictEqual(converters.AeadParams({ ...good, filtered: 'out' }, opts), good); + assertIdlDictionary(converters.AeadParams({ ...good, filtered: 'out' }, opts), good); assert.throws(() => converters.AeadParams({ ...good, iv: undefined }, opts), { name: 'TypeError', code: 'ERR_MISSING_OPTION', - message: `${prefix}: ${context} can not be converted to 'AeadParams' because 'iv' is required in 'AeadParams'.`, + message: `${prefix}: ${context} cannot be converted to 'AeadParams' because 'iv' is required in 'AeadParams'.`, }); } } @@ -495,13 +551,13 @@ const opts = { prefix, context }; // AesCtrParams { const good = { name: 'AES-CTR', counter: Buffer.alloc(16), length: 20 }; - assert.deepStrictEqual(converters.AesCtrParams({ ...good, filtered: 'out' }, opts), good); + assertIdlDictionary(converters.AesCtrParams({ ...good, filtered: 'out' }, opts), good); for (const required of ['counter', 'length']) { assert.throws(() => converters.AesCtrParams({ ...good, [required]: undefined }, opts), { name: 'TypeError', code: 'ERR_MISSING_OPTION', - message: `${prefix}: ${context} can not be converted to 'AesCtrParams' because '${required}' is required in 'AesCtrParams'.`, + message: `${prefix}: ${context} cannot be converted to 'AesCtrParams' because '${required}' is required in 'AesCtrParams'.`, }); } } @@ -510,12 +566,12 @@ const opts = { prefix, context }; { subtle.generateKey({ name: 'ECDH', namedCurve: 'P-256' }, false, ['deriveBits']).then((kp) => { const good = { name: 'ECDH', public: kp.publicKey }; - assert.deepStrictEqual(converters.EcdhKeyDeriveParams({ ...good, filtered: 'out' }, opts), good); + assertIdlDictionary(converters.EcdhKeyDeriveParams({ ...good, filtered: 'out' }, opts), good); assert.throws(() => converters.EcdhKeyDeriveParams({ ...good, public: undefined }, opts), { name: 'TypeError', code: 'ERR_MISSING_OPTION', - message: `${prefix}: ${context} can not be converted to 'EcdhKeyDeriveParams' because 'public' is required in 'EcdhKeyDeriveParams'.`, + message: `${prefix}: ${context} cannot be converted to 'EcdhKeyDeriveParams' because 'public' is required in 'EcdhKeyDeriveParams'.`, }); }).then(common.mustCall()); } @@ -526,6 +582,28 @@ const opts = { prefix, context }; { name: 'Ed448', context: new Uint8Array() }, { name: 'Ed448' }, ]) { - assert.deepStrictEqual(converters.ContextParams({ ...good, filtered: 'out' }, opts), good); + assertIdlDictionary(converters.ContextParams({ ...good, filtered: 'out' }, opts), good); } } + +// Argon2Params +{ + const maxParallelism = 2 ** 24 - 1; + const good = { + name: 'Argon2id', + nonce: Buffer.alloc(8), + parallelism: maxParallelism, + memory: 8 * maxParallelism, + passes: 1, + }; + assertIdlDictionary(converters.Argon2Params({ ...good, filtered: 'out' }, opts), good); + + assert.throws(() => converters.Argon2Params({ + ...good, + parallelism: maxParallelism + 1, + memory: 8 * (maxParallelism + 1), + }, opts), { + name: 'OperationError', + message: 'parallelism must be > 0 and <= 16777215', + }); +} From c735003666b7de98cf54120bcd8bc9c46bac50b7 Mon Sep 17 00:00:00 2001 From: Chengzhong Wu Date: Mon, 4 May 2026 23:22:00 +0800 Subject: [PATCH 049/168] src: remove license headers for new node_profiling files Signed-off-by: Chengzhong Wu PR-URL: https://github.com/nodejs/node/pull/63066 Refs: https://github.com/nodejs/node/pull/62273 Reviewed-By: Ilyas Shabi Reviewed-By: Joyee Cheung --- src/node_profiling.cc | 21 --------------------- src/node_profiling.h | 21 --------------------- 2 files changed, 42 deletions(-) diff --git a/src/node_profiling.cc b/src/node_profiling.cc index bc403776c33f8e..b6c42b286908e0 100644 --- a/src/node_profiling.cc +++ b/src/node_profiling.cc @@ -1,24 +1,3 @@ -// Copyright Joyent, Inc. and other Node contributors. -// -// Permission is hereby granted, free of charge, to any person obtaining a -// copy of this software and associated documentation files (the -// "Software"), to deal in the Software without restriction, including -// without limitation the rights to use, copy, modify, merge, publish, -// distribute, sublicense, and/or sell copies of the Software, and to permit -// persons to whom the Software is furnished to do so, subject to the -// following conditions: -// -// The above copyright notice and this permission notice shall be included -// in all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS -// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN -// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, -// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR -// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE -// USE OR OTHER DEALINGS IN THE SOFTWARE. - #include "node_profiling.h" #include "json_utils.h" diff --git a/src/node_profiling.h b/src/node_profiling.h index c6fc396cbc6ab1..1176eb8952db3e 100644 --- a/src/node_profiling.h +++ b/src/node_profiling.h @@ -1,24 +1,3 @@ -// Copyright Joyent, Inc. and other Node contributors. -// -// Permission is hereby granted, free of charge, to any person obtaining a -// copy of this software and associated documentation files (the -// "Software"), to deal in the Software without restriction, including -// without limitation the rights to use, copy, modify, merge, publish, -// distribute, sublicense, and/or sell copies of the Software, and to permit -// persons to whom the Software is furnished to do so, subject to the -// following conditions: -// -// The above copyright notice and this permission notice shall be included -// in all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS -// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN -// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, -// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR -// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE -// USE OR OTHER DEALINGS IN THE SOFTWARE. - #ifndef SRC_NODE_PROFILING_H_ #define SRC_NODE_PROFILING_H_ From e0200f2d73ae0f112c32ff55ae4ab8af18106b5f Mon Sep 17 00:00:00 2001 From: Matteo Collina Date: Mon, 4 May 2026 17:22:31 +0200 Subject: [PATCH 050/168] http: harden ClientRequest options merge Signed-off-by: Matteo Collina PR-URL: https://github.com/nodejs/node/pull/63082 Reviewed-By: Chemi Atlow Reviewed-By: Tim Perry Reviewed-By: James M Snell --- lib/_http_client.js | 2 +- ...test-http-client-null-prototype-options.js | 62 +++++++++++++++++++ 2 files changed, 63 insertions(+), 1 deletion(-) create mode 100644 test/parallel/test-http-client-null-prototype-options.js diff --git a/lib/_http_client.js b/lib/_http_client.js index 62215fc4c89b70..b7f0aa759b0643 100644 --- a/lib/_http_client.js +++ b/lib/_http_client.js @@ -209,7 +209,7 @@ function ClientRequest(input, options, cb) { cb = options; options = input || kEmptyObject; } else { - options = ObjectAssign(input || {}, options); + options = ObjectAssign({ __proto__: null }, input, options); } let agent = options.agent; diff --git a/test/parallel/test-http-client-null-prototype-options.js b/test/parallel/test-http-client-null-prototype-options.js new file mode 100644 index 00000000000000..22e1b2dcec0f3a --- /dev/null +++ b/test/parallel/test-http-client-null-prototype-options.js @@ -0,0 +1,62 @@ +'use strict'; + +const common = require('../common'); +const assert = require('node:assert'); +const http = require('node:http'); + +const server = http.createServer(common.mustCall((req, res) => { + req.resume(); + req.on('end', common.mustCall(() => { + res.end('ok'); + })); +}, 2)); + +function makeRequest(options, callback) { + Object.defineProperty(Object.prototype, 'hostname', { + __proto__: null, + configurable: true, + get: common.mustNotCall('get %Object.prototype%.hostname'), + }); + + let req; + try { + req = http.request(options, callback); + } finally { + delete Object.prototype.hostname; + } + + req.on('error', common.mustNotCall()); + req.end(); +} + +server.listen(0, common.localhostIPv4, common.mustCall(() => { + const { address, port } = server.address(); + + makeRequest( + { + host: address, + port, + path: '/', + }, + common.mustCall((res) => { + assert.strictEqual(res.statusCode, 200); + res.resume(); + res.on('end', common.mustCall()); + }), + ); + + const nullProtoOptions = { __proto__: null, host: address, port, path: '/' }; + + assert.strictEqual(Object.getPrototypeOf(nullProtoOptions), null); + + makeRequest( + nullProtoOptions, + common.mustCall((res) => { + assert.strictEqual(res.statusCode, 200); + res.resume(); + res.on('end', common.mustCall(() => { + server.close(common.mustCall()); + })); + }), + ); +})); From 266cd6749d5d49cd8347d6995b24655c98b30323 Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Mon, 4 May 2026 18:07:26 +0200 Subject: [PATCH 051/168] stream: remove duplicated utility Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/63031 Reviewed-By: Matteo Collina Reviewed-By: James M Snell --- lib/internal/webstreams/queuingstrategies.js | 9 +------- lib/internal/webstreams/readablestream.js | 19 +++++----------- lib/internal/webstreams/transformstream.js | 12 +++------- lib/internal/webstreams/util.js | 23 ++++++++++++++------ lib/internal/webstreams/writablestream.js | 21 ++++++------------ 5 files changed, 33 insertions(+), 51 deletions(-) diff --git a/lib/internal/webstreams/queuingstrategies.js b/lib/internal/webstreams/queuingstrategies.js index cb2adefdacaee9..aa5e5e58af23af 100644 --- a/lib/internal/webstreams/queuingstrategies.js +++ b/lib/internal/webstreams/queuingstrategies.js @@ -19,6 +19,7 @@ const { const { customInspect, + getNonWritablePropertyDescriptor, } = require('internal/webstreams/util'); const { @@ -46,14 +47,6 @@ const byteSizeFunction = ObjectDefineProperty( ); const countSizeFunction = ObjectDefineProperty(() => 1, 'name', nameDescriptor); -const getNonWritablePropertyDescriptor = (value) => { - return { - __proto__: null, - configurable: true, - value, - }; -}; - /** * @type {QueuingStrategy} */ diff --git a/lib/internal/webstreams/readablestream.js b/lib/internal/webstreams/readablestream.js index 597135778a1e0f..7abde514cf78a5 100644 --- a/lib/internal/webstreams/readablestream.js +++ b/lib/internal/webstreams/readablestream.js @@ -106,15 +106,16 @@ const { enqueueValueWithSize, extractHighWaterMark, extractSizeAlgorithm, - lazyTransfer, + getNonWritablePropertyDescriptor, isBrandCheck, - resetQueue, - setPromiseHandled, + kState, + kType, + lazyTransfer, nonOpCancel, nonOpPull, nonOpStart, - kType, - kState, + resetQueue, + setPromiseHandled, } = require('internal/webstreams/util'); const { @@ -171,14 +172,6 @@ function lazyReadableReleasingError() { return releasingError; } -const getNonWritablePropertyDescriptor = (value) => { - return { - __proto__: null, - configurable: true, - value, - }; -}; - /** * @typedef {import('../abort_controller').AbortSignal} AbortSignal * @typedef {import('./queuingstrategies').QueuingStrategy} QueuingStrategy diff --git a/lib/internal/webstreams/transformstream.js b/lib/internal/webstreams/transformstream.js index e2d15c05bca249..96d48b438d479c 100644 --- a/lib/internal/webstreams/transformstream.js +++ b/lib/internal/webstreams/transformstream.js @@ -47,11 +47,12 @@ const { customInspect, extractHighWaterMark, extractSizeAlgorithm, + getNonWritablePropertyDescriptor, isBrandCheck, - nonOpFlush, - kType, kState, + kType, nonOpCancel, + nonOpFlush, } = require('internal/webstreams/util'); const { @@ -72,13 +73,6 @@ const { const assert = require('internal/assert'); const kSkipThrow = Symbol('kSkipThrow'); -const getNonWritablePropertyDescriptor = (value) => { - return { - __proto__: null, - configurable: true, - value, - }; -}; /** * @typedef {import('./queuingstrategies').QueuingStrategy diff --git a/lib/internal/webstreams/util.js b/lib/internal/webstreams/util.js index de92c11bb12573..4bb4522e55c042 100644 --- a/lib/internal/webstreams/util.js +++ b/lib/internal/webstreams/util.js @@ -52,6 +52,14 @@ const AsyncIterator = { return: undefined, }; +const getNonWritablePropertyDescriptor = (value) => { + return { + __proto__: null, + configurable: true, + value, + }; +}; + function extractHighWaterMark(value, defaultHWM) { if (value === undefined) return defaultHWM; value = +value; @@ -204,25 +212,26 @@ module.exports = { ArrayBufferViewGetByteOffset, AsyncIterator, canCopyArrayBuffer, - createPromiseCallback, cloneAsUint8Array, copyArrayBuffer, + createPromiseCallback, customInspect, dequeueValue, enqueueValueWithSize, extractHighWaterMark, extractSizeAlgorithm, - lazyTransfer, + getNonWritablePropertyDescriptor, isBrandCheck, isPromisePending, - peekQueueValue, - resetQueue, - setPromiseHandled, + kState, + kType, + lazyTransfer, nonOpCancel, nonOpFlush, nonOpPull, nonOpStart, nonOpWrite, - kType, - kState, + peekQueueValue, + resetQueue, + setPromiseHandled, }; diff --git a/lib/internal/webstreams/writablestream.js b/lib/internal/webstreams/writablestream.js index ca20c08b258c3c..8f62a199d5b301 100644 --- a/lib/internal/webstreams/writablestream.js +++ b/lib/internal/webstreams/writablestream.js @@ -61,17 +61,18 @@ const { enqueueValueWithSize, extractHighWaterMark, extractSizeAlgorithm, - lazyTransfer, + getNonWritablePropertyDescriptor, isBrandCheck, isPromisePending, - peekQueueValue, - resetQueue, - setPromiseHandled, + kState, + kType, + lazyTransfer, nonOpCancel, nonOpStart, nonOpWrite, - kType, - kState, + peekQueueValue, + resetQueue, + setPromiseHandled, } = require('internal/webstreams/util'); const { @@ -106,14 +107,6 @@ function lazyWritableReleasedError() { return releasedError; } -const getNonWritablePropertyDescriptor = (value) => { - return { - __proto__: null, - configurable: true, - value, - }; -}; - /** * @typedef {import('../abort_controller').AbortSignal} AbortSignal * @typedef {import('./queuingstrategies').QueuingStrategy From c21c6645587a652a52dc045aafe3e0c7169a9a96 Mon Sep 17 00:00:00 2001 From: Robert Nagy Date: Mon, 4 May 2026 18:30:52 +0200 Subject: [PATCH 052/168] http: emit 'drain' on OutgoingMessage only after buffers drain MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Previously, socketOnDrain could be invoked synchronously from _flushOutput (via _onPendingData -> updateOutgoingData) while the bytes just handed to the socket were still buffered and while outputSize had not yet been reset on the OutgoingMessage. The 'drain' event fired even though res.writableLength was non-zero, breaking the invariant a user would reasonably expect after `while (!res.write(...));`. Gate the emission in socketOnDrain on msg.writableLength === 0 (which also covers outputSize + chunked buffer + socket.writableLength), and apply the same check in OutgoingMessage._flush so that 'drain' is only emitted when the response is genuinely drained. The socket's own 'drain' event will otherwise propagate through socketOnDrain when the socket buffer actually empties. Signed-off-by: Robert Nagy Assisted-by: Claude Opus 4.6 (1M context) PR-URL: https://github.com/nodejs/node/pull/62936 Reviewed-By: Matteo Collina Reviewed-By: Ethan Arrowood Reviewed-By: Gürgün Dayıoğlu --- lib/_http_outgoing.js | 4 +- lib/_http_server.js | 8 ++- ...est-http-outgoing-drain-writable-length.js | 58 +++++++++++++++++++ 3 files changed, 67 insertions(+), 3 deletions(-) create mode 100644 test/parallel/test-http-outgoing-drain-writable-length.js diff --git a/lib/_http_outgoing.js b/lib/_http_outgoing.js index c5702bc9eab092..5a83849086294f 100644 --- a/lib/_http_outgoing.js +++ b/lib/_http_outgoing.js @@ -1148,12 +1148,12 @@ OutgoingMessage.prototype._flush = function _flush() { if (socket?.writable) { // There might be remaining data in this.output; write it out - const ret = this._flushOutput(socket); + this._flushOutput(socket); if (this.finished) { // This is a queue to the server or client to bring in the next this. this._finish(); - } else if (ret && this[kNeedDrain]) { + } else if (this[kNeedDrain] && this.writableLength === 0) { this[kNeedDrain] = false; this.emit('drain'); } diff --git a/lib/_http_server.js b/lib/_http_server.js index 575bb2582741e5..ccb7a1c754d569 100644 --- a/lib/_http_server.js +++ b/lib/_http_server.js @@ -820,7 +820,13 @@ function socketOnDrain(socket, state) { } const msg = socket._httpMessage; - if (msg && !msg.finished && msg[kNeedDrain]) { + // Only emit 'drain' once the message has no data pending anywhere, so that + // msg.writableLength === 0 when the event fires. socketOnDrain is called + // synchronously from updateOutgoingData during _flushOutput, at which point + // the bytes we just handed to the socket (or the stale outputSize) mean + // the message is not actually drained yet - we wait for the socket's + // own 'drain' event instead. + if (msg && !msg.finished && msg[kNeedDrain] && msg.writableLength === 0) { msg[kNeedDrain] = false; msg.emit('drain'); } diff --git a/test/parallel/test-http-outgoing-drain-writable-length.js b/test/parallel/test-http-outgoing-drain-writable-length.js new file mode 100644 index 00000000000000..39bb0a9447676d --- /dev/null +++ b/test/parallel/test-http-outgoing-drain-writable-length.js @@ -0,0 +1,58 @@ +'use strict'; +// Regression test: when a pipelined ServerResponse (whose writes were +// buffered in outputData while the socket belonged to a previous response) +// is finally assigned its socket and flushed, 'drain' must not be emitted +// until the socket's own buffer has actually drained. Previously, +// socketOnDrain was called synchronously from _flushOutput via _onPendingData +// and emitted 'drain' even though the bytes we just wrote were still sitting +// in the socket's writable buffer, so res.writableLength was non-zero. + +const common = require('../common'); +const http = require('http'); +const net = require('net'); +const assert = require('assert'); + +let step = 0; + +const server = http.createServer(common.mustCall((req, res) => { + step++; + + if (step === 1) { + // Keep the first response open briefly so the second is queued with + // res.socket === null. + res.writeHead(200, { 'Content-Type': 'text/plain' }); + setTimeout(() => res.end('ok'), 50); + return; + } + + // Second (pipelined) response - queued in state.outgoing, no socket yet. + assert.strictEqual(res.socket, null); + + res.writeHead(200, { 'Content-Type': 'text/plain' }); + + // Write past the response's highWaterMark so res.write() returns false + // and kNeedDrain is set. Data is buffered in outputData. + const chunk = Buffer.alloc(16 * 1024, 'x'); + while (res.write(chunk)); + assert.strictEqual(res.writableNeedDrain, true); + + res.on('drain', common.mustCall(() => { + assert.strictEqual( + res.writableLength, 0, + `'drain' fired with writableLength=${res.writableLength}`, + ); + res.end(); + server.close(); + })); +}, 2)); + +server.listen(0, common.mustCall(function() { + const port = this.address().port; + const client = net.connect(port); + client.write( + `GET /1 HTTP/1.1\r\nHost: localhost:${port}\r\n\r\n` + + `GET /2 HTTP/1.1\r\nHost: localhost:${port}\r\n\r\n`, + ); + client.resume(); + client.on('error', () => {}); +})); From 7eab492728cfe87f704ef6bcf1d5f2fda3b3bf77 Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Mon, 4 May 2026 18:31:06 +0200 Subject: [PATCH 053/168] stream: copyedit `webstreams/adapter.js` - Simplify `ZLIB_FAILURES` creation. - Cache `cause.code` in `handleKnownInternalErrors` in case of a getter. - Replace `SafePromiseAll` with `SafePromiseAllReturnVoid` to reduce the number of allocated promises. Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/63034 Reviewed-By: Matteo Collina Reviewed-By: James M Snell --- lib/internal/webstreams/adapters.js | 49 +++++++++++++---------------- 1 file changed, 22 insertions(+), 27 deletions(-) diff --git a/lib/internal/webstreams/adapters.js b/lib/internal/webstreams/adapters.js index 8befa6bbbafd72..a57c1241bf82be 100644 --- a/lib/internal/webstreams/adapters.js +++ b/lib/internal/webstreams/adapters.js @@ -2,13 +2,11 @@ const { ArrayPrototypeFilter, - ArrayPrototypeMap, - Boolean, - ObjectEntries, + ObjectKeys, PromisePrototypeThen, PromiseResolve, PromiseWithResolvers, - SafePromiseAll, + SafePromiseAllReturnVoid, SafePromisePrototypeFinally, SafeSet, StringPrototypeStartsWith, @@ -74,6 +72,7 @@ const { getDeprecationWarningEmitter, kEmptyObject, normalizeEncoding, + setOwnProperty, } = require('internal/util'); const { @@ -93,6 +92,7 @@ const { const { eos } = require('internal/streams/end-of-stream'); +const { zlib } = internalBinding('constants'); const { UV_EOF } = internalBinding('uv'); const encoder = new TextEncoder(); @@ -101,37 +101,34 @@ const kValidateChunk = Symbol('kValidateChunk'); const kDestroyOnSyncError = Symbol('kDestroyOnSyncError'); // Collect all negative (error) ZLIB codes and Z_NEED_DICT -const ZLIB_FAILURES = new SafeSet([ - ...ArrayPrototypeFilter( - ArrayPrototypeMap( - ObjectEntries(internalBinding('constants').zlib), - ({ 0: code, 1: value }) => (value < 0 ? code : null), - ), - Boolean, +const ZLIB_FAILURES = new SafeSet( + ArrayPrototypeFilter( + ObjectKeys(zlib), + (code) => code === 'Z_NEED_DICT' || zlib[code] < 0, ), - 'Z_NEED_DICT', -]); +); /** * @param {Error|null} cause * @returns {Error|null} */ function handleKnownInternalErrors(cause) { + const causeCode = cause?.code; switch (true) { - case cause?.code === 'ERR_STREAM_PREMATURE_CLOSE': { + case causeCode === 'ERR_STREAM_PREMATURE_CLOSE': { return new AbortError(undefined, { cause }); } - case ZLIB_FAILURES.has(cause?.code): + case ZLIB_FAILURES.has(causeCode): // Brotli decoder error codes are formatted as 'ERR_' + // BrotliDecoderErrorString(), where the latter returns strings like // '_ERROR_FORMAT_...', '_ERROR_ALLOC_...', '_ERROR_UNREACHABLE', etc. // The resulting JS error codes all start with 'ERR__ERROR_'. // Falls through - case cause?.code != null && - StringPrototypeStartsWith(cause.code, 'ERR__ERROR_'): { + case causeCode != null && + StringPrototypeStartsWith(causeCode, 'ERR__ERROR_'): { // eslint-disable-next-line no-restricted-syntax const error = new TypeError(undefined, { cause }); - error.code = cause.code; + setOwnProperty(error, 'code', causeCode); return error; } default: @@ -190,8 +187,7 @@ function newWritableStreamFromStreamWritable(streamWritable, options = kEmptyObj let closed; function onDrain() { - if (backpressurePromise !== undefined) - backpressurePromise.resolve(); + backpressurePromise?.resolve(); } const cleanup = eos(streamWritable, (error) => { @@ -202,8 +198,7 @@ function newWritableStreamFromStreamWritable(streamWritable, options = kEmptyObj // that happen to emit an error event again after finished is called. streamWritable.on('error', () => {}); if (error != null) { - if (backpressurePromise !== undefined) - backpressurePromise.reject(error); + backpressurePromise?.reject(error); // If closed is not undefined, the error is happening // after the WritableStream close has already started. // We need to reject it here. @@ -330,10 +325,10 @@ function newStreamWritableFromWritableStream(writableStream, options = kEmptyObj writer.ready, () => { return PromisePrototypeThen( - SafePromiseAll( + SafePromiseAllReturnVoid( chunks, (data) => writer.write(data.chunk)), - () => done(), + done, done); }, done); @@ -802,10 +797,10 @@ function newStreamDuplexFromReadableWritablePair(pair = kEmptyObject, options = writer.ready, () => { return PromisePrototypeThen( - SafePromiseAll( + SafePromiseAllReturnVoid( chunks, (data) => writer.write(data.chunk)), - () => done(), + done, done); }, done); @@ -907,7 +902,7 @@ function newStreamDuplexFromReadableWritablePair(pair = kEmptyObject, options = if (!writableClosed || !readableClosed) { PromisePrototypeThen( - SafePromiseAll([ + SafePromiseAllReturnVoid([ closeWriter(), closeReader(), ]), From 396a07a08b66fbf6c81e8279d5cebb1c9c11dafb Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Mon, 4 May 2026 18:31:20 +0200 Subject: [PATCH 054/168] tools: implements a few nits on `build-aarch64-linux-v8` Rename things, and merge some steps. Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/63048 Reviewed-By: Filip Skokan Reviewed-By: James M Snell --- .github/workflows/test-shared.yml | 39 +++++++++++++------------------ 1 file changed, 16 insertions(+), 23 deletions(-) diff --git a/.github/workflows/test-shared.yml b/.github/workflows/test-shared.yml index a9f18bfc6b6629..26e55b07078b16 100644 --- a/.github/workflows/test-shared.yml +++ b/.github/workflows/test-shared.yml @@ -173,6 +173,8 @@ jobs: outputs: local-cache: ${{ steps.upload.outcome != 'skipped' && 'true' || '' }} matrix: ${{ steps.query.outputs.matrix }} + env: + HAS_CACHIX_AUTH_TOKEN: ${{ secrets.CACHIX_AUTH_TOKEN && 'true' }} steps: - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 with: @@ -189,58 +191,49 @@ jobs: with: extra_nix_config: sandbox = true - - name: Evaluate V8 derivation + - name: Evaluate V8 derivation, check its cache status id: v8-drv run: | V8_DRV=$( nix-instantiate -E "builtins.filter (p: p.pname == ''v8'') (import $TAR_DIR/shell.nix { useSeparateDerivationForV8=true; }).buildInputs" ) + V8_STORE_PATH=$(nix-store -q --outputs "$V8_DRV") echo "V8_DRV=$V8_DRV" >> "$GITHUB_OUTPUT" - echo "STORE_PATH=$(nix-store -q --outputs "$V8_DRV")" >> "$GITHUB_OUTPUT" - - - name: Check if available on Cachix - id: cachix-check - run: | - echo 'HAS_WRITE_TOKEN=${{ secrets.CACHIX_AUTH_TOKEN && 'true' }}' >> "$GITHUB_OUTPUT" set -x [ "$(curl -ISsw "%{http_code}" -o /dev/null "https://nodejs.cachix.org/$(basename ${V8_STORE_PATH%-v8-*}).narinfo")" != "200" ] || echo "ALREADY_CACHED=true" >> "$GITHUB_OUTPUT" - env: - V8_STORE_PATH: ${{ steps.v8-drv.outputs.STORE_PATH }} - uses: cachix/cachix-action@1eb2ef646ac0255473d23a5907ad7b04ce94065c # v17 - if: ${{ steps.cachix-check.outputs.ALREADY_CACHED != 'true' }} + if: ${{ steps.v8-drv.outputs.ALREADY_CACHED != 'true' }} with: name: nodejs authToken: ${{ secrets.CACHIX_AUTH_TOKEN }} - - name: Build V8 derivation - if: ${{ steps.cachix-check.outputs.ALREADY_CACHED != 'true' }} - run: nix-store --export "$(nix-build "$V8_DRV")" > libv8 + - name: Build V8 to cache it + if: ${{ steps.v8-drv.outputs.ALREADY_CACHED != 'true' }} + run: nix-store --export "$(nix-build "$V8_DRV")" > libv8-aarch64-linux.nar env: V8_DRV: ${{ steps.v8-drv.outputs.V8_DRV }} - - name: Upload libv8 - if: ${{ steps.cachix-check.outputs.ALREADY_CACHED != 'true' && steps.cachix-check.outputs.HAS_WRITE_TOKEN != 'true' }} + - name: Upload libv8-aarch64-linux.nar + if: ${{ steps.v8-drv.outputs.ALREADY_CACHED != 'true' && env.HAS_CACHIX_AUTH_TOKEN != 'true' }} id: upload uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 with: - name: libv8 - path: libv8 + name: libv8-aarch64-linux.nar + path: libv8-aarch64-linux.nar - name: Collect matrix of support OpenSSL versions id: query run: | - { - echo 'matrix<> "$GITHUB_OUTPUT" + )" >> "$GITHUB_OUTPUT" # Builds and tests Node.js with shared libraries against every supported # OpenSSL release version available in the repo-pinned nixpkgs. The default @@ -268,7 +261,7 @@ jobs: - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 if: ${{ needs.build-aarch64-linux-v8.outputs.local-cache }} with: - name: libv8 + name: libv8-aarch64-linux.nar - uses: ./.github/actions/build-shared name: Build and test Node.js @@ -281,7 +274,7 @@ jobs: # release (e.g. `openssl-1.1.1w`) so EOL-with-extended-support # cycles evaluate without relaxing nixpkgs' meta check globally. extra-nix-flags: | - --arg useSeparateDerivationForV8 ${{ needs.build-aarch64-linux-v8.outputs.local-cache && '"$(nix-store --import < libv8)"' || 'true' }} \ + --arg useSeparateDerivationForV8 ${{ needs.build-aarch64-linux-v8.outputs.local-cache && '"$(nix-store --import < libv8-aarch64-linux.nar)"' || 'true' }} \ --arg sharedLibDeps "(import $TAR_DIR/tools/nix/sharedLibDeps.nix {}) // { openssl = (import $TAR_DIR/tools/nix/openssl-matrix.nix {}).$OPENSSL_ATTR; }" \ From 6e2188e5d28a4717673bcfd06748110d8ce2b4f5 Mon Sep 17 00:00:00 2001 From: Robo Date: Tue, 5 May 2026 01:33:19 +0900 Subject: [PATCH 055/168] build: track PDL files as inputs in inspector GN build The `node_protocol_generated_sources` action was missing `gypi_values.node_pdl_files` from its inputs, causing Ninja to skip regeneration when PDL domain files changed. PR-URL: https://github.com/nodejs/node/pull/62888 Reviewed-By: Chengzhong Wu Reviewed-By: Anna Henningsen Reviewed-By: Kohei Ueno --- src/inspector/unofficial.gni | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/inspector/unofficial.gni b/src/inspector/unofficial.gni index 4810d93eb971b2..48cf5102630737 100644 --- a/src/inspector/unofficial.gni +++ b/src/inspector/unofficial.gni @@ -29,7 +29,7 @@ template("inspector_gn_build") { deps = [ ":node_protocol_json" ] outputs = gypi_values.node_inspector_generated_sources - inputs = gypi_values.node_protocol_files + [ + inputs = gypi_values.node_protocol_files + gypi_values.node_pdl_files + [ "node_protocol_config.json", "$node_gen_dir/src/node_protocol.json", ] From 6ef8dc8cc23366af36a664e3a60c04965a9c1488 Mon Sep 17 00:00:00 2001 From: Nenad Spasenic <40522817+nsinfoPRO@users.noreply.github.com> Date: Mon, 4 May 2026 21:45:44 +0200 Subject: [PATCH 056/168] tools: use LTS Node.js in notify-on-push workflow MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Without pinning Node.js, the runner defaults to Node 20 and npx falls back to core-validate-commit@5.0.1 instead of 6.0.0 (requires Node 22+). Version 5 does not recognise the ffi subsystem, causing false invalid-commit alerts. Signed-off-by: Nenad Spasenic <40522817+nsinfoPRO@users.noreply.github.com> PR-URL: https://github.com/nodejs/node/pull/63084 Fixes: https://github.com/nodejs/node/issues/63070 Reviewed-By: Antoine du Hamel Reviewed-By: Michaël Zasso --- .github/workflows/notify-on-push.yml | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/.github/workflows/notify-on-push.yml b/.github/workflows/notify-on-push.yml index 605a896541f2f3..9ca33943c968c5 100644 --- a/.github/workflows/notify-on-push.yml +++ b/.github/workflows/notify-on-push.yml @@ -7,6 +7,9 @@ name: Notify on Push permissions: contents: read +env: + NODE_VERSION: lts/* + jobs: notifyOnForcePush: name: Notify on Force Push on `main` @@ -33,6 +36,10 @@ jobs: # cannot use ubuntu-slim here because rtCamp/action-slack-notify is dockerized runs-on: ubuntu-24.04-arm steps: + - name: Install Node.js + uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0 + with: + node-version: ${{ env.NODE_VERSION }} - name: Validate commits run: echo "$COMMITS" | npx -q core-validate-commit - id: commit-check From 63c076ebd7f77ce4845480859717993e5f09a67c Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 4 May 2026 22:11:39 +0000 Subject: [PATCH 057/168] tools: bump postcss from 8.5.8 to 8.5.10 in /tools/doc Bumps [postcss](https://github.com/postcss/postcss) from 8.5.8 to 8.5.10. - [Release notes](https://github.com/postcss/postcss/releases) - [Changelog](https://github.com/postcss/postcss/blob/main/CHANGELOG.md) - [Commits](https://github.com/postcss/postcss/compare/8.5.8...8.5.10) --- updated-dependencies: - dependency-name: postcss dependency-version: 8.5.10 dependency-type: indirect ... Signed-off-by: dependabot[bot] PR-URL: https://github.com/nodejs/node/pull/62966 Reviewed-By: Antoine du Hamel --- tools/doc/package-lock.json | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tools/doc/package-lock.json b/tools/doc/package-lock.json index 592efc9b202a8b..98473009405ae5 100644 --- a/tools/doc/package-lock.json +++ b/tools/doc/package-lock.json @@ -5156,9 +5156,9 @@ } }, "node_modules/postcss": { - "version": "8.5.8", - "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.8.tgz", - "integrity": "sha512-OW/rX8O/jXnm82Ey1k44pObPtdblfiuWnrd8X7GJ7emImCOstunGbXUpp7HdBrFQX6rJzn3sPT397Wp5aCwCHg==", + "version": "8.5.10", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.10.tgz", + "integrity": "sha512-pMMHxBOZKFU6HgAZ4eyGnwXF/EvPGGqUr0MnZ5+99485wwW41kW91A4LOGxSHhgugZmSChL5AlElNdwlNgcnLQ==", "funding": [ { "type": "opencollective", From 459672f50350274937089f3b324b543bcbafce34 Mon Sep 17 00:00:00 2001 From: "Node.js GitHub Bot" Date: Mon, 4 May 2026 21:04:58 -0400 Subject: [PATCH 058/168] test: update WPT for url to 258f285de0 PR-URL: https://github.com/nodejs/node/pull/63087 Reviewed-By: Chemi Atlow Reviewed-By: Luigi Pinca Reviewed-By: Colin Ihrig Reviewed-By: Matteo Collina --- test/fixtures/wpt/README.md | 2 +- test/fixtures/wpt/url/resources/urltestdata.json | 10 ++++++++++ test/fixtures/wpt/versions.json | 2 +- 3 files changed, 12 insertions(+), 2 deletions(-) diff --git a/test/fixtures/wpt/README.md b/test/fixtures/wpt/README.md index 2129ee15c5b8a8..ebbffd5e53fe3b 100644 --- a/test/fixtures/wpt/README.md +++ b/test/fixtures/wpt/README.md @@ -28,7 +28,7 @@ Last update: - resource-timing: https://github.com/web-platform-tests/wpt/tree/22d38586d0/resource-timing - resources: https://github.com/web-platform-tests/wpt/tree/6a2f322376/resources - streams: https://github.com/web-platform-tests/wpt/tree/f8f26a372f/streams -- url: https://github.com/web-platform-tests/wpt/tree/7a3645b79a/url +- url: https://github.com/web-platform-tests/wpt/tree/258f285de0/url - urlpattern: https://github.com/web-platform-tests/wpt/tree/f07c03cbed/urlpattern - user-timing: https://github.com/web-platform-tests/wpt/tree/5ae85bf826/user-timing - wasm/jsapi: https://github.com/web-platform-tests/wpt/tree/65a2134d50/wasm/jsapi diff --git a/test/fixtures/wpt/url/resources/urltestdata.json b/test/fixtures/wpt/url/resources/urltestdata.json index e88d22690361ee..2c29e7907b2484 100644 --- a/test/fixtures/wpt/url/resources/urltestdata.json +++ b/test/fixtures/wpt/url/resources/urltestdata.json @@ -6070,6 +6070,16 @@ "base": "http://other.com/", "failure": true }, + { + "input": "http://18446744073709551616", + "base": "http://other.com/", + "failure": true + }, + { + "input": "http://18446744075840258049", + "base": "http://other.com/", + "failure": true + }, { "input": "http://0xffffffff", "base": "http://other.com/", diff --git a/test/fixtures/wpt/versions.json b/test/fixtures/wpt/versions.json index 68dde063450d82..e3c707ac35cc28 100644 --- a/test/fixtures/wpt/versions.json +++ b/test/fixtures/wpt/versions.json @@ -72,7 +72,7 @@ "path": "streams" }, "url": { - "commit": "7a3645b79ade98a05066a09ce88e143daac31535", + "commit": "258f285de043b79e44324228c0fd800b38d21879", "path": "url" }, "urlpattern": { From 270a694ed149c7c60bac41d55dbf94d26b1c3ea1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ren=C3=A9?= Date: Tue, 5 May 2026 02:47:12 +0100 Subject: [PATCH 059/168] doc: minor structural stream/iter edits Signed-off-by: Renegade334 PR-URL: https://github.com/nodejs/node/pull/63089 Reviewed-By: Antoine du Hamel Reviewed-By: James M Snell --- doc/api/index.md | 3 +- doc/api/stream_iter.md | 21 ++-- doc/api/zlib.md | 255 ++++++++++++++++++++++++++++++++++++++++- doc/api/zlib_iter.md | 254 ---------------------------------------- 4 files changed, 265 insertions(+), 268 deletions(-) delete mode 100644 doc/api/zlib_iter.md diff --git a/doc/api/index.md b/doc/api/index.md index 1c9cc02c6d80a7..1f766e11454fb6 100644 --- a/doc/api/index.md +++ b/doc/api/index.md @@ -35,13 +35,13 @@ * [HTTPS](https.md) * [Inspector](inspector.md) * [Internationalization](intl.md) +* [Iterable Streams API](stream_iter.md) * [Modules: CommonJS modules](modules.md) * [Modules: ECMAScript modules](esm.md) * [Modules: `node:module` API](module.md) * [Modules: Packages](packages.md) * [Modules: TypeScript](typescript.md) * [Net](net.md) -* [Iterable Streams API](stream_iter.md) * [OS](os.md) * [Path](path.md) * [Performance hooks](perf_hooks.md) @@ -71,7 +71,6 @@ * [Web Streams API](webstreams.md) * [Worker threads](worker_threads.md) * [Zlib](zlib.md) -* [Zlib Iterable Compression](zlib_iter.md)
diff --git a/doc/api/stream_iter.md b/doc/api/stream_iter.md index 55b7d0a70240b8..2f8d0341216380 100644 --- a/doc/api/stream_iter.md +++ b/doc/api/stream_iter.md @@ -416,7 +416,7 @@ if (writer.endSync() < 0) await writer.end(); writer.fail(err); // Always synchronous, no fallback needed ``` -### `writer.desiredSize` +#### `writer.desiredSize` * {number|null} @@ -425,7 +425,7 @@ Returns `null` if the writer is closed or the consumer has disconnected. The value is always non-negative. -### `writer.end([options])` +#### `writer.end([options])` * `options` {Object} * `signal` {AbortSignal} Cancel just this operation. The signal cancels only @@ -434,7 +434,7 @@ The value is always non-negative. Signal that no more data will be written. -### `writer.endSync()` +#### `writer.endSync()` * Returns: {number} Total bytes written, or `-1` if the writer is not open. @@ -448,7 +448,7 @@ if (result < 0) { } ``` -### `writer.fail(reason)` +#### `writer.fail(reason)` * `reason` {any} @@ -457,7 +457,7 @@ or errored, this is a no-op. Unlike `write()` and `end()`, `fail()` is unconditionally synchronous because failing a writer is a pure state transition with no async work to perform. -### `writer.write(chunk[, options])` +#### `writer.write(chunk[, options])` * `chunk` {Uint8Array|string} * `options` {Object} @@ -467,7 +467,7 @@ transition with no async work to perform. Write a chunk. The promise resolves when buffer space is available. -### `writer.writeSync(chunk)` +#### `writer.writeSync(chunk)` * `chunk` {Uint8Array|string} * Returns: {boolean} `true` if the write was accepted, `false` if the @@ -475,7 +475,7 @@ Write a chunk. The promise resolves when buffer space is available. Synchronous write. Does not block; returns `false` if backpressure is active. -### `writer.writev(chunks[, options])` +#### `writer.writev(chunks[, options])` * `chunks` {Uint8Array\[]|string\[]} * `options` {Object} @@ -485,7 +485,7 @@ Synchronous write. Does not block; returns `false` if backpressure is active. Write multiple chunks as a single batch. -### `writer.writevSync(chunks)` +#### `writer.writevSync(chunks)` * `chunks` {Uint8Array\[]|string\[]} * Returns: {boolean} `true` if the write was accepted, `false` if the @@ -1422,7 +1422,7 @@ added: v25.9.0 Compression and decompression transforms for use with `pull()`, `pullSync()`, `pipeTo()`, and `pipeToSync()` are available via the [`node:zlib/iter`][] -module. See the [`node:zlib/iter` documentation][] for details. +module. See the [`node:zlib/iter` documentation][`node:zlib/iter`] for details. ## Classic stream interop @@ -2069,8 +2069,7 @@ console.log(textSync(stream)); // 'hello world' [`bytes()`]: #bytessource-options [`from()`]: #frominput [`fromSync()`]: #fromsyncinput -[`node:zlib/iter`]: zlib_iter.md -[`node:zlib/iter` documentation]: zlib_iter.md +[`node:zlib/iter`]: zlib.md#iterable-compression [`pipeTo()`]: #pipetosource-transforms-writer-options [`pull()`]: #pullsource-transforms-options [`pullSync()`]: #pullsyncsource-transforms-options diff --git a/doc/api/zlib.md b/doc/api/zlib.md index 4ef24328ca6ec0..ce296a07ac6c05 100644 --- a/doc/api/zlib.md +++ b/doc/api/zlib.md @@ -1746,11 +1746,261 @@ added: Decompress a chunk of data with [`ZstdDecompress`][]. +## Iterable Compression + + + +> Stability: 1 - Experimental + +The `node:zlib/iter` module provides compression and decompression transforms +for use with the [`node:stream/iter`][] iterable streams API. + +This module is available only when the `--experimental-stream-iter` CLI flag +is enabled. + +Each algorithm has both an async variant (stateful async generator, for use +with [`pull()`][] and [`pipeTo()`][]) and a sync variant (stateful sync +generator, for use with `pullSync()` and `pipeToSync()`). + +The async transforms run compression on the libuv threadpool, overlapping +I/O with JavaScript execution. The sync transforms run compression directly +on the main thread. + +> Note: The defaults for these transforms are tuned for streaming throughput, +> and differ from the defaults in `node:zlib`. In particular, gzip/deflate +> default to level 4 (not 6) and memLevel 9 (not 8), and Brotli defaults to +> quality 6 (not 11). These choices match common HTTP server configurations +> and provide significantly faster compression with only a small reduction in +> compression ratio. All defaults can be overridden via options. + +```mjs +import { from, pull, bytes, text } from 'node:stream/iter'; +import { compressGzip, decompressGzip } from 'node:zlib/iter'; + +// Async round-trip +const compressed = await bytes(pull(from('hello'), compressGzip())); +const original = await text(pull(from(compressed), decompressGzip())); +console.log(original); // 'hello' +``` + +```cjs +const { from, pull, bytes, text } = require('node:stream/iter'); +const { compressGzip, decompressGzip } = require('node:zlib/iter'); + +async function run() { + const compressed = await bytes(pull(from('hello'), compressGzip())); + const original = await text(pull(from(compressed), decompressGzip())); + console.log(original); // 'hello' +} + +run().catch(console.error); +``` + +```mjs +import { fromSync, pullSync, textSync } from 'node:stream/iter'; +import { compressGzipSync, decompressGzipSync } from 'node:zlib/iter'; + +// Sync round-trip +const compressed = pullSync(fromSync('hello'), compressGzipSync()); +const original = textSync(pullSync(compressed, decompressGzipSync())); +console.log(original); // 'hello' +``` + +```cjs +const { fromSync, pullSync, textSync } = require('node:stream/iter'); +const { compressGzipSync, decompressGzipSync } = require('node:zlib/iter'); + +const compressed = pullSync(fromSync('hello'), compressGzipSync()); +const original = textSync(pullSync(compressed, decompressGzipSync())); +console.log(original); // 'hello' +``` + +### `compressBrotli([options])` + +### `compressBrotliSync([options])` + + + +* `options` {Object} + * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). + * `params` {Object} Key-value object where keys and values are + `zlib.constants` entries. The most important compressor parameters are: + * `BROTLI_PARAM_MODE` -- `BROTLI_MODE_GENERIC` (default), + `BROTLI_MODE_TEXT`, or `BROTLI_MODE_FONT`. + * `BROTLI_PARAM_QUALITY` -- ranges from `BROTLI_MIN_QUALITY` to + `BROTLI_MAX_QUALITY`. **Default:** `6` (not `BROTLI_DEFAULT_QUALITY` + which is 11). Quality 6 is appropriate for streaming; quality 11 is + intended for offline/build-time compression. + * `BROTLI_PARAM_SIZE_HINT` -- expected input size. **Default:** `0` + (unknown). + * `BROTLI_PARAM_LGWIN` -- window size (log2). **Default:** `20` (1 MB). + The Brotli library default is 22 (4 MB); the reduced default saves + memory without significant compression impact for streaming workloads. + * `BROTLI_PARAM_LGBLOCK` -- input block size (log2). + See the [Brotli compressor options][] in the zlib documentation for the + full list. + * `dictionary` {Buffer|TypedArray|DataView} +* Returns: {Object} A stateful transform. + +Create a Brotli compression transform. Output is compatible with +`zlib.brotliDecompress()` and `decompressBrotli()`/`decompressBrotliSync()`. + +### `compressDeflate([options])` + +### `compressDeflateSync([options])` + + + +* `options` {Object} + * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). + * `level` {number} Compression level (`0`-`9`). **Default:** `4`. + * `windowBits` {number} **Default:** `Z_DEFAULT_WINDOWBITS` (15). + * `memLevel` {number} **Default:** `9`. + * `strategy` {number} **Default:** `Z_DEFAULT_STRATEGY`. + * `dictionary` {Buffer|TypedArray|DataView} +* Returns: {Object} A stateful transform. + +Create a deflate compression transform. Output is compatible with +`zlib.inflate()` and `decompressDeflate()`/`decompressDeflateSync()`. + +### `compressGzip([options])` + +### `compressGzipSync([options])` + + + +* `options` {Object} + * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). + * `level` {number} Compression level (`0`-`9`). **Default:** `4`. + * `windowBits` {number} **Default:** `Z_DEFAULT_WINDOWBITS` (15). + * `memLevel` {number} **Default:** `9`. + * `strategy` {number} **Default:** `Z_DEFAULT_STRATEGY`. + * `dictionary` {Buffer|TypedArray|DataView} +* Returns: {Object} A stateful transform. + +Create a gzip compression transform. Output is compatible with `zlib.gunzip()` +and `decompressGzip()`/`decompressGzipSync()`. + +### `compressZstd([options])` + +### `compressZstdSync([options])` + + + +* `options` {Object} + * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). + * `params` {Object} Key-value object where keys and values are + `zlib.constants` entries. The most important compressor parameters are: + * `ZSTD_c_compressionLevel` -- **Default:** `ZSTD_CLEVEL_DEFAULT` (3). + * `ZSTD_c_checksumFlag` -- generate a checksum. **Default:** `0`. + * `ZSTD_c_strategy` -- compression strategy. Values include + `ZSTD_fast`, `ZSTD_dfast`, `ZSTD_greedy`, `ZSTD_lazy`, + `ZSTD_lazy2`, `ZSTD_btlazy2`, `ZSTD_btopt`, `ZSTD_btultra`, + `ZSTD_btultra2`. + See the [Zstd compressor options][] in the zlib documentation for the + full list. + * `pledgedSrcSize` {number} Expected uncompressed size (optional hint). + * `dictionary` {Buffer|TypedArray|DataView} +* Returns: {Object} A stateful transform. + +Create a Zstandard compression transform. Output is compatible with +`zlib.zstdDecompress()` and `decompressZstd()`/`decompressZstdSync()`. + +### `decompressBrotli([options])` + +### `decompressBrotliSync([options])` + + + +* `options` {Object} + * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). + * `params` {Object} Key-value object where keys and values are + `zlib.constants` entries. Available decompressor parameters: + * `BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION` -- boolean + flag affecting internal memory allocation. + * `BROTLI_DECODER_PARAM_LARGE_WINDOW` -- boolean flag enabling "Large + Window Brotli" mode (not compatible with [RFC 7932][]). + See the [Brotli decompressor options][] in the zlib documentation for + details. + * `dictionary` {Buffer|TypedArray|DataView} +* Returns: {Object} A stateful transform. + +Create a Brotli decompression transform. + +### `decompressDeflate([options])` + +### `decompressDeflateSync([options])` + + + +* `options` {Object} + * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). + * `windowBits` {number} **Default:** `Z_DEFAULT_WINDOWBITS` (15). + * `dictionary` {Buffer|TypedArray|DataView} +* Returns: {Object} A stateful transform. + +Create a deflate decompression transform. + +### `decompressGzip([options])` + +### `decompressGzipSync([options])` + + + +* `options` {Object} + * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). + * `windowBits` {number} **Default:** `Z_DEFAULT_WINDOWBITS` (15). + * `dictionary` {Buffer|TypedArray|DataView} +* Returns: {Object} A stateful transform. + +Create a gzip decompression transform. + +### `decompressZstd([options])` + +### `decompressZstdSync([options])` + + + +* `options` {Object} + * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). + * `params` {Object} Key-value object where keys and values are + `zlib.constants` entries. Available decompressor parameters: + * `ZSTD_d_windowLogMax` -- maximum window size (log2) the decompressor + will allocate. Limits memory usage against malicious input. + See the [Zstd decompressor options][] in the zlib documentation for + details. + * `dictionary` {Buffer|TypedArray|DataView} +* Returns: {Object} A stateful transform. + +Create a Zstandard decompression transform. + +[Brotli compressor options]: #compressor-options +[Brotli decompressor options]: #decompressor-options [Brotli parameters]: #brotli-constants [Cyclic redundancy check]: https://en.wikipedia.org/wiki/Cyclic_redundancy_check [Memory usage tuning]: #memory-usage-tuning -[RFC 7932]: https://www.rfc-editor.org/rfc/rfc7932.txt +[RFC 7932]: https://www.rfc-editor.org/rfc/rfc7932.html [Streams API]: stream.md +[Zstd compressor options]: #compressor-options-1 +[Zstd decompressor options]: #decompressor-options-1 [Zstd parameters]: #zstd-constants [`.flush()`]: #zlibflushkind-callback [`Accept-Encoding`]: https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.3 @@ -1769,6 +2019,9 @@ Decompress a chunk of data with [`ZstdDecompress`][]. [`ZstdDecompress`]: #class-zlibzstddecompress [`buffer.kMaxLength`]: buffer.md#bufferkmaxlength [`deflateInit2` and `inflateInit2`]: https://zlib.net/manual.html#Advanced +[`node:stream/iter`]: stream_iter.md +[`pipeTo()`]: stream_iter.md#pipetosource-transforms-writer-options +[`pull()`]: stream_iter.md#pullsource-transforms-options [`stream.Transform`]: stream.md#class-streamtransform [convenience methods]: #convenience-methods [zlib documentation]: https://zlib.net/manual.html#Constants diff --git a/doc/api/zlib_iter.md b/doc/api/zlib_iter.md deleted file mode 100644 index 99bcdba745203d..00000000000000 --- a/doc/api/zlib_iter.md +++ /dev/null @@ -1,254 +0,0 @@ -# Iterable Compression - - - -> Stability: 1 - Experimental - - - -The `node:zlib/iter` module provides compression and decompression transforms -for use with the [`node:stream/iter`][] iterable streams API. - -This module is available only when the `--experimental-stream-iter` CLI flag -is enabled. - -Each algorithm has both an async variant (stateful async generator, for use -with [`pull()`][] and [`pipeTo()`][]) and a sync variant (stateful sync -generator, for use with `pullSync()` and `pipeToSync()`). - -The async transforms run compression on the libuv threadpool, overlapping -I/O with JavaScript execution. The sync transforms run compression directly -on the main thread. - -> Note: The defaults for these transforms are tuned for streaming throughput, -> and differ from the defaults in `node:zlib`. In particular, gzip/deflate -> default to level 4 (not 6) and memLevel 9 (not 8), and Brotli defaults to -> quality 6 (not 11). These choices match common HTTP server configurations -> and provide significantly faster compression with only a small reduction in -> compression ratio. All defaults can be overridden via options. - -```mjs -import { from, pull, bytes, text } from 'node:stream/iter'; -import { compressGzip, decompressGzip } from 'node:zlib/iter'; - -// Async round-trip -const compressed = await bytes(pull(from('hello'), compressGzip())); -const original = await text(pull(from(compressed), decompressGzip())); -console.log(original); // 'hello' -``` - -```cjs -const { from, pull, bytes, text } = require('node:stream/iter'); -const { compressGzip, decompressGzip } = require('node:zlib/iter'); - -async function run() { - const compressed = await bytes(pull(from('hello'), compressGzip())); - const original = await text(pull(from(compressed), decompressGzip())); - console.log(original); // 'hello' -} - -run().catch(console.error); -``` - -```mjs -import { fromSync, pullSync, textSync } from 'node:stream/iter'; -import { compressGzipSync, decompressGzipSync } from 'node:zlib/iter'; - -// Sync round-trip -const compressed = pullSync(fromSync('hello'), compressGzipSync()); -const original = textSync(pullSync(compressed, decompressGzipSync())); -console.log(original); // 'hello' -``` - -```cjs -const { fromSync, pullSync, textSync } = require('node:stream/iter'); -const { compressGzipSync, decompressGzipSync } = require('node:zlib/iter'); - -const compressed = pullSync(fromSync('hello'), compressGzipSync()); -const original = textSync(pullSync(compressed, decompressGzipSync())); -console.log(original); // 'hello' -``` - -## `compressBrotli([options])` - -## `compressBrotliSync([options])` - - - -* `options` {Object} - * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). - * `params` {Object} Key-value object where keys and values are - `zlib.constants` entries. The most important compressor parameters are: - * `BROTLI_PARAM_MODE` -- `BROTLI_MODE_GENERIC` (default), - `BROTLI_MODE_TEXT`, or `BROTLI_MODE_FONT`. - * `BROTLI_PARAM_QUALITY` -- ranges from `BROTLI_MIN_QUALITY` to - `BROTLI_MAX_QUALITY`. **Default:** `6` (not `BROTLI_DEFAULT_QUALITY` - which is 11). Quality 6 is appropriate for streaming; quality 11 is - intended for offline/build-time compression. - * `BROTLI_PARAM_SIZE_HINT` -- expected input size. **Default:** `0` - (unknown). - * `BROTLI_PARAM_LGWIN` -- window size (log2). **Default:** `20` (1 MB). - The Brotli library default is 22 (4 MB); the reduced default saves - memory without significant compression impact for streaming workloads. - * `BROTLI_PARAM_LGBLOCK` -- input block size (log2). - See the [Brotli compressor options][] in the zlib documentation for the - full list. - * `dictionary` {Buffer|TypedArray|DataView} -* Returns: {Object} A stateful transform. - -Create a Brotli compression transform. Output is compatible with -`zlib.brotliDecompress()` and `decompressBrotli()`/`decompressBrotliSync()`. - -## `compressDeflate([options])` - -## `compressDeflateSync([options])` - - - -* `options` {Object} - * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). - * `level` {number} Compression level (`0`-`9`). **Default:** `4`. - * `windowBits` {number} **Default:** `Z_DEFAULT_WINDOWBITS` (15). - * `memLevel` {number} **Default:** `9`. - * `strategy` {number} **Default:** `Z_DEFAULT_STRATEGY`. - * `dictionary` {Buffer|TypedArray|DataView} -* Returns: {Object} A stateful transform. - -Create a deflate compression transform. Output is compatible with -`zlib.inflate()` and `decompressDeflate()`/`decompressDeflateSync()`. - -## `compressGzip([options])` - -## `compressGzipSync([options])` - - - -* `options` {Object} - * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). - * `level` {number} Compression level (`0`-`9`). **Default:** `4`. - * `windowBits` {number} **Default:** `Z_DEFAULT_WINDOWBITS` (15). - * `memLevel` {number} **Default:** `9`. - * `strategy` {number} **Default:** `Z_DEFAULT_STRATEGY`. - * `dictionary` {Buffer|TypedArray|DataView} -* Returns: {Object} A stateful transform. - -Create a gzip compression transform. Output is compatible with `zlib.gunzip()` -and `decompressGzip()`/`decompressGzipSync()`. - -## `compressZstd([options])` - -## `compressZstdSync([options])` - - - -* `options` {Object} - * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). - * `params` {Object} Key-value object where keys and values are - `zlib.constants` entries. The most important compressor parameters are: - * `ZSTD_c_compressionLevel` -- **Default:** `ZSTD_CLEVEL_DEFAULT` (3). - * `ZSTD_c_checksumFlag` -- generate a checksum. **Default:** `0`. - * `ZSTD_c_strategy` -- compression strategy. Values include - `ZSTD_fast`, `ZSTD_dfast`, `ZSTD_greedy`, `ZSTD_lazy`, - `ZSTD_lazy2`, `ZSTD_btlazy2`, `ZSTD_btopt`, `ZSTD_btultra`, - `ZSTD_btultra2`. - See the [Zstd compressor options][] in the zlib documentation for the - full list. - * `pledgedSrcSize` {number} Expected uncompressed size (optional hint). - * `dictionary` {Buffer|TypedArray|DataView} -* Returns: {Object} A stateful transform. - -Create a Zstandard compression transform. Output is compatible with -`zlib.zstdDecompress()` and `decompressZstd()`/`decompressZstdSync()`. - -## `decompressBrotli([options])` - -## `decompressBrotliSync([options])` - - - -* `options` {Object} - * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). - * `params` {Object} Key-value object where keys and values are - `zlib.constants` entries. Available decompressor parameters: - * `BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION` -- boolean - flag affecting internal memory allocation. - * `BROTLI_DECODER_PARAM_LARGE_WINDOW` -- boolean flag enabling "Large - Window Brotli" mode (not compatible with [RFC 7932][]). - See the [Brotli decompressor options][] in the zlib documentation for - details. - * `dictionary` {Buffer|TypedArray|DataView} -* Returns: {Object} A stateful transform. - -Create a Brotli decompression transform. - -## `decompressDeflate([options])` - -## `decompressDeflateSync([options])` - - - -* `options` {Object} - * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). - * `windowBits` {number} **Default:** `Z_DEFAULT_WINDOWBITS` (15). - * `dictionary` {Buffer|TypedArray|DataView} -* Returns: {Object} A stateful transform. - -Create a deflate decompression transform. - -## `decompressGzip([options])` - -## `decompressGzipSync([options])` - - - -* `options` {Object} - * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). - * `windowBits` {number} **Default:** `Z_DEFAULT_WINDOWBITS` (15). - * `dictionary` {Buffer|TypedArray|DataView} -* Returns: {Object} A stateful transform. - -Create a gzip decompression transform. - -## `decompressZstd([options])` - -## `decompressZstdSync([options])` - - - -* `options` {Object} - * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). - * `params` {Object} Key-value object where keys and values are - `zlib.constants` entries. Available decompressor parameters: - * `ZSTD_d_windowLogMax` -- maximum window size (log2) the decompressor - will allocate. Limits memory usage against malicious input. - See the [Zstd decompressor options][] in the zlib documentation for - details. - * `dictionary` {Buffer|TypedArray|DataView} -* Returns: {Object} A stateful transform. - -Create a Zstandard decompression transform. - -[Brotli compressor options]: zlib.md#compressor-options -[Brotli decompressor options]: zlib.md#decompressor-options -[RFC 7932]: https://www.rfc-editor.org/rfc/rfc7932 -[Zstd compressor options]: zlib.md#compressor-options-1 -[Zstd decompressor options]: zlib.md#decompressor-options-1 -[`node:stream/iter`]: stream_iter.md -[`pipeTo()`]: stream_iter.md#pipetosource-transforms-writer-options -[`pull()`]: stream_iter.md#pullsource-transforms-options From e3af572e5eaceccb008b53fdc633e23fdb22cead Mon Sep 17 00:00:00 2001 From: "Node.js GitHub Bot" Date: Mon, 4 May 2026 21:47:24 -0400 Subject: [PATCH 060/168] deps: update amaro to 1.1.9 PR-URL: https://github.com/nodejs/node/pull/63090 Reviewed-By: Marco Ippolito Reviewed-By: Chemi Atlow --- deps/amaro/README.md | 4 ---- deps/amaro/dist/index.js | 10 +++++----- deps/amaro/dist/package.json | 2 +- deps/amaro/package.json | 2 +- src/amaro_version.h | 2 +- 5 files changed, 8 insertions(+), 12 deletions(-) diff --git a/deps/amaro/README.md b/deps/amaro/README.md index 75653766de7a6b..44c44c4dc6ad4a 100644 --- a/deps/amaro/README.md +++ b/deps/amaro/README.md @@ -67,10 +67,6 @@ node --watch ./bootstrap.mjs For transform mode, swap `amaro/strip` with `amaro/transform` and run Node with `--enable-source-maps`. -#### Type stripping in dependencies - -Contrary to the Node.js [TypeScript support](https://nodejs.org/docs/latest/api/typescript.html#type-stripping-in-dependencies), when used as a loader, Amaro handles TypeScript files inside folders under a `node_modules` path. - ### Monorepo usage Amaro makes working in monorepos smoother by removing the need to rebuild internal packages during development. When used with the [`--conditions`](https://nodejs.org/docs/latest/api/cli.html#-c-condition---conditionscondition) flag, you can reference TypeScript source files directly in exports: diff --git a/deps/amaro/dist/index.js b/deps/amaro/dist/index.js index b0f6fd4d108780..8ee217cd4903df 100644 --- a/deps/amaro/dist/index.js +++ b/deps/amaro/dist/index.js @@ -244,7 +244,7 @@ ${val.stack}`; function __wbg_adapter_50(arg0, arg1, arg2) { wasm.__wbindgen_export_4(arg0, arg1, addHeapObject(arg2)); } - function __wbg_adapter_95(arg0, arg1, arg2, arg3) { + function __wbg_adapter_79(arg0, arg1, arg2, arg3) { wasm.__wbindgen_export_5(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3)); } module2.exports.__wbg_buffer_609cc3eee51ed158 = function(arg0) { @@ -342,7 +342,7 @@ ${val.stack}`; const a = state0.a; state0.a = 0; try { - return __wbg_adapter_95(a, state0.b, arg02, arg12); + return __wbg_adapter_79(a, state0.b, arg02, arg12); } finally { state0.a = a; } @@ -456,8 +456,8 @@ ${val.stack}`; const ret = false; return ret; }; - module2.exports.__wbindgen_closure_wrapper5029 = function(arg0, arg1, arg2) { - const ret = makeMutClosure(arg0, arg1, 668, __wbg_adapter_50); + module2.exports.__wbindgen_closure_wrapper5442 = function(arg0, arg1, arg2) { + const ret = makeMutClosure(arg0, arg1, 900, __wbg_adapter_50); return addHeapObject(ret); }; module2.exports.__wbindgen_debug_string = function(arg0, arg1) { @@ -545,7 +545,7 @@ ${val.stack}`; throw new Error(getStringFromWasm0(arg0, arg1)); }; var { Buffer: Buffer2 } = require("node:buffer"); - var bytes = Buffer2.from("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", "base64"); + var bytes = Buffer2.from("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", "base64"); var wasmModule = new WebAssembly.Module(bytes); var wasmInstance = new WebAssembly.Instance(wasmModule, imports); wasm = wasmInstance.exports; diff --git a/deps/amaro/dist/package.json b/deps/amaro/dist/package.json index 99a1362b1c6682..bf2f6c48412160 100644 --- a/deps/amaro/dist/package.json +++ b/deps/amaro/dist/package.json @@ -4,7 +4,7 @@ "강동윤 " ], "description": "wasm module for swc", - "version": "1.15.18", + "version": "1.15.30", "license": "Apache-2.0", "repository": { "type": "git", diff --git a/deps/amaro/package.json b/deps/amaro/package.json index d8d5c9f497b90d..fd8d0d9e9ae9ff 100644 --- a/deps/amaro/package.json +++ b/deps/amaro/package.json @@ -1,6 +1,6 @@ { "name": "amaro", - "version": "1.1.8", + "version": "1.1.9", "description": "Node.js TypeScript wrapper", "license": "MIT", "type": "commonjs", diff --git a/src/amaro_version.h b/src/amaro_version.h index 203d46ebc74217..9f7d980111ed6a 100644 --- a/src/amaro_version.h +++ b/src/amaro_version.h @@ -2,5 +2,5 @@ // Refer to tools/dep_updaters/update-amaro.sh #ifndef SRC_AMARO_VERSION_H_ #define SRC_AMARO_VERSION_H_ -#define AMARO_VERSION "1.1.8" +#define AMARO_VERSION "1.1.9" #endif // SRC_AMARO_VERSION_H_ From 711c02241694cf3cb22eee53f31d066af1d0667c Mon Sep 17 00:00:00 2001 From: "Node.js GitHub Bot" Date: Mon, 4 May 2026 21:47:39 -0400 Subject: [PATCH 061/168] tools: update nixpkgs-unstable to c6d65881c5624c9cae5ea6cedef24699b0c PR-URL: https://github.com/nodejs/node/pull/63091 Reviewed-By: Antoine du Hamel Reviewed-By: Colin Ihrig Reviewed-By: James M Snell --- tools/nix/pkgs.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tools/nix/pkgs.nix b/tools/nix/pkgs.nix index 9867fa897bd09e..2f0dc20684a2cc 100644 --- a/tools/nix/pkgs.nix +++ b/tools/nix/pkgs.nix @@ -1,10 +1,10 @@ arg: let repo = "https://github.com/NixOS/nixpkgs"; - rev = "01fbdeef22b76df85ea168fbfe1bfd9e63681b30"; + rev = "c6d65881c5624c9cae5ea6cedef24699b0c0a4c0"; nixpkgs = import (builtins.fetchTarball { url = "${repo}/archive/${rev}.tar.gz"; - sha256 = "0b76m4i1sn0dg78ylapvbkgw9knkf6lm1lss39w6zyshgv1rbi0q"; + sha256 = "1yf4qv3scjygdkg67nibrhbddg3154mv9cxffvykmwcrwfcrrlaq"; }) arg; in nixpkgs From ee37fcea081f05dc4585a01c36b3fa9d249f5b44 Mon Sep 17 00:00:00 2001 From: "Node.js GitHub Bot" Date: Mon, 4 May 2026 21:47:50 -0400 Subject: [PATCH 062/168] deps: update undici to 8.2.0 PR-URL: https://github.com/nodejs/node/pull/63092 Reviewed-By: Chemi Atlow Reviewed-By: Antoine du Hamel Reviewed-By: Rafael Gonzaga --- deps/undici/src/.gitignore | 8 - deps/undici/src/.npmrc | 1 + deps/undici/src/SECURITY.md | 163 ++- deps/undici/src/deps/llhttp/include/llhttp.h | 22 +- deps/undici/src/deps/llhttp/src/llhttp.c | 22 +- deps/undici/src/docs/docs/api/Dispatcher.md | 4 +- deps/undici/src/lib/api/api-connect.js | 2 +- deps/undici/src/lib/api/api-pipeline.js | 4 +- deps/undici/src/lib/api/api-request.js | 4 +- deps/undici/src/lib/api/api-stream.js | 2 +- deps/undici/src/lib/api/api-upgrade.js | 10 +- deps/undici/src/lib/api/readable.js | 5 +- .../src/lib/cache/memory-cache-store.js | 2 +- .../src/lib/cache/sqlite-cache-store.js | 10 +- deps/undici/src/lib/core/connect.js | 16 + deps/undici/src/lib/core/constants.js | 25 +- deps/undici/src/lib/core/errors.js | 4 +- deps/undici/src/lib/core/request.js | 19 +- deps/undici/src/lib/core/socks5-client.js | 33 +- deps/undici/src/lib/core/socks5-utils.js | 55 +- deps/undici/src/lib/core/util.js | 31 +- deps/undici/src/lib/dispatcher/agent.js | 76 +- .../src/lib/dispatcher/balanced-pool.js | 44 +- deps/undici/src/lib/dispatcher/client-h1.js | 50 +- deps/undici/src/lib/dispatcher/client-h2.js | 547 ++++++-- deps/undici/src/lib/dispatcher/h2c-client.js | 8 +- deps/undici/src/lib/dispatcher/pool-base.js | 12 +- deps/undici/src/lib/dispatcher/pool.js | 9 +- deps/undici/src/lib/dispatcher/proxy-agent.js | 2 + .../src/lib/dispatcher/round-robin-pool.js | 11 +- .../src/lib/dispatcher/socks5-proxy-agent.js | 37 +- deps/undici/src/lib/handler/cache-handler.js | 2 +- .../src/lib/handler/redirect-handler.js | 4 + deps/undici/src/lib/interceptor/redirect.js | 6 +- deps/undici/src/lib/llhttp/.gitkeep | 0 deps/undici/src/lib/llhttp/llhttp-wasm.js | 2 +- deps/undici/src/lib/llhttp/llhttp.wasm | Bin 54013 -> 54013 bytes .../undici/src/lib/llhttp/llhttp_simd-wasm.js | 2 +- deps/undici/src/lib/llhttp/llhttp_simd.wasm | Bin 54202 -> 54202 bytes deps/undici/src/lib/llhttp/wasm_build_env.txt | 2 +- deps/undici/src/lib/mock/mock-agent.js | 16 +- deps/undici/src/lib/mock/mock-call-history.js | 30 +- deps/undici/src/lib/util/cache.js | 2 +- .../lib/web/eventsource/eventsource-stream.js | 395 +++--- .../src/lib/web/fetch/formdata-parser.js | 23 +- deps/undici/src/lib/web/fetch/index.js | 66 +- deps/undici/src/lib/web/webidl/index.js | 10 +- deps/undici/src/lib/web/websocket/frame.js | 8 +- .../web/websocket/stream/websocketstream.js | 11 +- deps/undici/src/package-lock.json | 4 +- deps/undici/src/package.json | 2 +- deps/undici/src/types/dispatcher.d.ts | 8 +- deps/undici/src/types/header.d.ts | 5 + deps/undici/src/types/interceptors.d.ts | 2 +- deps/undici/src/types/proxy-agent.d.ts | 4 +- deps/undici/src/types/socks5-proxy-agent.d.ts | 4 +- deps/undici/undici.js | 1177 +++++++++++------ src/undici_version.h | 2 +- 58 files changed, 2036 insertions(+), 989 deletions(-) create mode 100644 deps/undici/src/.npmrc delete mode 100644 deps/undici/src/lib/llhttp/.gitkeep diff --git a/deps/undici/src/.gitignore b/deps/undici/src/.gitignore index a5faeafdfa6dd5..2af62573ea7ee8 100644 --- a/deps/undici/src/.gitignore +++ b/deps/undici/src/.gitignore @@ -60,11 +60,6 @@ typings/ # next.js build output .next -# lock files -package-lock.json -yarn.lock -pnpm-lock.yaml - # IDE files .idea .vscode @@ -81,9 +76,6 @@ fuzz-results-*.json undici-fetch.js /test/imports/undici-import.js -# .npmrc has platform specific value for windows -.npmrc - .tap # File generated by /test/request-timeout.js diff --git a/deps/undici/src/.npmrc b/deps/undici/src/.npmrc new file mode 100644 index 00000000000000..6c6f2f20de0c8e --- /dev/null +++ b/deps/undici/src/.npmrc @@ -0,0 +1 @@ +min-release-age=1 diff --git a/deps/undici/src/SECURITY.md b/deps/undici/src/SECURITY.md index dc5499ae10b162..96bc98e2cec4d8 100644 --- a/deps/undici/src/SECURITY.md +++ b/deps/undici/src/SECURITY.md @@ -1,2 +1,161 @@ -If you believe you have found a security issue in the software in this -repository, please consult https://github.com/nodejs/node/blob/HEAD/SECURITY.md. +# Security + +## Reporting a vulnerability in undici + +Report security bugs in undici via +[GitHub Security Advisories](https://github.com/nodejs/undici/security/advisories/new) +or [HackerOne](https://hackerone.com/nodejs). + +Your report will normally be acknowledged within 5 days, and you will receive +a more detailed response within 10 days indicating the next steps in handling +your submission. These timelines may extend when our triage volunteers are +away, particularly at the end of the year. + +After the initial reply to your report, the security team will endeavor to keep +you informed of the progress being made towards a fix and full announcement, +and may ask for additional information or guidance surrounding the reported +issue. + +## Disclosure policy + +* The security report is received and assigned a primary handler. The problem + is validated against all supported versions of undici. Once confirmed, a list + of all affected versions is determined. Code is audited to find any potential + similar problems. Fixes are prepared for all supported releases. These fixes + are not committed to the public repository but rather held locally pending + the announcement. + +* Because undici is bundled into Node.js, security releases are often + coordinated with the Node.js project to avoid leaving Node.js users + vulnerable. As a result, fixed versions of undici are published to npm + before the corresponding CVE is disclosed, since the CVE will only be + published after the coordinated Node.js release. This delay is typically + a few days but can take up to a week. + +## The undici threat model + +Undici is an HTTP client library for Node.js. Its threat model is derived from +and aligned with the [Node.js threat model](https://github.com/nodejs/node/blob/HEAD/SECURITY.md#the-nodejs-threat-model). + +### What constitutes a vulnerability + +Being able to cause the following through control of the elements that undici +does not trust is considered a vulnerability: + +* Disclosure or loss of integrity or confidentiality of data protected through + the correct use of undici APIs. +* The unavailability of the runtime, including the unbounded degradation of its + performance. + +#### Denial of Service (DoS) vulnerabilities + +For a behavior to be considered a DoS vulnerability, the proof of concept must +meet the following criteria: + +* The API is being correctly used. +* The API is public and documented. +* The behavior is significant enough to cause a denial of service quickly + or in a context not controlled by the application developer (for example, + HTTP parsing). +* The behavior is directly exploitable by an untrusted source without requiring + application mistakes. +* The behavior cannot be reasonably mitigated through standard operational + practices (like process recycling). +* The attack demonstrates + [asymmetric resource consumption](https://cwe.mitre.org/data/definitions/405.html), + where the attacker expends significantly fewer resources than what is required + by the client to process the attack. + +**Undici does NOT trust**: + +* Data received from the remote end of HTTP connections (both inbound responses + and server-sent data) that is parsed or transformed by undici before being + passed to the application. This includes: + * HTTP response headers and status lines. + * HTTP response bodies when processed by undici (e.g., chunked transfer + decoding, content-encoding). + * WebSocket frames received from a server. + * Server-Sent Events (EventSource) data received from a server. +* TLS certificate validation performed by undici on behalf of the application. + +**Undici trusts**: + +* The application code that uses its APIs, including all configuration, + options, and callbacks provided by the application. +* The operating system and its network stack. +* The Node.js runtime undici is running on. +* Dependencies installed by the application. +* The DNS resolution results provided by the operating system or configured + resolvers. + +In other words, if untrusted data passing through undici to the application +can trigger actions other than those documented for the APIs, there is likely +a security vulnerability. Examples of unwanted actions are polluting globals, +causing an unrecoverable crash, or any other unexpected side effects that can +lead to a loss of confidentiality, integrity, or availability. + +### Examples of vulnerabilities + +#### Improper Certificate Validation (CWE-295) + +* Undici provides TLS connections to HTTPS endpoints. If certificates can be + crafted that result in incorrect validation by undici, that is considered + a vulnerability. + +#### Inconsistent Interpretation of HTTP Responses (CWE-444) + +* Undici parses HTTP responses received from servers. Bugs in parsing response + headers or transfer encoding which can result in response smuggling or + desynchronization are considered vulnerabilities. + +#### HTTP Request Smuggling (CWE-444) + +* Bugs that allow crafting requests that are interpreted differently by undici + and an upstream server, leading to request smuggling, are considered + vulnerabilities. + +#### CRLF Injection in Request Headers (CWE-93) + +* If untrusted input passed to undici APIs (such as header values or URLs) + can inject additional headers or corrupt the HTTP request stream, that is + considered a vulnerability. + +### Examples of non-vulnerabilities + +#### Malicious Third-Party Modules (CWE-1357) + +* Application code and its dependencies are trusted by undici. Any scenario + that requires a malicious third-party module cannot result in a vulnerability + in undici. + +#### Prototype Pollution Attacks (CWE-1321) + +* Undici trusts the inputs provided to it by application code. It is up to the + application to sanitize appropriately. Any scenario that requires control + over user input passed directly by the application is not considered a + vulnerability in undici. + +#### Uncontrolled Resource Consumption on Outbound Connections (CWE-400) + +* If undici is asked to connect to a remote site and the response payload is + large enough to impact performance or cause the runtime to run out of + resources, that is not considered a vulnerability. Applications are + responsible for setting appropriate limits on response sizes. + +#### Application Misconfiguration + +* Issues arising from incorrect or insecure use of undici APIs (such as + disabling TLS verification, ignoring errors, or passing unsanitized user + input to request options) are the application's responsibility, not + vulnerabilities in undici. + +## Receiving security updates + +Security notifications will be distributed via +[GitHub Security Advisories](https://github.com/nodejs/undici/security/advisories). + +## Comments on this policy + +If you have suggestions on how this process could be improved, please open an +issue on the [nodejs/undici](https://github.com/nodejs/undici/issues) +repository or file a pull request. diff --git a/deps/undici/src/deps/llhttp/include/llhttp.h b/deps/undici/src/deps/llhttp/include/llhttp.h index 60544596a9942c..194fee8c906ed3 100644 --- a/deps/undici/src/deps/llhttp/include/llhttp.h +++ b/deps/undici/src/deps/llhttp/include/llhttp.h @@ -4,7 +4,7 @@ #define LLHTTP_VERSION_MAJOR 9 #define LLHTTP_VERSION_MINOR 3 -#define LLHTTP_VERSION_PATCH 0 +#define LLHTTP_VERSION_PATCH 1 #ifndef INCLUDE_LLHTTP_ITSELF_H_ #define INCLUDE_LLHTTP_ITSELF_H_ @@ -58,10 +58,8 @@ enum llhttp_errno { HPE_OK = 0, HPE_INTERNAL = 1, HPE_STRICT = 2, - HPE_CR_EXPECTED = 25, HPE_LF_EXPECTED = 3, HPE_UNEXPECTED_CONTENT_LENGTH = 4, - HPE_UNEXPECTED_SPACE = 30, HPE_CLOSED_CONNECTION = 5, HPE_INVALID_METHOD = 6, HPE_INVALID_URL = 7, @@ -82,15 +80,17 @@ enum llhttp_errno { HPE_PAUSED_UPGRADE = 22, HPE_PAUSED_H2_UPGRADE = 23, HPE_USER = 24, + HPE_CR_EXPECTED = 25, HPE_CB_URL_COMPLETE = 26, HPE_CB_STATUS_COMPLETE = 27, - HPE_CB_METHOD_COMPLETE = 32, - HPE_CB_VERSION_COMPLETE = 33, HPE_CB_HEADER_FIELD_COMPLETE = 28, HPE_CB_HEADER_VALUE_COMPLETE = 29, + HPE_UNEXPECTED_SPACE = 30, + HPE_CB_RESET = 31, + HPE_CB_METHOD_COMPLETE = 32, + HPE_CB_VERSION_COMPLETE = 33, HPE_CB_CHUNK_EXTENSION_NAME_COMPLETE = 34, HPE_CB_CHUNK_EXTENSION_VALUE_COMPLETE = 35, - HPE_CB_RESET = 31, HPE_CB_PROTOCOL_COMPLETE = 38 }; typedef enum llhttp_errno llhttp_errno_t; @@ -294,10 +294,8 @@ typedef enum llhttp_status llhttp_status_t; XX(0, OK, OK) \ XX(1, INTERNAL, INTERNAL) \ XX(2, STRICT, STRICT) \ - XX(25, CR_EXPECTED, CR_EXPECTED) \ XX(3, LF_EXPECTED, LF_EXPECTED) \ XX(4, UNEXPECTED_CONTENT_LENGTH, UNEXPECTED_CONTENT_LENGTH) \ - XX(30, UNEXPECTED_SPACE, UNEXPECTED_SPACE) \ XX(5, CLOSED_CONNECTION, CLOSED_CONNECTION) \ XX(6, INVALID_METHOD, INVALID_METHOD) \ XX(7, INVALID_URL, INVALID_URL) \ @@ -318,15 +316,17 @@ typedef enum llhttp_status llhttp_status_t; XX(22, PAUSED_UPGRADE, PAUSED_UPGRADE) \ XX(23, PAUSED_H2_UPGRADE, PAUSED_H2_UPGRADE) \ XX(24, USER, USER) \ + XX(25, CR_EXPECTED, CR_EXPECTED) \ XX(26, CB_URL_COMPLETE, CB_URL_COMPLETE) \ XX(27, CB_STATUS_COMPLETE, CB_STATUS_COMPLETE) \ - XX(32, CB_METHOD_COMPLETE, CB_METHOD_COMPLETE) \ - XX(33, CB_VERSION_COMPLETE, CB_VERSION_COMPLETE) \ XX(28, CB_HEADER_FIELD_COMPLETE, CB_HEADER_FIELD_COMPLETE) \ XX(29, CB_HEADER_VALUE_COMPLETE, CB_HEADER_VALUE_COMPLETE) \ + XX(30, UNEXPECTED_SPACE, UNEXPECTED_SPACE) \ + XX(31, CB_RESET, CB_RESET) \ + XX(32, CB_METHOD_COMPLETE, CB_METHOD_COMPLETE) \ + XX(33, CB_VERSION_COMPLETE, CB_VERSION_COMPLETE) \ XX(34, CB_CHUNK_EXTENSION_NAME_COMPLETE, CB_CHUNK_EXTENSION_NAME_COMPLETE) \ XX(35, CB_CHUNK_EXTENSION_VALUE_COMPLETE, CB_CHUNK_EXTENSION_VALUE_COMPLETE) \ - XX(31, CB_RESET, CB_RESET) \ XX(38, CB_PROTOCOL_COMPLETE, CB_PROTOCOL_COMPLETE) \ diff --git a/deps/undici/src/deps/llhttp/src/llhttp.c b/deps/undici/src/deps/llhttp/src/llhttp.c index aa4c468209700c..515ba512abbdb0 100644 --- a/deps/undici/src/deps/llhttp/src/llhttp.c +++ b/deps/undici/src/deps/llhttp/src/llhttp.c @@ -10,7 +10,7 @@ #endif /* _MSC_VER */ #endif /* __SSE4_2__ */ -#ifdef __ARM_NEON__ +#if defined(__ARM_NEON__) || defined(__ARM_NEON) #include #endif /* __ARM_NEON__ */ @@ -1542,7 +1542,7 @@ static llparse_state_t llhttp__internal__run( 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -2625,7 +2625,7 @@ static llparse_state_t llhttp__internal__run( goto s_n_llhttp__internal__n_header_value_otherwise; } #endif /* __SSE4_2__ */ - #ifdef __ARM_NEON__ + #if defined(__ARM_NEON__) || defined(__ARM_NEON) while (endp - p >= 16) { uint8x16_t input; uint8x16_t single; @@ -2639,19 +2639,23 @@ static llparse_state_t llhttp__internal__run( /* Find first character that does not match `ranges` */ single = vceqq_u8(input, vdupq_n_u8(0x9)); mask = single; - single = vandq_u16( + single = vandq_u8( vcgeq_u8(input, vdupq_n_u8(' ')), vcleq_u8(input, vdupq_n_u8('~')) ); - mask = vorrq_u16(mask, single); - single = vandq_u16( + mask = vorrq_u8(mask, single); + single = vandq_u8( vcgeq_u8(input, vdupq_n_u8(0x80)), vcleq_u8(input, vdupq_n_u8(0xff)) ); - mask = vorrq_u16(mask, single); - narrow = vshrn_n_u16(mask, 4); + mask = vorrq_u8(mask, single); + narrow = vshrn_n_u16(vreinterpretq_u16_u8(mask), 4); match_mask = ~vget_lane_u64(vreinterpret_u64_u8(narrow), 0); - match_len = __builtin_ctzll(match_mask) >> 2; + if (match_mask == 0) { + match_len = 16; + } else { + match_len = __builtin_ctzll(match_mask) >> 2; + } if (match_len != 16) { p += match_len; goto s_n_llhttp__internal__n_header_value_otherwise; diff --git a/deps/undici/src/docs/docs/api/Dispatcher.md b/deps/undici/src/docs/docs/api/Dispatcher.md index 4ceba0122d53ee..b1674b3092aa38 100644 --- a/deps/undici/src/docs/docs/api/Dispatcher.md +++ b/deps/undici/src/docs/docs/api/Dispatcher.md @@ -1354,10 +1354,10 @@ Emitted when dispatcher is no longer busy. ## Parameter: `UndiciHeaders` -* `Record | string[] | Iterable<[string, string | string[] | undefined]> | null` +* `Record | string[] | Iterable<[string, string | string[] | undefined]> | null` Header arguments such as `options.headers` in [`Client.dispatch`](/docs/docs/api/Client.md#clientdispatchoptions-handlers) can be specified in three forms: -* As an object specified by the `Record` (`IncomingHttpHeaders`) type. +* As an object specified by the `Record` (`OutgoingHttpHeaders`) type. * As an array of strings. An array representation of a header list must have an even length, or an `InvalidArgumentError` will be thrown. * As an iterable that can encompass `Headers`, `Map`, or a custom iterator returning key-value pairs. Keys are lowercase and values are not modified. diff --git a/deps/undici/src/lib/api/api-connect.js b/deps/undici/src/lib/api/api-connect.js index b545a3eb5c1f44..f449c787d617b3 100644 --- a/deps/undici/src/lib/api/api-connect.js +++ b/deps/undici/src/lib/api/api-connect.js @@ -60,7 +60,7 @@ class ConnectHandler extends AsyncResource { // Indicates is an HTTP2Session if (responseHeaders != null) { responseHeaders = this.responseHeaders === 'raw' - ? (Array.isArray(rawHeaders) ? util.parseRawHeaders(rawHeaders) : []) + ? util.parseRawHeaders(rawHeaders) : headers } diff --git a/deps/undici/src/lib/api/api-pipeline.js b/deps/undici/src/lib/api/api-pipeline.js index c8bd7414932e4f..6e61710b90741a 100644 --- a/deps/undici/src/lib/api/api-pipeline.js +++ b/deps/undici/src/lib/api/api-pipeline.js @@ -167,7 +167,7 @@ class PipelineHandler extends AsyncResource { if (this.onInfo) { const rawHeaders = controller?.rawHeaders const responseHeaders = this.responseHeaders === 'raw' - ? (Array.isArray(rawHeaders) ? util.parseRawHeaders(rawHeaders) : []) + ? util.parseRawHeaders(rawHeaders) : headers this.onInfo({ statusCode, headers: responseHeaders }) } @@ -181,7 +181,7 @@ class PipelineHandler extends AsyncResource { this.handler = null const rawHeaders = controller?.rawHeaders const responseHeaders = this.responseHeaders === 'raw' - ? (Array.isArray(rawHeaders) ? util.parseRawHeaders(rawHeaders) : []) + ? util.parseRawHeaders(rawHeaders) : headers body = this.runInAsyncScope(handler, null, { statusCode, diff --git a/deps/undici/src/lib/api/api-request.js b/deps/undici/src/lib/api/api-request.js index 1d56fb0c9ad904..aabb46f728d3b0 100644 --- a/deps/undici/src/lib/api/api-request.js +++ b/deps/undici/src/lib/api/api-request.js @@ -21,7 +21,7 @@ class RequestHandler extends AsyncResource { throw new InvalidArgumentError('invalid callback') } - if (highWaterMark && (typeof highWaterMark !== 'number' || highWaterMark < 0)) { + if (highWaterMark != null && (!Number.isFinite(highWaterMark) || highWaterMark < 0)) { throw new InvalidArgumentError('invalid highWaterMark') } @@ -92,7 +92,7 @@ class RequestHandler extends AsyncResource { const rawHeaders = controller?.rawHeaders const responseHeaderData = responseHeaders === 'raw' - ? (Array.isArray(rawHeaders) ? util.parseRawHeaders(rawHeaders) : []) + ? util.parseRawHeaders(rawHeaders) : headers if (statusCode < 200) { diff --git a/deps/undici/src/lib/api/api-stream.js b/deps/undici/src/lib/api/api-stream.js index daee5681223ee6..249d6774f6bea8 100644 --- a/deps/undici/src/lib/api/api-stream.js +++ b/deps/undici/src/lib/api/api-stream.js @@ -85,7 +85,7 @@ class StreamHandler extends AsyncResource { const rawHeaders = controller?.rawHeaders const responseHeaderData = responseHeaders === 'raw' - ? (Array.isArray(rawHeaders) ? util.parseRawHeaders(rawHeaders) : []) + ? util.parseRawHeaders(rawHeaders) : headers if (statusCode < 200) { diff --git a/deps/undici/src/lib/api/api-upgrade.js b/deps/undici/src/lib/api/api-upgrade.js index 9f1d80c62dc8a5..42cb29ed3ce1f1 100644 --- a/deps/undici/src/lib/api/api-upgrade.js +++ b/deps/undici/src/lib/api/api-upgrade.js @@ -51,7 +51,13 @@ class UpgradeHandler extends AsyncResource { } onRequestUpgrade (controller, statusCode, headers, socket) { - assert(socket[kHTTP2Stream] === true ? statusCode === 200 : statusCode === 101) + const expectedStatusCode = socket[kHTTP2Stream] === true ? 200 : 101 + + if (statusCode !== expectedStatusCode) { + const socketInfo = socket[kHTTP2Stream] === true ? null : util.getSocketInfo(socket) + controller.abort(new SocketError('bad upgrade', socketInfo)) + return + } const { callback, opaque, context } = this @@ -61,7 +67,7 @@ class UpgradeHandler extends AsyncResource { const rawHeaders = controller?.rawHeaders const responseHeaders = this.responseHeaders === 'raw' - ? (Array.isArray(rawHeaders) ? util.parseRawHeaders(rawHeaders) : []) + ? util.parseRawHeaders(rawHeaders) : headers this.runInAsyncScope(callback, null, null, { diff --git a/deps/undici/src/lib/api/readable.js b/deps/undici/src/lib/api/readable.js index cdede9599809b7..5ebd04ebe83c6b 100644 --- a/deps/undici/src/lib/api/readable.js +++ b/deps/undici/src/lib/api/readable.js @@ -1,6 +1,7 @@ 'use strict' const assert = require('node:assert') +const { addAbortListener } = require('node:events') const { Readable } = require('node:stream') const { RequestAbortedError, NotSupportedError, InvalidArgumentError, AbortError } = require('../core/errors') const util = require('../core/util') @@ -293,10 +294,10 @@ class BodyReadable extends Readable { const onAbort = () => { this.destroy(signal.reason ?? new AbortError()) } - signal.addEventListener('abort', onAbort) + const abortListener = addAbortListener(signal, onAbort) this .on('close', function () { - signal.removeEventListener('abort', onAbort) + abortListener[Symbol.dispose]() if (signal.aborted) { reject(signal.reason ?? new AbortError()) } else { diff --git a/deps/undici/src/lib/cache/memory-cache-store.js b/deps/undici/src/lib/cache/memory-cache-store.js index dba29ae4de9d82..ea9c6cae7e9418 100644 --- a/deps/undici/src/lib/cache/memory-cache-store.js +++ b/deps/undici/src/lib/cache/memory-cache-store.js @@ -138,7 +138,7 @@ class MemoryCacheStore extends EventEmitter { entry.size += chunk.byteLength - if (entry.size >= store.#maxEntrySize) { + if (entry.size > store.#maxEntrySize) { this.destroy() } else { entry.body.push(chunk) diff --git a/deps/undici/src/lib/cache/sqlite-cache-store.js b/deps/undici/src/lib/cache/sqlite-cache-store.js index 7cb4aa7e2466e3..bf1e04b791736b 100644 --- a/deps/undici/src/lib/cache/sqlite-cache-store.js +++ b/deps/undici/src/lib/cache/sqlite-cache-store.js @@ -173,6 +173,7 @@ module.exports = class SqliteCacheStore { headers = ?, etag = ?, cacheControlDirectives = ?, + vary = ?, cachedAt = ?, staleAt = ? WHERE @@ -216,7 +217,7 @@ module.exports = class SqliteCacheStore { SELECT id FROM cacheInterceptorV${VERSION} - ORDER BY cachedAt DESC + ORDER BY cachedAt ASC LIMIT ? ) `) @@ -278,12 +279,12 @@ module.exports = class SqliteCacheStore { value.headers ? JSON.stringify(value.headers) : null, value.etag ? value.etag : null, value.cacheControlDirectives ? JSON.stringify(value.cacheControlDirectives) : null, + value.vary ? JSON.stringify(value.vary) : null, value.cachedAt, value.staleAt, existingValue.id ) } else { - this.#prune() // New response, let's insert it this.#insertValueQuery.run( url, @@ -299,6 +300,7 @@ module.exports = class SqliteCacheStore { value.cachedAt, value.staleAt ) + this.#prune() } } @@ -323,7 +325,7 @@ module.exports = class SqliteCacheStore { write (chunk, encoding, callback) { size += chunk.byteLength - if (size < store.#maxEntrySize) { + if (size <= store.#maxEntrySize) { body.push(chunk) } else { this.destroy() @@ -409,7 +411,7 @@ module.exports = class SqliteCacheStore { const now = Date.now() for (const value of values) { if (now >= value.deleteAt && !canBeExpired) { - return undefined + continue } let matches = true diff --git a/deps/undici/src/lib/core/connect.js b/deps/undici/src/lib/core/connect.js index 605cb9fdd9bd1c..4a922c7dcf0378 100644 --- a/deps/undici/src/lib/core/connect.js +++ b/deps/undici/src/lib/core/connect.js @@ -38,6 +38,22 @@ const SessionCache = class WeakSessionCache { return } + if (this._sessionCache.has(sessionKey)) { + this._sessionCache.delete(sessionKey) + } else if (this._sessionCache.size >= this._maxCachedSessions) { + for (const [key, ref] of this._sessionCache) { + if (ref.deref() === undefined) { + this._sessionCache.delete(key) + return + } + } + + const oldest = this._sessionCache.keys().next() + if (!oldest.done) { + this._sessionCache.delete(oldest.value) + } + } + this._sessionCache.set(sessionKey, new WeakRef(session)) this._sessionRegistry.register(session, sessionKey) } diff --git a/deps/undici/src/lib/core/constants.js b/deps/undici/src/lib/core/constants.js index 088cf47d80f1d7..000c01949099b8 100644 --- a/deps/undici/src/lib/core/constants.js +++ b/deps/undici/src/lib/core/constants.js @@ -107,28 +107,6 @@ const headerNameLowerCasedRecord = {} // Note: object prototypes should not be able to be referenced. e.g. `Object#hasOwnProperty`. Object.setPrototypeOf(headerNameLowerCasedRecord, null) -/** - * @type {Record, Buffer>} - */ -const wellknownHeaderNameBuffers = {} - -// Note: object prototypes should not be able to be referenced. e.g. `Object#hasOwnProperty`. -Object.setPrototypeOf(wellknownHeaderNameBuffers, null) - -/** - * @param {string} header Lowercased header - * @returns {Buffer} - */ -function getHeaderNameAsBuffer (header) { - let buffer = wellknownHeaderNameBuffers[header] - - if (buffer === undefined) { - buffer = Buffer.from(header) - } - - return buffer -} - for (let i = 0; i < wellknownHeaderNames.length; ++i) { const key = wellknownHeaderNames[i] const lowerCasedKey = key.toLowerCase() @@ -138,6 +116,5 @@ for (let i = 0; i < wellknownHeaderNames.length; ++i) { module.exports = { wellknownHeaderNames, - headerNameLowerCasedRecord, - getHeaderNameAsBuffer + headerNameLowerCasedRecord } diff --git a/deps/undici/src/lib/core/errors.js b/deps/undici/src/lib/core/errors.js index 5a7fcbff3adc27..ed690393d00be8 100644 --- a/deps/undici/src/lib/core/errors.js +++ b/deps/undici/src/lib/core/errors.js @@ -163,8 +163,8 @@ class RequestAbortedError extends AbortError { const kInformationalError = Symbol.for('undici.error.UND_ERR_INFO') class InformationalError extends UndiciError { - constructor (message) { - super(message) + constructor (message, options) { + super(message, options) this.name = 'InformationalError' this.message = message || 'Request information' this.code = 'UND_ERR_INFO' diff --git a/deps/undici/src/lib/core/request.js b/deps/undici/src/lib/core/request.js index 2b2633f3d04224..2d2675a5065590 100644 --- a/deps/undici/src/lib/core/request.js +++ b/deps/undici/src/lib/core/request.js @@ -28,6 +28,21 @@ const { headerNameLowerCasedRecord } = require('./constants') // Verifies that a given path is valid does not contain control chars \x00 to \x20 const invalidPathRegex = /[^\u0021-\u00ff]/ +function isValidContentLengthHeaderValue (val) { + if (typeof val !== 'string' || val.length === 0) { + return false + } + + for (let i = 0; i < val.length; i++) { + const charCode = val.charCodeAt(i) + if (charCode < 48 || charCode > 57) { + return false + } + } + + return true +} + const kHandler = Symbol('handler') const kController = Symbol('controller') const kResume = Symbol('resume') @@ -484,10 +499,10 @@ function processHeader (request, key, val) { if (request.contentLength !== null) { throw new InvalidArgumentError('duplicate content-length header') } - request.contentLength = parseInt(val, 10) - if (!Number.isFinite(request.contentLength)) { + if (!isValidContentLengthHeaderValue(val)) { throw new InvalidArgumentError('invalid content-length header') } + request.contentLength = parseInt(val, 10) } else if (request.contentType === null && headerName === 'content-type') { request.contentType = val request.headers.push(key, val) diff --git a/deps/undici/src/lib/core/socks5-client.js b/deps/undici/src/lib/core/socks5-client.js index 5d175d70366ac5..90f6d0a680f419 100644 --- a/deps/undici/src/lib/core/socks5-client.js +++ b/deps/undici/src/lib/core/socks5-client.js @@ -7,6 +7,7 @@ const { debuglog } = require('node:util') const { parseAddress } = require('./socks5-utils') const debug = debuglog('undici:socks5') +const EMPTY_BUFFER = Buffer.alloc(0) // SOCKS5 constants const SOCKS_VERSION = 0x05 @@ -51,6 +52,7 @@ const STATES = { INITIAL: 'initial', HANDSHAKING: 'handshaking', AUTHENTICATING: 'authenticating', + AUTHENTICATED: 'authenticated', CONNECTING: 'connecting', CONNECTED: 'connected', ERROR: 'error', @@ -72,7 +74,10 @@ class Socks5Client extends EventEmitter { this.socket = socket this.options = options this.state = STATES.INITIAL - this.buffer = Buffer.alloc(0) + this.buffer = EMPTY_BUFFER + this.onSocketData = this.onData.bind(this) + this.onSocketError = this.onError.bind(this) + this.onSocketClose = this.onClose.bind(this) // Authentication settings this.authMethods = [] @@ -82,9 +87,9 @@ class Socks5Client extends EventEmitter { this.authMethods.push(AUTH_METHODS.NO_AUTH) // Socket event handlers - this.socket.on('data', this.onData.bind(this)) - this.socket.on('error', this.onError.bind(this)) - this.socket.on('close', this.onClose.bind(this)) + this.socket.on('data', this.onSocketData) + this.socket.on('error', this.onSocketError) + this.socket.on('close', this.onSocketClose) } /** @@ -139,6 +144,11 @@ class Socks5Client extends EventEmitter { } } + markAuthenticated () { + this.state = STATES.AUTHENTICATED + this.emit('authenticated') + } + /** * Start the SOCKS5 handshake */ @@ -189,7 +199,7 @@ class Socks5Client extends EventEmitter { debug('server selected auth method', method) if (method === AUTH_METHODS.NO_AUTH) { - this.emit('authenticated') + this.markAuthenticated() } else if (method === AUTH_METHODS.USERNAME_PASSWORD) { this.state = STATES.AUTHENTICATING this.sendAuthRequest() @@ -254,7 +264,7 @@ class Socks5Client extends EventEmitter { this.buffer = this.buffer.subarray(2) debug('authentication successful') - this.emit('authenticated') + this.markAuthenticated() } /** @@ -263,8 +273,12 @@ class Socks5Client extends EventEmitter { * @param {number} port - Target port */ connect (address, port) { - if (this.state === STATES.CONNECTED) { - throw new InvalidArgumentError('Already connected') + if (this.state === STATES.CONNECTING || this.state === STATES.CONNECTED) { + throw new InvalidArgumentError('Connection already in progress') + } + + if (this.state !== STATES.AUTHENTICATED) { + throw new InvalidArgumentError('Client must be authenticated before CONNECT') } debug('connecting to', address, port) @@ -363,8 +377,9 @@ class Socks5Client extends EventEmitter { const boundPort = this.buffer.readUInt16BE(offset) - this.buffer = this.buffer.subarray(responseLength) + this.buffer = EMPTY_BUFFER this.state = STATES.CONNECTED + this.socket.removeListener('data', this.onSocketData) debug('connected, bound address:', boundAddress, 'port:', boundPort) this.emit('connected', { address: boundAddress, port: boundPort }) diff --git a/deps/undici/src/lib/core/socks5-utils.js b/deps/undici/src/lib/core/socks5-utils.js index 2b5a3662bf560a..e6098bef05fc4c 100644 --- a/deps/undici/src/lib/core/socks5-utils.js +++ b/deps/undici/src/lib/core/socks5-utils.js @@ -46,34 +46,43 @@ function parseAddress (address) { */ function parseIPv6 (address) { const buffer = Buffer.alloc(16) - const parts = address.split(':') - let partIndex = 0 - let bufferIndex = 0 + let normalizedAddress = address + + // Expand an embedded IPv4 tail into the last two IPv6 groups. + if (address.includes('.')) { + const lastColonIndex = address.lastIndexOf(':') + const ipv4Part = address.slice(lastColonIndex + 1) + + if (net.isIPv4(ipv4Part)) { + const octets = ipv4Part.split('.').map(Number) + const high = ((octets[0] << 8) | octets[1]).toString(16) + const low = ((octets[2] << 8) | octets[3]).toString(16) + normalizedAddress = `${address.slice(0, lastColonIndex)}:${high}:${low}` + } + } // Handle compressed notation (::) - const doubleColonIndex = address.indexOf('::') + const doubleColonIndex = normalizedAddress.indexOf('::') if (doubleColonIndex !== -1) { - // Count non-empty parts - const nonEmptyParts = parts.filter(p => p.length > 0).length - const skipParts = 8 - nonEmptyParts - - for (let i = 0; i < parts.length; i++) { - if (parts[i] === '' && i === doubleColonIndex / 3) { - // Skip empty parts for :: - bufferIndex += skipParts * 2 - } else if (parts[i] !== '') { - const value = parseInt(parts[i], 16) - buffer.writeUInt16BE(value, bufferIndex) - bufferIndex += 2 - } + const before = normalizedAddress.slice(0, doubleColonIndex) + const after = normalizedAddress.slice(doubleColonIndex + 2) + const beforeParts = before === '' ? [] : before.split(':') + const afterParts = after === '' ? [] : after.split(':') + + let bufferIndex = 0 + for (const part of beforeParts) { + buffer.writeUInt16BE(parseInt(part, 16), bufferIndex) + bufferIndex += 2 + } + bufferIndex = 16 - afterParts.length * 2 + for (const part of afterParts) { + buffer.writeUInt16BE(parseInt(part, 16), bufferIndex) + bufferIndex += 2 } } else { - // No compression, parse normally - for (const part of parts) { - if (part === '') continue - const value = parseInt(part, 16) - buffer.writeUInt16BE(value, partIndex * 2) - partIndex++ + const parts = normalizedAddress.split(':') + for (let i = 0; i < parts.length; i++) { + buffer.writeUInt16BE(parseInt(parts[i], 16), i * 2) } } diff --git a/deps/undici/src/lib/core/util.js b/deps/undici/src/lib/core/util.js index 0c72e5d598a353..54346a2567c2d2 100644 --- a/deps/undici/src/lib/core/util.js +++ b/deps/undici/src/lib/core/util.js @@ -6,7 +6,7 @@ const { IncomingMessage } = require('node:http') const stream = require('node:stream') const net = require('node:net') const { stringify } = require('node:querystring') -const { EventEmitter: EE } = require('node:events') +const { EventEmitter: EE, addAbortListener: addAbortListenerNative } = require('node:events') const timers = require('../util/timers') const { InvalidArgumentError, ConnectTimeoutError } = require('./errors') const { headerNameLowerCasedRecord } = require('./constants') @@ -464,10 +464,30 @@ function parseHeaders (headers, obj) { } /** - * @param {Buffer[]} headers + * @param {Buffer[] | string[] | Record | null | undefined} headers * @returns {string[]} */ function parseRawHeaders (headers) { + if (headers == null) { + return [] + } + + if (!Array.isArray(headers)) { + const rawHeaders = [] + + for (const [name, value] of Object.entries(headers)) { + if (Array.isArray(value)) { + for (const entry of value) { + rawHeaders.push(name, `${entry}`) + } + } else { + rawHeaders.push(name, `${value}`) + } + } + + return rawHeaders + } + const headersLength = headers.length /** * @type {string[]} @@ -678,7 +698,12 @@ function isFormDataLike (object) { } function addAbortListener (signal, listener) { - if ('addEventListener' in signal) { + if (signal instanceof AbortSignal) { + const disposable = addAbortListenerNative(signal, listener) + return () => disposable[Symbol.dispose]() + } + + if (typeof signal.addEventListener === 'function') { signal.addEventListener('abort', listener, { once: true }) return () => signal.removeEventListener('abort', listener) } diff --git a/deps/undici/src/lib/dispatcher/agent.js b/deps/undici/src/lib/dispatcher/agent.js index a1cc7fd6817c59..858a5f248f7efb 100644 --- a/deps/undici/src/lib/dispatcher/agent.js +++ b/deps/undici/src/lib/dispatcher/agent.js @@ -1,7 +1,7 @@ 'use strict' const { InvalidArgumentError, MaxOriginsReachedError } = require('../core/errors') -const { kClients, kRunning, kClose, kDestroy, kDispatch, kUrl } = require('../core/symbols') +const { kBusy, kClients, kConnected, kRunning, kClose, kDestroy, kDispatch, kUrl } = require('../core/symbols') const DispatcherBase = require('./dispatcher-base') const Pool = require('./pool') const Client = require('./client') @@ -65,7 +65,7 @@ class Agent extends DispatcherBase { get [kRunning] () { let ret = 0 - for (const { dispatcher } of this[kClients].values()) { + for (const dispatcher of this[kClients].values()) { ret += dispatcher[kRunning] } return ret @@ -86,54 +86,52 @@ class Agent extends DispatcherBase { throw new MaxOriginsReachedError() } - const result = this[kClients].get(key) - let dispatcher = result && result.dispatcher + let dispatcher = this[kClients].get(key) if (!dispatcher) { - const closeClientIfUnused = (connected) => { - const result = this[kClients].get(key) - if (result) { - if (connected) result.count -= 1 - if (result.count <= 0) { - this[kClients].delete(key) - if (!result.dispatcher.destroyed) { - result.dispatcher.close() - } - } + dispatcher = this[kFactory](opts.origin, allowH2 === false + ? { ...this[kOptions], allowH2: false } + : this[kOptions]) - let hasOrigin = false - for (const entry of this[kClients].values()) { - if (entry.origin === origin) { - hasOrigin = true - break - } - } + const closeClientIfUnused = () => { + if (this[kClients].get(key) !== dispatcher) { + return + } + + if (dispatcher[kConnected] > 0 || dispatcher[kBusy]) { + return + } + + this[kClients].delete(key) + if (!dispatcher.destroyed) { + dispatcher.close() + } - if (!hasOrigin) { - this[kOrigins].delete(origin) + let hasOrigin = false + for (const client of this[kClients].values()) { + if (client[kUrl].origin === dispatcher[kUrl].origin) { + hasOrigin = true + break } } + + if (!hasOrigin) { + this[kOrigins].delete(dispatcher[kUrl].origin) + } } - dispatcher = this[kFactory](opts.origin, allowH2 === false - ? { ...this[kOptions], allowH2: false } - : this[kOptions]) + + dispatcher .on('drain', this[kOnDrain]) - .on('connect', (origin, targets) => { - const result = this[kClients].get(key) - if (result) { - result.count += 1 - } - this[kOnConnect](origin, targets) - }) + .on('connect', this[kOnConnect]) .on('disconnect', (origin, targets, err) => { - closeClientIfUnused(true) + closeClientIfUnused() this[kOnDisconnect](origin, targets, err) }) .on('connectionError', (origin, targets, err) => { - closeClientIfUnused(false) + closeClientIfUnused() this[kOnConnectionError](origin, targets, err) }) - this[kClients].set(key, { count: 0, dispatcher, origin }) + this[kClients].set(key, dispatcher) this[kOrigins].add(origin) } @@ -142,7 +140,7 @@ class Agent extends DispatcherBase { [kClose] () { const closePromises = [] - for (const { dispatcher } of this[kClients].values()) { + for (const dispatcher of this[kClients].values()) { closePromises.push(dispatcher.close()) } this[kClients].clear() @@ -152,7 +150,7 @@ class Agent extends DispatcherBase { [kDestroy] (err) { const destroyPromises = [] - for (const { dispatcher } of this[kClients].values()) { + for (const dispatcher of this[kClients].values()) { destroyPromises.push(dispatcher.destroy(err)) } this[kClients].clear() @@ -162,7 +160,7 @@ class Agent extends DispatcherBase { get stats () { const allClientStats = {} - for (const { dispatcher } of this[kClients].values()) { + for (const dispatcher of this[kClients].values()) { if (dispatcher.stats) { allClientStats[dispatcher[kUrl].origin] = dispatcher.stats } diff --git a/deps/undici/src/lib/dispatcher/balanced-pool.js b/deps/undici/src/lib/dispatcher/balanced-pool.js index 8bad487b3f2367..ca14bf6ed1d54c 100644 --- a/deps/undici/src/lib/dispatcher/balanced-pool.js +++ b/deps/undici/src/lib/dispatcher/balanced-pool.js @@ -164,35 +164,14 @@ class BalancedPool extends PoolBase { throw new BalancedPoolMissingUpstreamError() } - const dispatcher = this[kClients].find(dispatcher => ( - !dispatcher[kNeedDrain] && - dispatcher.closed !== true && - dispatcher.destroyed !== true - )) - - if (!dispatcher) { - return - } - - const allClientsBusy = this[kClients].map(pool => pool[kNeedDrain]).reduce((a, b) => a && b, true) - - if (allClientsBusy) { - return - } - let counter = 0 - let maxWeightIndex = this[kClients].findIndex(pool => !pool[kNeedDrain]) + let maxWeightIndex = -1 while (counter++ < this[kClients].length) { this[kIndex] = (this[kIndex] + 1) % this[kClients].length const pool = this[kClients][this[kIndex]] - // find pool index with the largest weight - if (pool[kWeight] > this[kClients][maxWeightIndex][kWeight] && !pool[kNeedDrain]) { - maxWeightIndex = this[kIndex] - } - // decrease the current weight every `this[kClients].length`. if (this[kIndex] === 0) { // Set the current weight to the next lower weight. @@ -202,11 +181,30 @@ class BalancedPool extends PoolBase { this[kCurrentWeight] = this[kMaxWeightPerServer] } } - if (pool[kWeight] >= this[kCurrentWeight] && (!pool[kNeedDrain])) { + + // Skip unavailable pools after updating the current weight for this cycle. + if ( + pool[kNeedDrain] || + pool.closed === true || + pool.destroyed === true + ) { + continue + } + + // Track the best fallback if no pool matches the current weight. + if (maxWeightIndex === -1 || pool[kWeight] > this[kClients][maxWeightIndex][kWeight]) { + maxWeightIndex = this[kIndex] + } + + if (pool[kWeight] >= this[kCurrentWeight]) { return pool } } + if (maxWeightIndex === -1) { + return + } + this[kCurrentWeight] = this[kClients][maxWeightIndex][kWeight] this[kIndex] = maxWeightIndex return this[kClients][maxWeightIndex] diff --git a/deps/undici/src/lib/dispatcher/client-h1.js b/deps/undici/src/lib/dispatcher/client-h1.js index 887b0fb029fadf..f64d3f11324c7a 100644 --- a/deps/undici/src/lib/dispatcher/client-h1.js +++ b/deps/undici/src/lib/dispatcher/client-h1.js @@ -69,9 +69,9 @@ function lazyllhttp () { let useWasmSIMD = process.arch !== 'ppc64' // The Env Variable UNDICI_NO_WASM_SIMD allows explicitly overriding the default behavior if (process.env.UNDICI_NO_WASM_SIMD === '1') { - useWasmSIMD = true - } else if (process.env.UNDICI_NO_WASM_SIMD === '0') { useWasmSIMD = false + } else if (process.env.UNDICI_NO_WASM_SIMD === '0') { + useWasmSIMD = true } if (useWasmSIMD) { @@ -188,6 +188,7 @@ let currentBufferRef = null */ let currentBufferSize = 0 let currentBufferPtr = null +let currentBuffer = null const USE_NATIVE_TIMER = 0 const USE_FAST_TIMER = 1 @@ -216,6 +217,7 @@ class Parser { */ this.socket = socket this.timeout = null + this.timeoutWeakRef = new WeakRef(this) this.timeoutValue = null this.timeoutType = null this.statusCode = 0 @@ -231,8 +233,8 @@ class Parser { this.bytesRead = 0 this.keepAlive = '' - this.contentLength = '' - this.connection = '' + this.contentLength = -1 + this.connectionKeepAlive = false this.maxResponseSize = client[kMaxResponseSize] } @@ -253,9 +255,9 @@ class Parser { if (delay) { if (type & USE_FAST_TIMER) { - this.timeout = timers.setFastTimeout(onParserTimeout, delay, new WeakRef(this)) + this.timeout = timers.setFastTimeout(onParserTimeout, delay, this.timeoutWeakRef) } else { - this.timeout = setTimeout(onParserTimeout, delay, new WeakRef(this)) + this.timeout = setTimeout(onParserTimeout, delay, this.timeoutWeakRef) this.timeout?.unref() } } @@ -322,7 +324,16 @@ class Parser { currentBufferPtr = llhttp.malloc(currentBufferSize) } - new Uint8Array(llhttp.memory.buffer, currentBufferPtr, currentBufferSize).set(chunk) + if ( + currentBuffer === null || + currentBuffer.buffer !== llhttp.memory.buffer || + currentBuffer.byteOffset !== currentBufferPtr || + currentBuffer.byteLength !== currentBufferSize + ) { + currentBuffer = new Uint8Array(llhttp.memory.buffer, currentBufferPtr, currentBufferSize) + } + + currentBuffer.set(chunk) // Call `execute` on the wasm parser. // We pass the `llhttp_parser` pointer address, the pointer address of buffer view data, @@ -447,10 +458,17 @@ class Parser { if (headerName === 'keep-alive') { this.keepAlive += buf.toString() } else if (headerName === 'connection') { - this.connection += buf.toString() + this.connectionKeepAlive = + this.headers[len - 1].length === 10 && + util.bufferToLowerCasedHeaderName(this.headers[len - 1]) === 'keep-alive' } } else if (key.length === 14 && util.bufferToLowerCasedHeaderName(key) === 'content-length') { - this.contentLength += buf.toString() + if (this.contentLength === -1) { + this.contentLength = 0 + } + for (let i = 0; i < buf.length; i++) { + this.contentLength = (this.contentLength * 10) + (buf[i] - 0x30) + } } this.trackHeader(buf.length) @@ -554,7 +572,7 @@ class Parser { this.shouldKeepAlive = ( shouldKeepAlive || // Override llhttp value which does not allow keepAlive for HEAD. - (request.method === 'HEAD' && !socket[kReset] && this.connection.toLowerCase() === 'keep-alive') + (request.method === 'HEAD' && !socket[kReset] && this.connectionKeepAlive) ) if (this.statusCode >= 200) { @@ -687,9 +705,9 @@ class Parser { this.statusCode = 0 this.statusText = '' this.bytesRead = 0 - this.contentLength = '' + this.contentLength = -1 this.keepAlive = '' - this.connection = '' + this.connectionKeepAlive = false this.headers = [] this.headersSize = 0 @@ -698,7 +716,7 @@ class Parser { return 0 } - if (request.method !== 'HEAD' && contentLength && bytesRead !== parseInt(contentLength, 10)) { + if (request.method !== 'HEAD' && contentLength !== -1 && bytesRead !== contentLength) { util.destroy(socket, new ResponseContentLengthMismatchError()) return -1 } @@ -1106,7 +1124,7 @@ function writeH1 (client, request) { socket[kReset] = reset } - if (client[kMaxRequests] && socket[kCounter]++ >= client[kMaxRequests]) { + if (client[kMaxRequests] && ++socket[kCounter] >= client[kMaxRequests]) { socket[kReset] = true } @@ -1477,7 +1495,7 @@ class AsyncWriter { } /** - * @param {Buffer} chunk + * @param {string|Uint8Array} chunk * @returns */ write (chunk) { @@ -1491,7 +1509,7 @@ class AsyncWriter { return false } - const len = Buffer.byteLength(chunk) + const len = chunk instanceof Uint8Array ? chunk.byteLength : Buffer.byteLength(chunk) if (!len) { return true } diff --git a/deps/undici/src/lib/dispatcher/client-h2.js b/deps/undici/src/lib/dispatcher/client-h2.js index 58ccdfb75ec6f8..b77013df98da46 100644 --- a/deps/undici/src/lib/dispatcher/client-h2.js +++ b/deps/undici/src/lib/dispatcher/client-h2.js @@ -41,6 +41,12 @@ const { const { channels } = require('../core/diagnostics.js') const kOpenStreams = Symbol('open streams') +const kRequestStreamId = Symbol('request stream id') +const kRequestStream = Symbol('request stream') +const kRequestStreamCleanup = Symbol('request stream cleanup') +const kRequestStreamOnData = Symbol('request stream on data') +const kRequestStreamOnCloseError = Symbol('request stream on close error') +const kReceivedGoAway = Symbol('received goaway') let extractBody @@ -63,29 +69,73 @@ const { HTTP2_HEADER_EXPECT, HTTP2_HEADER_STATUS, HTTP2_HEADER_PROTOCOL, - NGHTTP2_REFUSED_STREAM, - NGHTTP2_CANCEL + NGHTTP2_NO_ERROR, + NGHTTP2_REFUSED_STREAM } } = http2 -function parseH2Headers (headers) { - const result = [] - - for (const [name, value] of Object.entries(headers)) { - // h2 may concat the header value by array - // e.g. Set-Cookie - if (Array.isArray(value)) { - for (const subvalue of value) { - // we need to provide each header value of header name - // because the headers handler expect name-value pair - result.push(Buffer.from(name), Buffer.from(subvalue)) - } - } else { - result.push(Buffer.from(name), Buffer.from(value)) +function getGoAwayError (session, errorCode) { + return session[kError] || + (errorCode === NGHTTP2_NO_ERROR + ? new InformationalError(`HTTP/2: "GOAWAY" frame received with code ${errorCode}`) + : new SocketError(`HTTP/2: "GOAWAY" frame received with code ${errorCode}`, util.getSocketInfo(session[kSocket]))) +} + +function getGoAwayPendingIdx (client, lastStreamID) { + const maxAcceptedStreamID = Number.isInteger(lastStreamID) ? lastStreamID : Number.MAX_SAFE_INTEGER + + for (let i = client[kRunningIdx]; i < client[kPendingIdx]; i++) { + const request = client[kQueue][i] + + if (request == null) { + continue + } + + if (typeof request[kRequestStreamId] !== 'number' || request[kRequestStreamId] > maxAcceptedStreamID) { + return i } } - return result + return client[kPendingIdx] +} + +function detachRequestFromStream (request) { + request[kRequestStreamId] = null + request[kRequestStream] = null + request[kRequestStreamCleanup] = null +} + +function bindRequestToStream (request, stream, cleanup) { + const previousCleanup = request[kRequestStreamCleanup] + detachRequestFromStream(request) + previousCleanup?.() + request[kRequestStreamId] = stream.id + request[kRequestStream] = stream + request[kRequestStreamCleanup] = cleanup +} + +function clearRequestStream (request) { + const cleanup = request[kRequestStreamCleanup] + detachRequestFromStream(request) + cleanup?.() +} + +function canRetryRequestAfterGoAway (request) { + const { body } = request + + return body == null || util.isBuffer(body) || util.isBlobLike(body) +} + +function closeRequestStream (request, code = NGHTTP2_REFUSED_STREAM) { + const stream = request[kRequestStream] + + clearRequestStream(request) + + if (stream != null && !stream.destroyed && !stream.closed) { + try { + stream.close(code) + } catch {} + } } function connectH2 (client, socket) { @@ -113,6 +163,7 @@ function connectH2 (client, socket) { interval: client[kPingInterval] === 0 ? null : setInterval(onHttp2SendPing, client[kPingInterval], session).unref() } } + session[kReceivedGoAway] = false // We set it to true by default in a best-effort; however once connected to an H2 server // we will check if extended CONNECT protocol is supported or not // and set this value accordingly. @@ -184,6 +235,14 @@ function connectH2 (client, socket) { * @returns {boolean} */ busy (request) { + if (session[kRemoteSettings] === false && client[kRunning] > 0) { + return true + } + + if (client[kRunning] >= client[kMaxConcurrentStreams]) { + return true + } + if (request != null) { if (client[kRunning] > 0) { // We are already processing requests @@ -273,7 +332,7 @@ function onHttp2SendPing (session) { function onPing (err, duration) { const client = this[kClient] - const socket = this[kClient] + const socket = this[kSocket] if (err != null) { const error = new InformationalError(`HTTP/2: "PING" errored - type ${err.message}`) @@ -313,48 +372,68 @@ function onHttp2SessionEnd () { * * @this {import('http2').ClientHttp2Session} * @param {number} errorCode + * @param {number} lastStreamID */ -function onHttp2SessionGoAway (errorCode) { - // TODO(mcollina): Verify if GOAWAY implements the spec correctly: - // https://datatracker.ietf.org/doc/html/rfc7540#section-6.8 - // Specifically, we do not verify the "valid" stream id. +function onHttp2SessionGoAway (errorCode, lastStreamID) { + if (this[kReceivedGoAway]) { + return + } + + this[kReceivedGoAway] = true - const err = this[kError] || new SocketError(`HTTP/2: "GOAWAY" frame received with code ${errorCode}`, util.getSocketInfo(this[kSocket])) + const err = getGoAwayError(this, errorCode) const client = this[kClient] + const previousPendingIdx = client[kPendingIdx] + const pendingIdx = getGoAwayPendingIdx(client, lastStreamID) + const retriableRequests = [] - client[kSocket] = null - client[kHTTPContext] = null + for (let i = pendingIdx; i < previousPendingIdx; i++) { + const request = client[kQueue][i] - // this is an HTTP2 session - this.close() - this[kHTTP2Session] = null + if (request != null) { + closeRequestStream(request) - util.destroy(this[kSocket], err) + if (canRetryRequestAfterGoAway(request)) { + retriableRequests.push(request) + } else { + util.errorRequest(client, request, err) + } + } + } - // Fail head of pipeline. - if (client[kRunningIdx] < client[kQueue].length) { - const request = client[kQueue][client[kRunningIdx]] - client[kQueue][client[kRunningIdx]++] = null - util.errorRequest(client, request, err) - client[kPendingIdx] = client[kRunningIdx] + if (pendingIdx !== previousPendingIdx) { + const remainingPendingRequests = client[kQueue].slice(previousPendingIdx) + client[kQueue].length = pendingIdx + client[kQueue].push(...retriableRequests, ...remainingPendingRequests) } - assert(client[kRunning] === 0) + if (client[kHTTP2Session] === this) { + client[kSocket] = null + client[kHTTPContext] = null + client[kHTTP2Session] = null + } + + if (!this.closed && !this.destroyed) { + this.close() + } + + client[kPendingIdx] = pendingIdx client.emit('disconnect', client[kUrl], [client], err) - client.emit('connectionError', client[kUrl], [client], err) client[kResume]() } function onHttp2SessionClose () { - const { [kClient]: client, [kHTTP2SessionState]: state } = this - const { [kSocket]: socket } = client + const { [kClient]: client, [kHTTP2SessionState]: state, [kSocket]: socket } = this - const err = this[kSocket][kError] || this[kError] || new SocketError('closed', util.getSocketInfo(socket)) + const err = socket[kError] || this[kError] || new SocketError('closed', util.getSocketInfo(socket)) - client[kSocket] = null - client[kHTTPContext] = null + if (client[kHTTP2Session] === this) { + client[kSocket] = null + client[kHTTPContext] = null + client[kHTTP2Session] = null + } if (state.ping.interval != null) { clearInterval(state.ping.interval) @@ -376,15 +455,27 @@ function onHttp2SessionClose () { function onHttp2SocketClose () { const err = this[kError] || new SocketError('closed', util.getSocketInfo(this)) - const client = this[kHTTP2Session][kClient] + const session = this[kHTTP2Session] + const client = session[kClient] + + if (client[kSocket] !== this) { + // Ignore stale socket closes from a detached GOAWAY session and from any + // session that has already been replaced. If the session was detached + // without a GOAWAY and there is no replacement yet, we still need the + // close event to flush the client state. + if (session[kReceivedGoAway] || (client[kHTTP2Session] != null && client[kHTTP2Session] !== session)) { + return + } + } client[kSocket] = null client[kHTTPContext] = null - - if (this[kHTTP2Session] !== null) { - this[kHTTP2Session].destroy(err) + if (client[kHTTP2Session] === session) { + client[kHTTP2Session] = null } + session.destroy(err) + client[kPendingIdx] = client[kRunningIdx] assert(client[kRunning] === 0) @@ -410,6 +501,37 @@ function onSocketClose () { this[kClosed] = true } +function noop () {} + +function closeStreamSession (stream) { + const session = stream[kHTTP2Session] + + stream[kHTTP2Session] = null + session[kOpenStreams] -= 1 + if (session[kOpenStreams] === 0) { + session.unref() + } +} + +function onUpgradeStreamClose () { + this.off('error', noop) + + const failUpgradeStream = this[kRequestStreamOnCloseError] + this[kRequestStreamOnCloseError] = null + + failUpgradeStream(new InformationalError('HTTP/2: stream closed before response headers')) + closeStreamSession(this) +} + +function onRequestStreamClose () { + const onData = this[kRequestStreamOnData] + + this[kRequestStreamOnData] = null + this.off('data', onData) + this.off('error', noop) + closeStreamSession(this) +} + // https://www.rfc-editor.org/rfc/rfc7230#section-3.3.2 function shouldSendContentLength (method) { return method !== 'GET' && method !== 'HEAD' && method !== 'OPTIONS' && method !== 'TRACE' && method !== 'CONNECT' @@ -464,7 +586,23 @@ function writeH2 (client, request) { headers[HTTP2_HEADER_AUTHORITY] = host || `${hostname}${port ? `:${port}` : ''}` headers[HTTP2_HEADER_METHOD] = method - const abort = (err) => { + let requestFinalized = false + const finalizeRequest = (resetPendingIdx = false) => { + if (requestFinalized) { + return + } + + requestFinalized = true + client[kQueue][client[kRunningIdx]++] = null + + if (resetPendingIdx) { + client[kPendingIdx] = client[kRunningIdx] + } + + client[kResume]() + } + + const abort = (err, resetPendingIdx = false) => { if (request.aborted || request.completed) { return } @@ -474,16 +612,14 @@ function writeH2 (client, request) { util.errorRequest(client, request, err) if (stream != null) { - // Some chunks might still come after abort, - // let's ignore them - stream.removeAllListeners('data') + clearRequestStream(request) // On Abort, we close the stream to send RST_STREAM frame stream.close() // We move the running index to the next request client[kOnError](err) - client[kResume]() + finalizeRequest(resetPendingIdx) } // We do not destroy the socket as we can continue using the session @@ -491,6 +627,26 @@ function writeH2 (client, request) { util.destroy(body, err) } + const requestStream = (headers, options) => { + try { + return session.request(headers, options) + } catch (err) { + if (err?.code !== 'ERR_HTTP2_INVALID_CONNECTION_HEADERS') { + throw err + } + + const wrappedErr = new InformationalError(err.message, { cause: err }) + session[kError] = wrappedErr + session[kSocket][kError] = wrappedErr + + session.destroy(wrappedErr) + util.destroy(session[kSocket], wrappedErr) + abort(wrappedErr) + + return null + } + } + try { // We are already connected, streams are pending. // We can call on connect, and wait for abort @@ -506,6 +662,84 @@ function writeH2 (client, request) { if (upgrade || method === 'CONNECT') { session.ref() + const setupUpgradeStream = (stream) => { + let responseReceived = false + + const removeUpgradeStreamListeners = () => { + stream.off('response', onUpgradeResponse) + stream.off('error', onUpgradeStreamError) + stream.off('end', onUpgradeStreamEnd) + stream.off('timeout', onUpgradeStreamTimeout) + stream.off('error', noop) + } + + const releaseUpgradeStream = () => { + if (request[kRequestStream] === stream) { + detachRequestFromStream(request) + } + + removeUpgradeStreamListeners() + + if (!stream.destroyed && !stream.closed) { + stream.once('error', noop) + } + } + + const failUpgradeStream = (err) => { + if (responseReceived || request.aborted || request.completed) { + return + } + + releaseUpgradeStream() + abort(err, true) + } + + const onUpgradeStreamError = () => { + if (typeof stream.rstCode === 'number' && stream.rstCode !== 0) { + failUpgradeStream(new InformationalError(`HTTP/2: "stream error" received - code ${stream.rstCode}`)) + } else { + failUpgradeStream(new InformationalError('HTTP/2: stream errored before response headers')) + } + } + + const onUpgradeStreamEnd = () => { + failUpgradeStream(new InformationalError('HTTP/2: stream half-closed (remote)')) + } + + const onUpgradeStreamTimeout = () => { + failUpgradeStream(new InformationalError(`HTTP/2: "stream timeout after ${requestTimeout}"`)) + } + + const onUpgradeResponse = (headers, _flags) => { + responseReceived = true + + const statusCode = headers[HTTP2_HEADER_STATUS] + delete headers[HTTP2_HEADER_STATUS] + + request.onRequestUpgrade(statusCode, headers, stream) + + if (request.aborted || request.completed) { + return + } + + removeUpgradeStreamListeners() + detachRequestFromStream(request) + finalizeRequest() + } + + bindRequestToStream(request, stream, releaseUpgradeStream) + stream.once('response', onUpgradeResponse) + stream.on('error', onUpgradeStreamError) + stream.once('end', onUpgradeStreamEnd) + stream.on('timeout', onUpgradeStreamTimeout) + stream[kHTTP2Session] = session + stream[kRequestStreamOnCloseError] = failUpgradeStream + stream.once('close', onUpgradeStreamClose) + + ++session[kOpenStreams] + stream.setTimeout(requestTimeout) + } + if (upgrade === 'websocket') { // We cannot upgrade to websocket if extended CONNECT protocol is not supported if (session[kEnableConnectProtocol] === false) { @@ -528,33 +762,13 @@ function writeH2 (client, request) { headers[HTTP2_HEADER_SCHEME] = protocol === 'http:' ? 'http' : 'https' } - stream = session.request(headers, { endStream: false, signal }) + stream = requestStream(headers, { endStream: false, signal }) + if (stream == null) { + session.unref() + return false + } stream[kHTTP2Stream] = true - - stream.once('response', (headers, _flags) => { - const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers - - request.onRequestUpgrade(statusCode, parseH2Headers(realHeaders), stream) - - ++session[kOpenStreams] - client[kQueue][client[kRunningIdx]++] = null - }) - - stream.on('error', () => { - if (stream.rstCode === NGHTTP2_REFUSED_STREAM || stream.rstCode === NGHTTP2_CANCEL) { - // NGHTTP2_REFUSED_STREAM (7) or NGHTTP2_CANCEL (8) - // We do not treat those as errors as the server might - // not support websockets and refuse the stream - abort(new InformationalError(`HTTP/2: "stream error" received - code ${stream.rstCode}`)) - } - }) - - stream.once('close', () => { - session[kOpenStreams] -= 1 - if (session[kOpenStreams] === 0) session.unref() - }) - - stream.setTimeout(requestTimeout) + setupUpgradeStream(stream) return true } @@ -563,20 +777,13 @@ function writeH2 (client, request) { // will create a new stream. We trigger a request to create the stream and wait until // `ready` event is triggered // We disabled endStream to allow the user to write to the stream - stream = session.request(headers, { endStream: false, signal }) + stream = requestStream(headers, { endStream: false, signal }) + if (stream == null) { + session.unref() + return false + } stream[kHTTP2Stream] = true - stream.on('response', headers => { - const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers - - request.onRequestUpgrade(statusCode, parseH2Headers(realHeaders), stream) - ++session[kOpenStreams] - client[kQueue][client[kRunningIdx]++] = null - }) - stream.once('close', () => { - session[kOpenStreams] -= 1 - if (session[kOpenStreams] === 0) session.unref() - }) - stream.setTimeout(requestTimeout) + setupUpgradeStream(stream) return true } @@ -622,7 +829,7 @@ function writeH2 (client, request) { contentLength = request.contentLength } - if (!expectsPayload) { + if (contentLength === 0 && !expectsPayload) { // https://tools.ietf.org/html/rfc7230#section-3.3.2 // A user agent SHOULD NOT send a Content-Length header field when // the request message does not contain a payload body and the method @@ -658,21 +865,25 @@ function writeH2 (client, request) { } // TODO(metcoder95): add support for sending trailers - const shouldEndStream = method === 'GET' || method === 'HEAD' || body === null + const shouldEndStream = body === null if (expectContinue) { headers[HTTP2_HEADER_EXPECT] = '100-continue' - stream = session.request(headers, { endStream: shouldEndStream, signal }) + stream = requestStream(headers, { endStream: shouldEndStream, signal }) + if (stream == null) { + return false + } stream[kHTTP2Stream] = true - - stream.once('continue', writeBodyH2) + bindRequestToStream(request, stream, null) } else { - stream = session.request(headers, { + stream = requestStream(headers, { endStream: shouldEndStream, signal }) + if (stream == null) { + return false + } stream[kHTTP2Stream] = true - - writeBodyH2() + bindRequestToStream(request, stream, null) } // Increment counter as we have new streams open @@ -681,9 +892,46 @@ function writeH2 (client, request) { // Track whether we received a response (headers) let responseReceived = false + const onData = (chunk) => { + if (request.aborted || request.completed) { + return + } - stream.once('response', headers => { - const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers + if (request.onResponseData(chunk) === false) { + stream.pause() + } + } + + const removeRequestStreamListeners = () => { + stream.off('error', noop) + stream.off('continue', writeBodyH2) + stream.off('response', onResponse) + stream.off('end', onEnd) + stream.off('error', onError) + stream.off('frameError', onFrameError) + stream.off('aborted', onAborted) + stream.off('timeout', onTimeout) + stream.off('trailers', onTrailers) + stream.off('data', onData) + } + + const releaseRequestStream = () => { + if (request[kRequestStream] === stream) { + detachRequestFromStream(request) + } + + removeRequestStreamListeners() + + if (!stream.destroyed && !stream.closed) { + stream.once('error', noop) + } + } + + const onResponse = (headers) => { + stream.off('response', onResponse) + + const statusCode = headers[HTTP2_HEADER_STATUS] + delete headers[HTTP2_HEADER_STATUS] request.onResponseStarted() responseReceived = true @@ -693,86 +941,91 @@ function writeH2 (client, request) { // for those scenarios, best effort is to destroy the stream immediately // as there's no value to keep it open. if (request.aborted) { - stream.removeAllListeners('data') + releaseRequestStream() return } - if (request.onResponseStart(Number(statusCode), parseH2Headers(realHeaders), stream.resume.bind(stream), '') === false) { + if (request.onResponseStart(Number(statusCode), headers, stream.resume.bind(stream), '') === false) { stream.pause() } - stream.on('data', (chunk) => { - if (request.aborted || request.completed) { - return - } + stream.on('data', onData) + } - if (request.onResponseData(chunk) === false) { - stream.pause() - } - }) - }) + const onEnd = () => { + stream.off('end', onEnd) - stream.once('end', () => { - stream.removeAllListeners('data') + releaseRequestStream() // If we received a response, this is a normal completion if (responseReceived) { if (!request.aborted && !request.completed) { request.onResponseEnd({}) } - client[kQueue][client[kRunningIdx]++] = null - client[kResume]() + finalizeRequest() } else { // Stream ended without receiving a response - this is an error // (e.g., server destroyed the stream before sending headers) - abort(new InformationalError('HTTP/2: stream half-closed (remote)')) - client[kQueue][client[kRunningIdx]++] = null - client[kPendingIdx] = client[kRunningIdx] - client[kResume]() + abort(new InformationalError('HTTP/2: stream half-closed (remote)'), true) } - }) + } - stream.once('close', () => { - stream.removeAllListeners('data') - session[kOpenStreams] -= 1 - if (session[kOpenStreams] === 0) { - session.unref() - } - }) + stream[kHTTP2Session] = session + stream[kRequestStreamOnData] = onData + stream.once('close', onRequestStreamClose) - stream.once('error', function (err) { - stream.removeAllListeners('data') + const onError = function (err) { + stream.off('error', onError) + + releaseRequestStream() abort(err) - }) + } - stream.once('frameError', (type, code) => { - stream.removeAllListeners('data') - abort(new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`)) - }) + const onFrameError = (type, code) => { + stream.off('frameError', onFrameError) - stream.on('aborted', () => { - stream.removeAllListeners('data') - }) + releaseRequestStream() + abort(new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`)) + } - stream.on('timeout', () => { - const err = new InformationalError(`HTTP/2: "stream timeout after ${requestTimeout}"`) - stream.removeAllListeners('data') - session[kOpenStreams] -= 1 + const onAborted = () => { + stream.off('data', onData) + } - if (session[kOpenStreams] === 0) { - session.unref() - } + const onTimeout = () => { + releaseRequestStream() + const err = new InformationalError(`HTTP/2: "stream timeout after ${requestTimeout}"`) abort(err) - }) + } + + const onTrailers = (trailers) => { + stream.off('trailers', onTrailers) - stream.once('trailers', trailers => { if (request.aborted || request.completed) { return } + releaseRequestStream() request.onResponseEnd(trailers) - }) + finalizeRequest() + } + + bindRequestToStream(request, stream, releaseRequestStream) + if (expectContinue) { + stream.once('continue', writeBodyH2) + } + stream.once('response', onResponse) + stream.once('end', onEnd) + stream.once('error', onError) + stream.once('frameError', onFrameError) + stream.on('aborted', onAborted) + stream.on('timeout', onTimeout) + stream.once('trailers', onTrailers) + + if (!expectContinue) { + writeBodyH2() + } return true diff --git a/deps/undici/src/lib/dispatcher/h2c-client.js b/deps/undici/src/lib/dispatcher/h2c-client.js index 5fe7e778ba40e5..b79bdb68d2b77a 100644 --- a/deps/undici/src/lib/dispatcher/h2c-client.js +++ b/deps/undici/src/lib/dispatcher/h2c-client.js @@ -17,15 +17,15 @@ class H2CClient extends Client { const { maxConcurrentStreams, pipelining, ...opts } = clientOpts ?? {} - let defaultMaxConcurrentStreams = 100 + const defaultMaxConcurrentStreams = maxConcurrentStreams ?? 100 let defaultPipelining = 100 if ( maxConcurrentStreams != null && - Number.isInteger(maxConcurrentStreams) && - maxConcurrentStreams > 0 + (!Number.isInteger(maxConcurrentStreams) || + maxConcurrentStreams < 1) ) { - defaultMaxConcurrentStreams = maxConcurrentStreams + throw new InvalidArgumentError('maxConcurrentStreams must be a positive integer, greater than 0') } if (pipelining != null && Number.isInteger(pipelining) && pipelining > 0) { diff --git a/deps/undici/src/lib/dispatcher/pool-base.js b/deps/undici/src/lib/dispatcher/pool-base.js index daa19cb812ef61..1395cd7f2772ec 100644 --- a/deps/undici/src/lib/dispatcher/pool-base.js +++ b/deps/undici/src/lib/dispatcher/pool-base.js @@ -189,12 +189,12 @@ class PoolBase extends DispatcherBase { } [kRemoveClient] (client) { - client.close(() => { - const idx = this[kClients].indexOf(client) - if (idx !== -1) { - this[kClients].splice(idx, 1) - } - }) + const idx = this[kClients].indexOf(client) + if (idx !== -1) { + this[kClients].splice(idx, 1) + } + + client.close(() => {}) this[kNeedDrain] = this[kClients].some(dispatcher => ( !dispatcher[kNeedDrain] && diff --git a/deps/undici/src/lib/dispatcher/pool.js b/deps/undici/src/lib/dispatcher/pool.js index 24a2c41c2f396c..f5898b02b3551c 100644 --- a/deps/undici/src/lib/dispatcher/pool.js +++ b/deps/undici/src/lib/dispatcher/pool.js @@ -36,6 +36,7 @@ class Pool extends PoolBase { autoSelectFamily, autoSelectFamilyAttemptTimeout, allowH2, + useH2c, clientTtl, ...options } = {}) { @@ -56,6 +57,7 @@ class Pool extends PoolBase { ...tls, maxCachedSessions, allowH2, + useH2c, socketPath, timeout: connectTimeout, ...(typeof autoSelectFamily === 'boolean' ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : undefined), @@ -67,7 +69,7 @@ class Pool extends PoolBase { this[kConnections] = connections || null this[kUrl] = util.parseOrigin(origin) - this[kOptions] = { ...util.deepClone(options), connect, allowH2, clientTtl, socketPath } + this[kOptions] = { ...util.deepClone(options), connect, allowH2, useH2c, clientTtl, socketPath } this[kFactory] = factory this.on('connect', (origin, targets) => { @@ -95,10 +97,13 @@ class Pool extends PoolBase { [kGetDispatcher] () { const clientTtlOption = this[kOptions].clientTtl - for (const client of this[kClients]) { + for (let i = 0; i < this[kClients].length; i++) { + const client = this[kClients][i] + // check ttl of client and if it's stale, remove it from the pool if (clientTtlOption != null && clientTtlOption > 0 && client.ttl && ((Date.now() - client.ttl) > clientTtlOption)) { this[kRemoveClient](client) + i-- } else if (!client[kNeedDrain]) { return client } diff --git a/deps/undici/src/lib/dispatcher/proxy-agent.js b/deps/undici/src/lib/dispatcher/proxy-agent.js index f7bb461e5d49a9..b89b88bde969d2 100644 --- a/deps/undici/src/lib/dispatcher/proxy-agent.js +++ b/deps/undici/src/lib/dispatcher/proxy-agent.js @@ -126,6 +126,8 @@ class ProxyAgent extends DispatcherBase { this[kProxyHeaders]['proxy-authorization'] = opts.token } else if (username && password) { this[kProxyHeaders]['proxy-authorization'] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:${decodeURIComponent(password)}`).toString('base64')}` + } else if (username) { + this[kProxyHeaders]['proxy-authorization'] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:`).toString('base64')}` } const connect = buildConnector({ timeout: connectTimeout, ...opts.proxyTls }) diff --git a/deps/undici/src/lib/dispatcher/round-robin-pool.js b/deps/undici/src/lib/dispatcher/round-robin-pool.js index ac08f4609231c1..17daea7a4a3274 100644 --- a/deps/undici/src/lib/dispatcher/round-robin-pool.js +++ b/deps/undici/src/lib/dispatcher/round-robin-pool.js @@ -92,10 +92,9 @@ class RoundRobinPool extends PoolBase { [kGetDispatcher] () { const clientTtlOption = this[kOptions].clientTtl - const clientsLength = this[kClients].length // If we have no clients yet, create one - if (clientsLength === 0) { + if (this[kClients].length === 0) { const dispatcher = this[kFactory](this[kUrl], this[kOptions]) this[kAddClient](dispatcher) return dispatcher @@ -103,14 +102,14 @@ class RoundRobinPool extends PoolBase { // Round-robin through existing clients let checked = 0 - while (checked < clientsLength) { - this[kIndex] = (this[kIndex] + 1) % clientsLength + while (checked < this[kClients].length) { + this[kIndex] = (this[kIndex] + 1) % this[kClients].length const client = this[kClients][this[kIndex]] // Check if client is stale (TTL expired) if (clientTtlOption != null && clientTtlOption > 0 && client.ttl && ((Date.now() - client.ttl) > clientTtlOption)) { this[kRemoveClient](client) - checked++ + this[kIndex]-- continue } @@ -123,7 +122,7 @@ class RoundRobinPool extends PoolBase { } // All clients are busy, create a new one if we haven't reached the limit - if (!this[kConnections] || clientsLength < this[kConnections]) { + if (!this[kConnections] || this[kClients].length < this[kConnections]) { const dispatcher = this[kFactory](this[kUrl], this[kOptions]) this[kAddClient](dispatcher) return dispatcher diff --git a/deps/undici/src/lib/dispatcher/socks5-proxy-agent.js b/deps/undici/src/lib/dispatcher/socks5-proxy-agent.js index 4a2f65e6eed5e0..c0b681929ac499 100644 --- a/deps/undici/src/lib/dispatcher/socks5-proxy-agent.js +++ b/deps/undici/src/lib/dispatcher/socks5-proxy-agent.js @@ -6,7 +6,7 @@ const { URL } = require('node:url') let tls // include tls conditionally since it is not always available const DispatcherBase = require('./dispatcher-base') const { InvalidArgumentError } = require('../core/errors') -const { Socks5Client } = require('../core/socks5-client') +const { Socks5Client, STATES } = require('../core/socks5-client') const { kDispatch, kClose, kDestroy } = require('../core/symbols') const Pool = require('./pool') const buildConnector = require('../core/connect') @@ -17,7 +17,7 @@ const debug = debuglog('undici:socks5-proxy') const kProxyUrl = Symbol('proxy url') const kProxyHeaders = Symbol('proxy headers') const kProxyAuth = Symbol('proxy auth') -const kPool = Symbol('pool') +const kPools = Symbol('pools') const kConnector = Symbol('connector') // Static flag to ensure warning is only emitted once per process @@ -65,8 +65,8 @@ class Socks5ProxyAgent extends DispatcherBase { servername: options.proxyTls?.servername || url.hostname }) - // Pool for the actual HTTP connections (with SOCKS5 tunnel connect function) - this[kPool] = null + // Pools for the actual HTTP connections (with SOCKS5 tunnel connect function), keyed by origin + this[kPools] = new Map() } /** @@ -133,7 +133,7 @@ class Socks5ProxyAgent extends DispatcherBase { } // Check if already authenticated (for NO_AUTH method) - if (socks5Client.state === 'authenticated') { + if (socks5Client.state === STATES.AUTHENTICATED) { clearTimeout(authenticationTimeout) authenticationReady.resolve() } else { @@ -183,9 +183,11 @@ class Socks5ProxyAgent extends DispatcherBase { debug('dispatching request to', origin, 'via SOCKS5') try { - // Create Pool with custom connect function if we don't have one yet - if (!this[kPool] || this[kPool].destroyed || this[kPool].closed) { - this[kPool] = new Pool(origin, { + const originKey = String(origin) + let pool = this[kPools].get(originKey) + // Create a Pool per origin so requests are not routed to the wrong host + if (!pool || pool.destroyed || pool.closed) { + pool = new Pool(origin, { pipelining: opts.pipelining, connections: opts.connections, connect: async (connectOpts, callback) => { @@ -225,10 +227,11 @@ class Socks5ProxyAgent extends DispatcherBase { } } }) + this[kPools].set(originKey, pool) } - // Dispatch the request through the pool - return this[kPool][kDispatch](opts, handler) + // Dispatch the request through the per-origin pool + return pool[kDispatch](opts, handler) } catch (err) { debug('dispatch error:', err) if (typeof handler.onError === 'function') { @@ -240,15 +243,21 @@ class Socks5ProxyAgent extends DispatcherBase { } async [kClose] () { - if (this[kPool]) { - await this[kPool].close() + const closePromises = [] + for (const pool of this[kPools].values()) { + closePromises.push(pool.close()) } + this[kPools].clear() + await Promise.all(closePromises) } async [kDestroy] (err) { - if (this[kPool]) { - await this[kPool].destroy(err) + const destroyPromises = [] + for (const pool of this[kPools].values()) { + destroyPromises.push(pool.destroy(err)) } + this[kPools].clear() + await Promise.all(destroyPromises) } } diff --git a/deps/undici/src/lib/handler/cache-handler.js b/deps/undici/src/lib/handler/cache-handler.js index f3316f0f58d28c..6e13f8eb17c254 100644 --- a/deps/undici/src/lib/handler/cache-handler.js +++ b/deps/undici/src/lib/handler/cache-handler.js @@ -479,7 +479,7 @@ function determineStaleAt (cacheType, now, age, resHeaders, responseDate, cacheC if (cacheControlDirectives.immutable) { // https://www.rfc-editor.org/rfc/rfc8246.html#section-2.2 - return 31536000 + return 31536000000 } return undefined diff --git a/deps/undici/src/lib/handler/redirect-handler.js b/deps/undici/src/lib/handler/redirect-handler.js index bdc8cdfd004d97..35a4aa4232e218 100644 --- a/deps/undici/src/lib/handler/redirect-handler.js +++ b/deps/undici/src/lib/handler/redirect-handler.js @@ -23,6 +23,10 @@ class RedirectHandler { throw new InvalidArgumentError('maxRedirections must be a positive number') } + if (opts.throwOnMaxRedirect != null && typeof opts.throwOnMaxRedirect !== 'boolean') { + throw new InvalidArgumentError('throwOnMaxRedirect must be a boolean') + } + this.dispatch = dispatch this.location = null const { maxRedirections: _, ...cleanOpts } = opts diff --git a/deps/undici/src/lib/interceptor/redirect.js b/deps/undici/src/lib/interceptor/redirect.js index b7df180433e39e..83b4c9a7b2fac0 100644 --- a/deps/undici/src/lib/interceptor/redirect.js +++ b/deps/undici/src/lib/interceptor/redirect.js @@ -2,16 +2,16 @@ const RedirectHandler = require('../handler/redirect-handler') -function createRedirectInterceptor ({ maxRedirections: defaultMaxRedirections } = {}) { +function createRedirectInterceptor ({ maxRedirections: defaultMaxRedirections, throwOnMaxRedirect: defaultThrowOnMaxRedirect } = {}) { return (dispatch) => { return function Intercept (opts, handler) { - const { maxRedirections = defaultMaxRedirections, ...rest } = opts + const { maxRedirections = defaultMaxRedirections, throwOnMaxRedirect = defaultThrowOnMaxRedirect, ...rest } = opts if (maxRedirections == null || maxRedirections === 0) { return dispatch(opts, handler) } - const dispatchOpts = { ...rest } // Stop sub dispatcher from also redirecting. + const dispatchOpts = { ...rest, throwOnMaxRedirect } // Stop sub dispatcher from also redirecting. const redirectHandler = new RedirectHandler(dispatch, maxRedirections, dispatchOpts, handler) return dispatch(dispatchOpts, redirectHandler) } diff --git a/deps/undici/src/lib/llhttp/.gitkeep b/deps/undici/src/lib/llhttp/.gitkeep deleted file mode 100644 index e69de29bb2d1d6..00000000000000 diff --git a/deps/undici/src/lib/llhttp/llhttp-wasm.js b/deps/undici/src/lib/llhttp/llhttp-wasm.js index 8e898063575c19..bf3934b1dd6624 100644 --- a/deps/undici/src/lib/llhttp/llhttp-wasm.js +++ b/deps/undici/src/lib/llhttp/llhttp-wasm.js @@ -2,7 +2,7 @@ const { Buffer } = require('node:buffer') -const wasmBase64 = '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' +const wasmBase64 = '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' let wasmBuffer diff --git a/deps/undici/src/lib/llhttp/llhttp.wasm b/deps/undici/src/lib/llhttp/llhttp.wasm index 76ae48373e1915d1b8307f6bc89fc640a48c3454..fcc34dc9f9b6d91352682bb85aa4448c4f8ac03f 100755 GIT binary patch delta 18 acmeynl=<&c<_#xKPhN4hd9(MKO>6*ZSPGi} delta 22 gcmV+x0O|kzr33w?1F*=;li undici@8.1.0 build:wasm +> undici@8.2.0 build:wasm > node build/wasm.js --docker > docker run --rm --platform=linux/x86_64 --user 1001:1001 --mount type=bind,source=/home/runner/work/node/node/deps/undici/src/lib/llhttp,target=/home/node/build/lib/llhttp --mount type=bind,source=/home/runner/work/node/node/deps/undici/src/build,target=/home/node/build/build --mount type=bind,source=/home/runner/work/node/node/deps/undici/src/deps,target=/home/node/build/deps -t ghcr.io/nodejs/wasm-builder@sha256:975f391d907e42a75b8c72eb77c782181e941608687d4d8694c3e9df415a0970 node build/wasm.js diff --git a/deps/undici/src/lib/mock/mock-agent.js b/deps/undici/src/lib/mock/mock-agent.js index 61449e077ead35..17a7b717c21390 100644 --- a/deps/undici/src/lib/mock/mock-agent.js +++ b/deps/undici/src/lib/mock/mock-agent.js @@ -167,7 +167,7 @@ class MockAgent extends Dispatcher { } [kMockAgentSet] (origin, dispatcher) { - this[kClients].set(origin, { count: 0, dispatcher }) + this[kClients].set(origin, dispatcher) } [kFactory] (origin) { @@ -179,9 +179,9 @@ class MockAgent extends Dispatcher { [kMockAgentGet] (origin) { // First check if we can immediately find it - const result = this[kClients].get(origin) - if (result?.dispatcher) { - return result.dispatcher + const dispatcher = this[kClients].get(origin) + if (dispatcher) { + return dispatcher } // If the origin is not a string create a dummy parent pool and return to user @@ -192,11 +192,11 @@ class MockAgent extends Dispatcher { } // If we match, create a pool and assign the same dispatches - for (const [keyMatcher, result] of Array.from(this[kClients])) { - if (result && typeof keyMatcher !== 'string' && matchValue(keyMatcher, origin)) { + for (const [keyMatcher, nonExplicitDispatcher] of Array.from(this[kClients])) { + if (nonExplicitDispatcher && typeof keyMatcher !== 'string' && matchValue(keyMatcher, origin)) { const dispatcher = this[kFactory](origin) this[kMockAgentSet](origin, dispatcher) - dispatcher[kDispatches] = result.dispatcher[kDispatches] + dispatcher[kDispatches] = nonExplicitDispatcher[kDispatches] return dispatcher } } @@ -210,7 +210,7 @@ class MockAgent extends Dispatcher { const mockAgentClients = this[kClients] return Array.from(mockAgentClients.entries()) - .flatMap(([origin, result]) => result.dispatcher[kDispatches].map(dispatch => ({ ...dispatch, origin }))) + .flatMap(([origin, dispatcher]) => dispatcher[kDispatches].map(dispatch => ({ ...dispatch, origin }))) .filter(({ pending }) => pending) } diff --git a/deps/undici/src/lib/mock/mock-call-history.js b/deps/undici/src/lib/mock/mock-call-history.js index d4a92b2b24bc77..74de68247c7d2d 100644 --- a/deps/undici/src/lib/mock/mock-call-history.js +++ b/deps/undici/src/lib/mock/mock-call-history.js @@ -3,14 +3,14 @@ const { kMockCallHistoryAddLog } = require('./mock-symbols') const { InvalidArgumentError } = require('../core/errors') -function handleFilterCallsWithOptions (criteria, options, handler, store) { +function handleFilterCallsWithOptions (criteria, options, handler, store, allLogs) { switch (options.operator) { case 'OR': - store.push(...handler(criteria)) + store.push(...handler(criteria, allLogs)) return store case 'AND': - return handler.call({ logs: store }, criteria) + return handler(criteria, store) default: // guard -- should never happens because buildAndValidateFilterCallsOptions is called before throw new InvalidArgumentError('options.operator must to be a case insensitive string equal to \'OR\' or \'AND\'') @@ -35,14 +35,14 @@ function buildAndValidateFilterCallsOptions (options = {}) { } function makeFilterCalls (parameterName) { - return (parameterValue) => { + return (parameterValue, logs) => { if (typeof parameterValue === 'string' || parameterValue == null) { - return this.logs.filter((log) => { + return logs.filter((log) => { return log[parameterName] === parameterValue }) } if (parameterValue instanceof RegExp) { - return this.logs.filter((log) => { + return logs.filter((log) => { return parameterValue.test(log[parameterName]) }) } @@ -175,30 +175,30 @@ class MockCallHistory { const finalOptions = { operator: 'OR', ...buildAndValidateFilterCallsOptions(options) } - let maybeDuplicatedLogsFiltered = [] + let maybeDuplicatedLogsFiltered = finalOptions.operator === 'AND' ? this.logs : [] if ('protocol' in criteria) { - maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.protocol, finalOptions, this.filterCallsByProtocol, maybeDuplicatedLogsFiltered) + maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.protocol, finalOptions, this.filterCallsByProtocol, maybeDuplicatedLogsFiltered, this.logs) } if ('host' in criteria) { - maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.host, finalOptions, this.filterCallsByHost, maybeDuplicatedLogsFiltered) + maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.host, finalOptions, this.filterCallsByHost, maybeDuplicatedLogsFiltered, this.logs) } if ('port' in criteria) { - maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.port, finalOptions, this.filterCallsByPort, maybeDuplicatedLogsFiltered) + maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.port, finalOptions, this.filterCallsByPort, maybeDuplicatedLogsFiltered, this.logs) } if ('origin' in criteria) { - maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.origin, finalOptions, this.filterCallsByOrigin, maybeDuplicatedLogsFiltered) + maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.origin, finalOptions, this.filterCallsByOrigin, maybeDuplicatedLogsFiltered, this.logs) } if ('path' in criteria) { - maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.path, finalOptions, this.filterCallsByPath, maybeDuplicatedLogsFiltered) + maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.path, finalOptions, this.filterCallsByPath, maybeDuplicatedLogsFiltered, this.logs) } if ('hash' in criteria) { - maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.hash, finalOptions, this.filterCallsByHash, maybeDuplicatedLogsFiltered) + maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.hash, finalOptions, this.filterCallsByHash, maybeDuplicatedLogsFiltered, this.logs) } if ('fullUrl' in criteria) { - maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.fullUrl, finalOptions, this.filterCallsByFullUrl, maybeDuplicatedLogsFiltered) + maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.fullUrl, finalOptions, this.filterCallsByFullUrl, maybeDuplicatedLogsFiltered, this.logs) } if ('method' in criteria) { - maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.method, finalOptions, this.filterCallsByMethod, maybeDuplicatedLogsFiltered) + maybeDuplicatedLogsFiltered = handleFilterCallsWithOptions(criteria.method, finalOptions, this.filterCallsByMethod, maybeDuplicatedLogsFiltered, this.logs) } const uniqLogsFiltered = [...new Set(maybeDuplicatedLogsFiltered)] diff --git a/deps/undici/src/lib/util/cache.js b/deps/undici/src/lib/util/cache.js index 2da2c044dbdd6d..e5abe0f0de0162 100644 --- a/deps/undici/src/lib/util/cache.js +++ b/deps/undici/src/lib/util/cache.js @@ -18,7 +18,7 @@ function makeCacheKey (opts) { let fullPath = opts.path || '/' - if (opts.query && !pathHasQueryOrFragment(opts.path)) { + if (opts.query && !pathHasQueryOrFragment(fullPath)) { fullPath = serializePathWithQuery(fullPath, opts.query) } diff --git a/deps/undici/src/lib/web/eventsource/eventsource-stream.js b/deps/undici/src/lib/web/eventsource/eventsource-stream.js index d24e8f6a1b1a8c..7b9e2f8cbba87f 100644 --- a/deps/undici/src/lib/web/eventsource/eventsource-stream.js +++ b/deps/undici/src/lib/web/eventsource/eventsource-stream.js @@ -23,6 +23,49 @@ const COLON = 0x3A */ const SPACE = 0x20 +const DATA = Buffer.from('data') +const EVENT = Buffer.from('event') +const ID = Buffer.from('id') +const RETRY = Buffer.from('retry') + +function isASCIINumberBytes (buffer, start) { + if (start >= buffer.length) { + return false + } + + for (let i = start; i < buffer.length; i++) { + if (buffer[i] < 0x30 || buffer[i] > 0x39) { + return false + } + } + + return true +} + +function isValidLastEventIdBytes (buffer, start) { + for (let i = start; i < buffer.length; i++) { + if (buffer[i] === 0x00) { + return false + } + } + + return true +} + +function isFieldName (line, length, field) { + if (length !== field.length) { + return false + } + + for (let i = 0; i < length; i++) { + if (line[i] !== field[i]) { + return false + } + } + + return true +} + /** * @typedef {object} EventSourceStreamEvent * @type {object} @@ -63,11 +106,14 @@ class EventSourceStream extends Transform { eventEndCheck = false /** - * @type {Buffer|null} + * @type {Buffer[]} */ - buffer = null + chunks = [] + chunkIndex = 0 pos = 0 + lineChunkIndex = 0 + linePos = 0 event = { data: undefined, @@ -107,92 +153,20 @@ class EventSourceStream extends Transform { return } - // Cache the chunk in the buffer, as the data might not be complete while - // processing it - // TODO: Investigate if there is a more performant way to handle - // incoming chunks - // see: https://github.com/nodejs/undici/issues/2630 - if (this.buffer) { - this.buffer = Buffer.concat([this.buffer, chunk]) - } else { - this.buffer = chunk - } + this.chunks.push(chunk) // Strip leading byte-order-mark if we opened the stream and started // the processing of the incoming data if (this.checkBOM) { - switch (this.buffer.length) { - case 1: - // Check if the first byte is the same as the first byte of the BOM - if (this.buffer[0] === BOM[0]) { - // If it is, we need to wait for more data - callback() - return - } - // Set the checkBOM flag to false as we don't need to check for the - // BOM anymore - this.checkBOM = false - - // The buffer only contains one byte so we need to wait for more data - callback() - return - case 2: - // Check if the first two bytes are the same as the first two bytes - // of the BOM - if ( - this.buffer[0] === BOM[0] && - this.buffer[1] === BOM[1] - ) { - // If it is, we need to wait for more data, because the third byte - // is needed to determine if it is the BOM or not - callback() - return - } - - // Set the checkBOM flag to false as we don't need to check for the - // BOM anymore - this.checkBOM = false - break - case 3: - // Check if the first three bytes are the same as the first three - // bytes of the BOM - if ( - this.buffer[0] === BOM[0] && - this.buffer[1] === BOM[1] && - this.buffer[2] === BOM[2] - ) { - // If it is, we can drop the buffered data, as it is only the BOM - this.buffer = Buffer.alloc(0) - // Set the checkBOM flag to false as we don't need to check for the - // BOM anymore - this.checkBOM = false - - // Await more data - callback() - return - } - // If it is not the BOM, we can start processing the data - this.checkBOM = false - break - default: - // The buffer is longer than 3 bytes, so we can drop the BOM if it is - // present - if ( - this.buffer[0] === BOM[0] && - this.buffer[1] === BOM[1] && - this.buffer[2] === BOM[2] - ) { - // Remove the BOM from the buffer - this.buffer = this.buffer.subarray(3) - } - - // Set the checkBOM flag to false as we don't need to check for the - this.checkBOM = false - break + if (this.handleBOM()) { + callback() + return } } - while (this.pos < this.buffer.length) { + while (this.hasCurrentByte()) { + const byte = this.currentByte() + // If the previous line ended with an end-of-line, we need to check // if the next character is also an end-of-line. if (this.eventEndCheck) { @@ -205,10 +179,9 @@ class EventSourceStream extends Transform { if (this.crlfCheck) { // If the current character is a line feed, we can remove it // from the buffer and reset the crlfCheck flag - if (this.buffer[this.pos] === LF) { - this.buffer = this.buffer.subarray(this.pos + 1) - this.pos = 0 + if (byte === LF) { this.crlfCheck = false + this.consumeCurrentByte() // It is possible that the line feed is not the end of the // event. We need to check if the next character is an @@ -224,19 +197,17 @@ class EventSourceStream extends Transform { this.crlfCheck = false } - if (this.buffer[this.pos] === LF || this.buffer[this.pos] === CR) { + if (byte === LF || byte === CR) { // If the current character is a carriage return, we need to // set the crlfCheck flag to true, as we need to check if the // next character is a line feed so we can remove it from the // buffer - if (this.buffer[this.pos] === CR) { + if (byte === CR) { this.crlfCheck = true } - this.buffer = this.buffer.subarray(this.pos + 1) - this.pos = 0 - if ( - this.event.data !== undefined || this.event.event || this.event.id !== undefined || this.event.retry) { + this.consumeCurrentByte() + if (this.hasPendingEvent()) { this.processEvent(this.event) } this.clearEvent() @@ -250,22 +221,18 @@ class EventSourceStream extends Transform { // If the current character is an end-of-line, we can process the // line - if (this.buffer[this.pos] === LF || this.buffer[this.pos] === CR) { + if (byte === LF || byte === CR) { // If the current character is a carriage return, we need to // set the crlfCheck flag to true, as we need to check if the // next character is a line feed - if (this.buffer[this.pos] === CR) { + if (byte === CR) { this.crlfCheck = true } // In any case, we can process the line as we reached an // end-of-line character - this.parseLine(this.buffer.subarray(0, this.pos), this.event) - - // Remove the processed line from the buffer - this.buffer = this.buffer.subarray(this.pos + 1) - // Reset the position as we removed the processed line from the buffer - this.pos = 0 + this.parseLine(this.readLine(), this.event) + this.consumeCurrentByte() // A line was processed and this could be the end of the event. We need // to check if the next line is empty to determine if the event is // finished. @@ -273,7 +240,7 @@ class EventSourceStream extends Transform { continue } - this.pos++ + this.advanceCursor() } callback() @@ -298,64 +265,53 @@ class EventSourceStream extends Transform { return } - let field = '' - let value = '' + let fieldLength = line.length + let valueStart = line.length // If the line contains a U+003A COLON character (:) if (colonPosition !== -1) { - // Collect the characters on the line before the first U+003A COLON - // character (:), and let field be that string. - // TODO: Investigate if there is a more performant way to extract the - // field - // see: https://github.com/nodejs/undici/issues/2630 - field = line.subarray(0, colonPosition).toString('utf8') + fieldLength = colonPosition // Collect the characters on the line after the first U+003A COLON // character (:), and let value be that string. // If value starts with a U+0020 SPACE character, remove it from value. - let valueStart = colonPosition + 1 + valueStart = colonPosition + 1 if (line[valueStart] === SPACE) { ++valueStart } - // TODO: Investigate if there is a more performant way to extract the - // value - // see: https://github.com/nodejs/undici/issues/2630 - value = line.subarray(valueStart).toString('utf8') - - // Otherwise, the string is not empty but does not contain a U+003A COLON - // character (:) - } else { - // Process the field using the steps described below, using the whole - // line as the field name, and the empty string as the field value. - field = line.toString('utf8') - value = '' } - // Modify the event with the field name and value. The value is also - // decoded as UTF-8 - switch (field) { - case 'data': - if (event[field] === undefined) { - event[field] = value - } else { - event[field] += `\n${value}` - } - break - case 'retry': - if (isASCIINumber(value)) { - event[field] = value - } - break - case 'id': - if (isValidLastEventId(value)) { - event[field] = value - } - break - case 'event': - if (value.length > 0) { - event[field] = value - } - break + if (isFieldName(line, fieldLength, DATA)) { + const value = line.toString('utf8', valueStart) + + if (event.data === undefined) { + event.data = value + } else { + event.data += `\n${value}` + } + return + } + + if (isFieldName(line, fieldLength, RETRY)) { + if (isASCIINumberBytes(line, valueStart)) { + event.retry = line.toString('utf8', valueStart) + } + return + } + + if (isFieldName(line, fieldLength, ID)) { + if (isValidLastEventIdBytes(line, valueStart)) { + event.id = line.toString('utf8', valueStart) + } + return + } + + if (isFieldName(line, fieldLength, EVENT)) { + const value = line.toString('utf8', valueStart) + + if (value.length > 0) { + event.event = value + } } } @@ -385,12 +341,151 @@ class EventSourceStream extends Transform { } clearEvent () { - this.event = { - data: undefined, - event: undefined, - id: undefined, - retry: undefined + this.event.data = undefined + this.event.event = undefined + this.event.id = undefined + this.event.retry = undefined + } + + hasPendingEvent () { + return this.event.data !== undefined || + this.event.event !== undefined || + this.event.id !== undefined || + this.event.retry !== undefined + } + + hasCurrentByte () { + return this.chunkIndex < this.chunks.length && + this.pos < this.chunks[this.chunkIndex].length + } + + currentByte () { + return this.chunks[this.chunkIndex][this.pos] + } + + consumeCurrentByte () { + this.advanceCursor() + this.syncLineStartToCursor() + } + + advanceCursor () { + this.pos++ + + while (this.chunkIndex < this.chunks.length && this.pos >= this.chunks[this.chunkIndex].length) { + this.chunkIndex++ + this.pos = 0 + } + } + + syncLineStartToCursor () { + this.lineChunkIndex = this.chunkIndex + this.linePos = this.pos + this.dropConsumedChunks() + } + + dropConsumedChunks () { + while (this.lineChunkIndex > 0) { + this.chunks.shift() + this.lineChunkIndex-- + this.chunkIndex-- + } + + if (this.chunkIndex === this.chunks.length) { + this.chunks.length = 0 + this.chunkIndex = 0 + this.pos = 0 + this.lineChunkIndex = 0 + this.linePos = 0 + } + } + + readLine () { + if (this.lineChunkIndex === this.chunkIndex) { + return this.chunks[this.chunkIndex].subarray(this.linePos, this.pos) + } + + const chunks = [] + let length = 0 + + for (let i = this.lineChunkIndex; i <= this.chunkIndex; i++) { + const chunk = this.chunks[i] + const start = i === this.lineChunkIndex ? this.linePos : 0 + const end = i === this.chunkIndex ? this.pos : chunk.length + const slice = chunk.subarray(start, end) + length += slice.length + chunks.push(slice) + } + + return Buffer.concat(chunks, length) + } + + peekBufferedByte (offset) { + let chunkIndex = this.lineChunkIndex + let pos = this.linePos + + while (chunkIndex < this.chunks.length) { + const chunk = this.chunks[chunkIndex] + const remaining = chunk.length - pos + + if (offset < remaining) { + return chunk[pos + offset] + } + + offset -= remaining + chunkIndex++ + pos = 0 + } + } + + discardLeadingBytes (count) { + while (count > 0 && this.lineChunkIndex < this.chunks.length) { + const chunk = this.chunks[this.lineChunkIndex] + const remaining = chunk.length - this.linePos + + if (count < remaining) { + this.linePos += count + count = 0 + } else { + count -= remaining + this.lineChunkIndex++ + this.linePos = 0 + } + } + + this.chunkIndex = this.lineChunkIndex + this.pos = this.linePos + this.dropConsumedChunks() + } + + handleBOM () { + const first = this.peekBufferedByte(0) + const second = this.peekBufferedByte(1) + const third = this.peekBufferedByte(2) + + if (second === undefined) { + if (first === BOM[0]) { + return true + } + + this.checkBOM = false + return true + } + + if (third === undefined) { + if (first === BOM[0] && second === BOM[1]) { + return true + } + + this.checkBOM = false + return false } + + if (first === BOM[0] && second === BOM[1] && third === BOM[2]) { + this.discardLeadingBytes(3) + } + + this.checkBOM = false + return !this.hasCurrentByte() } } diff --git a/deps/undici/src/lib/web/fetch/formdata-parser.js b/deps/undici/src/lib/web/fetch/formdata-parser.js index b65848998f7616..a4622ae10a356d 100644 --- a/deps/undici/src/lib/web/fetch/formdata-parser.js +++ b/deps/undici/src/lib/web/fetch/formdata-parser.js @@ -204,7 +204,7 @@ function multipartFormDataParser (input, mimeType) { * Parses content-disposition attributes (e.g., name="value" or filename*=utf-8''encoded) * @param {Buffer} input * @param {{ position: number }} position - * @returns {{ name: string, value: string }} + * @returns {{ name: string, value: string, extended: boolean } | null} */ function parseContentDispositionAttribute (input, position) { // Skip leading semicolon and whitespace @@ -304,7 +304,7 @@ function parseContentDispositionAttribute (input, position) { value = decoder.decode(tokenValue) } - return { name: attrNameStr, value } + return { name: attrNameStr, value, extended: isExtended } } /** @@ -368,6 +368,9 @@ function parseMultipartFormDataHeaders (input, position) { switch (bufferToLowerCasedHeaderName(headerName)) { case 'content-disposition': { name = filename = null + // Track whether filename was set from the extended (RFC 5987) form so + // a subsequent legacy `filename` attribute does not override it. + let filenameIsExtended = false // Collect the disposition type (should be "form-data") const dispositionType = collectASequenceOfBytes( @@ -383,8 +386,8 @@ function parseMultipartFormDataHeaders (input, position) { // Parse attributes recursively until CRLF while ( position.position < input.length && - input[position.position] !== 0x0d && - input[position.position + 1] !== 0x0a + (input[position.position] !== 0x0d || + input[position.position + 1] !== 0x0a) ) { const attribute = parseContentDispositionAttribute(input, position) @@ -395,7 +398,15 @@ function parseMultipartFormDataHeaders (input, position) { if (attribute.name === 'name') { name = attribute.value } else if (attribute.name === 'filename') { - filename = attribute.value + // Per RFC 5987 §4.1, when both legacy and extended forms of the + // same parameter are present, the extended (filename*) form takes + // precedence regardless of the order they appear in. + if (attribute.extended) { + filename = attribute.value + filenameIsExtended = true + } else if (!filenameIsExtended) { + filename = attribute.value + } } } @@ -448,7 +459,7 @@ function parseMultipartFormDataHeaders (input, position) { // 2.9. If position does not point to a sequence of bytes starting with 0x0D 0x0A // (CR LF), return failure. Otherwise, advance position by 2 (past the newline). - if (input[position.position] !== 0x0d && input[position.position + 1] !== 0x0a) { + if (input[position.position] !== 0x0d || input[position.position + 1] !== 0x0a) { throw parsingError('expected CRLF') } else { position.position += 2 diff --git a/deps/undici/src/lib/web/fetch/index.js b/deps/undici/src/lib/web/fetch/index.js index 85d4c2e9feda0c..33d7761cecda9f 100644 --- a/deps/undici/src/lib/web/fetch/index.js +++ b/deps/undici/src/lib/web/fetch/index.js @@ -75,6 +75,35 @@ const defaultUserAgent = typeof __UNDICI_IS_NODE__ !== 'undefined' || typeof esb /** @type {import('buffer').resolveObjectURL} */ let resolveObjectURL +function appendHeadersListFromResponseHeaders (headersList, headers, rawHeaders) { + if (Array.isArray(rawHeaders)) { + for (let i = 0; i < rawHeaders.length; i += 2) { + const nameStr = bufferToLowerCasedHeaderName(rawHeaders[i]) + const value = rawHeaders[i + 1] + + if (Array.isArray(value) && !Buffer.isBuffer(value)) { + for (const val of value) { + headersList.append(nameStr, val.toString('latin1'), true) + } + } else { + headersList.append(nameStr, value.toString('latin1'), true) + } + } + + return + } + + for (const [name, value] of Object.entries(headers ?? {})) { + if (Array.isArray(value)) { + for (const entry of value) { + headersList.append(name, `${entry}`, true) + } + } else { + headersList.append(name, `${value}`, true) + } + } +} + class Fetch extends EE { constructor (dispatcher) { super() @@ -1025,7 +1054,7 @@ function fetchFinale (fetchParams, response) { let responseStatus = 0 // 7. If fetchParams’s request’s mode is not "navigate" or response’s has-cross-origin-redirects is false: - if (fetchParams.request.mode !== 'navigator' || !response.hasCrossOriginRedirects) { + if (fetchParams.request.mode !== 'navigate' || !response.hasCrossOriginRedirects) { // 1. Set responseStatus to response’s status. responseStatus = response.status @@ -1428,7 +1457,10 @@ async function httpNetworkOrCacheFetch ( // 8. If contentLengthHeaderValue is non-null, then append // `Content-Length`/contentLengthHeaderValue to httpRequest’s header // list. - if (contentLengthHeaderValue != null) { + if ( + contentLengthHeaderValue != null && + !httpRequest.headersList.contains('content-length', true) + ) { httpRequest.headersList.append('content-length', contentLengthHeaderValue, true) } @@ -2193,25 +2225,14 @@ async function httpNetworkFetch ( timingInfo.finalNetworkResponseStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability) }, - onResponseStart (controller, status, _headers, statusText) { + onResponseStart (controller, status, headers, statusText) { if (status < 200) { return } const rawHeaders = controller?.rawHeaders ?? [] const headersList = new HeadersList() - - for (let i = 0; i < rawHeaders.length; i += 2) { - const nameStr = bufferToLowerCasedHeaderName(rawHeaders[i]) - const value = rawHeaders[i + 1] - if (Array.isArray(value) && !Buffer.isBuffer(rawHeaders[i + 1])) { - for (const val of value) { - headersList.append(nameStr, val.toString('latin1'), true) - } - } else { - headersList.append(nameStr, value.toString('latin1'), true) - } - } + appendHeadersListFromResponseHeaders(headersList, headers, rawHeaders) const location = headersList.get('location', true) this.body = new Readable({ read: () => controller.resume() }) @@ -2346,7 +2367,7 @@ async function httpNetworkFetch ( reject(error) }, - onRequestUpgrade (controller, status, _headers, socket) { + onRequestUpgrade (controller, status, headers, socket) { // We need to support 200 for websocket over h2 as per RFC-8441 // Absence of session means H1 if ((socket.session != null && status !== 200) || (socket.session == null && status !== 101)) { @@ -2355,18 +2376,7 @@ async function httpNetworkFetch ( const rawHeaders = controller?.rawHeaders ?? [] const headersList = new HeadersList() - - for (let i = 0; i < rawHeaders.length; i += 2) { - const nameStr = bufferToLowerCasedHeaderName(rawHeaders[i]) - const value = rawHeaders[i + 1] - if (Array.isArray(value) && !Buffer.isBuffer(rawHeaders[i + 1])) { - for (const val of value) { - headersList.append(nameStr, val.toString('latin1'), true) - } - } else { - headersList.append(nameStr, value.toString('latin1'), true) - } - } + appendHeadersListFromResponseHeaders(headersList, headers, rawHeaders) resolve({ status, diff --git a/deps/undici/src/lib/web/webidl/index.js b/deps/undici/src/lib/web/webidl/index.js index e5ee5cbb6e726b..05a6a4bce58028 100644 --- a/deps/undici/src/lib/web/webidl/index.js +++ b/deps/undici/src/lib/web/webidl/index.js @@ -188,10 +188,10 @@ webidl.util.ConvertToInt = function (V, bitLength, signedness, flags) { } else { // 3. Otherwise: - // 1. Let lowerBound be -2^bitLength − 1. - lowerBound = Math.pow(-2, bitLength) - 1 + // 1. Let lowerBound be -2^(bitLength − 1). + lowerBound = -Math.pow(2, bitLength - 1) - // 2. Let upperBound be 2^bitLength − 1 − 1. + // 2. Let upperBound be 2^(bitLength − 1) − 1. upperBound = Math.pow(2, bitLength - 1) - 1 } @@ -270,9 +270,9 @@ webidl.util.ConvertToInt = function (V, bitLength, signedness, flags) { // 10. Set x to x modulo 2^bitLength. x = x % Math.pow(2, bitLength) - // 11. If signedness is "signed" and x ≥ 2^bitLength − 1, + // 11. If signedness is "signed" and x ≥ 2^(bitLength − 1), // then return x − 2^bitLength. - if (signedness === 'signed' && x >= Math.pow(2, bitLength) - 1) { + if (signedness === 'signed' && x >= Math.pow(2, bitLength - 1)) { return x - Math.pow(2, bitLength) } diff --git a/deps/undici/src/lib/web/websocket/frame.js b/deps/undici/src/lib/web/websocket/frame.js index e397c878a4fdad..c29ab46096adce 100644 --- a/deps/undici/src/lib/web/websocket/frame.js +++ b/deps/undici/src/lib/web/websocket/frame.js @@ -10,13 +10,7 @@ let bufIdx = BUFFER_SIZE const randomFillSync = runtimeFeatures.has('crypto') ? require('node:crypto').randomFillSync - // not full compatibility, but minimum. - : function randomFillSync (buffer, _offset, _size) { - for (let i = 0; i < buffer.length; ++i) { - buffer[i] = Math.random() * 255 | 0 - } - return buffer - } + : null function generateMask () { if (bufIdx === BUFFER_SIZE) { diff --git a/deps/undici/src/lib/web/websocket/stream/websocketstream.js b/deps/undici/src/lib/web/websocket/stream/websocketstream.js index d8061658fd968e..1a070e2f979fe7 100644 --- a/deps/undici/src/lib/web/websocket/stream/websocketstream.js +++ b/deps/undici/src/lib/web/websocket/stream/websocketstream.js @@ -1,6 +1,7 @@ 'use strict' -const { environmentSettingsObject } = require('../../fetch/util') +const { addAbortListener } = require('node:events') +const { environmentSettingsObject, readableStreamClose } = require('../../fetch/util') const { states, opcodes, sentCloseFrameState } = require('../constants') const { webidl } = require('../../webidl') const { getURLRecord, isValidSubprotocol, isEstablished, utf8Decode } = require('../util') @@ -132,7 +133,7 @@ class WebSocketStream { } // 8.3. Add the following abort steps to signal : - signal.addEventListener('abort', () => { + addAbortListener(signal, () => { // 8.3.1. If the WebSocket connection is not yet established : [WSP] if (!isEstablished(this.#handler.readyState)) { // 8.3.1.1. Fail the WebSocket connection . @@ -148,7 +149,7 @@ class WebSocketStream { // Set this 's handshake aborted to true. this.#handshakeAborted = true } - }, { once: true }) + }) } // 9. Let client be this 's relevant settings object . @@ -331,7 +332,7 @@ class WebSocketStream { try { chunk = utf8Decode(data) } catch { - failWebsocketConnection(this.#handler, 'Received invalid UTF-8 in text frame.') + failWebsocketConnection(this.#handler, 1007, 'Received invalid UTF-8 in text frame.') return } } else if (type === opcodes.BINARY) { @@ -385,7 +386,7 @@ class WebSocketStream { // 6. If the connection was closed cleanly , if (wasClean) { // 6.1. Close stream ’s readable stream . - this.#readableStreamController.close() + readableStreamClose(this.#readableStreamController) // 6.2. Error stream ’s writable stream with an " InvalidStateError " DOMException indicating that a closed WebSocketStream cannot be written to. if (!this.#writableStream.locked) { diff --git a/deps/undici/src/package-lock.json b/deps/undici/src/package-lock.json index 66122753babfaa..30097844c87d07 100644 --- a/deps/undici/src/package-lock.json +++ b/deps/undici/src/package-lock.json @@ -1,12 +1,12 @@ { "name": "undici", - "version": "8.1.0", + "version": "8.2.0", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "undici", - "version": "8.1.0", + "version": "8.2.0", "license": "MIT", "devDependencies": { "@fastify/busboy": "3.2.0", diff --git a/deps/undici/src/package.json b/deps/undici/src/package.json index 22a284be304367..082c56a4783ae1 100644 --- a/deps/undici/src/package.json +++ b/deps/undici/src/package.json @@ -1,6 +1,6 @@ { "name": "undici", - "version": "8.1.0", + "version": "8.2.0", "description": "An HTTP/1.1 client, written from scratch for Node.js", "homepage": "https://undici.nodejs.org", "bugs": { diff --git a/deps/undici/src/types/dispatcher.d.ts b/deps/undici/src/types/dispatcher.d.ts index de2545bc84dcf4..40a75de6743506 100644 --- a/deps/undici/src/types/dispatcher.d.ts +++ b/deps/undici/src/types/dispatcher.d.ts @@ -2,7 +2,7 @@ import { URL } from 'node:url' import { Duplex, Readable, Writable } from 'node:stream' import { EventEmitter } from 'node:events' import { Blob } from 'node:buffer' -import { IncomingHttpHeaders } from './header' +import { IncomingHttpHeaders, OutgoingHttpHeaders } from './header' import BodyReadable from './readable' import { FormData } from './formdata' import Errors from './errors' @@ -10,7 +10,7 @@ import { Autocomplete } from './utility' export default Dispatcher -export type UndiciHeaders = Record | IncomingHttpHeaders | string[] | Iterable<[string, string | string[] | undefined]> | null +export type UndiciHeaders = OutgoingHttpHeaders | string[] | Iterable<[string, string | string[] | undefined]> | null /** Dispatcher is the core API used to dispatch requests. */ declare class Dispatcher extends EventEmitter { @@ -210,8 +210,8 @@ declare namespace Dispatcher { get aborted(): boolean get paused(): boolean get reason(): Error | null - rawHeaders?: Buffer[] | string[] | null - rawTrailers?: Buffer[] | string[] | null + rawHeaders?: Buffer[] | string[] | IncomingHttpHeaders | null + rawTrailers?: Buffer[] | string[] | IncomingHttpHeaders | null abort(reason: Error): void pause(): void resume(): void diff --git a/deps/undici/src/types/header.d.ts b/deps/undici/src/types/header.d.ts index efd7b1dd0bbae5..17e72520f0f366 100644 --- a/deps/undici/src/types/header.d.ts +++ b/deps/undici/src/types/header.d.ts @@ -5,6 +5,11 @@ import { Autocomplete } from './utility' */ export type IncomingHttpHeaders = Record +/** + * The header type declaration of `undici` for outgoing requests. + */ +export type OutgoingHttpHeaders = Record + type HeaderNames = Autocomplete< | 'Accept' | 'Accept-CH' diff --git a/deps/undici/src/types/interceptors.d.ts b/deps/undici/src/types/interceptors.d.ts index 71983a768c0361..3b90a28592f9b1 100644 --- a/deps/undici/src/types/interceptors.d.ts +++ b/deps/undici/src/types/interceptors.d.ts @@ -8,7 +8,7 @@ export default Interceptors declare namespace Interceptors { export type DumpInterceptorOpts = { maxSize?: number } export type RetryInterceptorOpts = RetryHandler.RetryOptions - export type RedirectInterceptorOpts = { maxRedirections?: number } + export type RedirectInterceptorOpts = { maxRedirections?: number, throwOnMaxRedirect?: boolean } export type DecompressInterceptorOpts = { skipErrorResponses?: boolean skipStatusCodes?: number[] diff --git a/deps/undici/src/types/proxy-agent.d.ts b/deps/undici/src/types/proxy-agent.d.ts index 41555422178b57..05c7e95dcbf5d7 100644 --- a/deps/undici/src/types/proxy-agent.d.ts +++ b/deps/undici/src/types/proxy-agent.d.ts @@ -1,7 +1,7 @@ import Agent from './agent' import buildConnector from './connector' import Dispatcher from './dispatcher' -import { IncomingHttpHeaders } from './header' +import { OutgoingHttpHeaders } from './header' export default ProxyAgent @@ -20,7 +20,7 @@ declare namespace ProxyAgent { */ auth?: string; token?: string; - headers?: IncomingHttpHeaders; + headers?: OutgoingHttpHeaders; requestTls?: buildConnector.BuildOptions; proxyTls?: buildConnector.BuildOptions; clientFactory?(origin: URL, opts: object): Dispatcher; diff --git a/deps/undici/src/types/socks5-proxy-agent.d.ts b/deps/undici/src/types/socks5-proxy-agent.d.ts index 4b9c6a83a04627..05e4331670e962 100644 --- a/deps/undici/src/types/socks5-proxy-agent.d.ts +++ b/deps/undici/src/types/socks5-proxy-agent.d.ts @@ -1,6 +1,6 @@ import Dispatcher from './dispatcher' import buildConnector from './connector' -import { IncomingHttpHeaders } from './header' +import { OutgoingHttpHeaders } from './header' import Pool from './pool' export default Socks5ProxyAgent @@ -12,7 +12,7 @@ declare class Socks5ProxyAgent extends Dispatcher { declare namespace Socks5ProxyAgent { export interface Options extends Pool.Options { /** Additional headers to send with the proxy connection */ - headers?: IncomingHttpHeaders; + headers?: OutgoingHttpHeaders; /** SOCKS5 proxy username for authentication */ username?: string; /** SOCKS5 proxy password for authentication */ diff --git a/deps/undici/undici.js b/deps/undici/undici.js index 6be4f5b522b775..86f020015b22c2 100644 --- a/deps/undici/undici.js +++ b/deps/undici/undici.js @@ -176,8 +176,8 @@ var require_errors = __commonJS({ static { __name(this, "InformationalError"); } - constructor(message) { - super(message); + constructor(message, options) { + super(message, options); this.name = "InformationalError"; this.message = message || "Request information"; this.code = "UND_ERR_INFO"; @@ -1043,11 +1043,11 @@ var require_pool_base = __commonJS({ return this; } [kRemoveClient](client) { + const idx = this[kClients].indexOf(client); + if (idx !== -1) { + this[kClients].splice(idx, 1); + } client.close(() => { - const idx = this[kClients].indexOf(client); - if (idx !== -1) { - this[kClients].splice(idx, 1); - } }); this[kNeedDrain] = this[kClients].some((dispatcher) => !dispatcher[kNeedDrain] && dispatcher.closed !== true && dispatcher.destroyed !== true); } @@ -1403,16 +1403,6 @@ var require_constants = __commonJS({ ); var headerNameLowerCasedRecord = {}; Object.setPrototypeOf(headerNameLowerCasedRecord, null); - var wellknownHeaderNameBuffers = {}; - Object.setPrototypeOf(wellknownHeaderNameBuffers, null); - function getHeaderNameAsBuffer(header) { - let buffer = wellknownHeaderNameBuffers[header]; - if (buffer === void 0) { - buffer = Buffer.from(header); - } - return buffer; - } - __name(getHeaderNameAsBuffer, "getHeaderNameAsBuffer"); for (let i = 0; i < wellknownHeaderNames.length; ++i) { const key = wellknownHeaderNames[i]; const lowerCasedKey = key.toLowerCase(); @@ -1420,8 +1410,7 @@ var require_constants = __commonJS({ } module2.exports = { wellknownHeaderNames, - headerNameLowerCasedRecord, - getHeaderNameAsBuffer + headerNameLowerCasedRecord }; } }); @@ -1584,7 +1573,7 @@ var require_util = __commonJS({ var stream = require("node:stream"); var net = require("node:net"); var { stringify } = require("node:querystring"); - var { EventEmitter: EE } = require("node:events"); + var { EventEmitter: EE, addAbortListener: addAbortListenerNative } = require("node:events"); var timers = require_timers(); var { InvalidArgumentError, ConnectTimeoutError } = require_errors(); var { headerNameLowerCasedRecord } = require_constants(); @@ -1844,6 +1833,22 @@ var require_util = __commonJS({ } __name(parseHeaders, "parseHeaders"); function parseRawHeaders(headers) { + if (headers == null) { + return []; + } + if (!Array.isArray(headers)) { + const rawHeaders = []; + for (const [name, value] of Object.entries(headers)) { + if (Array.isArray(value)) { + for (const entry of value) { + rawHeaders.push(name, `${entry}`); + } + } else { + rawHeaders.push(name, `${value}`); + } + } + return rawHeaders; + } const headersLength = headers.length; const ret = new Array(headersLength); let key; @@ -1971,7 +1976,11 @@ var require_util = __commonJS({ } __name(isFormDataLike, "isFormDataLike"); function addAbortListener(signal, listener) { - if ("addEventListener" in signal) { + if (signal instanceof AbortSignal) { + const disposable = addAbortListenerNative(signal, listener); + return () => disposable[Symbol.dispose](); + } + if (typeof signal.addEventListener === "function") { signal.addEventListener("abort", listener, { once: true }); return () => signal.removeEventListener("abort", listener); } @@ -2691,6 +2700,19 @@ var require_request = __commonJS({ var { channels } = require_diagnostics(); var { headerNameLowerCasedRecord } = require_constants(); var invalidPathRegex = /[^\u0021-\u00ff]/; + function isValidContentLengthHeaderValue(val) { + if (typeof val !== "string" || val.length === 0) { + return false; + } + for (let i = 0; i < val.length; i++) { + const charCode = val.charCodeAt(i); + if (charCode < 48 || charCode > 57) { + return false; + } + } + return true; + } + __name(isValidContentLengthHeaderValue, "isValidContentLengthHeaderValue"); var kHandler = /* @__PURE__ */ Symbol("handler"); var kController = /* @__PURE__ */ Symbol("controller"); var kResume = /* @__PURE__ */ Symbol("resume"); @@ -3057,10 +3079,10 @@ var require_request = __commonJS({ if (request.contentLength !== null) { throw new InvalidArgumentError("duplicate content-length header"); } - request.contentLength = parseInt(val, 10); - if (!Number.isFinite(request.contentLength)) { + if (!isValidContentLengthHeaderValue(val)) { throw new InvalidArgumentError("invalid content-length header"); } + request.contentLength = parseInt(val, 10); } else if (request.contentType === null && headerName === "content-type") { request.contentType = val; request.headers.push(key, val); @@ -3125,6 +3147,20 @@ var require_connect = __commonJS({ if (this._maxCachedSessions === 0) { return; } + if (this._sessionCache.has(sessionKey)) { + this._sessionCache.delete(sessionKey); + } else if (this._sessionCache.size >= this._maxCachedSessions) { + for (const [key, ref] of this._sessionCache) { + if (ref.deref() === void 0) { + this._sessionCache.delete(key); + return; + } + } + const oldest = this._sessionCache.keys().next(); + if (!oldest.done) { + this._sessionCache.delete(oldest.value); + } + } this._sessionCache.set(sessionKey, new WeakRef(session)); this._sessionRegistry.register(session, sessionKey); } @@ -3852,7 +3888,7 @@ var require_llhttp_wasm = __commonJS({ "lib/llhttp/llhttp-wasm.js"(exports2, module2) { "use strict"; var { Buffer: Buffer2 } = require("node:buffer"); - var wasmBase64 = "AGFzbQEAAAABJwdgAX8Bf2ADf39/AX9gAn9/AGABfwBgBH9/f38Bf2AAAGADf39/AALLAQgDZW52GHdhc21fb25faGVhZGVyc19jb21wbGV0ZQAEA2VudhV3YXNtX29uX21lc3NhZ2VfYmVnaW4AAANlbnYLd2FzbV9vbl91cmwAAQNlbnYOd2FzbV9vbl9zdGF0dXMAAQNlbnYUd2FzbV9vbl9oZWFkZXJfZmllbGQAAQNlbnYUd2FzbV9vbl9oZWFkZXJfdmFsdWUAAQNlbnYMd2FzbV9vbl9ib2R5AAEDZW52GHdhc21fb25fbWVzc2FnZV9jb21wbGV0ZQAAAzU0BQYAAAMAAAAAAAADAQMAAwMDAAACAAAAAAICAgICAgICAgIBAQEBAQEBAQEBAwAAAwAAAAQFAXABExMFAwEAAgYIAX8BQcDZBAsHxQcoBm1lbW9yeQIAC19pbml0aWFsaXplAAgZX19pbmRpcmVjdF9mdW5jdGlvbl90YWJsZQEAC2xsaHR0cF9pbml0AAkYbGxodHRwX3Nob3VsZF9rZWVwX2FsaXZlADcMbGxodHRwX2FsbG9jAAsGbWFsbG9jADkLbGxodHRwX2ZyZWUADARmcmVlAAwPbGxodHRwX2dldF90eXBlAA0VbGxodHRwX2dldF9odHRwX21ham9yAA4VbGxodHRwX2dldF9odHRwX21pbm9yAA8RbGxodHRwX2dldF9tZXRob2QAEBZsbGh0dHBfZ2V0X3N0YXR1c19jb2RlABESbGxodHRwX2dldF91cGdyYWRlABIMbGxodHRwX3Jlc2V0ABMObGxodHRwX2V4ZWN1dGUAFBRsbGh0dHBfc2V0dGluZ3NfaW5pdAAVDWxsaHR0cF9maW5pc2gAFgxsbGh0dHBfcGF1c2UAFw1sbGh0dHBfcmVzdW1lABgbbGxodHRwX3Jlc3VtZV9hZnRlcl91cGdyYWRlABkQbGxodHRwX2dldF9lcnJubwAaF2xsaHR0cF9nZXRfZXJyb3JfcmVhc29uABsXbGxodHRwX3NldF9lcnJvcl9yZWFzb24AHBRsbGh0dHBfZ2V0X2Vycm9yX3BvcwAdEWxsaHR0cF9lcnJub19uYW1lAB4SbGxodHRwX21ldGhvZF9uYW1lAB8SbGxodHRwX3N0YXR1c19uYW1lACAabGxodHRwX3NldF9sZW5pZW50X2hlYWRlcnMAISFsbGh0dHBfc2V0X2xlbmllbnRfY2h1bmtlZF9sZW5ndGgAIh1sbGh0dHBfc2V0X2xlbmllbnRfa2VlcF9hbGl2ZQAjJGxsaHR0cF9zZXRfbGVuaWVudF90cmFuc2Zlcl9lbmNvZGluZwAkGmxsaHR0cF9zZXRfbGVuaWVudF92ZXJzaW9uACUjbGxodHRwX3NldF9sZW5pZW50X2RhdGFfYWZ0ZXJfY2xvc2UAJidsbGh0dHBfc2V0X2xlbmllbnRfb3B0aW9uYWxfbGZfYWZ0ZXJfY3IAJyxsbGh0dHBfc2V0X2xlbmllbnRfb3B0aW9uYWxfY3JsZl9hZnRlcl9jaHVuawAoKGxsaHR0cF9zZXRfbGVuaWVudF9vcHRpb25hbF9jcl9iZWZvcmVfbGYAKSpsbGh0dHBfc2V0X2xlbmllbnRfc3BhY2VzX2FmdGVyX2NodW5rX3NpemUAKhhsbGh0dHBfbWVzc2FnZV9uZWVkc19lb2YANgkYAQBBAQsSAQIDBAUKBgcyNDMuKy8tLDAxCq/ZAjQWAEHA1QAoAgAEQAALQcDVAEEBNgIACxQAIAAQOCAAIAI2AjggACABOgAoCxQAIAAgAC8BNCAALQAwIAAQNxAACx4BAX9BwAAQOiIBEDggAUGACDYCOCABIAA6ACggAQuPDAEHfwJAIABFDQAgAEEIayIBIABBBGsoAgAiAEF4cSIEaiEFAkAgAEEBcQ0AIABBA3FFDQEgASABKAIAIgBrIgFB1NUAKAIASQ0BIAAgBGohBAJAAkBB2NUAKAIAIAFHBEAgAEH/AU0EQCAAQQN2IQMgASgCCCIAIAEoAgwiAkYEQEHE1QBBxNUAKAIAQX4gA3dxNgIADAULIAIgADYCCCAAIAI2AgwMBAsgASgCGCEGIAEgASgCDCIARwRAIAAgASgCCCICNgIIIAIgADYCDAwDCyABQRRqIgMoAgAiAkUEQCABKAIQIgJFDQIgAUEQaiEDCwNAIAMhByACIgBBFGoiAygCACICDQAgAEEQaiEDIAAoAhAiAg0ACyAHQQA2AgAMAgsgBSgCBCIAQQNxQQNHDQIgBSAAQX5xNgIEQczVACAENgIAIAUgBDYCACABIARBAXI2AgQMAwtBACEACyAGRQ0AAkAgASgCHCICQQJ0QfTXAGoiAygCACABRgRAIAMgADYCACAADQFByNUAQcjVACgCAEF+IAJ3cTYCAAwCCyAGQRBBFCAGKAIQIAFGG2ogADYCACAARQ0BCyAAIAY2AhggASgCECICBEAgACACNgIQIAIgADYCGAsgAUEUaigCACICRQ0AIABBFGogAjYCACACIAA2AhgLIAEgBU8NACAFKAIEIgBBAXFFDQACQAJAAkACQCAAQQJxRQRAQdzVACgCACAFRgRAQdzVACABNgIAQdDVAEHQ1QAoAgAgBGoiADYCACABIABBAXI2AgQgAUHY1QAoAgBHDQZBzNUAQQA2AgBB2NUAQQA2AgAMBgtB2NUAKAIAIAVGBEBB2NUAIAE2AgBBzNUAQczVACgCACAEaiIANgIAIAEgAEEBcjYCBCAAIAFqIAA2AgAMBgsgAEF4cSAEaiEEIABB/wFNBEAgAEEDdiEDIAUoAggiACAFKAIMIgJGBEBBxNUAQcTVACgCAEF+IAN3cTYCAAwFCyACIAA2AgggACACNgIMDAQLIAUoAhghBiAFIAUoAgwiAEcEQEHU1QAoAgAaIAAgBSgCCCICNgIIIAIgADYCDAwDCyAFQRRqIgMoAgAiAkUEQCAFKAIQIgJFDQIgBUEQaiEDCwNAIAMhByACIgBBFGoiAygCACICDQAgAEEQaiEDIAAoAhAiAg0ACyAHQQA2AgAMAgsgBSAAQX5xNgIEIAEgBGogBDYCACABIARBAXI2AgQMAwtBACEACyAGRQ0AAkAgBSgCHCICQQJ0QfTXAGoiAygCACAFRgRAIAMgADYCACAADQFByNUAQcjVACgCAEF+IAJ3cTYCAAwCCyAGQRBBFCAGKAIQIAVGG2ogADYCACAARQ0BCyAAIAY2AhggBSgCECICBEAgACACNgIQIAIgADYCGAsgBUEUaigCACICRQ0AIABBFGogAjYCACACIAA2AhgLIAEgBGogBDYCACABIARBAXI2AgQgAUHY1QAoAgBHDQBBzNUAIAQ2AgAMAQsgBEH/AU0EQCAEQXhxQezVAGohAAJ/QcTVACgCACICQQEgBEEDdnQiA3FFBEBBxNUAIAIgA3I2AgAgAAwBCyAAKAIICyICIAE2AgwgACABNgIIIAEgADYCDCABIAI2AggMAQtBHyECIARB////B00EQCAEQSYgBEEIdmciAGt2QQFxIABBAXRrQT5qIQILIAEgAjYCHCABQgA3AhAgAkECdEH01wBqIQACQEHI1QAoAgAiA0EBIAJ0IgdxRQRAIAAgATYCAEHI1QAgAyAHcjYCACABIAA2AhggASABNgIIIAEgATYCDAwBCyAEQRkgAkEBdmtBACACQR9HG3QhAiAAKAIAIQACQANAIAAiAygCBEF4cSAERg0BIAJBHXYhACACQQF0IQIgAyAAQQRxakEQaiIHKAIAIgANAAsgByABNgIAIAEgAzYCGCABIAE2AgwgASABNgIIDAELIAMoAggiACABNgIMIAMgATYCCCABQQA2AhggASADNgIMIAEgADYCCAtB5NUAQeTVACgCAEEBayIAQX8gABs2AgALCwcAIAAtACgLBwAgAC0AKgsHACAALQArCwcAIAAtACkLBwAgAC8BNAsHACAALQAwC0ABBH8gACgCGCEBIAAvAS4hAiAALQAoIQMgACgCOCEEIAAQOCAAIAQ2AjggACADOgAoIAAgAjsBLiAAIAE2AhgL5YUCAgd/A34gASACaiEEAkAgACIDKAIMIgANACADKAIEBEAgAyABNgIECyMAQRBrIgkkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAygCHCICQQJrDvwBAfkBAgMEBQYHCAkKCwwNDg8QERL4ARP3ARQV9gEWF/UBGBkaGxwdHh8g/QH7ASH0ASIjJCUmJygpKivzASwtLi8wMTLyAfEBMzTwAe8BNTY3ODk6Ozw9Pj9AQUJDREVGR0hJSktMTU5P+gFQUVJT7gHtAVTsAVXrAVZXWFla6gFbXF1eX2BhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ent8fX5/gAGBAYIBgwGEAYUBhgGHAYgBiQGKAYsBjAGNAY4BjwGQAZEBkgGTAZQBlQGWAZcBmAGZAZoBmwGcAZ0BngGfAaABoQGiAaMBpAGlAaYBpwGoAakBqgGrAawBrQGuAa8BsAGxAbIBswG0AbUBtgG3AbgBuQG6AbsBvAG9Ab4BvwHAAcEBwgHDAcQBxQHGAccByAHJAcoBywHMAc0BzgHpAegBzwHnAdAB5gHRAdIB0wHUAeUB1QHWAdcB2AHZAdoB2wHcAd0B3gHfAeAB4QHiAeMBAPwBC0EADOMBC0EODOIBC0ENDOEBC0EPDOABC0EQDN8BC0ETDN4BC0EUDN0BC0EVDNwBC0EWDNsBC0EXDNoBC0EYDNkBC0EZDNgBC0EaDNcBC0EbDNYBC0EcDNUBC0EdDNQBC0EeDNMBC0EfDNIBC0EgDNEBC0EhDNABC0EIDM8BC0EiDM4BC0EkDM0BC0EjDMwBC0EHDMsBC0ElDMoBC0EmDMkBC0EnDMgBC0EoDMcBC0ESDMYBC0ERDMUBC0EpDMQBC0EqDMMBC0ErDMIBC0EsDMEBC0HeAQzAAQtBLgy/AQtBLwy+AQtBMAy9AQtBMQy8AQtBMgy7AQtBMwy6AQtBNAy5AQtB3wEMuAELQTUMtwELQTkMtgELQQwMtQELQTYMtAELQTcMswELQTgMsgELQT4MsQELQToMsAELQeABDK8BC0ELDK4BC0E/DK0BC0E7DKwBC0EKDKsBC0E8DKoBC0E9DKkBC0HhAQyoAQtBwQAMpwELQcAADKYBC0HCAAylAQtBCQykAQtBLQyjAQtBwwAMogELQcQADKEBC0HFAAygAQtBxgAMnwELQccADJ4BC0HIAAydAQtByQAMnAELQcoADJsBC0HLAAyaAQtBzAAMmQELQc0ADJgBC0HOAAyXAQtBzwAMlgELQdAADJUBC0HRAAyUAQtB0gAMkwELQdMADJIBC0HVAAyRAQtB1AAMkAELQdYADI8BC0HXAAyOAQtB2AAMjQELQdkADIwBC0HaAAyLAQtB2wAMigELQdwADIkBC0HdAAyIAQtB3gAMhwELQd8ADIYBC0HgAAyFAQtB4QAMhAELQeIADIMBC0HjAAyCAQtB5AAMgQELQeUADIABC0HiAQx/C0HmAAx+C0HnAAx9C0EGDHwLQegADHsLQQUMegtB6QAMeQtBBAx4C0HqAAx3C0HrAAx2C0HsAAx1C0HtAAx0C0EDDHMLQe4ADHILQe8ADHELQfAADHALQfIADG8LQfEADG4LQfMADG0LQfQADGwLQfUADGsLQfYADGoLQQIMaQtB9wAMaAtB+AAMZwtB+QAMZgtB+gAMZQtB+wAMZAtB/AAMYwtB/QAMYgtB/gAMYQtB/wAMYAtBgAEMXwtBgQEMXgtBggEMXQtBgwEMXAtBhAEMWwtBhQEMWgtBhgEMWQtBhwEMWAtBiAEMVwtBiQEMVgtBigEMVQtBiwEMVAtBjAEMUwtBjQEMUgtBjgEMUQtBjwEMUAtBkAEMTwtBkQEMTgtBkgEMTQtBkwEMTAtBlAEMSwtBlQEMSgtBlgEMSQtBlwEMSAtBmAEMRwtBmQEMRgtBmgEMRQtBmwEMRAtBnAEMQwtBnQEMQgtBngEMQQtBnwEMQAtBoAEMPwtBoQEMPgtBogEMPQtBowEMPAtBpAEMOwtBpQEMOgtBpgEMOQtBpwEMOAtBqAEMNwtBqQEMNgtBqgEMNQtBqwEMNAtBrAEMMwtBrQEMMgtBrgEMMQtBrwEMMAtBsAEMLwtBsQEMLgtBsgEMLQtBswEMLAtBtAEMKwtBtQEMKgtBtgEMKQtBtwEMKAtBuAEMJwtBuQEMJgtBugEMJQtBuwEMJAtBvAEMIwtBvQEMIgtBvgEMIQtBvwEMIAtBwAEMHwtBwQEMHgtBwgEMHQtBAQwcC0HDAQwbC0HEAQwaC0HFAQwZC0HGAQwYC0HHAQwXC0HIAQwWC0HJAQwVC0HKAQwUC0HLAQwTC0HMAQwSC0HNAQwRC0HOAQwQC0HPAQwPC0HQAQwOC0HRAQwNC0HSAQwMC0HTAQwLC0HUAQwKC0HVAQwJC0HWAQwIC0HjAQwHC0HXAQwGC0HYAQwFC0HZAQwEC0HaAQwDC0HbAQwCC0HdAQwBC0HcAQshAgNAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkACQAJ/AkACQAJAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAMCfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAg7jAQABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEjJCUnKCmeA5sDmgORA4oDgwOAA/0C+wL4AvIC8QLvAu0C6ALnAuYC5QLkAtwC2wLaAtkC2ALXAtYC1QLPAs4CzALLAsoCyQLIAscCxgLEAsMCvgK8AroCuQK4ArcCtgK1ArQCswKyArECsAKuAq0CqQKoAqcCpgKlAqQCowKiAqECoAKfApgCkAKMAosCigKBAv4B/QH8AfsB+gH5AfgB9wH1AfMB8AHrAekB6AHnAeYB5QHkAeMB4gHhAeAB3wHeAd0B3AHaAdkB2AHXAdYB1QHUAdMB0gHRAdABzwHOAc0BzAHLAcoByQHIAccBxgHFAcQBwwHCAcEBwAG/Ab4BvQG8AbsBugG5AbgBtwG2AbUBtAGzAbIBsQGwAa8BrgGtAawBqwGqAakBqAGnAaYBpQGkAaMBogGfAZ4BmQGYAZcBlgGVAZQBkwGSAZEBkAGPAY0BjAGHAYYBhQGEAYMBggF9fHt6eXZ1dFBRUlNUVQsgASAERw1yQf0BIQIMvgMLIAEgBEcNmAFB2wEhAgy9AwsgASAERw3xAUGOASECDLwDCyABIARHDfwBQYQBIQIMuwMLIAEgBEcNigJB/wAhAgy6AwsgASAERw2RAkH9ACECDLkDCyABIARHDZQCQfsAIQIMuAMLIAEgBEcNHkEeIQIMtwMLIAEgBEcNGUEYIQIMtgMLIAEgBEcNygJBzQAhAgy1AwsgASAERw3VAkHGACECDLQDCyABIARHDdYCQcMAIQIMswMLIAEgBEcN3AJBOCECDLIDCyADLQAwQQFGDa0DDIkDC0EAIQACQAJAAkAgAy0AKkUNACADLQArRQ0AIAMvATIiAkECcUUNAQwCCyADLwEyIgJBAXFFDQELQQEhACADLQAoQQFGDQAgAy8BNCIGQeQAa0HkAEkNACAGQcwBRg0AIAZBsAJGDQAgAkHAAHENAEEAIQAgAkGIBHFBgARGDQAgAkEocUEARyEACyADQQA7ATIgA0EAOgAxAkAgAEUEQCADQQA6ADEgAy0ALkEEcQ0BDLEDCyADQgA3AyALIANBADoAMSADQQE6ADYMSAtBACEAAkAgAygCOCICRQ0AIAIoAjAiAkUNACADIAIRAAAhAAsgAEUNSCAAQRVHDWIgA0EENgIcIAMgATYCFCADQdIbNgIQIANBFTYCDEEAIQIMrwMLIAEgBEYEQEEGIQIMrwMLIAEtAABBCkcNGSABQQFqIQEMGgsgA0IANwMgQRIhAgyUAwsgASAERw2KA0EjIQIMrAMLIAEgBEYEQEEHIQIMrAMLAkACQCABLQAAQQprDgQBGBgAGAsgAUEBaiEBQRAhAgyTAwsgAUEBaiEBIANBL2otAABBAXENF0EAIQIgA0EANgIcIAMgATYCFCADQZkgNgIQIANBGTYCDAyrAwsgAyADKQMgIgwgBCABa60iCn0iC0IAIAsgDFgbNwMgIAogDFoNGEEIIQIMqgMLIAEgBEcEQCADQQk2AgggAyABNgIEQRQhAgyRAwtBCSECDKkDCyADKQMgUA2uAgxDCyABIARGBEBBCyECDKgDCyABLQAAQQpHDRYgAUEBaiEBDBcLIANBL2otAABBAXFFDRkMJgtBACEAAkAgAygCOCICRQ0AIAIoAlAiAkUNACADIAIRAAAhAAsgAA0ZDEILQQAhAAJAIAMoAjgiAkUNACACKAJQIgJFDQAgAyACEQAAIQALIAANGgwkC0EAIQACQCADKAI4IgJFDQAgAigCUCICRQ0AIAMgAhEAACEACyAADRsMMgsgA0Evai0AAEEBcUUNHAwiC0EAIQACQCADKAI4IgJFDQAgAigCVCICRQ0AIAMgAhEAACEACyAADRwMQgtBACEAAkAgAygCOCICRQ0AIAIoAlQiAkUNACADIAIRAAAhAAsgAA0dDCALIAEgBEYEQEETIQIMoAMLAkAgAS0AACIAQQprDgQfIyMAIgsgAUEBaiEBDB8LQQAhAAJAIAMoAjgiAkUNACACKAJUIgJFDQAgAyACEQAAIQALIAANIgxCCyABIARGBEBBFiECDJ4DCyABLQAAQcDBAGotAABBAUcNIwyDAwsCQANAIAEtAABBsDtqLQAAIgBBAUcEQAJAIABBAmsOAgMAJwsgAUEBaiEBQSEhAgyGAwsgBCABQQFqIgFHDQALQRghAgydAwsgAygCBCEAQQAhAiADQQA2AgQgAyAAIAFBAWoiARA0IgANIQxBC0EAIQACQCADKAI4IgJFDQAgAigCVCICRQ0AIAMgAhEAACEACyAADSMMKgsgASAERgRAQRwhAgybAwsgA0EKNgIIIAMgATYCBEEAIQACQCADKAI4IgJFDQAgAigCUCICRQ0AIAMgAhEAACEACyAADSVBJCECDIEDCyABIARHBEADQCABLQAAQbA9ai0AACIAQQNHBEAgAEEBaw4FGBomggMlJgsgBCABQQFqIgFHDQALQRshAgyaAwtBGyECDJkDCwNAIAEtAABBsD9qLQAAIgBBA0cEQCAAQQFrDgUPEScTJicLIAQgAUEBaiIBRw0AC0EeIQIMmAMLIAEgBEcEQCADQQs2AgggAyABNgIEQQchAgz/AgtBHyECDJcDCyABIARGBEBBICECDJcDCwJAIAEtAABBDWsOFC4/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8APwtBACECIANBADYCHCADQb8LNgIQIANBAjYCDCADIAFBAWo2AhQMlgMLIANBL2ohAgNAIAEgBEYEQEEhIQIMlwMLAkACQAJAIAEtAAAiAEEJaw4YAgApKQEpKSkpKSkpKSkpKSkpKSkpKSkCJwsgAUEBaiEBIANBL2otAABBAXFFDQoMGAsgAUEBaiEBDBcLIAFBAWohASACLQAAQQJxDQALQQAhAiADQQA2AhwgAyABNgIUIANBnxU2AhAgA0EMNgIMDJUDCyADLQAuQYABcUUNAQtBACEAAkAgAygCOCICRQ0AIAIoAlwiAkUNACADIAIRAAAhAAsgAEUN5gIgAEEVRgRAIANBJDYCHCADIAE2AhQgA0GbGzYCECADQRU2AgxBACECDJQDC0EAIQIgA0EANgIcIAMgATYCFCADQZAONgIQIANBFDYCDAyTAwtBACECIANBADYCHCADIAE2AhQgA0G+IDYCECADQQI2AgwMkgMLIAMoAgQhAEEAIQIgA0EANgIEIAMgACABIAynaiIBEDIiAEUNKyADQQc2AhwgAyABNgIUIAMgADYCDAyRAwsgAy0ALkHAAHFFDQELQQAhAAJAIAMoAjgiAkUNACACKAJYIgJFDQAgAyACEQAAIQALIABFDSsgAEEVRgRAIANBCjYCHCADIAE2AhQgA0HrGTYCECADQRU2AgxBACECDJADC0EAIQIgA0EANgIcIAMgATYCFCADQZMMNgIQIANBEzYCDAyPAwtBACECIANBADYCHCADIAE2AhQgA0GCFTYCECADQQI2AgwMjgMLQQAhAiADQQA2AhwgAyABNgIUIANB3RQ2AhAgA0EZNgIMDI0DC0EAIQIgA0EANgIcIAMgATYCFCADQeYdNgIQIANBGTYCDAyMAwsgAEEVRg09QQAhAiADQQA2AhwgAyABNgIUIANB0A82AhAgA0EiNgIMDIsDCyADKAIEIQBBACECIANBADYCBCADIAAgARAzIgBFDSggA0ENNgIcIAMgATYCFCADIAA2AgwMigMLIABBFUYNOkEAIQIgA0EANgIcIAMgATYCFCADQdAPNgIQIANBIjYCDAyJAwsgAygCBCEAQQAhAiADQQA2AgQgAyAAIAEQMyIARQRAIAFBAWohAQwoCyADQQ42AhwgAyAANgIMIAMgAUEBajYCFAyIAwsgAEEVRg03QQAhAiADQQA2AhwgAyABNgIUIANB0A82AhAgA0EiNgIMDIcDCyADKAIEIQBBACECIANBADYCBCADIAAgARAzIgBFBEAgAUEBaiEBDCcLIANBDzYCHCADIAA2AgwgAyABQQFqNgIUDIYDC0EAIQIgA0EANgIcIAMgATYCFCADQeIXNgIQIANBGTYCDAyFAwsgAEEVRg0zQQAhAiADQQA2AhwgAyABNgIUIANB1gw2AhAgA0EjNgIMDIQDCyADKAIEIQBBACECIANBADYCBCADIAAgARA0IgBFDSUgA0ERNgIcIAMgATYCFCADIAA2AgwMgwMLIABBFUYNMEEAIQIgA0EANgIcIAMgATYCFCADQdYMNgIQIANBIzYCDAyCAwsgAygCBCEAQQAhAiADQQA2AgQgAyAAIAEQNCIARQRAIAFBAWohAQwlCyADQRI2AhwgAyAANgIMIAMgAUEBajYCFAyBAwsgA0Evai0AAEEBcUUNAQtBFyECDOYCC0EAIQIgA0EANgIcIAMgATYCFCADQeIXNgIQIANBGTYCDAz+AgsgAEE7Rw0AIAFBAWohAQwMC0EAIQIgA0EANgIcIAMgATYCFCADQZIYNgIQIANBAjYCDAz8AgsgAEEVRg0oQQAhAiADQQA2AhwgAyABNgIUIANB1gw2AhAgA0EjNgIMDPsCCyADQRQ2AhwgAyABNgIUIAMgADYCDAz6AgsgAygCBCEAQQAhAiADQQA2AgQgAyAAIAEQNCIARQRAIAFBAWohAQz1AgsgA0EVNgIcIAMgADYCDCADIAFBAWo2AhQM+QILIAMoAgQhAEEAIQIgA0EANgIEIAMgACABEDQiAEUEQCABQQFqIQEM8wILIANBFzYCHCADIAA2AgwgAyABQQFqNgIUDPgCCyAAQRVGDSNBACECIANBADYCHCADIAE2AhQgA0HWDDYCECADQSM2AgwM9wILIAMoAgQhAEEAIQIgA0EANgIEIAMgACABEDQiAEUEQCABQQFqIQEMHQsgA0EZNgIcIAMgADYCDCADIAFBAWo2AhQM9gILIAMoAgQhAEEAIQIgA0EANgIEIAMgACABEDQiAEUEQCABQQFqIQEM7wILIANBGjYCHCADIAA2AgwgAyABQQFqNgIUDPUCCyAAQRVGDR9BACECIANBADYCHCADIAE2AhQgA0HQDzYCECADQSI2AgwM9AILIAMoAgQhACADQQA2AgQgAyAAIAEQMyIARQRAIAFBAWohAQwbCyADQRw2AhwgAyAANgIMIAMgAUEBajYCFEEAIQIM8wILIAMoAgQhACADQQA2AgQgAyAAIAEQMyIARQRAIAFBAWohAQzrAgsgA0EdNgIcIAMgADYCDCADIAFBAWo2AhRBACECDPICCyAAQTtHDQEgAUEBaiEBC0EmIQIM1wILQQAhAiADQQA2AhwgAyABNgIUIANBnxU2AhAgA0EMNgIMDO8CCyABIARHBEADQCABLQAAQSBHDYQCIAQgAUEBaiIBRw0AC0EsIQIM7wILQSwhAgzuAgsgASAERgRAQTQhAgzuAgsCQAJAA0ACQCABLQAAQQprDgQCAAADAAsgBCABQQFqIgFHDQALQTQhAgzvAgsgAygCBCEAIANBADYCBCADIAAgARAxIgBFDZ8CIANBMjYCHCADIAE2AhQgAyAANgIMQQAhAgzuAgsgAygCBCEAIANBADYCBCADIAAgARAxIgBFBEAgAUEBaiEBDJ8CCyADQTI2AhwgAyAANgIMIAMgAUEBajYCFEEAIQIM7QILIAEgBEcEQAJAA0AgAS0AAEEwayIAQf8BcUEKTwRAQTohAgzXAgsgAykDICILQpmz5syZs+bMGVYNASADIAtCCn4iCjcDICAKIACtQv8BgyILQn+FVg0BIAMgCiALfDcDICAEIAFBAWoiAUcNAAtBwAAhAgzuAgsgAygCBCEAIANBADYCBCADIAAgAUEBaiIBEDEiAA0XDOICC0HAACECDOwCCyABIARGBEBByQAhAgzsAgsCQANAAkAgAS0AAEEJaw4YAAKiAqICqQKiAqICogKiAqICogKiAqICogKiAqICogKiAqICogKiAqICogIAogILIAQgAUEBaiIBRw0AC0HJACECDOwCCyABQQFqIQEgA0Evai0AAEEBcQ2lAiADQQA2AhwgAyABNgIUIANBlxA2AhAgA0EKNgIMQQAhAgzrAgsgASAERwRAA0AgAS0AAEEgRw0VIAQgAUEBaiIBRw0AC0H4ACECDOsCC0H4ACECDOoCCyADQQI6ACgMOAtBACECIANBADYCHCADQb8LNgIQIANBAjYCDCADIAFBAWo2AhQM6AILQQAhAgzOAgtBDSECDM0CC0ETIQIMzAILQRUhAgzLAgtBFiECDMoCC0EYIQIMyQILQRkhAgzIAgtBGiECDMcCC0EbIQIMxgILQRwhAgzFAgtBHSECDMQCC0EeIQIMwwILQR8hAgzCAgtBICECDMECC0EiIQIMwAILQSMhAgy/AgtBJSECDL4CC0HlACECDL0CCyADQT02AhwgAyABNgIUIAMgADYCDEEAIQIM1QILIANBGzYCHCADIAE2AhQgA0GkHDYCECADQRU2AgxBACECDNQCCyADQSA2AhwgAyABNgIUIANBmBo2AhAgA0EVNgIMQQAhAgzTAgsgA0ETNgIcIAMgATYCFCADQZgaNgIQIANBFTYCDEEAIQIM0gILIANBCzYCHCADIAE2AhQgA0GYGjYCECADQRU2AgxBACECDNECCyADQRA2AhwgAyABNgIUIANBmBo2AhAgA0EVNgIMQQAhAgzQAgsgA0EgNgIcIAMgATYCFCADQaQcNgIQIANBFTYCDEEAIQIMzwILIANBCzYCHCADIAE2AhQgA0GkHDYCECADQRU2AgxBACECDM4CCyADQQw2AhwgAyABNgIUIANBpBw2AhAgA0EVNgIMQQAhAgzNAgtBACECIANBADYCHCADIAE2AhQgA0HdDjYCECADQRI2AgwMzAILAkADQAJAIAEtAABBCmsOBAACAgACCyAEIAFBAWoiAUcNAAtB/QEhAgzMAgsCQAJAIAMtADZBAUcNAEEAIQACQCADKAI4IgJFDQAgAigCYCICRQ0AIAMgAhEAACEACyAARQ0AIABBFUcNASADQfwBNgIcIAMgATYCFCADQdwZNgIQIANBFTYCDEEAIQIMzQILQdwBIQIMswILIANBADYCHCADIAE2AhQgA0H5CzYCECADQR82AgxBACECDMsCCwJAAkAgAy0AKEEBaw4CBAEAC0HbASECDLICC0HUASECDLECCyADQQI6ADFBACEAAkAgAygCOCICRQ0AIAIoAgAiAkUNACADIAIRAAAhAAsgAEUEQEHdASECDLECCyAAQRVHBEAgA0EANgIcIAMgATYCFCADQbQMNgIQIANBEDYCDEEAIQIMygILIANB+wE2AhwgAyABNgIUIANBgRo2AhAgA0EVNgIMQQAhAgzJAgsgASAERgRAQfoBIQIMyQILIAEtAABByABGDQEgA0EBOgAoC0HAASECDK4CC0HaASECDK0CCyABIARHBEAgA0EMNgIIIAMgATYCBEHZASECDK0CC0H5ASECDMUCCyABIARGBEBB+AEhAgzFAgsgAS0AAEHIAEcNBCABQQFqIQFB2AEhAgyrAgsgASAERgRAQfcBIQIMxAILAkACQCABLQAAQcUAaw4QAAUFBQUFBQUFBQUFBQUFAQULIAFBAWohAUHWASECDKsCCyABQQFqIQFB1wEhAgyqAgtB9gEhAiABIARGDcICIAMoAgAiACAEIAFraiEFIAEgAGtBAmohBgJAA0AgAS0AACAAQbrVAGotAABHDQMgAEECRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAyAFNgIADMMCCyADKAIEIQAgA0IANwMAIAMgACAGQQFqIgEQLiIARQRAQeMBIQIMqgILIANB9QE2AhwgAyABNgIUIAMgADYCDEEAIQIMwgILQfQBIQIgASAERg3BAiADKAIAIgAgBCABa2ohBSABIABrQQFqIQYCQANAIAEtAAAgAEG41QBqLQAARw0CIABBAUYNASAAQQFqIQAgBCABQQFqIgFHDQALIAMgBTYCAAzCAgsgA0GBBDsBKCADKAIEIQAgA0IANwMAIAMgACAGQQFqIgEQLiIADQMMAgsgA0EANgIAC0EAIQIgA0EANgIcIAMgATYCFCADQeUfNgIQIANBCDYCDAy/AgtB1QEhAgylAgsgA0HzATYCHCADIAE2AhQgAyAANgIMQQAhAgy9AgtBACEAAkAgAygCOCICRQ0AIAIoAkAiAkUNACADIAIRAAAhAAsgAEUNbiAAQRVHBEAgA0EANgIcIAMgATYCFCADQYIPNgIQIANBIDYCDEEAIQIMvQILIANBjwE2AhwgAyABNgIUIANB7Bs2AhAgA0EVNgIMQQAhAgy8AgsgASAERwRAIANBDTYCCCADIAE2AgRB0wEhAgyjAgtB8gEhAgy7AgsgASAERgRAQfEBIQIMuwILAkACQAJAIAEtAABByABrDgsAAQgICAgICAgIAggLIAFBAWohAUHQASECDKMCCyABQQFqIQFB0QEhAgyiAgsgAUEBaiEBQdIBIQIMoQILQfABIQIgASAERg25AiADKAIAIgAgBCABa2ohBiABIABrQQJqIQUDQCABLQAAIABBtdUAai0AAEcNBCAAQQJGDQMgAEEBaiEAIAQgAUEBaiIBRw0ACyADIAY2AgAMuQILQe8BIQIgASAERg24AiADKAIAIgAgBCABa2ohBiABIABrQQFqIQUDQCABLQAAIABBs9UAai0AAEcNAyAAQQFGDQIgAEEBaiEAIAQgAUEBaiIBRw0ACyADIAY2AgAMuAILQe4BIQIgASAERg23AiADKAIAIgAgBCABa2ohBiABIABrQQJqIQUDQCABLQAAIABBsNUAai0AAEcNAiAAQQJGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyADIAY2AgAMtwILIAMoAgQhACADQgA3AwAgAyAAIAVBAWoiARArIgBFDQIgA0HsATYCHCADIAE2AhQgAyAANgIMQQAhAgy2AgsgA0EANgIACyADKAIEIQAgA0EANgIEIAMgACABECsiAEUNnAIgA0HtATYCHCADIAE2AhQgAyAANgIMQQAhAgy0AgtBzwEhAgyaAgtBACEAAkAgAygCOCICRQ0AIAIoAjQiAkUNACADIAIRAAAhAAsCQCAABEAgAEEVRg0BIANBADYCHCADIAE2AhQgA0HqDTYCECADQSY2AgxBACECDLQCC0HOASECDJoCCyADQesBNgIcIAMgATYCFCADQYAbNgIQIANBFTYCDEEAIQIMsgILIAEgBEYEQEHrASECDLICCyABLQAAQS9GBEAgAUEBaiEBDAELIANBADYCHCADIAE2AhQgA0GyODYCECADQQg2AgxBACECDLECC0HNASECDJcCCyABIARHBEAgA0EONgIIIAMgATYCBEHMASECDJcCC0HqASECDK8CCyABIARGBEBB6QEhAgyvAgsgAS0AAEEwayIAQf8BcUEKSQRAIAMgADoAKiABQQFqIQFBywEhAgyWAgsgAygCBCEAIANBADYCBCADIAAgARAvIgBFDZcCIANB6AE2AhwgAyABNgIUIAMgADYCDEEAIQIMrgILIAEgBEYEQEHnASECDK4CCwJAIAEtAABBLkYEQCABQQFqIQEMAQsgAygCBCEAIANBADYCBCADIAAgARAvIgBFDZgCIANB5gE2AhwgAyABNgIUIAMgADYCDEEAIQIMrgILQcoBIQIMlAILIAEgBEYEQEHlASECDK0CC0EAIQBBASEFQQEhB0EAIQICQAJAAkACQAJAAn8CQAJAAkACQAJAAkACQCABLQAAQTBrDgoKCQABAgMEBQYICwtBAgwGC0EDDAULQQQMBAtBBQwDC0EGDAILQQcMAQtBCAshAkEAIQVBACEHDAILQQkhAkEBIQBBACEFQQAhBwwBC0EAIQVBASECCyADIAI6ACsgAUEBaiEBAkACQCADLQAuQRBxDQACQAJAAkAgAy0AKg4DAQACBAsgB0UNAwwCCyAADQEMAgsgBUUNAQsgAygCBCEAIANBADYCBCADIAAgARAvIgBFDQIgA0HiATYCHCADIAE2AhQgAyAANgIMQQAhAgyvAgsgAygCBCEAIANBADYCBCADIAAgARAvIgBFDZoCIANB4wE2AhwgAyABNgIUIAMgADYCDEEAIQIMrgILIAMoAgQhACADQQA2AgQgAyAAIAEQLyIARQ2YAiADQeQBNgIcIAMgATYCFCADIAA2AgwMrQILQckBIQIMkwILQQAhAAJAIAMoAjgiAkUNACACKAJEIgJFDQAgAyACEQAAIQALAkAgAARAIABBFUYNASADQQA2AhwgAyABNgIUIANBpA02AhAgA0EhNgIMQQAhAgytAgtByAEhAgyTAgsgA0HhATYCHCADIAE2AhQgA0HQGjYCECADQRU2AgxBACECDKsCCyABIARGBEBB4QEhAgyrAgsCQCABLQAAQSBGBEAgA0EAOwE0IAFBAWohAQwBCyADQQA2AhwgAyABNgIUIANBmRE2AhAgA0EJNgIMQQAhAgyrAgtBxwEhAgyRAgsgASAERgRAQeABIQIMqgILAkAgAS0AAEEwa0H/AXEiAkEKSQRAIAFBAWohAQJAIAMvATQiAEGZM0sNACADIABBCmwiADsBNCAAQf7/A3EgAkH//wNzSw0AIAMgACACajsBNAwCC0EAIQIgA0EANgIcIAMgATYCFCADQZUeNgIQIANBDTYCDAyrAgsgA0EANgIcIAMgATYCFCADQZUeNgIQIANBDTYCDEEAIQIMqgILQcYBIQIMkAILIAEgBEYEQEHfASECDKkCCwJAIAEtAABBMGtB/wFxIgJBCkkEQCABQQFqIQECQCADLwE0IgBBmTNLDQAgAyAAQQpsIgA7ATQgAEH+/wNxIAJB//8Dc0sNACADIAAgAmo7ATQMAgtBACECIANBADYCHCADIAE2AhQgA0GVHjYCECADQQ02AgwMqgILIANBADYCHCADIAE2AhQgA0GVHjYCECADQQ02AgxBACECDKkCC0HFASECDI8CCyABIARGBEBB3gEhAgyoAgsCQCABLQAAQTBrQf8BcSICQQpJBEAgAUEBaiEBAkAgAy8BNCIAQZkzSw0AIAMgAEEKbCIAOwE0IABB/v8DcSACQf//A3NLDQAgAyAAIAJqOwE0DAILQQAhAiADQQA2AhwgAyABNgIUIANBlR42AhAgA0ENNgIMDKkCCyADQQA2AhwgAyABNgIUIANBlR42AhAgA0ENNgIMQQAhAgyoAgtBxAEhAgyOAgsgASAERgRAQd0BIQIMpwILAkACQAJAAkAgAS0AAEEKaw4XAgMDAAMDAwMDAwMDAwMDAwMDAwMDAwEDCyABQQFqDAULIAFBAWohAUHDASECDI8CCyABQQFqIQEgA0Evai0AAEEBcQ0IIANBADYCHCADIAE2AhQgA0GNCzYCECADQQ02AgxBACECDKcCCyADQQA2AhwgAyABNgIUIANBjQs2AhAgA0ENNgIMQQAhAgymAgsgASAERwRAIANBDzYCCCADIAE2AgRBASECDI0CC0HcASECDKUCCwJAAkADQAJAIAEtAABBCmsOBAIAAAMACyAEIAFBAWoiAUcNAAtB2wEhAgymAgsgAygCBCEAIANBADYCBCADIAAgARAtIgBFBEAgAUEBaiEBDAQLIANB2gE2AhwgAyAANgIMIAMgAUEBajYCFEEAIQIMpQILIAMoAgQhACADQQA2AgQgAyAAIAEQLSIADQEgAUEBagshAUHBASECDIoCCyADQdkBNgIcIAMgADYCDCADIAFBAWo2AhRBACECDKICC0HCASECDIgCCyADQS9qLQAAQQFxDQEgA0EANgIcIAMgATYCFCADQeQcNgIQIANBGTYCDEEAIQIMoAILIAEgBEYEQEHZASECDKACCwJAAkACQCABLQAAQQprDgQBAgIAAgsgAUEBaiEBDAILIAFBAWohAQwBCyADLQAuQcAAcUUNAQtBACEAAkAgAygCOCICRQ0AIAIoAjwiAkUNACADIAIRAAAhAAsgAEUNoAEgAEEVRgRAIANB2QA2AhwgAyABNgIUIANBtxo2AhAgA0EVNgIMQQAhAgyfAgsgA0EANgIcIAMgATYCFCADQYANNgIQIANBGzYCDEEAIQIMngILIANBADYCHCADIAE2AhQgA0HcKDYCECADQQI2AgxBACECDJ0CCyABIARHBEAgA0EMNgIIIAMgATYCBEG/ASECDIQCC0HYASECDJwCCyABIARGBEBB1wEhAgycAgsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEtAABBwQBrDhUAAQIDWgQFBlpaWgcICQoLDA0ODxBaCyABQQFqIQFB+wAhAgySAgsgAUEBaiEBQfwAIQIMkQILIAFBAWohAUGBASECDJACCyABQQFqIQFBhQEhAgyPAgsgAUEBaiEBQYYBIQIMjgILIAFBAWohAUGJASECDI0CCyABQQFqIQFBigEhAgyMAgsgAUEBaiEBQY0BIQIMiwILIAFBAWohAUGWASECDIoCCyABQQFqIQFBlwEhAgyJAgsgAUEBaiEBQZgBIQIMiAILIAFBAWohAUGlASECDIcCCyABQQFqIQFBpgEhAgyGAgsgAUEBaiEBQawBIQIMhQILIAFBAWohAUG0ASECDIQCCyABQQFqIQFBtwEhAgyDAgsgAUEBaiEBQb4BIQIMggILIAEgBEYEQEHWASECDJsCCyABLQAAQc4ARw1IIAFBAWohAUG9ASECDIECCyABIARGBEBB1QEhAgyaAgsCQAJAAkAgAS0AAEHCAGsOEgBKSkpKSkpKSkoBSkpKSkpKAkoLIAFBAWohAUG4ASECDIICCyABQQFqIQFBuwEhAgyBAgsgAUEBaiEBQbwBIQIMgAILQdQBIQIgASAERg2YAiADKAIAIgAgBCABa2ohBSABIABrQQdqIQYCQANAIAEtAAAgAEGo1QBqLQAARw1FIABBB0YNASAAQQFqIQAgBCABQQFqIgFHDQALIAMgBTYCAAyZAgsgA0EANgIAIAZBAWohAUEbDEULIAEgBEYEQEHTASECDJgCCwJAAkAgAS0AAEHJAGsOBwBHR0dHRwFHCyABQQFqIQFBuQEhAgz/AQsgAUEBaiEBQboBIQIM/gELQdIBIQIgASAERg2WAiADKAIAIgAgBCABa2ohBSABIABrQQFqIQYCQANAIAEtAAAgAEGm1QBqLQAARw1DIABBAUYNASAAQQFqIQAgBCABQQFqIgFHDQALIAMgBTYCAAyXAgsgA0EANgIAIAZBAWohAUEPDEMLQdEBIQIgASAERg2VAiADKAIAIgAgBCABa2ohBSABIABrQQFqIQYCQANAIAEtAAAgAEGk1QBqLQAARw1CIABBAUYNASAAQQFqIQAgBCABQQFqIgFHDQALIAMgBTYCAAyWAgsgA0EANgIAIAZBAWohAUEgDEILQdABIQIgASAERg2UAiADKAIAIgAgBCABa2ohBSABIABrQQJqIQYCQANAIAEtAAAgAEGh1QBqLQAARw1BIABBAkYNASAAQQFqIQAgBCABQQFqIgFHDQALIAMgBTYCAAyVAgsgA0EANgIAIAZBAWohAUESDEELIAEgBEYEQEHPASECDJQCCwJAAkAgAS0AAEHFAGsODgBDQ0NDQ0NDQ0NDQ0MBQwsgAUEBaiEBQbUBIQIM+wELIAFBAWohAUG2ASECDPoBC0HOASECIAEgBEYNkgIgAygCACIAIAQgAWtqIQUgASAAa0ECaiEGAkADQCABLQAAIABBntUAai0AAEcNPyAAQQJGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyADIAU2AgAMkwILIANBADYCACAGQQFqIQFBBww/C0HNASECIAEgBEYNkQIgAygCACIAIAQgAWtqIQUgASAAa0EFaiEGAkADQCABLQAAIABBmNUAai0AAEcNPiAAQQVGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyADIAU2AgAMkgILIANBADYCACAGQQFqIQFBKAw+CyABIARGBEBBzAEhAgyRAgsCQAJAAkAgAS0AAEHFAGsOEQBBQUFBQUFBQUEBQUFBQUECQQsgAUEBaiEBQbEBIQIM+QELIAFBAWohAUGyASECDPgBCyABQQFqIQFBswEhAgz3AQtBywEhAiABIARGDY8CIAMoAgAiACAEIAFraiEFIAEgAGtBBmohBgJAA0AgAS0AACAAQZHVAGotAABHDTwgAEEGRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAyAFNgIADJACCyADQQA2AgAgBkEBaiEBQRoMPAtBygEhAiABIARGDY4CIAMoAgAiACAEIAFraiEFIAEgAGtBA2ohBgJAA0AgAS0AACAAQY3VAGotAABHDTsgAEEDRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAyAFNgIADI8CCyADQQA2AgAgBkEBaiEBQSEMOwsgASAERgRAQckBIQIMjgILAkACQCABLQAAQcEAaw4UAD09PT09PT09PT09PT09PT09PQE9CyABQQFqIQFBrQEhAgz1AQsgAUEBaiEBQbABIQIM9AELIAEgBEYEQEHIASECDI0CCwJAAkAgAS0AAEHVAGsOCwA8PDw8PDw8PDwBPAsgAUEBaiEBQa4BIQIM9AELIAFBAWohAUGvASECDPMBC0HHASECIAEgBEYNiwIgAygCACIAIAQgAWtqIQUgASAAa0EIaiEGAkADQCABLQAAIABBhNUAai0AAEcNOCAAQQhGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyADIAU2AgAMjAILIANBADYCACAGQQFqIQFBKgw4CyABIARGBEBBxgEhAgyLAgsgAS0AAEHQAEcNOCABQQFqIQFBJQw3C0HFASECIAEgBEYNiQIgAygCACIAIAQgAWtqIQUgASAAa0ECaiEGAkADQCABLQAAIABBgdUAai0AAEcNNiAAQQJGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyADIAU2AgAMigILIANBADYCACAGQQFqIQFBDgw2CyABIARGBEBBxAEhAgyJAgsgAS0AAEHFAEcNNiABQQFqIQFBqwEhAgzvAQsgASAERgRAQcMBIQIMiAILAkACQAJAAkAgAS0AAEHCAGsODwABAjk5OTk5OTk5OTk5AzkLIAFBAWohAUGnASECDPEBCyABQQFqIQFBqAEhAgzwAQsgAUEBaiEBQakBIQIM7wELIAFBAWohAUGqASECDO4BC0HCASECIAEgBEYNhgIgAygCACIAIAQgAWtqIQUgASAAa0ECaiEGAkADQCABLQAAIABB/tQAai0AAEcNMyAAQQJGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyADIAU2AgAMhwILIANBADYCACAGQQFqIQFBFAwzC0HBASECIAEgBEYNhQIgAygCACIAIAQgAWtqIQUgASAAa0EEaiEGAkADQCABLQAAIABB+dQAai0AAEcNMiAAQQRGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyADIAU2AgAMhgILIANBADYCACAGQQFqIQFBKwwyC0HAASECIAEgBEYNhAIgAygCACIAIAQgAWtqIQUgASAAa0ECaiEGAkADQCABLQAAIABB9tQAai0AAEcNMSAAQQJGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyADIAU2AgAMhQILIANBADYCACAGQQFqIQFBLAwxC0G/ASECIAEgBEYNgwIgAygCACIAIAQgAWtqIQUgASAAa0ECaiEGAkADQCABLQAAIABBodUAai0AAEcNMCAAQQJGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyADIAU2AgAMhAILIANBADYCACAGQQFqIQFBEQwwC0G+ASECIAEgBEYNggIgAygCACIAIAQgAWtqIQUgASAAa0EDaiEGAkADQCABLQAAIABB8tQAai0AAEcNLyAAQQNGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyADIAU2AgAMgwILIANBADYCACAGQQFqIQFBLgwvCyABIARGBEBBvQEhAgyCAgsCQAJAAkACQAJAIAEtAABBwQBrDhUANDQ0NDQ0NDQ0NAE0NAI0NAM0NAQ0CyABQQFqIQFBmwEhAgzsAQsgAUEBaiEBQZwBIQIM6wELIAFBAWohAUGdASECDOoBCyABQQFqIQFBogEhAgzpAQsgAUEBaiEBQaQBIQIM6AELIAEgBEYEQEG8ASECDIECCwJAAkAgAS0AAEHSAGsOAwAwATALIAFBAWohAUGjASECDOgBCyABQQFqIQFBBAwtC0G7ASECIAEgBEYN/wEgAygCACIAIAQgAWtqIQUgASAAa0EBaiEGAkADQCABLQAAIABB8NQAai0AAEcNLCAAQQFGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyADIAU2AgAMgAILIANBADYCACAGQQFqIQFBHQwsCyABIARGBEBBugEhAgz/AQsCQAJAIAEtAABByQBrDgcBLi4uLi4ALgsgAUEBaiEBQaEBIQIM5gELIAFBAWohAUEiDCsLIAEgBEYEQEG5ASECDP4BCyABLQAAQdAARw0rIAFBAWohAUGgASECDOQBCyABIARGBEBBuAEhAgz9AQsCQAJAIAEtAABBxgBrDgsALCwsLCwsLCwsASwLIAFBAWohAUGeASECDOQBCyABQQFqIQFBnwEhAgzjAQtBtwEhAiABIARGDfsBIAMoAgAiACAEIAFraiEFIAEgAGtBA2ohBgJAA0AgAS0AACAAQezUAGotAABHDSggAEEDRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAyAFNgIADPwBCyADQQA2AgAgBkEBaiEBQQ0MKAtBtgEhAiABIARGDfoBIAMoAgAiACAEIAFraiEFIAEgAGtBAmohBgJAA0AgAS0AACAAQaHVAGotAABHDScgAEECRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAyAFNgIADPsBCyADQQA2AgAgBkEBaiEBQQwMJwtBtQEhAiABIARGDfkBIAMoAgAiACAEIAFraiEFIAEgAGtBAWohBgJAA0AgAS0AACAAQerUAGotAABHDSYgAEEBRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAyAFNgIADPoBCyADQQA2AgAgBkEBaiEBQQMMJgtBtAEhAiABIARGDfgBIAMoAgAiACAEIAFraiEFIAEgAGtBAWohBgJAA0AgAS0AACAAQejUAGotAABHDSUgAEEBRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAyAFNgIADPkBCyADQQA2AgAgBkEBaiEBQSYMJQsgASAERgRAQbMBIQIM+AELAkACQCABLQAAQdQAaw4CAAEnCyABQQFqIQFBmQEhAgzfAQsgAUEBaiEBQZoBIQIM3gELQbIBIQIgASAERg32ASADKAIAIgAgBCABa2ohBSABIABrQQFqIQYCQANAIAEtAAAgAEHm1ABqLQAARw0jIABBAUYNASAAQQFqIQAgBCABQQFqIgFHDQALIAMgBTYCAAz3AQsgA0EANgIAIAZBAWohAUEnDCMLQbEBIQIgASAERg31ASADKAIAIgAgBCABa2ohBSABIABrQQFqIQYCQANAIAEtAAAgAEHk1ABqLQAARw0iIABBAUYNASAAQQFqIQAgBCABQQFqIgFHDQALIAMgBTYCAAz2AQsgA0EANgIAIAZBAWohAUEcDCILQbABIQIgASAERg30ASADKAIAIgAgBCABa2ohBSABIABrQQVqIQYCQANAIAEtAAAgAEHe1ABqLQAARw0hIABBBUYNASAAQQFqIQAgBCABQQFqIgFHDQALIAMgBTYCAAz1AQsgA0EANgIAIAZBAWohAUEGDCELQa8BIQIgASAERg3zASADKAIAIgAgBCABa2ohBSABIABrQQRqIQYCQANAIAEtAAAgAEHZ1ABqLQAARw0gIABBBEYNASAAQQFqIQAgBCABQQFqIgFHDQALIAMgBTYCAAz0AQsgA0EANgIAIAZBAWohAUEZDCALIAEgBEYEQEGuASECDPMBCwJAAkACQAJAIAEtAABBLWsOIwAkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJAEkJCQkJAIkJCQDJAsgAUEBaiEBQY4BIQIM3AELIAFBAWohAUGPASECDNsBCyABQQFqIQFBlAEhAgzaAQsgAUEBaiEBQZUBIQIM2QELQa0BIQIgASAERg3xASADKAIAIgAgBCABa2ohBSABIABrQQFqIQYCQANAIAEtAAAgAEHX1ABqLQAARw0eIABBAUYNASAAQQFqIQAgBCABQQFqIgFHDQALIAMgBTYCAAzyAQsgA0EANgIAIAZBAWohAUELDB4LIAEgBEYEQEGsASECDPEBCwJAAkAgAS0AAEHBAGsOAwAgASALIAFBAWohAUGQASECDNgBCyABQQFqIQFBkwEhAgzXAQsgASAERgRAQasBIQIM8AELAkACQCABLQAAQcEAaw4PAB8fHx8fHx8fHx8fHx8BHwsgAUEBaiEBQZEBIQIM1wELIAFBAWohAUGSASECDNYBCyABIARGBEBBqgEhAgzvAQsgAS0AAEHMAEcNHCABQQFqIQFBCgwbC0GpASECIAEgBEYN7QEgAygCACIAIAQgAWtqIQUgASAAa0EFaiEGAkADQCABLQAAIABB0dQAai0AAEcNGiAAQQVGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyADIAU2AgAM7gELIANBADYCACAGQQFqIQFBHgwaC0GoASECIAEgBEYN7AEgAygCACIAIAQgAWtqIQUgASAAa0EGaiEGAkADQCABLQAAIABBytQAai0AAEcNGSAAQQZGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyADIAU2AgAM7QELIANBADYCACAGQQFqIQFBFQwZC0GnASECIAEgBEYN6wEgAygCACIAIAQgAWtqIQUgASAAa0ECaiEGAkADQCABLQAAIABBx9QAai0AAEcNGCAAQQJGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyADIAU2AgAM7AELIANBADYCACAGQQFqIQFBFwwYC0GmASECIAEgBEYN6gEgAygCACIAIAQgAWtqIQUgASAAa0EFaiEGAkADQCABLQAAIABBwdQAai0AAEcNFyAAQQVGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyADIAU2AgAM6wELIANBADYCACAGQQFqIQFBGAwXCyABIARGBEBBpQEhAgzqAQsCQAJAIAEtAABByQBrDgcAGRkZGRkBGQsgAUEBaiEBQYsBIQIM0QELIAFBAWohAUGMASECDNABC0GkASECIAEgBEYN6AEgAygCACIAIAQgAWtqIQUgASAAa0EBaiEGAkADQCABLQAAIABBptUAai0AAEcNFSAAQQFGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyADIAU2AgAM6QELIANBADYCACAGQQFqIQFBCQwVC0GjASECIAEgBEYN5wEgAygCACIAIAQgAWtqIQUgASAAa0EBaiEGAkADQCABLQAAIABBpNUAai0AAEcNFCAAQQFGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyADIAU2AgAM6AELIANBADYCACAGQQFqIQFBHwwUC0GiASECIAEgBEYN5gEgAygCACIAIAQgAWtqIQUgASAAa0ECaiEGAkADQCABLQAAIABBvtQAai0AAEcNEyAAQQJGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyADIAU2AgAM5wELIANBADYCACAGQQFqIQFBAgwTC0GhASECIAEgBEYN5QEgAygCACIAIAQgAWtqIQUgASAAa0EBaiEGA0AgAS0AACAAQbzUAGotAABHDREgAEEBRg0CIABBAWohACAEIAFBAWoiAUcNAAsgAyAFNgIADOUBCyABIARGBEBBoAEhAgzlAQtBASABLQAAQd8ARw0RGiABQQFqIQFBhwEhAgzLAQsgA0EANgIAIAZBAWohAUGIASECDMoBC0GfASECIAEgBEYN4gEgAygCACIAIAQgAWtqIQUgASAAa0EIaiEGAkADQCABLQAAIABBhNUAai0AAEcNDyAAQQhGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyADIAU2AgAM4wELIANBADYCACAGQQFqIQFBKQwPC0GeASECIAEgBEYN4QEgAygCACIAIAQgAWtqIQUgASAAa0EDaiEGAkADQCABLQAAIABBuNQAai0AAEcNDiAAQQNGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyADIAU2AgAM4gELIANBADYCACAGQQFqIQFBLQwOCyABIARGBEBBnQEhAgzhAQsgAS0AAEHFAEcNDiABQQFqIQFBhAEhAgzHAQsgASAERgRAQZwBIQIM4AELAkACQCABLQAAQcwAaw4IAA8PDw8PDwEPCyABQQFqIQFBggEhAgzHAQsgAUEBaiEBQYMBIQIMxgELQZsBIQIgASAERg3eASADKAIAIgAgBCABa2ohBSABIABrQQRqIQYCQANAIAEtAAAgAEGz1ABqLQAARw0LIABBBEYNASAAQQFqIQAgBCABQQFqIgFHDQALIAMgBTYCAAzfAQsgA0EANgIAIAZBAWohAUEjDAsLQZoBIQIgASAERg3dASADKAIAIgAgBCABa2ohBSABIABrQQJqIQYCQANAIAEtAAAgAEGw1ABqLQAARw0KIABBAkYNASAAQQFqIQAgBCABQQFqIgFHDQALIAMgBTYCAAzeAQsgA0EANgIAIAZBAWohAUEADAoLIAEgBEYEQEGZASECDN0BCwJAAkAgAS0AAEHIAGsOCAAMDAwMDAwBDAsgAUEBaiEBQf0AIQIMxAELIAFBAWohAUGAASECDMMBCyABIARGBEBBmAEhAgzcAQsCQAJAIAEtAABBzgBrDgMACwELCyABQQFqIQFB/gAhAgzDAQsgAUEBaiEBQf8AIQIMwgELIAEgBEYEQEGXASECDNsBCyABLQAAQdkARw0IIAFBAWohAUEIDAcLQZYBIQIgASAERg3ZASADKAIAIgAgBCABa2ohBSABIABrQQNqIQYCQANAIAEtAAAgAEGs1ABqLQAARw0GIABBA0YNASAAQQFqIQAgBCABQQFqIgFHDQALIAMgBTYCAAzaAQsgA0EANgIAIAZBAWohAUEFDAYLQZUBIQIgASAERg3YASADKAIAIgAgBCABa2ohBSABIABrQQVqIQYCQANAIAEtAAAgAEGm1ABqLQAARw0FIABBBUYNASAAQQFqIQAgBCABQQFqIgFHDQALIAMgBTYCAAzZAQsgA0EANgIAIAZBAWohAUEWDAULQZQBIQIgASAERg3XASADKAIAIgAgBCABa2ohBSABIABrQQJqIQYCQANAIAEtAAAgAEGh1QBqLQAARw0EIABBAkYNASAAQQFqIQAgBCABQQFqIgFHDQALIAMgBTYCAAzYAQsgA0EANgIAIAZBAWohAUEQDAQLIAEgBEYEQEGTASECDNcBCwJAAkAgAS0AAEHDAGsODAAGBgYGBgYGBgYGAQYLIAFBAWohAUH5ACECDL4BCyABQQFqIQFB+gAhAgy9AQtBkgEhAiABIARGDdUBIAMoAgAiACAEIAFraiEFIAEgAGtBBWohBgJAA0AgAS0AACAAQaDUAGotAABHDQIgAEEFRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAyAFNgIADNYBCyADQQA2AgAgBkEBaiEBQSQMAgsgA0EANgIADAILIAEgBEYEQEGRASECDNQBCyABLQAAQcwARw0BIAFBAWohAUETCzoAKSADKAIEIQAgA0EANgIEIAMgACABEC4iAA0CDAELQQAhAiADQQA2AhwgAyABNgIUIANB/h82AhAgA0EGNgIMDNEBC0H4ACECDLcBCyADQZABNgIcIAMgATYCFCADIAA2AgxBACECDM8BC0EAIQACQCADKAI4IgJFDQAgAigCQCICRQ0AIAMgAhEAACEACyAARQ0AIABBFUYNASADQQA2AhwgAyABNgIUIANBgg82AhAgA0EgNgIMQQAhAgzOAQtB9wAhAgy0AQsgA0GPATYCHCADIAE2AhQgA0HsGzYCECADQRU2AgxBACECDMwBCyABIARGBEBBjwEhAgzMAQsCQCABLQAAQSBGBEAgAUEBaiEBDAELIANBADYCHCADIAE2AhQgA0GbHzYCECADQQY2AgxBACECDMwBC0ECIQIMsgELA0AgAS0AAEEgRw0CIAQgAUEBaiIBRw0AC0GOASECDMoBCyABIARGBEBBjQEhAgzKAQsCQCABLQAAQQlrDgRKAABKAAtB9QAhAgywAQsgAy0AKUEFRgRAQfYAIQIMsAELQfQAIQIMrwELIAEgBEYEQEGMASECDMgBCyADQRA2AgggAyABNgIEDAoLIAEgBEYEQEGLASECDMcBCwJAIAEtAABBCWsOBEcAAEcAC0HzACECDK0BCyABIARHBEAgA0EQNgIIIAMgATYCBEHxACECDK0BC0GKASECDMUBCwJAIAEgBEcEQANAIAEtAABBoNAAai0AACIAQQNHBEACQCAAQQFrDgJJAAQLQfAAIQIMrwELIAQgAUEBaiIBRw0AC0GIASECDMYBC0GIASECDMUBCyADQQA2AhwgAyABNgIUIANB2yA2AhAgA0EHNgIMQQAhAgzEAQsgASAERgRAQYkBIQIMxAELAkACQAJAIAEtAABBoNIAai0AAEEBaw4DRgIAAQtB8gAhAgysAQsgA0EANgIcIAMgATYCFCADQbQSNgIQIANBBzYCDEEAIQIMxAELQeoAIQIMqgELIAEgBEcEQCABQQFqIQFB7wAhAgyqAQtBhwEhAgzCAQsgBCABIgBGBEBBhgEhAgzCAQsgAC0AACIBQS9GBEAgAEEBaiEBQe4AIQIMqQELIAFBCWsiAkEXSw0BIAAhAUEBIAJ0QZuAgARxDUEMAQsgBCABIgBGBEBBhQEhAgzBAQsgAC0AAEEvRw0AIABBAWohAQwDC0EAIQIgA0EANgIcIAMgADYCFCADQdsgNgIQIANBBzYCDAy/AQsCQAJAAkACQAJAA0AgAS0AAEGgzgBqLQAAIgBBBUcEQAJAAkAgAEEBaw4IRwUGBwgABAEIC0HrACECDK0BCyABQQFqIQFB7QAhAgysAQsgBCABQQFqIgFHDQALQYQBIQIMwwELIAFBAWoMFAsgAygCBCEAIANBADYCBCADIAAgARAsIgBFDR4gA0HbADYCHCADIAE2AhQgAyAANgIMQQAhAgzBAQsgAygCBCEAIANBADYCBCADIAAgARAsIgBFDR4gA0HdADYCHCADIAE2AhQgAyAANgIMQQAhAgzAAQsgAygCBCEAIANBADYCBCADIAAgARAsIgBFDR4gA0H6ADYCHCADIAE2AhQgAyAANgIMQQAhAgy/AQsgA0EANgIcIAMgATYCFCADQfkPNgIQIANBBzYCDEEAIQIMvgELIAEgBEYEQEGDASECDL4BCwJAIAEtAABBoM4Aai0AAEEBaw4IPgQFBgAIAgMHCyABQQFqIQELQQMhAgyjAQsgAUEBagwNC0EAIQIgA0EANgIcIANB0RI2AhAgA0EHNgIMIAMgAUEBajYCFAy6AQsgAygCBCEAIANBADYCBCADIAAgARAsIgBFDRYgA0HbADYCHCADIAE2AhQgAyAANgIMQQAhAgy5AQsgAygCBCEAIANBADYCBCADIAAgARAsIgBFDRYgA0HdADYCHCADIAE2AhQgAyAANgIMQQAhAgy4AQsgAygCBCEAIANBADYCBCADIAAgARAsIgBFDRYgA0H6ADYCHCADIAE2AhQgAyAANgIMQQAhAgy3AQsgA0EANgIcIAMgATYCFCADQfkPNgIQIANBBzYCDEEAIQIMtgELQewAIQIMnAELIAEgBEYEQEGCASECDLUBCyABQQFqDAILIAEgBEYEQEGBASECDLQBCyABQQFqDAELIAEgBEYNASABQQFqCyEBQQQhAgyYAQtBgAEhAgywAQsDQCABLQAAQaDMAGotAAAiAEECRwRAIABBAUcEQEHpACECDJkBCwwxCyAEIAFBAWoiAUcNAAtB/wAhAgyvAQsgASAERgRAQf4AIQIMrwELAkAgAS0AAEEJaw43LwMGLwQGBgYGBgYGBgYGBgYGBgYGBgYFBgYCBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGAAYLIAFBAWoLIQFBBSECDJQBCyABQQFqDAYLIAMoAgQhACADQQA2AgQgAyAAIAEQLCIARQ0IIANB2wA2AhwgAyABNgIUIAMgADYCDEEAIQIMqwELIAMoAgQhACADQQA2AgQgAyAAIAEQLCIARQ0IIANB3QA2AhwgAyABNgIUIAMgADYCDEEAIQIMqgELIAMoAgQhACADQQA2AgQgAyAAIAEQLCIARQ0IIANB+gA2AhwgAyABNgIUIAMgADYCDEEAIQIMqQELIANBADYCHCADIAE2AhQgA0GNFDYCECADQQc2AgxBACECDKgBCwJAAkACQAJAA0AgAS0AAEGgygBqLQAAIgBBBUcEQAJAIABBAWsOBi4DBAUGAAYLQegAIQIMlAELIAQgAUEBaiIBRw0AC0H9ACECDKsBCyADKAIEIQAgA0EANgIEIAMgACABECwiAEUNByADQdsANgIcIAMgATYCFCADIAA2AgxBACECDKoBCyADKAIEIQAgA0EANgIEIAMgACABECwiAEUNByADQd0ANgIcIAMgATYCFCADIAA2AgxBACECDKkBCyADKAIEIQAgA0EANgIEIAMgACABECwiAEUNByADQfoANgIcIAMgATYCFCADIAA2AgxBACECDKgBCyADQQA2AhwgAyABNgIUIANB5Ag2AhAgA0EHNgIMQQAhAgynAQsgASAERg0BIAFBAWoLIQFBBiECDIwBC0H8ACECDKQBCwJAAkACQAJAA0AgAS0AAEGgyABqLQAAIgBBBUcEQCAAQQFrDgQpAgMEBQsgBCABQQFqIgFHDQALQfsAIQIMpwELIAMoAgQhACADQQA2AgQgAyAAIAEQLCIARQ0DIANB2wA2AhwgAyABNgIUIAMgADYCDEEAIQIMpgELIAMoAgQhACADQQA2AgQgAyAAIAEQLCIARQ0DIANB3QA2AhwgAyABNgIUIAMgADYCDEEAIQIMpQELIAMoAgQhACADQQA2AgQgAyAAIAEQLCIARQ0DIANB+gA2AhwgAyABNgIUIAMgADYCDEEAIQIMpAELIANBADYCHCADIAE2AhQgA0G8CjYCECADQQc2AgxBACECDKMBC0HPACECDIkBC0HRACECDIgBC0HnACECDIcBCyABIARGBEBB+gAhAgygAQsCQCABLQAAQQlrDgQgAAAgAAsgAUEBaiEBQeYAIQIMhgELIAEgBEYEQEH5ACECDJ8BCwJAIAEtAABBCWsOBB8AAB8AC0EAIQACQCADKAI4IgJFDQAgAigCOCICRQ0AIAMgAhEAACEACyAARQRAQeIBIQIMhgELIABBFUcEQCADQQA2AhwgAyABNgIUIANByQ02AhAgA0EaNgIMQQAhAgyfAQsgA0H4ADYCHCADIAE2AhQgA0HqGjYCECADQRU2AgxBACECDJ4BCyABIARHBEAgA0ENNgIIIAMgATYCBEHkACECDIUBC0H3ACECDJ0BCyABIARGBEBB9gAhAgydAQsCQAJAAkAgAS0AAEHIAGsOCwABCwsLCwsLCwsCCwsgAUEBaiEBQd0AIQIMhQELIAFBAWohAUHgACECDIQBCyABQQFqIQFB4wAhAgyDAQtB9QAhAiABIARGDZsBIAMoAgAiACAEIAFraiEFIAEgAGtBAmohBgJAA0AgAS0AACAAQbXVAGotAABHDQggAEECRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAyAFNgIADJwBCyADKAIEIQAgA0IANwMAIAMgACAGQQFqIgEQKyIABEAgA0H0ADYCHCADIAE2AhQgAyAANgIMQQAhAgycAQtB4gAhAgyCAQtBACEAAkAgAygCOCICRQ0AIAIoAjQiAkUNACADIAIRAAAhAAsCQCAABEAgAEEVRg0BIANBADYCHCADIAE2AhQgA0HqDTYCECADQSY2AgxBACECDJwBC0HhACECDIIBCyADQfMANgIcIAMgATYCFCADQYAbNgIQIANBFTYCDEEAIQIMmgELIAMtACkiAEEja0ELSQ0JAkAgAEEGSw0AQQEgAHRBygBxRQ0ADAoLQQAhAiADQQA2AhwgAyABNgIUIANB7Qk2AhAgA0EINgIMDJkBC0HyACECIAEgBEYNmAEgAygCACIAIAQgAWtqIQUgASAAa0EBaiEGAkADQCABLQAAIABBs9UAai0AAEcNBSAAQQFGDQEgAEEBaiEAIAQgAUEBaiIBRw0ACyADIAU2AgAMmQELIAMoAgQhACADQgA3AwAgAyAAIAZBAWoiARArIgAEQCADQfEANgIcIAMgATYCFCADIAA2AgxBACECDJkBC0HfACECDH8LQQAhAAJAIAMoAjgiAkUNACACKAI0IgJFDQAgAyACEQAAIQALAkAgAARAIABBFUYNASADQQA2AhwgAyABNgIUIANB6g02AhAgA0EmNgIMQQAhAgyZAQtB3gAhAgx/CyADQfAANgIcIAMgATYCFCADQYAbNgIQIANBFTYCDEEAIQIMlwELIAMtAClBIUYNBiADQQA2AhwgAyABNgIUIANBkQo2AhAgA0EINgIMQQAhAgyWAQtB7wAhAiABIARGDZUBIAMoAgAiACAEIAFraiEFIAEgAGtBAmohBgJAA0AgAS0AACAAQbDVAGotAABHDQIgAEECRg0BIABBAWohACAEIAFBAWoiAUcNAAsgAyAFNgIADJYBCyADKAIEIQAgA0IANwMAIAMgACAGQQFqIgEQKyIARQ0CIANB7QA2AhwgAyABNgIUIAMgADYCDEEAIQIMlQELIANBADYCAAsgAygCBCEAIANBADYCBCADIAAgARArIgBFDYABIANB7gA2AhwgAyABNgIUIAMgADYCDEEAIQIMkwELQdwAIQIMeQtBACEAAkAgAygCOCICRQ0AIAIoAjQiAkUNACADIAIRAAAhAAsCQCAABEAgAEEVRg0BIANBADYCHCADIAE2AhQgA0HqDTYCECADQSY2AgxBACECDJMBC0HbACECDHkLIANB7AA2AhwgAyABNgIUIANBgBs2AhAgA0EVNgIMQQAhAgyRAQsgAy0AKSIAQSNJDQAgAEEuRg0AIANBADYCHCADIAE2AhQgA0HJCTYCECADQQg2AgxBACECDJABC0HaACECDHYLIAEgBEYEQEHrACECDI8BCwJAIAEtAABBL0YEQCABQQFqIQEMAQsgA0EANgIcIAMgATYCFCADQbI4NgIQIANBCDYCDEEAIQIMjwELQdkAIQIMdQsgASAERwRAIANBDjYCCCADIAE2AgRB2AAhAgx1C0HqACECDI0BCyABIARGBEBB6QAhAgyNAQsgAS0AAEEwayIAQf8BcUEKSQRAIAMgADoAKiABQQFqIQFB1wAhAgx0CyADKAIEIQAgA0EANgIEIAMgACABEC8iAEUNeiADQegANgIcIAMgATYCFCADIAA2AgxBACECDIwBCyABIARGBEBB5wAhAgyMAQsCQCABLQAAQS5GBEAgAUEBaiEBDAELIAMoAgQhACADQQA2AgQgAyAAIAEQLyIARQ17IANB5gA2AhwgAyABNgIUIAMgADYCDEEAIQIMjAELQdYAIQIMcgsgASAERgRAQeUAIQIMiwELQQAhAEEBIQVBASEHQQAhAgJAAkACQAJAAkACfwJAAkACQAJAAkACQAJAIAEtAABBMGsOCgoJAAECAwQFBggLC0ECDAYLQQMMBQtBBAwEC0EFDAMLQQYMAgtBBwwBC0EICyECQQAhBUEAIQcMAgtBCSECQQEhAEEAIQVBACEHDAELQQAhBUEBIQILIAMgAjoAKyABQQFqIQECQAJAIAMtAC5BEHENAAJAAkACQCADLQAqDgMBAAIECyAHRQ0DDAILIAANAQwCCyAFRQ0BCyADKAIEIQAgA0EANgIEIAMgACABEC8iAEUNAiADQeIANgIcIAMgATYCFCADIAA2AgxBACECDI0BCyADKAIEIQAgA0EANgIEIAMgACABEC8iAEUNfSADQeMANgIcIAMgATYCFCADIAA2AgxBACECDIwBCyADKAIEIQAgA0EANgIEIAMgACABEC8iAEUNeyADQeQANgIcIAMgATYCFCADIAA2AgwMiwELQdQAIQIMcQsgAy0AKUEiRg2GAUHTACECDHALQQAhAAJAIAMoAjgiAkUNACACKAJEIgJFDQAgAyACEQAAIQALIABFBEBB1QAhAgxwCyAAQRVHBEAgA0EANgIcIAMgATYCFCADQaQNNgIQIANBITYCDEEAIQIMiQELIANB4QA2AhwgAyABNgIUIANB0Bo2AhAgA0EVNgIMQQAhAgyIAQsgASAERgRAQeAAIQIMiAELAkACQAJAAkACQCABLQAAQQprDgQBBAQABAsgAUEBaiEBDAELIAFBAWohASADQS9qLQAAQQFxRQ0BC0HSACECDHALIANBADYCHCADIAE2AhQgA0G2ETYCECADQQk2AgxBACECDIgBCyADQQA2AhwgAyABNgIUIANBthE2AhAgA0EJNgIMQQAhAgyHAQsgASAERgRAQd8AIQIMhwELIAEtAABBCkYEQCABQQFqIQEMCQsgAy0ALkHAAHENCCADQQA2AhwgAyABNgIUIANBthE2AhAgA0ECNgIMQQAhAgyGAQsgASAERgRAQd0AIQIMhgELIAEtAAAiAkENRgRAIAFBAWohAUHQACECDG0LIAEhACACQQlrDgQFAQEFAQsgBCABIgBGBEBB3AAhAgyFAQsgAC0AAEEKRw0AIABBAWoMAgtBACECIANBADYCHCADIAA2AhQgA0HKLTYCECADQQc2AgwMgwELIAEgBEYEQEHbACECDIMBCwJAIAEtAABBCWsOBAMAAAMACyABQQFqCyEBQc4AIQIMaAsgASAERgRAQdoAIQIMgQELIAEtAABBCWsOBAABAQABC0EAIQIgA0EANgIcIANBmhI2AhAgA0EHNgIMIAMgAUEBajYCFAx/CyADQYASOwEqQQAhAAJAIAMoAjgiAkUNACACKAI4IgJFDQAgAyACEQAAIQALIABFDQAgAEEVRw0BIANB2QA2AhwgAyABNgIUIANB6ho2AhAgA0EVNgIMQQAhAgx+C0HNACECDGQLIANBADYCHCADIAE2AhQgA0HJDTYCECADQRo2AgxBACECDHwLIAEgBEYEQEHZACECDHwLIAEtAABBIEcNPSABQQFqIQEgAy0ALkEBcQ09IANBADYCHCADIAE2AhQgA0HCHDYCECADQR42AgxBACECDHsLIAEgBEYEQEHYACECDHsLAkACQAJAAkACQCABLQAAIgBBCmsOBAIDAwABCyABQQFqIQFBLCECDGULIABBOkcNASADQQA2AhwgAyABNgIUIANB5xE2AhAgA0EKNgIMQQAhAgx9CyABQQFqIQEgA0Evai0AAEEBcUUNcyADLQAyQYABcUUEQCADQTJqIQIgAxA1QQAhAAJAIAMoAjgiBkUNACAGKAIoIgZFDQAgAyAGEQAAIQALAkACQCAADhZNTEsBAQEBAQEBAQEBAQEBAQEBAQEAAQsgA0EpNgIcIAMgATYCFCADQawZNgIQIANBFTYCDEEAIQIMfgsgA0EANgIcIAMgATYCFCADQeULNgIQIANBETYCDEEAIQIMfQtBACEAAkAgAygCOCICRQ0AIAIoAlwiAkUNACADIAIRAAAhAAsgAEUNWSAAQRVHDQEgA0EFNgIcIAMgATYCFCADQZsbNgIQIANBFTYCDEEAIQIMfAtBywAhAgxiC0EAIQIgA0EANgIcIAMgATYCFCADQZAONgIQIANBFDYCDAx6CyADIAMvATJBgAFyOwEyDDsLIAEgBEcEQCADQRE2AgggAyABNgIEQcoAIQIMYAtB1wAhAgx4CyABIARGBEBB1gAhAgx4CwJAAkACQAJAIAEtAAAiAEEgciAAIABBwQBrQf8BcUEaSRtB/wFxQeMAaw4TAEBAQEBAQEBAQEBAQAFAQEACA0ALIAFBAWohAUHGACECDGELIAFBAWohAUHHACECDGALIAFBAWohAUHIACECDF8LIAFBAWohAUHJACECDF4LQdUAIQIgBCABIgBGDXYgBCABayADKAIAIgFqIQYgACABa0EFaiEHA0AgAUGQyABqLQAAIAAtAAAiBUEgciAFIAVBwQBrQf8BcUEaSRtB/wFxRw0IQQQgAUEFRg0KGiABQQFqIQEgBCAAQQFqIgBHDQALIAMgBjYCAAx2C0HUACECIAQgASIARg11IAQgAWsgAygCACIBaiEGIAAgAWtBD2ohBwNAIAFBgMgAai0AACAALQAAIgVBIHIgBSAFQcEAa0H/AXFBGkkbQf8BcUcNB0EDIAFBD0YNCRogAUEBaiEBIAQgAEEBaiIARw0ACyADIAY2AgAMdQtB0wAhAiAEIAEiAEYNdCAEIAFrIAMoAgAiAWohBiAAIAFrQQ5qIQcDQCABQeLHAGotAAAgAC0AACIFQSByIAUgBUHBAGtB/wFxQRpJG0H/AXFHDQYgAUEORg0HIAFBAWohASAEIABBAWoiAEcNAAsgAyAGNgIADHQLQdIAIQIgBCABIgBGDXMgBCABayADKAIAIgFqIQUgACABa0EBaiEGA0AgAUHgxwBqLQAAIAAtAAAiB0EgciAHIAdBwQBrQf8BcUEaSRtB/wFxRw0FIAFBAUYNAiABQQFqIQEgBCAAQQFqIgBHDQALIAMgBTYCAAxzCyABIARGBEBB0QAhAgxzCwJAAkAgAS0AACIAQSByIAAgAEHBAGtB/wFxQRpJG0H/AXFB7gBrDgcAOTk5OTkBOQsgAUEBaiEBQcMAIQIMWgsgAUEBaiEBQcQAIQIMWQsgA0EANgIAIAZBAWohAUHFACECDFgLQdAAIQIgBCABIgBGDXAgBCABayADKAIAIgFqIQYgACABa0EJaiEHA0AgAUHWxwBqLQAAIAAtAAAiBUEgciAFIAVBwQBrQf8BcUEaSRtB/wFxRw0CQQIgAUEJRg0EGiABQQFqIQEgBCAAQQFqIgBHDQALIAMgBjYCAAxwC0HPACECIAQgASIARg1vIAQgAWsgAygCACIBaiEGIAAgAWtBBWohBwNAIAFB0McAai0AACAALQAAIgVBIHIgBSAFQcEAa0H/AXFBGkkbQf8BcUcNASABQQVGDQIgAUEBaiEBIAQgAEEBaiIARw0ACyADIAY2AgAMbwsgACEBIANBADYCAAwzC0EBCzoALCADQQA2AgAgB0EBaiEBC0EtIQIMUgsCQANAIAEtAABB0MUAai0AAEEBRw0BIAQgAUEBaiIBRw0AC0HNACECDGsLQcIAIQIMUQsgASAERgRAQcwAIQIMagsgAS0AAEE6RgRAIAMoAgQhACADQQA2AgQgAyAAIAEQMCIARQ0zIANBywA2AhwgAyAANgIMIAMgAUEBajYCFEEAIQIMagsgA0EANgIcIAMgATYCFCADQecRNgIQIANBCjYCDEEAIQIMaQsCQAJAIAMtACxBAmsOAgABJwsgA0Ezai0AAEECcUUNJiADLQAuQQJxDSYgA0EANgIcIAMgATYCFCADQaYUNgIQIANBCzYCDEEAIQIMaQsgAy0AMkEgcUUNJSADLQAuQQJxDSUgA0EANgIcIAMgATYCFCADQb0TNgIQIANBDzYCDEEAIQIMaAtBACEAAkAgAygCOCICRQ0AIAIoAkgiAkUNACADIAIRAAAhAAsgAEUEQEHBACECDE8LIABBFUcEQCADQQA2AhwgAyABNgIUIANBpg82AhAgA0EcNgIMQQAhAgxoCyADQcoANgIcIAMgATYCFCADQYUcNgIQIANBFTYCDEEAIQIMZwsgASAERwRAA0AgAS0AAEHAwQBqLQAAQQFHDRcgBCABQQFqIgFHDQALQcQAIQIMZwtBxAAhAgxmCyABIARHBEADQAJAIAEtAAAiAEEgciAAIABBwQBrQf8BcUEaSRtB/wFxIgBBCUYNACAAQSBGDQACQAJAAkACQCAAQeMAaw4TAAMDAwMDAwMBAwMDAwMDAwMDAgMLIAFBAWohAUE2IQIMUgsgAUEBaiEBQTchAgxRCyABQQFqIQFBOCECDFALDBULIAQgAUEBaiIBRw0AC0E8IQIMZgtBPCECDGULIAEgBEYEQEHIACECDGULIANBEjYCCCADIAE2AgQCQAJAAkACQAJAIAMtACxBAWsOBBQAAQIJCyADLQAyQSBxDQNB4AEhAgxPCwJAIAMvATIiAEEIcUUNACADLQAoQQFHDQAgAy0ALkEIcUUNAgsgAyAAQff7A3FBgARyOwEyDAsLIAMgAy8BMkEQcjsBMgwECyADQQA2AgQgAyABIAEQMSIABEAgA0HBADYCHCADIAA2AgwgAyABQQFqNgIUQQAhAgxmCyABQQFqIQEMWAsgA0EANgIcIAMgATYCFCADQfQTNgIQIANBBDYCDEEAIQIMZAtBxwAhAiABIARGDWMgAygCACIAIAQgAWtqIQUgASAAa0EGaiEGAkADQCAAQcDFAGotAAAgAS0AAEEgckcNASAAQQZGDUogAEEBaiEAIAQgAUEBaiIBRw0ACyADIAU2AgAMZAsgA0EANgIADAULAkAgASAERwRAA0AgAS0AAEHAwwBqLQAAIgBBAUcEQCAAQQJHDQMgAUEBaiEBDAULIAQgAUEBaiIBRw0AC0HFACECDGQLQcUAIQIMYwsLIANBADoALAwBC0ELIQIMRwtBPyECDEYLAkACQANAIAEtAAAiAEEgRwRAAkAgAEEKaw4EAwUFAwALIABBLEYNAwwECyAEIAFBAWoiAUcNAAtBxgAhAgxgCyADQQg6ACwMDgsgAy0AKEEBRw0CIAMtAC5BCHENAiADKAIEIQAgA0EANgIEIAMgACABEDEiAARAIANBwgA2AhwgAyAANgIMIAMgAUEBajYCFEEAIQIMXwsgAUEBaiEBDFALQTshAgxECwJAA0AgAS0AACIAQSBHIABBCUdxDQEgBCABQQFqIgFHDQALQcMAIQIMXQsLQTwhAgxCCwJAAkAgASAERwRAA0AgAS0AACIAQSBHBEAgAEEKaw4EAwQEAwQLIAQgAUEBaiIBRw0AC0E/IQIMXQtBPyECDFwLIAMgAy8BMkEgcjsBMgwKCyADKAIEIQAgA0EANgIEIAMgACABEDEiAEUNTiADQT42AhwgAyABNgIUIAMgADYCDEEAIQIMWgsCQCABIARHBEADQCABLQAAQcDDAGotAAAiAEEBRwRAIABBAkYNAwwMCyAEIAFBAWoiAUcNAAtBNyECDFsLQTchAgxaCyABQQFqIQEMBAtBOyECIAQgASIARg1YIAQgAWsgAygCACIBaiEGIAAgAWtBBWohBwJAA0AgAUGQyABqLQAAIAAtAAAiBUEgciAFIAVBwQBrQf8BcUEaSRtB/wFxRw0BIAFBBUYEQEEHIQEMPwsgAUEBaiEBIAQgAEEBaiIARw0ACyADIAY2AgAMWQsgA0EANgIAIAAhAQwFC0E6IQIgBCABIgBGDVcgBCABayADKAIAIgFqIQYgACABa0EIaiEHAkADQCABQbTBAGotAAAgAC0AACIFQSByIAUgBUHBAGtB/wFxQRpJG0H/AXFHDQEgAUEIRgRAQQUhAQw+CyABQQFqIQEgBCAAQQFqIgBHDQALIAMgBjYCAAxYCyADQQA2AgAgACEBDAQLQTkhAiAEIAEiAEYNViAEIAFrIAMoAgAiAWohBiAAIAFrQQNqIQcCQANAIAFBsMEAai0AACAALQAAIgVBIHIgBSAFQcEAa0H/AXFBGkkbQf8BcUcNASABQQNGBEBBBiEBDD0LIAFBAWohASAEIABBAWoiAEcNAAsgAyAGNgIADFcLIANBADYCACAAIQEMAwsCQANAIAEtAAAiAEEgRwRAIABBCmsOBAcEBAcCCyAEIAFBAWoiAUcNAAtBOCECDFYLIABBLEcNASABQQFqIQBBASEBAkACQAJAAkACQCADLQAsQQVrDgQDAQIEAAsgACEBDAQLQQIhAQwBC0EEIQELIANBAToALCADIAMvATIgAXI7ATIgACEBDAELIAMgAy8BMkEIcjsBMiAAIQELQT4hAgw7CyADQQA6ACwLQTkhAgw5CyABIARGBEBBNiECDFILAkACQAJAAkACQCABLQAAQQprDgQAAgIBAgsgAygCBCEAIANBADYCBCADIAAgARAxIgBFDQIgA0EzNgIcIAMgATYCFCADIAA2AgxBACECDFULIAMoAgQhACADQQA2AgQgAyAAIAEQMSIARQRAIAFBAWohAQwGCyADQTI2AhwgAyAANgIMIAMgAUEBajYCFEEAIQIMVAsgAy0ALkEBcQRAQd8BIQIMOwsgAygCBCEAIANBADYCBCADIAAgARAxIgANAQxJC0E0IQIMOQsgA0E1NgIcIAMgATYCFCADIAA2AgxBACECDFELQTUhAgw3CyADQS9qLQAAQQFxDQAgA0EANgIcIAMgATYCFCADQesWNgIQIANBGTYCDEEAIQIMTwtBMyECDDULIAEgBEYEQEEyIQIMTgsCQCABLQAAQQpGBEAgAUEBaiEBDAELIANBADYCHCADIAE2AhQgA0GSFzYCECADQQM2AgxBACECDE4LQTIhAgw0CyABIARGBEBBMSECDE0LAkAgAS0AACIAQQlGDQAgAEEgRg0AQQEhAgJAIAMtACxBBWsOBAYEBQANCyADIAMvATJBCHI7ATIMDAsgAy0ALkEBcUUNASADLQAsQQhHDQAgA0EAOgAsC0E9IQIMMgsgA0EANgIcIAMgATYCFCADQcIWNgIQIANBCjYCDEEAIQIMSgtBAiECDAELQQQhAgsgA0EBOgAsIAMgAy8BMiACcjsBMgwGCyABIARGBEBBMCECDEcLIAEtAABBCkYEQCABQQFqIQEMAQsgAy0ALkEBcQ0AIANBADYCHCADIAE2AhQgA0HcKDYCECADQQI2AgxBACECDEYLQTAhAgwsCyABQQFqIQFBMSECDCsLIAEgBEYEQEEvIQIMRAsgAS0AACIAQQlHIABBIEdxRQRAIAFBAWohASADLQAuQQFxDQEgA0EANgIcIAMgATYCFCADQZcQNgIQIANBCjYCDEEAIQIMRAtBASECAkACQAJAAkACQAJAIAMtACxBAmsOBwUEBAMBAgAECyADIAMvATJBCHI7ATIMAwtBAiECDAELQQQhAgsgA0EBOgAsIAMgAy8BMiACcjsBMgtBLyECDCsLIANBADYCHCADIAE2AhQgA0GEEzYCECADQQs2AgxBACECDEMLQeEBIQIMKQsgASAERgRAQS4hAgxCCyADQQA2AgQgA0ESNgIIIAMgASABEDEiAA0BC0EuIQIMJwsgA0EtNgIcIAMgATYCFCADIAA2AgxBACECDD8LQQAhAAJAIAMoAjgiAkUNACACKAJMIgJFDQAgAyACEQAAIQALIABFDQAgAEEVRw0BIANB2AA2AhwgAyABNgIUIANBsxs2AhAgA0EVNgIMQQAhAgw+C0HMACECDCQLIANBADYCHCADIAE2AhQgA0GzDjYCECADQR02AgxBACECDDwLIAEgBEYEQEHOACECDDwLIAEtAAAiAEEgRg0CIABBOkYNAQsgA0EAOgAsQQkhAgwhCyADKAIEIQAgA0EANgIEIAMgACABEDAiAA0BDAILIAMtAC5BAXEEQEHeASECDCALIAMoAgQhACADQQA2AgQgAyAAIAEQMCIARQ0CIANBKjYCHCADIAA2AgwgAyABQQFqNgIUQQAhAgw4CyADQcsANgIcIAMgADYCDCADIAFBAWo2AhRBACECDDcLIAFBAWohAUHAACECDB0LIAFBAWohAQwsCyABIARGBEBBKyECDDULAkAgAS0AAEEKRgRAIAFBAWohAQwBCyADLQAuQcAAcUUNBgsgAy0AMkGAAXEEQEEAIQACQCADKAI4IgJFDQAgAigCXCICRQ0AIAMgAhEAACEACyAARQ0SIABBFUYEQCADQQU2AhwgAyABNgIUIANBmxs2AhAgA0EVNgIMQQAhAgw2CyADQQA2AhwgAyABNgIUIANBkA42AhAgA0EUNgIMQQAhAgw1CyADQTJqIQIgAxA1QQAhAAJAIAMoAjgiBkUNACAGKAIoIgZFDQAgAyAGEQAAIQALIAAOFgIBAAQEBAQEBAQEBAQEBAQEBAQEBAMECyADQQE6ADALIAIgAi8BAEHAAHI7AQALQSshAgwYCyADQSk2AhwgAyABNgIUIANBrBk2AhAgA0EVNgIMQQAhAgwwCyADQQA2AhwgAyABNgIUIANB5Qs2AhAgA0ERNgIMQQAhAgwvCyADQQA2AhwgAyABNgIUIANBpQs2AhAgA0ECNgIMQQAhAgwuC0EBIQcgAy8BMiIFQQhxRQRAIAMpAyBCAFIhBwsCQCADLQAwBEBBASEAIAMtAClBBUYNASAFQcAAcUUgB3FFDQELAkAgAy0AKCICQQJGBEBBASEAIAMvATQiBkHlAEYNAkEAIQAgBUHAAHENAiAGQeQARg0CIAZB5gBrQQJJDQIgBkHMAUYNAiAGQbACRg0CDAELQQAhACAFQcAAcQ0BC0ECIQAgBUEIcQ0AIAVBgARxBEACQCACQQFHDQAgAy0ALkEKcQ0AQQUhAAwCC0EEIQAMAQsgBUEgcUUEQCADEDZBAEdBAnQhAAwBC0EAQQMgAykDIFAbIQALIABBAWsOBQIABwEDBAtBESECDBMLIANBAToAMQwpC0EAIQICQCADKAI4IgBFDQAgACgCMCIARQ0AIAMgABEAACECCyACRQ0mIAJBFUYEQCADQQM2AhwgAyABNgIUIANB0hs2AhAgA0EVNgIMQQAhAgwrC0EAIQIgA0EANgIcIAMgATYCFCADQd0ONgIQIANBEjYCDAwqCyADQQA2AhwgAyABNgIUIANB+SA2AhAgA0EPNgIMQQAhAgwpC0EAIQACQCADKAI4IgJFDQAgAigCMCICRQ0AIAMgAhEAACEACyAADQELQQ4hAgwOCyAAQRVGBEAgA0ECNgIcIAMgATYCFCADQdIbNgIQIANBFTYCDEEAIQIMJwsgA0EANgIcIAMgATYCFCADQd0ONgIQIANBEjYCDEEAIQIMJgtBKiECDAwLIAEgBEcEQCADQQk2AgggAyABNgIEQSkhAgwMC0EmIQIMJAsgAyADKQMgIgwgBCABa60iCn0iC0IAIAsgDFgbNwMgIAogDFQEQEElIQIMJAsgAygCBCEAIANBADYCBCADIAAgASAMp2oiARAyIgBFDQAgA0EFNgIcIAMgATYCFCADIAA2AgxBACECDCMLQQ8hAgwJC0IAIQoCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAS0AAEEwaw43FxYAAQIDBAUGBxQUFBQUFBQICQoLDA0UFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFA4PEBESExQLQgIhCgwWC0IDIQoMFQtCBCEKDBQLQgUhCgwTC0IGIQoMEgtCByEKDBELQgghCgwQC0IJIQoMDwtCCiEKDA4LQgshCgwNC0IMIQoMDAtCDSEKDAsLQg4hCgwKC0IPIQoMCQtCCiEKDAgLQgshCgwHC0IMIQoMBgtCDSEKDAULQg4hCgwEC0IPIQoMAwsgA0EANgIcIAMgATYCFCADQZ8VNgIQIANBDDYCDEEAIQIMIQsgASAERgRAQSIhAgwhC0IAIQoCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEtAABBMGsONxUUAAECAwQFBgcWFhYWFhYWCAkKCwwNFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYODxAREhMWC0ICIQoMFAtCAyEKDBMLQgQhCgwSC0IFIQoMEQtCBiEKDBALQgchCgwPC0IIIQoMDgtCCSEKDA0LQgohCgwMC0ILIQoMCwtCDCEKDAoLQg0hCgwJC0IOIQoMCAtCDyEKDAcLQgohCgwGC0ILIQoMBQtCDCEKDAQLQg0hCgwDC0IOIQoMAgtCDyEKDAELQgEhCgsgAUEBaiEBIAMpAyAiC0L//////////w9YBEAgAyALQgSGIAqENwMgDAILIANBADYCHCADIAE2AhQgA0G1CTYCECADQQw2AgxBACECDB4LQSchAgwEC0EoIQIMAwsgAyABOgAsIANBADYCACAHQQFqIQFBDCECDAILIANBADYCACAGQQFqIQFBCiECDAELIAFBAWohAUEIIQIMAAsAC0EAIQIgA0EANgIcIAMgATYCFCADQbI4NgIQIANBCDYCDAwXC0EAIQIgA0EANgIcIAMgATYCFCADQYMRNgIQIANBCTYCDAwWC0EAIQIgA0EANgIcIAMgATYCFCADQd8KNgIQIANBCTYCDAwVC0EAIQIgA0EANgIcIAMgATYCFCADQe0QNgIQIANBCTYCDAwUC0EAIQIgA0EANgIcIAMgATYCFCADQdIRNgIQIANBCTYCDAwTC0EAIQIgA0EANgIcIAMgATYCFCADQbI4NgIQIANBCDYCDAwSC0EAIQIgA0EANgIcIAMgATYCFCADQYMRNgIQIANBCTYCDAwRC0EAIQIgA0EANgIcIAMgATYCFCADQd8KNgIQIANBCTYCDAwQC0EAIQIgA0EANgIcIAMgATYCFCADQe0QNgIQIANBCTYCDAwPC0EAIQIgA0EANgIcIAMgATYCFCADQdIRNgIQIANBCTYCDAwOC0EAIQIgA0EANgIcIAMgATYCFCADQbkXNgIQIANBDzYCDAwNC0EAIQIgA0EANgIcIAMgATYCFCADQbkXNgIQIANBDzYCDAwMC0EAIQIgA0EANgIcIAMgATYCFCADQZkTNgIQIANBCzYCDAwLC0EAIQIgA0EANgIcIAMgATYCFCADQZ0JNgIQIANBCzYCDAwKC0EAIQIgA0EANgIcIAMgATYCFCADQZcQNgIQIANBCjYCDAwJC0EAIQIgA0EANgIcIAMgATYCFCADQbEQNgIQIANBCjYCDAwIC0EAIQIgA0EANgIcIAMgATYCFCADQbsdNgIQIANBAjYCDAwHC0EAIQIgA0EANgIcIAMgATYCFCADQZYWNgIQIANBAjYCDAwGC0EAIQIgA0EANgIcIAMgATYCFCADQfkYNgIQIANBAjYCDAwFC0EAIQIgA0EANgIcIAMgATYCFCADQcQYNgIQIANBAjYCDAwECyADQQI2AhwgAyABNgIUIANBqR42AhAgA0EWNgIMQQAhAgwDC0HeACECIAEgBEYNAiAJQQhqIQcgAygCACEFAkACQCABIARHBEAgBUGWyABqIQggBCAFaiABayEGIAVBf3NBCmoiBSABaiEAA0AgAS0AACAILQAARwRAQQIhCAwDCyAFRQRAQQAhCCAAIQEMAwsgBUEBayEFIAhBAWohCCAEIAFBAWoiAUcNAAsgBiEFIAQhAQsgB0EBNgIAIAMgBTYCAAwBCyADQQA2AgAgByAINgIACyAHIAE2AgQgCSgCDCEAAkACQCAJKAIIQQFrDgIEAQALIANBADYCHCADQcIeNgIQIANBFzYCDCADIABBAWo2AhRBACECDAMLIANBADYCHCADIAA2AhQgA0HXHjYCECADQQk2AgxBACECDAILIAEgBEYEQEEoIQIMAgsgA0EJNgIIIAMgATYCBEEnIQIMAQsgASAERgRAQQEhAgwBCwNAAkACQAJAIAEtAABBCmsOBAABAQABCyABQQFqIQEMAQsgAUEBaiEBIAMtAC5BIHENAEEAIQIgA0EANgIcIAMgATYCFCADQaEhNgIQIANBBTYCDAwCC0EBIQIgASAERw0ACwsgCUEQaiQAIAJFBEAgAygCDCEADAELIAMgAjYCHEEAIQAgAygCBCIBRQ0AIAMgASAEIAMoAggRAQAiAUUNACADIAQ2AhQgAyABNgIMIAEhAAsgAAu+AgECfyAAQQA6AAAgAEHkAGoiAUEBa0EAOgAAIABBADoAAiAAQQA6AAEgAUEDa0EAOgAAIAFBAmtBADoAACAAQQA6AAMgAUEEa0EAOgAAQQAgAGtBA3EiASAAaiIAQQA2AgBB5AAgAWtBfHEiAiAAaiIBQQRrQQA2AgACQCACQQlJDQAgAEEANgIIIABBADYCBCABQQhrQQA2AgAgAUEMa0EANgIAIAJBGUkNACAAQQA2AhggAEEANgIUIABBADYCECAAQQA2AgwgAUEQa0EANgIAIAFBFGtBADYCACABQRhrQQA2AgAgAUEca0EANgIAIAIgAEEEcUEYciICayIBQSBJDQAgACACaiEAA0AgAEIANwMYIABCADcDECAAQgA3AwggAEIANwMAIABBIGohACABQSBrIgFBH0sNAAsLC1YBAX8CQCAAKAIMDQACQAJAAkACQCAALQAxDgMBAAMCCyAAKAI4IgFFDQAgASgCMCIBRQ0AIAAgAREAACIBDQMLQQAPCwALIABByhk2AhBBDiEBCyABCxoAIAAoAgxFBEAgAEHeHzYCECAAQRU2AgwLCxQAIAAoAgxBFUYEQCAAQQA2AgwLCxQAIAAoAgxBFkYEQCAAQQA2AgwLCwcAIAAoAgwLBwAgACgCEAsJACAAIAE2AhALBwAgACgCFAsrAAJAIABBJ08NAEL//////wkgAK2IQgGDUA0AIABBAnRB0DhqKAIADwsACxcAIABBL08EQAALIABBAnRB7DlqKAIAC78JAQF/QfQtIQECQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAAQeQAaw70A2NiAAFhYWFhYWECAwQFYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYQYHCAkKCwwNDg9hYWFhYRBhYWFhYWFhYWFhYRFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWESExQVFhcYGRobYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYRwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1NmE3ODk6YWFhYWFhYWE7YWFhPGFhYWE9Pj9hYWFhYWFhYUBhYUFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFCQ0RFRkdISUpLTE1OT1BRUlNhYWFhYWFhYVRVVldYWVpbYVxdYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhXmFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYV9gYQtB6iwPC0GYJg8LQe0xDwtBoDcPC0HJKQ8LQbQpDwtBli0PC0HrKw8LQaI1DwtB2zQPC0HgKQ8LQeMkDwtB1SQPC0HuJA8LQeYlDwtByjQPC0HQNw8LQao1DwtB9SwPC0H2Jg8LQYIiDwtB8jMPC0G+KA8LQec3DwtBzSEPC0HAIQ8LQbglDwtByyUPC0GWJA8LQY80DwtBzTUPC0HdKg8LQe4zDwtBnDQPC0GeMQ8LQfQ1DwtB5SIPC0GvJQ8LQZkxDwtBsjYPC0H5Ng8LQcQyDwtB3SwPC0GCMQ8LQcExDwtBjTcPC0HJJA8LQew2DwtB5yoPC0HIIw8LQeIhDwtByTcPC0GlIg8LQZQiDwtB2zYPC0HeNQ8LQYYmDwtBvCsPC0GLMg8LQaAjDwtB9jAPC0GALA8LQYkrDwtBpCYPC0HyIw8LQYEoDwtBqzIPC0HrJw8LQcI2DwtBoiQPC0HPKg8LQdwjDwtBhycPC0HkNA8LQbciDwtBrTEPC0HVIg8LQa80DwtB3iYPC0HWMg8LQfQ0DwtBgTgPC0H0Nw8LQZI2DwtBnScPC0GCKQ8LQY0jDwtB1zEPC0G9NQ8LQbQ3DwtB2DAPC0G2Jw8LQZo4DwtBpyoPC0HEJw8LQa4jDwtB9SIPCwALQcomIQELIAELFwAgACAALwEuQf7/A3EgAUEAR3I7AS4LGgAgACAALwEuQf3/A3EgAUEAR0EBdHI7AS4LGgAgACAALwEuQfv/A3EgAUEAR0ECdHI7AS4LGgAgACAALwEuQff/A3EgAUEAR0EDdHI7AS4LGgAgACAALwEuQe//A3EgAUEAR0EEdHI7AS4LGgAgACAALwEuQd//A3EgAUEAR0EFdHI7AS4LGgAgACAALwEuQb//A3EgAUEAR0EGdHI7AS4LGgAgACAALwEuQf/+A3EgAUEAR0EHdHI7AS4LGgAgACAALwEuQf/9A3EgAUEAR0EIdHI7AS4LGgAgACAALwEuQf/7A3EgAUEAR0EJdHI7AS4LPgECfwJAIAAoAjgiA0UNACADKAIEIgNFDQAgACABIAIgAWsgAxEBACIEQX9HDQAgAEHhEjYCEEEYIQQLIAQLPgECfwJAIAAoAjgiA0UNACADKAIIIgNFDQAgACABIAIgAWsgAxEBACIEQX9HDQAgAEH8ETYCEEEYIQQLIAQLPgECfwJAIAAoAjgiA0UNACADKAIMIgNFDQAgACABIAIgAWsgAxEBACIEQX9HDQAgAEHsCjYCEEEYIQQLIAQLPgECfwJAIAAoAjgiA0UNACADKAIQIgNFDQAgACABIAIgAWsgAxEBACIEQX9HDQAgAEH6HjYCEEEYIQQLIAQLPgECfwJAIAAoAjgiA0UNACADKAIUIgNFDQAgACABIAIgAWsgAxEBACIEQX9HDQAgAEHLEDYCEEEYIQQLIAQLPgECfwJAIAAoAjgiA0UNACADKAIYIgNFDQAgACABIAIgAWsgAxEBACIEQX9HDQAgAEG3HzYCEEEYIQQLIAQLPgECfwJAIAAoAjgiA0UNACADKAIcIgNFDQAgACABIAIgAWsgAxEBACIEQX9HDQAgAEG/FTYCEEEYIQQLIAQLPgECfwJAIAAoAjgiA0UNACADKAIsIgNFDQAgACABIAIgAWsgAxEBACIEQX9HDQAgAEH+CDYCEEEYIQQLIAQLPgECfwJAIAAoAjgiA0UNACADKAIgIgNFDQAgACABIAIgAWsgAxEBACIEQX9HDQAgAEGMHTYCEEEYIQQLIAQLPgECfwJAIAAoAjgiA0UNACADKAIkIgNFDQAgACABIAIgAWsgAxEBACIEQX9HDQAgAEHmFTYCEEEYIQQLIAQLOAAgAAJ/IAAvATJBFHFBFEYEQEEBIAAtAChBAUYNARogAC8BNEHlAEYMAQsgAC0AKUEFRgs6ADALWQECfwJAIAAtAChBAUYNACAALwE0IgFB5ABrQeQASQ0AIAFBzAFGDQAgAUGwAkYNACAALwEyIgBBwABxDQBBASECIABBiARxQYAERg0AIABBKHFFIQILIAILjAEBAn8CQAJAAkAgAC0AKkUNACAALQArRQ0AIAAvATIiAUECcUUNAQwCCyAALwEyIgFBAXFFDQELQQEhAiAALQAoQQFGDQAgAC8BNCIAQeQAa0HkAEkNACAAQcwBRg0AIABBsAJGDQAgAUHAAHENAEEAIQIgAUGIBHFBgARGDQAgAUEocUEARyECCyACC1cAIABBGGpCADcDACAAQgA3AwAgAEE4akIANwMAIABBMGpCADcDACAAQShqQgA3AwAgAEEgakIANwMAIABBEGpCADcDACAAQQhqQgA3AwAgAEH9ATYCHAsGACAAEDoLmi0BC38jAEEQayIKJABB3NUAKAIAIglFBEBBnNkAKAIAIgVFBEBBqNkAQn83AgBBoNkAQoCAhICAgMAANwIAQZzZACAKQQhqQXBxQdiq1aoFcyIFNgIAQbDZAEEANgIAQYDZAEEANgIAC0GE2QBBwNkENgIAQdTVAEHA2QQ2AgBB6NUAIAU2AgBB5NUAQX82AgBBiNkAQcCmAzYCAANAIAFBgNYAaiABQfTVAGoiAjYCACACIAFB7NUAaiIDNgIAIAFB+NUAaiADNgIAIAFBiNYAaiABQfzVAGoiAzYCACADIAI2AgAgAUGQ1gBqIAFBhNYAaiICNgIAIAIgAzYCACABQYzWAGogAjYCACABQSBqIgFBgAJHDQALQczZBEGBpgM2AgBB4NUAQazZACgCADYCAEHQ1QBBgKYDNgIAQdzVAEHI2QQ2AgBBzP8HQTg2AgBByNkEIQkLAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAEHsAU0EQEHE1QAoAgAiBkEQIABBE2pBcHEgAEELSRsiBEEDdiIAdiIBQQNxBEACQCABQQFxIAByQQFzIgJBA3QiAEHs1QBqIgEgAEH01QBqKAIAIgAoAggiA0YEQEHE1QAgBkF+IAJ3cTYCAAwBCyABIAM2AgggAyABNgIMCyAAQQhqIQEgACACQQN0IgJBA3I2AgQgACACaiIAIAAoAgRBAXI2AgQMEQtBzNUAKAIAIgggBE8NASABBEACQEECIAB0IgJBACACa3IgASAAdHFoIgBBA3QiAkHs1QBqIgEgAkH01QBqKAIAIgIoAggiA0YEQEHE1QAgBkF+IAB3cSIGNgIADAELIAEgAzYCCCADIAE2AgwLIAIgBEEDcjYCBCAAQQN0IgAgBGshBSAAIAJqIAU2AgAgAiAEaiIEIAVBAXI2AgQgCARAIAhBeHFB7NUAaiEAQdjVACgCACEDAn9BASAIQQN2dCIBIAZxRQRAQcTVACABIAZyNgIAIAAMAQsgACgCCAsiASADNgIMIAAgAzYCCCADIAA2AgwgAyABNgIICyACQQhqIQFB2NUAIAQ2AgBBzNUAIAU2AgAMEQtByNUAKAIAIgtFDQEgC2hBAnRB9NcAaigCACIAKAIEQXhxIARrIQUgACECA0ACQCACKAIQIgFFBEAgAkEUaigCACIBRQ0BCyABKAIEQXhxIARrIgMgBUkhAiADIAUgAhshBSABIAAgAhshACABIQIMAQsLIAAoAhghCSAAKAIMIgMgAEcEQEHU1QAoAgAaIAMgACgCCCIBNgIIIAEgAzYCDAwQCyAAQRRqIgIoAgAiAUUEQCAAKAIQIgFFDQMgAEEQaiECCwNAIAIhByABIgNBFGoiAigCACIBDQAgA0EQaiECIAMoAhAiAQ0ACyAHQQA2AgAMDwtBfyEEIABBv39LDQAgAEETaiIBQXBxIQRByNUAKAIAIghFDQBBACAEayEFAkACQAJAAn9BACAEQYACSQ0AGkEfIARB////B0sNABogBEEmIAFBCHZnIgBrdkEBcSAAQQF0a0E+agsiBkECdEH01wBqKAIAIgJFBEBBACEBQQAhAwwBC0EAIQEgBEEZIAZBAXZrQQAgBkEfRxt0IQBBACEDA0ACQCACKAIEQXhxIARrIgcgBU8NACACIQMgByIFDQBBACEFIAIhAQwDCyABIAJBFGooAgAiByAHIAIgAEEddkEEcWpBEGooAgAiAkYbIAEgBxshASAAQQF0IQAgAg0ACwsgASADckUEQEEAIQNBAiAGdCIAQQAgAGtyIAhxIgBFDQMgAGhBAnRB9NcAaigCACEBCyABRQ0BCwNAIAEoAgRBeHEgBGsiAiAFSSEAIAIgBSAAGyEFIAEgAyAAGyEDIAEoAhAiAAR/IAAFIAFBFGooAgALIgENAAsLIANFDQAgBUHM1QAoAgAgBGtPDQAgAygCGCEHIAMgAygCDCIARwRAQdTVACgCABogACADKAIIIgE2AgggASAANgIMDA4LIANBFGoiAigCACIBRQRAIAMoAhAiAUUNAyADQRBqIQILA0AgAiEGIAEiAEEUaiICKAIAIgENACAAQRBqIQIgACgCECIBDQALIAZBADYCAAwNC0HM1QAoAgAiAyAETwRAQdjVACgCACEBAkAgAyAEayICQRBPBEAgASAEaiIAIAJBAXI2AgQgASADaiACNgIAIAEgBEEDcjYCBAwBCyABIANBA3I2AgQgASADaiIAIAAoAgRBAXI2AgRBACEAQQAhAgtBzNUAIAI2AgBB2NUAIAA2AgAgAUEIaiEBDA8LQdDVACgCACIDIARLBEAgBCAJaiIAIAMgBGsiAUEBcjYCBEHc1QAgADYCAEHQ1QAgATYCACAJIARBA3I2AgQgCUEIaiEBDA8LQQAhASAEAn9BnNkAKAIABEBBpNkAKAIADAELQajZAEJ/NwIAQaDZAEKAgISAgIDAADcCAEGc2QAgCkEMakFwcUHYqtWqBXM2AgBBsNkAQQA2AgBBgNkAQQA2AgBBgIAECyIAIARBxwBqIgVqIgZBACAAayIHcSICTwRAQbTZAEEwNgIADA8LAkBB/NgAKAIAIgFFDQBB9NgAKAIAIgggAmohACAAIAFNIAAgCEtxDQBBACEBQbTZAEEwNgIADA8LQYDZAC0AAEEEcQ0EAkACQCAJBEBBhNkAIQEDQCABKAIAIgAgCU0EQCAAIAEoAgRqIAlLDQMLIAEoAggiAQ0ACwtBABA7IgBBf0YNBSACIQZBoNkAKAIAIgFBAWsiAyAAcQRAIAIgAGsgACADakEAIAFrcWohBgsgBCAGTw0FIAZB/v///wdLDQVB/NgAKAIAIgMEQEH02AAoAgAiByAGaiEBIAEgB00NBiABIANLDQYLIAYQOyIBIABHDQEMBwsgBiADayAHcSIGQf7///8HSw0EIAYQOyEAIAAgASgCACABKAIEakYNAyAAIQELAkAgBiAEQcgAak8NACABQX9GDQBBpNkAKAIAIgAgBSAGa2pBACAAa3EiAEH+////B0sEQCABIQAMBwsgABA7QX9HBEAgACAGaiEGIAEhAAwHC0EAIAZrEDsaDAQLIAEiAEF/Rw0FDAMLQQAhAwwMC0EAIQAMCgsgAEF/Rw0CC0GA2QBBgNkAKAIAQQRyNgIACyACQf7///8HSw0BIAIQOyEAQQAQOyEBIABBf0YNASABQX9GDQEgACABTw0BIAEgAGsiBiAEQThqTQ0BC0H02ABB9NgAKAIAIAZqIgE2AgBB+NgAKAIAIAFJBEBB+NgAIAE2AgALAkACQAJAQdzVACgCACICBEBBhNkAIQEDQCAAIAEoAgAiAyABKAIEIgVqRg0CIAEoAggiAQ0ACwwCC0HU1QAoAgAiAUEARyAAIAFPcUUEQEHU1QAgADYCAAtBACEBQYjZACAGNgIAQYTZACAANgIAQeTVAEF/NgIAQejVAEGc2QAoAgA2AgBBkNkAQQA2AgADQCABQYDWAGogAUH01QBqIgI2AgAgAiABQezVAGoiAzYCACABQfjVAGogAzYCACABQYjWAGogAUH81QBqIgM2AgAgAyACNgIAIAFBkNYAaiABQYTWAGoiAjYCACACIAM2AgAgAUGM1gBqIAI2AgAgAUEgaiIBQYACRw0AC0F4IABrQQ9xIgEgAGoiAiAGQThrIgMgAWsiAUEBcjYCBEHg1QBBrNkAKAIANgIAQdDVACABNgIAQdzVACACNgIAIAAgA2pBODYCBAwCCyAAIAJNDQAgAiADSQ0AIAEoAgxBCHENAEF4IAJrQQ9xIgAgAmoiA0HQ1QAoAgAgBmoiByAAayIAQQFyNgIEIAEgBSAGajYCBEHg1QBBrNkAKAIANgIAQdDVACAANgIAQdzVACADNgIAIAIgB2pBODYCBAwBCyAAQdTVACgCAEkEQEHU1QAgADYCAAsgACAGaiEDQYTZACEBAkACQAJAA0AgAyABKAIARwRAIAEoAggiAQ0BDAILCyABLQAMQQhxRQ0BC0GE2QAhAQNAIAEoAgAiAyACTQRAIAMgASgCBGoiBSACSw0DCyABKAIIIQEMAAsACyABIAA2AgAgASABKAIEIAZqNgIEIABBeCAAa0EPcWoiCSAEQQNyNgIEIANBeCADa0EPcWoiBiAEIAlqIgRrIQEgAiAGRgRAQdzVACAENgIAQdDVAEHQ1QAoAgAgAWoiADYCACAEIABBAXI2AgQMCAtB2NUAKAIAIAZGBEBB2NUAIAQ2AgBBzNUAQczVACgCACABaiIANgIAIAQgAEEBcjYCBCAAIARqIAA2AgAMCAsgBigCBCIFQQNxQQFHDQYgBUF4cSEIIAVB/wFNBEAgBUEDdiEDIAYoAggiACAGKAIMIgJGBEBBxNUAQcTVACgCAEF+IAN3cTYCAAwHCyACIAA2AgggACACNgIMDAYLIAYoAhghByAGIAYoAgwiAEcEQCAAIAYoAggiAjYCCCACIAA2AgwMBQsgBkEUaiICKAIAIgVFBEAgBigCECIFRQ0EIAZBEGohAgsDQCACIQMgBSIAQRRqIgIoAgAiBQ0AIABBEGohAiAAKAIQIgUNAAsgA0EANgIADAQLQXggAGtBD3EiASAAaiIHIAZBOGsiAyABayIBQQFyNgIEIAAgA2pBODYCBCACIAVBNyAFa0EPcWpBP2siAyADIAJBEGpJGyIDQSM2AgRB4NUAQazZACgCADYCAEHQ1QAgATYCAEHc1QAgBzYCACADQRBqQYzZACkCADcCACADQYTZACkCADcCCEGM2QAgA0EIajYCAEGI2QAgBjYCAEGE2QAgADYCAEGQ2QBBADYCACADQSRqIQEDQCABQQc2AgAgBSABQQRqIgFLDQALIAIgA0YNACADIAMoAgRBfnE2AgQgAyADIAJrIgU2AgAgAiAFQQFyNgIEIAVB/wFNBEAgBUF4cUHs1QBqIQACf0HE1QAoAgAiAUEBIAVBA3Z0IgNxRQRAQcTVACABIANyNgIAIAAMAQsgACgCCAsiASACNgIMIAAgAjYCCCACIAA2AgwgAiABNgIIDAELQR8hASAFQf///wdNBEAgBUEmIAVBCHZnIgBrdkEBcSAAQQF0a0E+aiEBCyACIAE2AhwgAkIANwIQIAFBAnRB9NcAaiEAQcjVACgCACIDQQEgAXQiBnFFBEAgACACNgIAQcjVACADIAZyNgIAIAIgADYCGCACIAI2AgggAiACNgIMDAELIAVBGSABQQF2a0EAIAFBH0cbdCEBIAAoAgAhAwJAA0AgAyIAKAIEQXhxIAVGDQEgAUEddiEDIAFBAXQhASAAIANBBHFqQRBqIgYoAgAiAw0ACyAGIAI2AgAgAiAANgIYIAIgAjYCDCACIAI2AggMAQsgACgCCCIBIAI2AgwgACACNgIIIAJBADYCGCACIAA2AgwgAiABNgIIC0HQ1QAoAgAiASAETQ0AQdzVACgCACIAIARqIgIgASAEayIBQQFyNgIEQdDVACABNgIAQdzVACACNgIAIAAgBEEDcjYCBCAAQQhqIQEMCAtBACEBQbTZAEEwNgIADAcLQQAhAAsgB0UNAAJAIAYoAhwiAkECdEH01wBqIgMoAgAgBkYEQCADIAA2AgAgAA0BQcjVAEHI1QAoAgBBfiACd3E2AgAMAgsgB0EQQRQgBygCECAGRhtqIAA2AgAgAEUNAQsgACAHNgIYIAYoAhAiAgRAIAAgAjYCECACIAA2AhgLIAZBFGooAgAiAkUNACAAQRRqIAI2AgAgAiAANgIYCyABIAhqIQEgBiAIaiIGKAIEIQULIAYgBUF+cTYCBCABIARqIAE2AgAgBCABQQFyNgIEIAFB/wFNBEAgAUF4cUHs1QBqIQACf0HE1QAoAgAiAkEBIAFBA3Z0IgFxRQRAQcTVACABIAJyNgIAIAAMAQsgACgCCAsiASAENgIMIAAgBDYCCCAEIAA2AgwgBCABNgIIDAELQR8hBSABQf///wdNBEAgAUEmIAFBCHZnIgBrdkEBcSAAQQF0a0E+aiEFCyAEIAU2AhwgBEIANwIQIAVBAnRB9NcAaiEAQcjVACgCACICQQEgBXQiA3FFBEAgACAENgIAQcjVACACIANyNgIAIAQgADYCGCAEIAQ2AgggBCAENgIMDAELIAFBGSAFQQF2a0EAIAVBH0cbdCEFIAAoAgAhAAJAA0AgACICKAIEQXhxIAFGDQEgBUEddiEAIAVBAXQhBSACIABBBHFqQRBqIgMoAgAiAA0ACyADIAQ2AgAgBCACNgIYIAQgBDYCDCAEIAQ2AggMAQsgAigCCCIAIAQ2AgwgAiAENgIIIARBADYCGCAEIAI2AgwgBCAANgIICyAJQQhqIQEMAgsCQCAHRQ0AAkAgAygCHCIBQQJ0QfTXAGoiAigCACADRgRAIAIgADYCACAADQFByNUAIAhBfiABd3EiCDYCAAwCCyAHQRBBFCAHKAIQIANGG2ogADYCACAARQ0BCyAAIAc2AhggAygCECIBBEAgACABNgIQIAEgADYCGAsgA0EUaigCACIBRQ0AIABBFGogATYCACABIAA2AhgLAkAgBUEPTQRAIAMgBCAFaiIAQQNyNgIEIAAgA2oiACAAKAIEQQFyNgIEDAELIAMgBGoiAiAFQQFyNgIEIAMgBEEDcjYCBCACIAVqIAU2AgAgBUH/AU0EQCAFQXhxQezVAGohAAJ/QcTVACgCACIBQQEgBUEDdnQiBXFFBEBBxNUAIAEgBXI2AgAgAAwBCyAAKAIICyIBIAI2AgwgACACNgIIIAIgADYCDCACIAE2AggMAQtBHyEBIAVB////B00EQCAFQSYgBUEIdmciAGt2QQFxIABBAXRrQT5qIQELIAIgATYCHCACQgA3AhAgAUECdEH01wBqIQBBASABdCIEIAhxRQRAIAAgAjYCAEHI1QAgBCAIcjYCACACIAA2AhggAiACNgIIIAIgAjYCDAwBCyAFQRkgAUEBdmtBACABQR9HG3QhASAAKAIAIQQCQANAIAQiACgCBEF4cSAFRg0BIAFBHXYhBCABQQF0IQEgACAEQQRxakEQaiIGKAIAIgQNAAsgBiACNgIAIAIgADYCGCACIAI2AgwgAiACNgIIDAELIAAoAggiASACNgIMIAAgAjYCCCACQQA2AhggAiAANgIMIAIgATYCCAsgA0EIaiEBDAELAkAgCUUNAAJAIAAoAhwiAUECdEH01wBqIgIoAgAgAEYEQCACIAM2AgAgAw0BQcjVACALQX4gAXdxNgIADAILIAlBEEEUIAkoAhAgAEYbaiADNgIAIANFDQELIAMgCTYCGCAAKAIQIgEEQCADIAE2AhAgASADNgIYCyAAQRRqKAIAIgFFDQAgA0EUaiABNgIAIAEgAzYCGAsCQCAFQQ9NBEAgACAEIAVqIgFBA3I2AgQgACABaiIBIAEoAgRBAXI2AgQMAQsgACAEaiIHIAVBAXI2AgQgACAEQQNyNgIEIAUgB2ogBTYCACAIBEAgCEF4cUHs1QBqIQFB2NUAKAIAIQMCf0EBIAhBA3Z0IgIgBnFFBEBBxNUAIAIgBnI2AgAgAQwBCyABKAIICyICIAM2AgwgASADNgIIIAMgATYCDCADIAI2AggLQdjVACAHNgIAQczVACAFNgIACyAAQQhqIQELIApBEGokACABC0MAIABFBEA/AEEQdA8LAkAgAEH//wNxDQAgAEEASA0AIABBEHZAACIAQX9GBEBBtNkAQTA2AgBBfw8LIABBEHQPCwALC5lCIgBBgAgLDQEAAAAAAAAAAgAAAAMAQZgICwUEAAAABQBBqAgLCQYAAAAHAAAACABB5AgLwjJJbnZhbGlkIGNoYXIgaW4gdXJsIHF1ZXJ5AFNwYW4gY2FsbGJhY2sgZXJyb3IgaW4gb25fYm9keQBDb250ZW50LUxlbmd0aCBvdmVyZmxvdwBDaHVuayBzaXplIG92ZXJmbG93AEludmFsaWQgbWV0aG9kIGZvciBIVFRQL3gueCByZXF1ZXN0AEludmFsaWQgbWV0aG9kIGZvciBSVFNQL3gueCByZXF1ZXN0AEV4cGVjdGVkIFNPVVJDRSBtZXRob2QgZm9yIElDRS94LnggcmVxdWVzdABJbnZhbGlkIGNoYXIgaW4gdXJsIGZyYWdtZW50IHN0YXJ0AEV4cGVjdGVkIGRvdABTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX3N0YXR1cwBJbnZhbGlkIHJlc3BvbnNlIHN0YXR1cwBFeHBlY3RlZCBMRiBhZnRlciBoZWFkZXJzAEludmFsaWQgY2hhcmFjdGVyIGluIGNodW5rIGV4dGVuc2lvbnMAVXNlciBjYWxsYmFjayBlcnJvcgBgb25fcmVzZXRgIGNhbGxiYWNrIGVycm9yAGBvbl9jaHVua19oZWFkZXJgIGNhbGxiYWNrIGVycm9yAGBvbl9tZXNzYWdlX2JlZ2luYCBjYWxsYmFjayBlcnJvcgBgb25fY2h1bmtfZXh0ZW5zaW9uX3ZhbHVlYCBjYWxsYmFjayBlcnJvcgBgb25fc3RhdHVzX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25fdmVyc2lvbl9jb21wbGV0ZWAgY2FsbGJhY2sgZXJyb3IAYG9uX3VybF9jb21wbGV0ZWAgY2FsbGJhY2sgZXJyb3IAYG9uX3Byb3RvY29sX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25fY2h1bmtfY29tcGxldGVgIGNhbGxiYWNrIGVycm9yAGBvbl9oZWFkZXJfdmFsdWVfY29tcGxldGVgIGNhbGxiYWNrIGVycm9yAGBvbl9tZXNzYWdlX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25fbWV0aG9kX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25faGVhZGVyX2ZpZWxkX2NvbXBsZXRlYCBjYWxsYmFjayBlcnJvcgBgb25fY2h1bmtfZXh0ZW5zaW9uX25hbWVgIGNhbGxiYWNrIGVycm9yAFVuZXhwZWN0ZWQgY2hhciBpbiB1cmwgc2VydmVyAEludmFsaWQgaGVhZGVyIHZhbHVlIGNoYXIASW52YWxpZCBoZWFkZXIgZmllbGQgY2hhcgBTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX3ZlcnNpb24ASW52YWxpZCBtaW5vciB2ZXJzaW9uAEludmFsaWQgbWFqb3IgdmVyc2lvbgBFeHBlY3RlZCBzcGFjZSBhZnRlciB2ZXJzaW9uAEV4cGVjdGVkIENSTEYgYWZ0ZXIgdmVyc2lvbgBJbnZhbGlkIEhUVFAgdmVyc2lvbgBJbnZhbGlkIGhlYWRlciB0b2tlbgBTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX3VybABJbnZhbGlkIGNoYXJhY3RlcnMgaW4gdXJsAFVuZXhwZWN0ZWQgc3RhcnQgY2hhciBpbiB1cmwARG91YmxlIEAgaW4gdXJsAFNwYW4gY2FsbGJhY2sgZXJyb3IgaW4gb25fcHJvdG9jb2wARW1wdHkgQ29udGVudC1MZW5ndGgASW52YWxpZCBjaGFyYWN0ZXIgaW4gQ29udGVudC1MZW5ndGgAVHJhbnNmZXItRW5jb2RpbmcgY2FuJ3QgYmUgcHJlc2VudCB3aXRoIENvbnRlbnQtTGVuZ3RoAER1cGxpY2F0ZSBDb250ZW50LUxlbmd0aABJbnZhbGlkIGNoYXIgaW4gdXJsIHBhdGgAQ29udGVudC1MZW5ndGggY2FuJ3QgYmUgcHJlc2VudCB3aXRoIFRyYW5zZmVyLUVuY29kaW5nAE1pc3NpbmcgZXhwZWN0ZWQgQ1IgYWZ0ZXIgY2h1bmsgc2l6ZQBFeHBlY3RlZCBMRiBhZnRlciBjaHVuayBzaXplAEludmFsaWQgY2hhcmFjdGVyIGluIGNodW5rIHNpemUAU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl9oZWFkZXJfdmFsdWUAU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl9jaHVua19leHRlbnNpb25fdmFsdWUASW52YWxpZCBjaGFyYWN0ZXIgaW4gY2h1bmsgZXh0ZW5zaW9ucyB2YWx1ZQBVbmV4cGVjdGVkIHdoaXRlc3BhY2UgYWZ0ZXIgaGVhZGVyIHZhbHVlAE1pc3NpbmcgZXhwZWN0ZWQgQ1IgYWZ0ZXIgaGVhZGVyIHZhbHVlAE1pc3NpbmcgZXhwZWN0ZWQgTEYgYWZ0ZXIgaGVhZGVyIHZhbHVlAEludmFsaWQgYFRyYW5zZmVyLUVuY29kaW5nYCBoZWFkZXIgdmFsdWUATWlzc2luZyBleHBlY3RlZCBDUiBhZnRlciBjaHVuayBleHRlbnNpb24gdmFsdWUASW52YWxpZCBjaGFyYWN0ZXIgaW4gY2h1bmsgZXh0ZW5zaW9ucyBxdW90ZSB2YWx1ZQBJbnZhbGlkIHF1b3RlZC1wYWlyIGluIGNodW5rIGV4dGVuc2lvbnMgcXVvdGVkIHZhbHVlAEludmFsaWQgY2hhcmFjdGVyIGluIGNodW5rIGV4dGVuc2lvbnMgcXVvdGVkIHZhbHVlAFBhdXNlZCBieSBvbl9oZWFkZXJzX2NvbXBsZXRlAEludmFsaWQgRU9GIHN0YXRlAG9uX3Jlc2V0IHBhdXNlAG9uX2NodW5rX2hlYWRlciBwYXVzZQBvbl9tZXNzYWdlX2JlZ2luIHBhdXNlAG9uX2NodW5rX2V4dGVuc2lvbl92YWx1ZSBwYXVzZQBvbl9zdGF0dXNfY29tcGxldGUgcGF1c2UAb25fdmVyc2lvbl9jb21wbGV0ZSBwYXVzZQBvbl91cmxfY29tcGxldGUgcGF1c2UAb25fcHJvdG9jb2xfY29tcGxldGUgcGF1c2UAb25fY2h1bmtfY29tcGxldGUgcGF1c2UAb25faGVhZGVyX3ZhbHVlX2NvbXBsZXRlIHBhdXNlAG9uX21lc3NhZ2VfY29tcGxldGUgcGF1c2UAb25fbWV0aG9kX2NvbXBsZXRlIHBhdXNlAG9uX2hlYWRlcl9maWVsZF9jb21wbGV0ZSBwYXVzZQBvbl9jaHVua19leHRlbnNpb25fbmFtZSBwYXVzZQBVbmV4cGVjdGVkIHNwYWNlIGFmdGVyIHN0YXJ0IGxpbmUATWlzc2luZyBleHBlY3RlZCBDUiBhZnRlciByZXNwb25zZSBsaW5lAFNwYW4gY2FsbGJhY2sgZXJyb3IgaW4gb25fY2h1bmtfZXh0ZW5zaW9uX25hbWUASW52YWxpZCBjaGFyYWN0ZXIgaW4gY2h1bmsgZXh0ZW5zaW9ucyBuYW1lAE1pc3NpbmcgZXhwZWN0ZWQgQ1IgYWZ0ZXIgY2h1bmsgZXh0ZW5zaW9uIG5hbWUASW52YWxpZCBzdGF0dXMgY29kZQBQYXVzZSBvbiBDT05ORUNUL1VwZ3JhZGUAUGF1c2Ugb24gUFJJL1VwZ3JhZGUARXhwZWN0ZWQgSFRUUC8yIENvbm5lY3Rpb24gUHJlZmFjZQBTcGFuIGNhbGxiYWNrIGVycm9yIGluIG9uX21ldGhvZABFeHBlY3RlZCBzcGFjZSBhZnRlciBtZXRob2QAU3BhbiBjYWxsYmFjayBlcnJvciBpbiBvbl9oZWFkZXJfZmllbGQAUGF1c2VkAEludmFsaWQgd29yZCBlbmNvdW50ZXJlZABJbnZhbGlkIG1ldGhvZCBlbmNvdW50ZXJlZABNaXNzaW5nIGV4cGVjdGVkIENSIGFmdGVyIGNodW5rIGRhdGEARXhwZWN0ZWQgTEYgYWZ0ZXIgY2h1bmsgZGF0YQBVbmV4cGVjdGVkIGNoYXIgaW4gdXJsIHNjaGVtYQBSZXF1ZXN0IGhhcyBpbnZhbGlkIGBUcmFuc2Zlci1FbmNvZGluZ2AARGF0YSBhZnRlciBgQ29ubmVjdGlvbjogY2xvc2VgAFNXSVRDSF9QUk9YWQBVU0VfUFJPWFkATUtBQ1RJVklUWQBVTlBST0NFU1NBQkxFX0VOVElUWQBRVUVSWQBDT1BZAE1PVkVEX1BFUk1BTkVOVExZAFRPT19FQVJMWQBOT1RJRlkARkFJTEVEX0RFUEVOREVOQ1kAQkFEX0dBVEVXQVkAUExBWQBQVVQAQ0hFQ0tPVVQAR0FURVdBWV9USU1FT1VUAFJFUVVFU1RfVElNRU9VVABORVRXT1JLX0NPTk5FQ1RfVElNRU9VVABDT05ORUNUSU9OX1RJTUVPVVQATE9HSU5fVElNRU9VVABORVRXT1JLX1JFQURfVElNRU9VVABQT1NUAE1JU0RJUkVDVEVEX1JFUVVFU1QAQ0xJRU5UX0NMT1NFRF9SRVFVRVNUAENMSUVOVF9DTE9TRURfTE9BRF9CQUxBTkNFRF9SRVFVRVNUAEJBRF9SRVFVRVNUAEhUVFBfUkVRVUVTVF9TRU5UX1RPX0hUVFBTX1BPUlQAUkVQT1JUAElNX0FfVEVBUE9UAFJFU0VUX0NPTlRFTlQATk9fQ09OVEVOVABQQVJUSUFMX0NPTlRFTlQASFBFX0lOVkFMSURfQ09OU1RBTlQASFBFX0NCX1JFU0VUAEdFVABIUEVfU1RSSUNUAENPTkZMSUNUAFRFTVBPUkFSWV9SRURJUkVDVABQRVJNQU5FTlRfUkVESVJFQ1QAQ09OTkVDVABNVUxUSV9TVEFUVVMASFBFX0lOVkFMSURfU1RBVFVTAFRPT19NQU5ZX1JFUVVFU1RTAEVBUkxZX0hJTlRTAFVOQVZBSUxBQkxFX0ZPUl9MRUdBTF9SRUFTT05TAE9QVElPTlMAU1dJVENISU5HX1BST1RPQ09MUwBWQVJJQU5UX0FMU09fTkVHT1RJQVRFUwBNVUxUSVBMRV9DSE9JQ0VTAElOVEVSTkFMX1NFUlZFUl9FUlJPUgBXRUJfU0VSVkVSX1VOS05PV05fRVJST1IAUkFJTEdVTl9FUlJPUgBJREVOVElUWV9QUk9WSURFUl9BVVRIRU5USUNBVElPTl9FUlJPUgBTU0xfQ0VSVElGSUNBVEVfRVJST1IASU5WQUxJRF9YX0ZPUldBUkRFRF9GT1IAU0VUX1BBUkFNRVRFUgBHRVRfUEFSQU1FVEVSAEhQRV9VU0VSAFNFRV9PVEhFUgBIUEVfQ0JfQ0hVTktfSEVBREVSAEV4cGVjdGVkIExGIGFmdGVyIENSAE1LQ0FMRU5EQVIAU0VUVVAAV0VCX1NFUlZFUl9JU19ET1dOAFRFQVJET1dOAEhQRV9DTE9TRURfQ09OTkVDVElPTgBIRVVSSVNUSUNfRVhQSVJBVElPTgBESVNDT05ORUNURURfT1BFUkFUSU9OAE5PTl9BVVRIT1JJVEFUSVZFX0lORk9STUFUSU9OAEhQRV9JTlZBTElEX1ZFUlNJT04ASFBFX0NCX01FU1NBR0VfQkVHSU4AU0lURV9JU19GUk9aRU4ASFBFX0lOVkFMSURfSEVBREVSX1RPS0VOAElOVkFMSURfVE9LRU4ARk9SQklEREVOAEVOSEFOQ0VfWU9VUl9DQUxNAEhQRV9JTlZBTElEX1VSTABCTE9DS0VEX0JZX1BBUkVOVEFMX0NPTlRST0wATUtDT0wAQUNMAEhQRV9JTlRFUk5BTABSRVFVRVNUX0hFQURFUl9GSUVMRFNfVE9PX0xBUkdFX1VOT0ZGSUNJQUwASFBFX09LAFVOTElOSwBVTkxPQ0sAUFJJAFJFVFJZX1dJVEgASFBFX0lOVkFMSURfQ09OVEVOVF9MRU5HVEgASFBFX1VORVhQRUNURURfQ09OVEVOVF9MRU5HVEgARkxVU0gAUFJPUFBBVENIAE0tU0VBUkNIAFVSSV9UT09fTE9ORwBQUk9DRVNTSU5HAE1JU0NFTExBTkVPVVNfUEVSU0lTVEVOVF9XQVJOSU5HAE1JU0NFTExBTkVPVVNfV0FSTklORwBIUEVfSU5WQUxJRF9UUkFOU0ZFUl9FTkNPRElORwBFeHBlY3RlZCBDUkxGAEhQRV9JTlZBTElEX0NIVU5LX1NJWkUATU9WRQBDT05USU5VRQBIUEVfQ0JfU1RBVFVTX0NPTVBMRVRFAEhQRV9DQl9IRUFERVJTX0NPTVBMRVRFAEhQRV9DQl9WRVJTSU9OX0NPTVBMRVRFAEhQRV9DQl9VUkxfQ09NUExFVEUASFBFX0NCX1BST1RPQ09MX0NPTVBMRVRFAEhQRV9DQl9DSFVOS19DT01QTEVURQBIUEVfQ0JfSEVBREVSX1ZBTFVFX0NPTVBMRVRFAEhQRV9DQl9DSFVOS19FWFRFTlNJT05fVkFMVUVfQ09NUExFVEUASFBFX0NCX0NIVU5LX0VYVEVOU0lPTl9OQU1FX0NPTVBMRVRFAEhQRV9DQl9NRVNTQUdFX0NPTVBMRVRFAEhQRV9DQl9NRVRIT0RfQ09NUExFVEUASFBFX0NCX0hFQURFUl9GSUVMRF9DT01QTEVURQBERUxFVEUASFBFX0lOVkFMSURfRU9GX1NUQVRFAElOVkFMSURfU1NMX0NFUlRJRklDQVRFAFBBVVNFAE5PX1JFU1BPTlNFAFVOU1VQUE9SVEVEX01FRElBX1RZUEUAR09ORQBOT1RfQUNDRVBUQUJMRQBTRVJWSUNFX1VOQVZBSUxBQkxFAFJBTkdFX05PVF9TQVRJU0ZJQUJMRQBPUklHSU5fSVNfVU5SRUFDSEFCTEUAUkVTUE9OU0VfSVNfU1RBTEUAUFVSR0UATUVSR0UAUkVRVUVTVF9IRUFERVJfRklFTERTX1RPT19MQVJHRQBSRVFVRVNUX0hFQURFUl9UT09fTEFSR0UAUEFZTE9BRF9UT09fTEFSR0UASU5TVUZGSUNJRU5UX1NUT1JBR0UASFBFX1BBVVNFRF9VUEdSQURFAEhQRV9QQVVTRURfSDJfVVBHUkFERQBTT1VSQ0UAQU5OT1VOQ0UAVFJBQ0UASFBFX1VORVhQRUNURURfU1BBQ0UAREVTQ1JJQkUAVU5TVUJTQ1JJQkUAUkVDT1JEAEhQRV9JTlZBTElEX01FVEhPRABOT1RfRk9VTkQAUFJPUEZJTkQAVU5CSU5EAFJFQklORABVTkFVVEhPUklaRUQATUVUSE9EX05PVF9BTExPV0VEAEhUVFBfVkVSU0lPTl9OT1RfU1VQUE9SVEVEAEFMUkVBRFlfUkVQT1JURUQAQUNDRVBURUQATk9UX0lNUExFTUVOVEVEAExPT1BfREVURUNURUQASFBFX0NSX0VYUEVDVEVEAEhQRV9MRl9FWFBFQ1RFRABDUkVBVEVEAElNX1VTRUQASFBFX1BBVVNFRABUSU1FT1VUX09DQ1VSRUQAUEFZTUVOVF9SRVFVSVJFRABQUkVDT05ESVRJT05fUkVRVUlSRUQAUFJPWFlfQVVUSEVOVElDQVRJT05fUkVRVUlSRUQATkVUV09SS19BVVRIRU5USUNBVElPTl9SRVFVSVJFRABMRU5HVEhfUkVRVUlSRUQAU1NMX0NFUlRJRklDQVRFX1JFUVVJUkVEAFVQR1JBREVfUkVRVUlSRUQAUEFHRV9FWFBJUkVEAFBSRUNPTkRJVElPTl9GQUlMRUQARVhQRUNUQVRJT05fRkFJTEVEAFJFVkFMSURBVElPTl9GQUlMRUQAU1NMX0hBTkRTSEFLRV9GQUlMRUQATE9DS0VEAFRSQU5TRk9STUFUSU9OX0FQUExJRUQATk9UX01PRElGSUVEAE5PVF9FWFRFTkRFRABCQU5EV0lEVEhfTElNSVRfRVhDRUVERUQAU0lURV9JU19PVkVSTE9BREVEAEhFQUQARXhwZWN0ZWQgSFRUUC8sIFJUU1AvIG9yIElDRS8A5xUAAK8VAACkEgAAkhoAACYWAACeFAAA2xkAAHkVAAB+EgAA/hQAADYVAAALFgAA2BYAAPMSAABCGAAArBYAABIVAAAUFwAA7xcAAEgUAABxFwAAshoAAGsZAAB+GQAANRQAAIIaAABEFwAA/RYAAB4YAACHFwAAqhkAAJMSAAAHGAAALBcAAMoXAACkFwAA5xUAAOcVAABYFwAAOxgAAKASAAAtHAAAwxEAAEgRAADeEgAAQhMAAKQZAAD9EAAA9xUAAKUVAADvFgAA+BkAAEoWAABWFgAA9RUAAAoaAAAIGgAAARoAAKsVAABCEgAA1xAAAEwRAAAFGQAAVBYAAB4RAADKGQAAyBkAAE4WAAD/GAAAcRQAAPAVAADuFQAAlBkAAPwVAAC/GQAAmxkAAHwUAABDEQAAcBgAAJUUAAAnFAAAGRQAANUSAADUGQAARBYAAPcQAEG5OwsBAQBB0DsL4AEBAQIBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEDAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQBBuj0LBAEAAAIAQdE9C14DBAMDAwMDAAADAwADAwADAwMDAwMDAwMDAAUAAAAAAAMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAAAAAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMAAwADAEG6PwsEAQAAAgBB0T8LXgMAAwMDAwMAAAMDAAMDAAMDAwMDAwMDAwMABAAFAAAAAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMAAAADAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwADAAMAQbDBAAsNbG9zZWVlcC1hbGl2ZQBBycEACwEBAEHgwQAL4AEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQBBycMACwEBAEHgwwAL5wEBAQEBAQEBAQEBAQECAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAWNodW5rZWQAQfHFAAteAQABAQEBAQAAAQEAAQEAAQEBAQEBAQEBAQAAAAAAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAEAAQBB0McACyFlY3Rpb25lbnQtbGVuZ3Rob25yb3h5LWNvbm5lY3Rpb24AQYDIAAsgcmFuc2Zlci1lbmNvZGluZ3BncmFkZQ0KDQpTTQ0KDQoAQanIAAsFAQIAAQMAQcDIAAtfBAUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUAQanKAAsFAQIAAQMAQcDKAAtfBAUFBgUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUAQanMAAsEAQAAAQBBwcwAC14CAgACAgICAgICAgICAgICAgICAgICAgICAgICAgIAAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAEGpzgALBQECAAEDAEHAzgALXwQFAAAFBQUFBQUFBQUFBQYFBQUFBQUFBQUFBQUABQAHCAUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQAFAAUABQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUAAAAFAEGp0AALBQEBAAEBAEHA0AALAQEAQdrQAAtBAgAAAAAAAAMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAAAAAAAAAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMAQanSAAsFAQEAAQEAQcDSAAsBAQBBytIACwYCAAAAAAIAQeHSAAs6AwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMAAAAAAAADAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwBBoNQAC50BTk9VTkNFRUNLT1VUTkVDVEVURUNSSUJFTFVTSEVURUFEU0VBUkNIUkdFQ1RJVklUWUxFTkRBUlZFT1RJRllQVElPTlNDSFNFQVlTVEFUQ0hHRVVFUllPUkRJUkVDVE9SVFJDSFBBUkFNRVRFUlVSQ0VCU0NSSUJFQVJET1dOQUNFSU5ETktDS1VCU0NSSUJFVFRQQ0VUU1BBRFRQLw=="; + var wasmBase64 = "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"; var wasmBuffer; Object.defineProperty(module2, "exports", { get: /* @__PURE__ */ __name(() => { @@ -3867,7 +3903,7 @@ var require_llhttp_simd_wasm = __commonJS({ "lib/llhttp/llhttp_simd-wasm.js"(exports2, module2) { "use strict"; var { Buffer: Buffer2 } = require("node:buffer"); - var wasmBase64 = "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"; + var wasmBase64 = "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"; var wasmBuffer; Object.defineProperty(module2, "exports", { get: /* @__PURE__ */ __name(() => { @@ -4716,7 +4752,7 @@ var require_webidl = __commonJS({ lowerBound = 0; upperBound = Math.pow(2, bitLength) - 1; } else { - lowerBound = Math.pow(-2, bitLength) - 1; + lowerBound = -Math.pow(2, bitLength - 1); upperBound = Math.pow(2, bitLength - 1) - 1; } let x = Number(V); @@ -4753,7 +4789,7 @@ var require_webidl = __commonJS({ } x = webidl.util.IntegerPart(x); x = x % Math.pow(2, bitLength); - if (signedness === "signed" && x >= Math.pow(2, bitLength) - 1) { + if (signedness === "signed" && x >= Math.pow(2, bitLength - 1)) { return x - Math.pow(2, bitLength); } return x; @@ -6339,7 +6375,7 @@ var require_formdata_parser = __commonJS({ ); value = decoder.decode(tokenValue); } - return { name: attrNameStr, value }; + return { name: attrNameStr, value, extended: isExtended }; } __name(parseContentDispositionAttribute, "parseContentDispositionAttribute"); function parseMultipartFormDataHeaders(input, position) { @@ -6375,6 +6411,7 @@ var require_formdata_parser = __commonJS({ switch (bufferToLowerCasedHeaderName(headerName)) { case "content-disposition": { name = filename = null; + let filenameIsExtended = false; const dispositionType = collectASequenceOfBytes( (char) => isToken(char), input, @@ -6383,7 +6420,7 @@ var require_formdata_parser = __commonJS({ if (dispositionType.toString("ascii").toLowerCase() !== "form-data") { throw parsingError("expected form-data for content-disposition header"); } - while (position.position < input.length && input[position.position] !== 13 && input[position.position + 1] !== 10) { + while (position.position < input.length && (input[position.position] !== 13 || input[position.position + 1] !== 10)) { const attribute = parseContentDispositionAttribute(input, position); if (!attribute) { break; @@ -6391,7 +6428,12 @@ var require_formdata_parser = __commonJS({ if (attribute.name === "name") { name = attribute.value; } else if (attribute.name === "filename") { - filename = attribute.value; + if (attribute.extended) { + filename = attribute.value; + filenameIsExtended = true; + } else if (!filenameIsExtended) { + filename = attribute.value; + } } } if (name === null) { @@ -6427,7 +6469,7 @@ var require_formdata_parser = __commonJS({ ); } } - if (input[position.position] !== 13 && input[position.position + 1] !== 10) { + if (input[position.position] !== 13 || input[position.position + 1] !== 10) { throw parsingError("expected CRLF"); } else { position.position += 2; @@ -6941,9 +6983,9 @@ var require_client_h1 = __commonJS({ let mod; let useWasmSIMD = process.arch !== "ppc64"; if (process.env.UNDICI_NO_WASM_SIMD === "1") { - useWasmSIMD = true; - } else if (process.env.UNDICI_NO_WASM_SIMD === "0") { useWasmSIMD = false; + } else if (process.env.UNDICI_NO_WASM_SIMD === "0") { + useWasmSIMD = true; } if (useWasmSIMD) { try { @@ -7045,6 +7087,7 @@ var require_client_h1 = __commonJS({ var currentBufferRef = null; var currentBufferSize = 0; var currentBufferPtr = null; + var currentBuffer = null; var USE_NATIVE_TIMER = 0; var USE_FAST_TIMER = 1; var TIMEOUT_HEADERS = 2 | USE_FAST_TIMER; @@ -7065,6 +7108,7 @@ var require_client_h1 = __commonJS({ this.client = client; this.socket = socket; this.timeout = null; + this.timeoutWeakRef = new WeakRef(this); this.timeoutValue = null; this.timeoutType = null; this.statusCode = 0; @@ -7078,8 +7122,8 @@ var require_client_h1 = __commonJS({ this.resume = this.resume.bind(this); this.bytesRead = 0; this.keepAlive = ""; - this.contentLength = ""; - this.connection = ""; + this.contentLength = -1; + this.connectionKeepAlive = false; this.maxResponseSize = client[kMaxResponseSize]; } setTimeout(delay, type) { @@ -7090,9 +7134,9 @@ var require_client_h1 = __commonJS({ } if (delay) { if (type & USE_FAST_TIMER) { - this.timeout = timers.setFastTimeout(onParserTimeout, delay, new WeakRef(this)); + this.timeout = timers.setFastTimeout(onParserTimeout, delay, this.timeoutWeakRef); } else { - this.timeout = setTimeout(onParserTimeout, delay, new WeakRef(this)); + this.timeout = setTimeout(onParserTimeout, delay, this.timeoutWeakRef); this.timeout?.unref(); } } @@ -7145,7 +7189,10 @@ var require_client_h1 = __commonJS({ currentBufferSize = Math.ceil(chunk.length / 4096) * 4096; currentBufferPtr = llhttp.malloc(currentBufferSize); } - new Uint8Array(llhttp.memory.buffer, currentBufferPtr, currentBufferSize).set(chunk); + if (currentBuffer === null || currentBuffer.buffer !== llhttp.memory.buffer || currentBuffer.byteOffset !== currentBufferPtr || currentBuffer.byteLength !== currentBufferSize) { + currentBuffer = new Uint8Array(llhttp.memory.buffer, currentBufferPtr, currentBufferSize); + } + currentBuffer.set(chunk); try { let ret; try { @@ -7243,10 +7290,15 @@ var require_client_h1 = __commonJS({ if (headerName === "keep-alive") { this.keepAlive += buf.toString(); } else if (headerName === "connection") { - this.connection += buf.toString(); + this.connectionKeepAlive = this.headers[len - 1].length === 10 && util.bufferToLowerCasedHeaderName(this.headers[len - 1]) === "keep-alive"; } } else if (key.length === 14 && util.bufferToLowerCasedHeaderName(key) === "content-length") { - this.contentLength += buf.toString(); + if (this.contentLength === -1) { + this.contentLength = 0; + } + for (let i = 0; i < buf.length; i++) { + this.contentLength = this.contentLength * 10 + (buf[i] - 48); + } } this.trackHeader(buf.length); return 0; @@ -7323,7 +7375,7 @@ var require_client_h1 = __commonJS({ assert(this.timeoutType === TIMEOUT_HEADERS); this.statusCode = statusCode; this.shouldKeepAlive = shouldKeepAlive || // Override llhttp value which does not allow keepAlive for HEAD. - request.method === "HEAD" && !socket[kReset] && this.connection.toLowerCase() === "keep-alive"; + request.method === "HEAD" && !socket[kReset] && this.connectionKeepAlive; if (this.statusCode >= 200) { const bodyTimeout = request.bodyTimeout != null ? request.bodyTimeout : client[kBodyTimeout]; this.setTimeout(bodyTimeout, TIMEOUT_BODY); @@ -7425,15 +7477,15 @@ var require_client_h1 = __commonJS({ this.statusCode = 0; this.statusText = ""; this.bytesRead = 0; - this.contentLength = ""; + this.contentLength = -1; this.keepAlive = ""; - this.connection = ""; + this.connectionKeepAlive = false; this.headers = []; this.headersSize = 0; if (statusCode < 200) { return 0; } - if (request.method !== "HEAD" && contentLength && bytesRead !== parseInt(contentLength, 10)) { + if (request.method !== "HEAD" && contentLength !== -1 && bytesRead !== contentLength) { util.destroy(socket, new ResponseContentLengthMismatchError()); return -1; } @@ -7701,7 +7753,7 @@ var require_client_h1 = __commonJS({ if (reset != null) { socket[kReset] = reset; } - if (client[kMaxRequests] && socket[kCounter]++ >= client[kMaxRequests]) { + if (client[kMaxRequests] && ++socket[kCounter] >= client[kMaxRequests]) { socket[kReset] = true; } if (blocking) { @@ -7956,7 +8008,7 @@ upgrade: ${upgrade}\r socket[kWriting] = true; } /** - * @param {Buffer} chunk + * @param {string|Uint8Array} chunk * @returns */ write(chunk) { @@ -7967,7 +8019,7 @@ upgrade: ${upgrade}\r if (socket.destroyed) { return false; } - const len = Buffer.byteLength(chunk); + const len = chunk instanceof Uint8Array ? chunk.byteLength : Buffer.byteLength(chunk); if (!len) { return true; } @@ -8109,6 +8161,12 @@ var require_client_h2 = __commonJS({ } = require_symbols(); var { channels } = require_diagnostics(); var kOpenStreams = /* @__PURE__ */ Symbol("open streams"); + var kRequestStreamId = /* @__PURE__ */ Symbol("request stream id"); + var kRequestStream = /* @__PURE__ */ Symbol("request stream"); + var kRequestStreamCleanup = /* @__PURE__ */ Symbol("request stream cleanup"); + var kRequestStreamOnData = /* @__PURE__ */ Symbol("request stream on data"); + var kRequestStreamOnCloseError = /* @__PURE__ */ Symbol("request stream on close error"); + var kReceivedGoAway = /* @__PURE__ */ Symbol("received goaway"); var extractBody; var http2; try { @@ -8126,24 +8184,65 @@ var require_client_h2 = __commonJS({ HTTP2_HEADER_EXPECT, HTTP2_HEADER_STATUS, HTTP2_HEADER_PROTOCOL, - NGHTTP2_REFUSED_STREAM, - NGHTTP2_CANCEL + NGHTTP2_NO_ERROR, + NGHTTP2_REFUSED_STREAM } } = http2; - function parseH2Headers(headers) { - const result = []; - for (const [name, value] of Object.entries(headers)) { - if (Array.isArray(value)) { - for (const subvalue of value) { - result.push(Buffer.from(name), Buffer.from(subvalue)); - } - } else { - result.push(Buffer.from(name), Buffer.from(value)); + function getGoAwayError(session, errorCode) { + return session[kError] || (errorCode === NGHTTP2_NO_ERROR ? new InformationalError(`HTTP/2: "GOAWAY" frame received with code ${errorCode}`) : new SocketError(`HTTP/2: "GOAWAY" frame received with code ${errorCode}`, util.getSocketInfo(session[kSocket]))); + } + __name(getGoAwayError, "getGoAwayError"); + function getGoAwayPendingIdx(client, lastStreamID) { + const maxAcceptedStreamID = Number.isInteger(lastStreamID) ? lastStreamID : Number.MAX_SAFE_INTEGER; + for (let i = client[kRunningIdx]; i < client[kPendingIdx]; i++) { + const request = client[kQueue][i]; + if (request == null) { + continue; + } + if (typeof request[kRequestStreamId] !== "number" || request[kRequestStreamId] > maxAcceptedStreamID) { + return i; + } + } + return client[kPendingIdx]; + } + __name(getGoAwayPendingIdx, "getGoAwayPendingIdx"); + function detachRequestFromStream(request) { + request[kRequestStreamId] = null; + request[kRequestStream] = null; + request[kRequestStreamCleanup] = null; + } + __name(detachRequestFromStream, "detachRequestFromStream"); + function bindRequestToStream(request, stream, cleanup) { + const previousCleanup = request[kRequestStreamCleanup]; + detachRequestFromStream(request); + previousCleanup?.(); + request[kRequestStreamId] = stream.id; + request[kRequestStream] = stream; + request[kRequestStreamCleanup] = cleanup; + } + __name(bindRequestToStream, "bindRequestToStream"); + function clearRequestStream(request) { + const cleanup = request[kRequestStreamCleanup]; + detachRequestFromStream(request); + cleanup?.(); + } + __name(clearRequestStream, "clearRequestStream"); + function canRetryRequestAfterGoAway(request) { + const { body } = request; + return body == null || util.isBuffer(body) || util.isBlobLike(body); + } + __name(canRetryRequestAfterGoAway, "canRetryRequestAfterGoAway"); + function closeRequestStream(request, code = NGHTTP2_REFUSED_STREAM) { + const stream = request[kRequestStream]; + clearRequestStream(request); + if (stream != null && !stream.destroyed && !stream.closed) { + try { + stream.close(code); + } catch { } } - return result; } - __name(parseH2Headers, "parseH2Headers"); + __name(closeRequestStream, "closeRequestStream"); function connectH2(client, socket) { client[kSocket] = socket; const http2InitialWindowSize = client[kHTTP2InitialWindowSize]; @@ -8166,6 +8265,7 @@ var require_client_h2 = __commonJS({ interval: client[kPingInterval] === 0 ? null : setInterval(onHttp2SendPing, client[kPingInterval], session).unref() } }; + session[kReceivedGoAway] = false; session[kEnableConnectProtocol] = false; session[kRemoteSettings] = false; if (http2ConnectionWindowSize) { @@ -8223,6 +8323,12 @@ var require_client_h2 = __commonJS({ * @returns {boolean} */ busy(request) { + if (session[kRemoteSettings] === false && client[kRunning] > 0) { + return true; + } + if (client[kRunning] >= client[kMaxConcurrentStreams]) { + return true; + } if (request != null) { if (client[kRunning] > 0) { if (request.idempotent === false) return true; @@ -8282,7 +8388,7 @@ var require_client_h2 = __commonJS({ session.ping(onPing.bind(session)); function onPing(err, duration) { const client = this[kClient]; - const socket = this[kClient]; + const socket = this[kSocket]; if (err != null) { const error = new InformationalError(`HTTP/2: "PING" errored - type ${err.message}`); socket[kError] = error; @@ -8314,32 +8420,53 @@ var require_client_h2 = __commonJS({ util.destroy(this[kSocket], err); } __name(onHttp2SessionEnd, "onHttp2SessionEnd"); - function onHttp2SessionGoAway(errorCode) { - const err = this[kError] || new SocketError(`HTTP/2: "GOAWAY" frame received with code ${errorCode}`, util.getSocketInfo(this[kSocket])); + function onHttp2SessionGoAway(errorCode, lastStreamID) { + if (this[kReceivedGoAway]) { + return; + } + this[kReceivedGoAway] = true; + const err = getGoAwayError(this, errorCode); const client = this[kClient]; - client[kSocket] = null; - client[kHTTPContext] = null; - this.close(); - this[kHTTP2Session] = null; - util.destroy(this[kSocket], err); - if (client[kRunningIdx] < client[kQueue].length) { - const request = client[kQueue][client[kRunningIdx]]; - client[kQueue][client[kRunningIdx]++] = null; - util.errorRequest(client, request, err); - client[kPendingIdx] = client[kRunningIdx]; + const previousPendingIdx = client[kPendingIdx]; + const pendingIdx = getGoAwayPendingIdx(client, lastStreamID); + const retriableRequests = []; + for (let i = pendingIdx; i < previousPendingIdx; i++) { + const request = client[kQueue][i]; + if (request != null) { + closeRequestStream(request); + if (canRetryRequestAfterGoAway(request)) { + retriableRequests.push(request); + } else { + util.errorRequest(client, request, err); + } + } } - assert(client[kRunning] === 0); + if (pendingIdx !== previousPendingIdx) { + const remainingPendingRequests = client[kQueue].slice(previousPendingIdx); + client[kQueue].length = pendingIdx; + client[kQueue].push(...retriableRequests, ...remainingPendingRequests); + } + if (client[kHTTP2Session] === this) { + client[kSocket] = null; + client[kHTTPContext] = null; + client[kHTTP2Session] = null; + } + if (!this.closed && !this.destroyed) { + this.close(); + } + client[kPendingIdx] = pendingIdx; client.emit("disconnect", client[kUrl], [client], err); - client.emit("connectionError", client[kUrl], [client], err); client[kResume](); } __name(onHttp2SessionGoAway, "onHttp2SessionGoAway"); function onHttp2SessionClose() { - const { [kClient]: client, [kHTTP2SessionState]: state } = this; - const { [kSocket]: socket } = client; - const err = this[kSocket][kError] || this[kError] || new SocketError("closed", util.getSocketInfo(socket)); - client[kSocket] = null; - client[kHTTPContext] = null; + const { [kClient]: client, [kHTTP2SessionState]: state, [kSocket]: socket } = this; + const err = socket[kError] || this[kError] || new SocketError("closed", util.getSocketInfo(socket)); + if (client[kHTTP2Session] === this) { + client[kSocket] = null; + client[kHTTPContext] = null; + client[kHTTP2Session] = null; + } if (state.ping.interval != null) { clearInterval(state.ping.interval); state.ping.interval = null; @@ -8356,12 +8483,19 @@ var require_client_h2 = __commonJS({ __name(onHttp2SessionClose, "onHttp2SessionClose"); function onHttp2SocketClose() { const err = this[kError] || new SocketError("closed", util.getSocketInfo(this)); - const client = this[kHTTP2Session][kClient]; + const session = this[kHTTP2Session]; + const client = session[kClient]; + if (client[kSocket] !== this) { + if (session[kReceivedGoAway] || client[kHTTP2Session] != null && client[kHTTP2Session] !== session) { + return; + } + } client[kSocket] = null; client[kHTTPContext] = null; - if (this[kHTTP2Session] !== null) { - this[kHTTP2Session].destroy(err); + if (client[kHTTP2Session] === session) { + client[kHTTP2Session] = null; } + session.destroy(err); client[kPendingIdx] = client[kRunningIdx]; assert(client[kRunning] === 0); client.emit("disconnect", client[kUrl], [client], err); @@ -8382,6 +8516,34 @@ var require_client_h2 = __commonJS({ this[kClosed] = true; } __name(onSocketClose, "onSocketClose"); + function noop() { + } + __name(noop, "noop"); + function closeStreamSession(stream) { + const session = stream[kHTTP2Session]; + stream[kHTTP2Session] = null; + session[kOpenStreams] -= 1; + if (session[kOpenStreams] === 0) { + session.unref(); + } + } + __name(closeStreamSession, "closeStreamSession"); + function onUpgradeStreamClose() { + this.off("error", noop); + const failUpgradeStream = this[kRequestStreamOnCloseError]; + this[kRequestStreamOnCloseError] = null; + failUpgradeStream(new InformationalError("HTTP/2: stream closed before response headers")); + closeStreamSession(this); + } + __name(onUpgradeStreamClose, "onUpgradeStreamClose"); + function onRequestStreamClose() { + const onData = this[kRequestStreamOnData]; + this[kRequestStreamOnData] = null; + this.off("data", onData); + this.off("error", noop); + closeStreamSession(this); + } + __name(onRequestStreamClose, "onRequestStreamClose"); function shouldSendContentLength(method) { return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT"; } @@ -8425,20 +8587,48 @@ var require_client_h2 = __commonJS({ const { hostname, port } = client[kUrl]; headers[HTTP2_HEADER_AUTHORITY] = host || `${hostname}${port ? `:${port}` : ""}`; headers[HTTP2_HEADER_METHOD] = method; - const abort = /* @__PURE__ */ __name((err) => { + let requestFinalized = false; + const finalizeRequest = /* @__PURE__ */ __name((resetPendingIdx = false) => { + if (requestFinalized) { + return; + } + requestFinalized = true; + client[kQueue][client[kRunningIdx]++] = null; + if (resetPendingIdx) { + client[kPendingIdx] = client[kRunningIdx]; + } + client[kResume](); + }, "finalizeRequest"); + const abort = /* @__PURE__ */ __name((err, resetPendingIdx = false) => { if (request.aborted || request.completed) { return; } err = err || new RequestAbortedError(); util.errorRequest(client, request, err); if (stream != null) { - stream.removeAllListeners("data"); + clearRequestStream(request); stream.close(); client[kOnError](err); - client[kResume](); + finalizeRequest(resetPendingIdx); } util.destroy(body, err); }, "abort"); + const requestStream = /* @__PURE__ */ __name((headers2, options) => { + try { + return session.request(headers2, options); + } catch (err) { + if (err?.code !== "ERR_HTTP2_INVALID_CONNECTION_HEADERS") { + throw err; + } + const wrappedErr = new InformationalError(err.message, { cause: err }); + session[kError] = wrappedErr; + session[kSocket][kError] = wrappedErr; + session.destroy(wrappedErr); + util.destroy(session[kSocket], wrappedErr); + abort(wrappedErr); + return null; + } + }, "requestStream"); try { request.onRequestStart(abort, null); } catch (err) { @@ -8449,6 +8639,67 @@ var require_client_h2 = __commonJS({ } if (upgrade || method === "CONNECT") { session.ref(); + const setupUpgradeStream = /* @__PURE__ */ __name((stream2) => { + let responseReceived2 = false; + const removeUpgradeStreamListeners = /* @__PURE__ */ __name(() => { + stream2.off("response", onUpgradeResponse); + stream2.off("error", onUpgradeStreamError); + stream2.off("end", onUpgradeStreamEnd); + stream2.off("timeout", onUpgradeStreamTimeout); + stream2.off("error", noop); + }, "removeUpgradeStreamListeners"); + const releaseUpgradeStream = /* @__PURE__ */ __name(() => { + if (request[kRequestStream] === stream2) { + detachRequestFromStream(request); + } + removeUpgradeStreamListeners(); + if (!stream2.destroyed && !stream2.closed) { + stream2.once("error", noop); + } + }, "releaseUpgradeStream"); + const failUpgradeStream = /* @__PURE__ */ __name((err) => { + if (responseReceived2 || request.aborted || request.completed) { + return; + } + releaseUpgradeStream(); + abort(err, true); + }, "failUpgradeStream"); + const onUpgradeStreamError = /* @__PURE__ */ __name(() => { + if (typeof stream2.rstCode === "number" && stream2.rstCode !== 0) { + failUpgradeStream(new InformationalError(`HTTP/2: "stream error" received - code ${stream2.rstCode}`)); + } else { + failUpgradeStream(new InformationalError("HTTP/2: stream errored before response headers")); + } + }, "onUpgradeStreamError"); + const onUpgradeStreamEnd = /* @__PURE__ */ __name(() => { + failUpgradeStream(new InformationalError("HTTP/2: stream half-closed (remote)")); + }, "onUpgradeStreamEnd"); + const onUpgradeStreamTimeout = /* @__PURE__ */ __name(() => { + failUpgradeStream(new InformationalError(`HTTP/2: "stream timeout after ${requestTimeout}"`)); + }, "onUpgradeStreamTimeout"); + const onUpgradeResponse = /* @__PURE__ */ __name((headers2, _flags) => { + responseReceived2 = true; + const statusCode = headers2[HTTP2_HEADER_STATUS]; + delete headers2[HTTP2_HEADER_STATUS]; + request.onRequestUpgrade(statusCode, headers2, stream2); + if (request.aborted || request.completed) { + return; + } + removeUpgradeStreamListeners(); + detachRequestFromStream(request); + finalizeRequest(); + }, "onUpgradeResponse"); + bindRequestToStream(request, stream2, releaseUpgradeStream); + stream2.once("response", onUpgradeResponse); + stream2.on("error", onUpgradeStreamError); + stream2.once("end", onUpgradeStreamEnd); + stream2.on("timeout", onUpgradeStreamTimeout); + stream2[kHTTP2Session] = session; + stream2[kRequestStreamOnCloseError] = failUpgradeStream; + stream2.once("close", onUpgradeStreamClose); + ++session[kOpenStreams]; + stream2.setTimeout(requestTimeout); + }, "setupUpgradeStream"); if (upgrade === "websocket") { if (session[kEnableConnectProtocol] === false) { util.errorRequest(client, request, new InformationalError("HTTP/2: Extended CONNECT protocol not supported by server")); @@ -8463,39 +8714,22 @@ var require_client_h2 = __commonJS({ } else { headers[HTTP2_HEADER_SCHEME] = protocol === "http:" ? "http" : "https"; } - stream = session.request(headers, { endStream: false, signal }); + stream = requestStream(headers, { endStream: false, signal }); + if (stream == null) { + session.unref(); + return false; + } stream[kHTTP2Stream] = true; - stream.once("response", (headers2, _flags) => { - const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers2; - request.onRequestUpgrade(statusCode, parseH2Headers(realHeaders), stream); - ++session[kOpenStreams]; - client[kQueue][client[kRunningIdx]++] = null; - }); - stream.on("error", () => { - if (stream.rstCode === NGHTTP2_REFUSED_STREAM || stream.rstCode === NGHTTP2_CANCEL) { - abort(new InformationalError(`HTTP/2: "stream error" received - code ${stream.rstCode}`)); - } - }); - stream.once("close", () => { - session[kOpenStreams] -= 1; - if (session[kOpenStreams] === 0) session.unref(); - }); - stream.setTimeout(requestTimeout); + setupUpgradeStream(stream); return true; } - stream = session.request(headers, { endStream: false, signal }); + stream = requestStream(headers, { endStream: false, signal }); + if (stream == null) { + session.unref(); + return false; + } stream[kHTTP2Stream] = true; - stream.on("response", (headers2) => { - const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers2; - request.onRequestUpgrade(statusCode, parseH2Headers(realHeaders), stream); - ++session[kOpenStreams]; - client[kQueue][client[kRunningIdx]++] = null; - }); - stream.once("close", () => { - session[kOpenStreams] -= 1; - if (session[kOpenStreams] === 0) session.unref(); - }); - stream.setTimeout(requestTimeout); + setupUpgradeStream(stream); return true; } headers[HTTP2_HEADER_PATH] = path; @@ -8515,7 +8749,7 @@ var require_client_h2 = __commonJS({ if (contentLength == null) { contentLength = request.contentLength; } - if (!expectsPayload) { + if (contentLength === 0 && !expectsPayload) { contentLength = null; } if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength != null && request.contentLength !== contentLength) { @@ -8538,91 +8772,129 @@ var require_client_h2 = __commonJS({ } channels.sendHeaders.publish({ request, headers: header, socket: session[kSocket] }); } - const shouldEndStream = method === "GET" || method === "HEAD" || body === null; + const shouldEndStream = body === null; if (expectContinue) { headers[HTTP2_HEADER_EXPECT] = "100-continue"; - stream = session.request(headers, { endStream: shouldEndStream, signal }); + stream = requestStream(headers, { endStream: shouldEndStream, signal }); + if (stream == null) { + return false; + } stream[kHTTP2Stream] = true; - stream.once("continue", writeBodyH2); + bindRequestToStream(request, stream, null); } else { - stream = session.request(headers, { + stream = requestStream(headers, { endStream: shouldEndStream, signal }); + if (stream == null) { + return false; + } stream[kHTTP2Stream] = true; - writeBodyH2(); + bindRequestToStream(request, stream, null); } ++session[kOpenStreams]; stream.setTimeout(requestTimeout); let responseReceived = false; - stream.once("response", (headers2) => { - const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers2; + const onData = /* @__PURE__ */ __name((chunk) => { + if (request.aborted || request.completed) { + return; + } + if (request.onResponseData(chunk) === false) { + stream.pause(); + } + }, "onData"); + const removeRequestStreamListeners = /* @__PURE__ */ __name(() => { + stream.off("error", noop); + stream.off("continue", writeBodyH2); + stream.off("response", onResponse); + stream.off("end", onEnd); + stream.off("error", onError); + stream.off("frameError", onFrameError); + stream.off("aborted", onAborted); + stream.off("timeout", onTimeout); + stream.off("trailers", onTrailers); + stream.off("data", onData); + }, "removeRequestStreamListeners"); + const releaseRequestStream = /* @__PURE__ */ __name(() => { + if (request[kRequestStream] === stream) { + detachRequestFromStream(request); + } + removeRequestStreamListeners(); + if (!stream.destroyed && !stream.closed) { + stream.once("error", noop); + } + }, "releaseRequestStream"); + const onResponse = /* @__PURE__ */ __name((headers2) => { + stream.off("response", onResponse); + const statusCode = headers2[HTTP2_HEADER_STATUS]; + delete headers2[HTTP2_HEADER_STATUS]; request.onResponseStarted(); responseReceived = true; if (request.aborted) { - stream.removeAllListeners("data"); + releaseRequestStream(); return; } - if (request.onResponseStart(Number(statusCode), parseH2Headers(realHeaders), stream.resume.bind(stream), "") === false) { + if (request.onResponseStart(Number(statusCode), headers2, stream.resume.bind(stream), "") === false) { stream.pause(); } - stream.on("data", (chunk) => { - if (request.aborted || request.completed) { - return; - } - if (request.onResponseData(chunk) === false) { - stream.pause(); - } - }); - }); - stream.once("end", () => { - stream.removeAllListeners("data"); + stream.on("data", onData); + }, "onResponse"); + const onEnd = /* @__PURE__ */ __name(() => { + stream.off("end", onEnd); + releaseRequestStream(); if (responseReceived) { if (!request.aborted && !request.completed) { request.onResponseEnd({}); } - client[kQueue][client[kRunningIdx]++] = null; - client[kResume](); + finalizeRequest(); } else { - abort(new InformationalError("HTTP/2: stream half-closed (remote)")); - client[kQueue][client[kRunningIdx]++] = null; - client[kPendingIdx] = client[kRunningIdx]; - client[kResume](); - } - }); - stream.once("close", () => { - stream.removeAllListeners("data"); - session[kOpenStreams] -= 1; - if (session[kOpenStreams] === 0) { - session.unref(); - } - }); - stream.once("error", function(err) { - stream.removeAllListeners("data"); + abort(new InformationalError("HTTP/2: stream half-closed (remote)"), true); + } + }, "onEnd"); + stream[kHTTP2Session] = session; + stream[kRequestStreamOnData] = onData; + stream.once("close", onRequestStreamClose); + const onError = /* @__PURE__ */ __name(function(err) { + stream.off("error", onError); + releaseRequestStream(); abort(err); - }); - stream.once("frameError", (type, code) => { - stream.removeAllListeners("data"); + }, "onError"); + const onFrameError = /* @__PURE__ */ __name((type, code) => { + stream.off("frameError", onFrameError); + releaseRequestStream(); abort(new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`)); - }); - stream.on("aborted", () => { - stream.removeAllListeners("data"); - }); - stream.on("timeout", () => { + }, "onFrameError"); + const onAborted = /* @__PURE__ */ __name(() => { + stream.off("data", onData); + }, "onAborted"); + const onTimeout = /* @__PURE__ */ __name(() => { + releaseRequestStream(); const err = new InformationalError(`HTTP/2: "stream timeout after ${requestTimeout}"`); - stream.removeAllListeners("data"); - session[kOpenStreams] -= 1; - if (session[kOpenStreams] === 0) { - session.unref(); - } abort(err); - }); - stream.once("trailers", (trailers) => { + }, "onTimeout"); + const onTrailers = /* @__PURE__ */ __name((trailers) => { + stream.off("trailers", onTrailers); if (request.aborted || request.completed) { return; } + releaseRequestStream(); request.onResponseEnd(trailers); - }); + finalizeRequest(); + }, "onTrailers"); + bindRequestToStream(request, stream, releaseRequestStream); + if (expectContinue) { + stream.once("continue", writeBodyH2); + } + stream.once("response", onResponse); + stream.once("end", onEnd); + stream.once("error", onError); + stream.once("frameError", onFrameError); + stream.on("aborted", onAborted); + stream.on("timeout", onTimeout); + stream.once("trailers", onTrailers); + if (!expectContinue) { + writeBodyH2(); + } return true; function writeBodyH2() { if (!body || contentLength === 0) { @@ -9394,6 +9666,7 @@ var require_pool = __commonJS({ autoSelectFamily, autoSelectFamilyAttemptTimeout, allowH2, + useH2c, clientTtl, ...options } = {}) { @@ -9411,6 +9684,7 @@ var require_pool = __commonJS({ ...tls, maxCachedSessions, allowH2, + useH2c, socketPath, timeout: connectTimeout, ...typeof autoSelectFamily === "boolean" ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0, @@ -9420,7 +9694,7 @@ var require_pool = __commonJS({ super(options); this[kConnections] = connections || null; this[kUrl] = util.parseOrigin(origin); - this[kOptions] = { ...util.deepClone(options), connect, allowH2, clientTtl, socketPath }; + this[kOptions] = { ...util.deepClone(options), connect, allowH2, useH2c, clientTtl, socketPath }; this[kFactory] = factory; this.on("connect", (origin2, targets) => { if (clientTtl != null && clientTtl > 0) { @@ -9440,9 +9714,11 @@ var require_pool = __commonJS({ } [kGetDispatcher]() { const clientTtlOption = this[kOptions].clientTtl; - for (const client of this[kClients]) { + for (let i = 0; i < this[kClients].length; i++) { + const client = this[kClients][i]; if (clientTtlOption != null && clientTtlOption > 0 && client.ttl && Date.now() - client.ttl > clientTtlOption) { this[kRemoveClient](client); + i--; } else if (!client[kNeedDrain]) { return client; } @@ -9463,7 +9739,7 @@ var require_agent = __commonJS({ "lib/dispatcher/agent.js"(exports2, module2) { "use strict"; var { InvalidArgumentError, MaxOriginsReachedError } = require_errors(); - var { kClients, kRunning, kClose, kDestroy, kDispatch, kUrl } = require_symbols(); + var { kBusy, kClients, kConnected, kRunning, kClose, kDestroy, kDispatch, kUrl } = require_symbols(); var DispatcherBase = require_dispatcher_base(); var Pool = require_pool(); var Client = require_client(); @@ -9516,7 +9792,7 @@ var require_agent = __commonJS({ } get [kRunning]() { let ret = 0; - for (const { dispatcher } of this[kClients].values()) { + for (const dispatcher of this[kClients].values()) { ret += dispatcher[kRunning]; } return ret; @@ -9533,52 +9809,46 @@ var require_agent = __commonJS({ if (this[kOrigins].size >= this[kOptions].maxOrigins && !this[kOrigins].has(origin)) { throw new MaxOriginsReachedError(); } - const result = this[kClients].get(key); - let dispatcher = result && result.dispatcher; + let dispatcher = this[kClients].get(key); if (!dispatcher) { - const closeClientIfUnused = /* @__PURE__ */ __name((connected) => { - const result2 = this[kClients].get(key); - if (result2) { - if (connected) result2.count -= 1; - if (result2.count <= 0) { - this[kClients].delete(key); - if (!result2.dispatcher.destroyed) { - result2.dispatcher.close(); - } - } - let hasOrigin = false; - for (const entry of this[kClients].values()) { - if (entry.origin === origin) { - hasOrigin = true; - break; - } - } - if (!hasOrigin) { - this[kOrigins].delete(origin); + dispatcher = this[kFactory](opts.origin, allowH2 === false ? { ...this[kOptions], allowH2: false } : this[kOptions]); + const closeClientIfUnused = /* @__PURE__ */ __name(() => { + if (this[kClients].get(key) !== dispatcher) { + return; + } + if (dispatcher[kConnected] > 0 || dispatcher[kBusy]) { + return; + } + this[kClients].delete(key); + if (!dispatcher.destroyed) { + dispatcher.close(); + } + let hasOrigin = false; + for (const client of this[kClients].values()) { + if (client[kUrl].origin === dispatcher[kUrl].origin) { + hasOrigin = true; + break; } } - }, "closeClientIfUnused"); - dispatcher = this[kFactory](opts.origin, allowH2 === false ? { ...this[kOptions], allowH2: false } : this[kOptions]).on("drain", this[kOnDrain]).on("connect", (origin2, targets) => { - const result2 = this[kClients].get(key); - if (result2) { - result2.count += 1; + if (!hasOrigin) { + this[kOrigins].delete(dispatcher[kUrl].origin); } - this[kOnConnect](origin2, targets); - }).on("disconnect", (origin2, targets, err) => { - closeClientIfUnused(true); + }, "closeClientIfUnused"); + dispatcher.on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", (origin2, targets, err) => { + closeClientIfUnused(); this[kOnDisconnect](origin2, targets, err); }).on("connectionError", (origin2, targets, err) => { - closeClientIfUnused(false); + closeClientIfUnused(); this[kOnConnectionError](origin2, targets, err); }); - this[kClients].set(key, { count: 0, dispatcher, origin }); + this[kClients].set(key, dispatcher); this[kOrigins].add(origin); } return dispatcher.dispatch(opts, handler); } [kClose]() { const closePromises = []; - for (const { dispatcher } of this[kClients].values()) { + for (const dispatcher of this[kClients].values()) { closePromises.push(dispatcher.close()); } this[kClients].clear(); @@ -9586,7 +9856,7 @@ var require_agent = __commonJS({ } [kDestroy](err) { const destroyPromises = []; - for (const { dispatcher } of this[kClients].values()) { + for (const dispatcher of this[kClients].values()) { destroyPromises.push(dispatcher.destroy(err)); } this[kClients].clear(); @@ -9594,7 +9864,7 @@ var require_agent = __commonJS({ } get stats() { const allClientStats = {}; - for (const { dispatcher } of this[kClients].values()) { + for (const dispatcher of this[kClients].values()) { if (dispatcher.stats) { allClientStats[dispatcher[kUrl].origin] = dispatcher.stats; } @@ -9791,28 +10061,37 @@ var require_socks5_utils = __commonJS({ __name(parseAddress, "parseAddress"); function parseIPv6(address) { const buffer = Buffer2.alloc(16); - const parts = address.split(":"); - let partIndex = 0; - let bufferIndex = 0; - const doubleColonIndex = address.indexOf("::"); + let normalizedAddress = address; + if (address.includes(".")) { + const lastColonIndex = address.lastIndexOf(":"); + const ipv4Part = address.slice(lastColonIndex + 1); + if (net.isIPv4(ipv4Part)) { + const octets = ipv4Part.split(".").map(Number); + const high = (octets[0] << 8 | octets[1]).toString(16); + const low = (octets[2] << 8 | octets[3]).toString(16); + normalizedAddress = `${address.slice(0, lastColonIndex)}:${high}:${low}`; + } + } + const doubleColonIndex = normalizedAddress.indexOf("::"); if (doubleColonIndex !== -1) { - const nonEmptyParts = parts.filter((p) => p.length > 0).length; - const skipParts = 8 - nonEmptyParts; - for (let i = 0; i < parts.length; i++) { - if (parts[i] === "" && i === doubleColonIndex / 3) { - bufferIndex += skipParts * 2; - } else if (parts[i] !== "") { - const value = parseInt(parts[i], 16); - buffer.writeUInt16BE(value, bufferIndex); - bufferIndex += 2; - } + const before = normalizedAddress.slice(0, doubleColonIndex); + const after = normalizedAddress.slice(doubleColonIndex + 2); + const beforeParts = before === "" ? [] : before.split(":"); + const afterParts = after === "" ? [] : after.split(":"); + let bufferIndex = 0; + for (const part of beforeParts) { + buffer.writeUInt16BE(parseInt(part, 16), bufferIndex); + bufferIndex += 2; + } + bufferIndex = 16 - afterParts.length * 2; + for (const part of afterParts) { + buffer.writeUInt16BE(parseInt(part, 16), bufferIndex); + bufferIndex += 2; } } else { - for (const part of parts) { - if (part === "") continue; - const value = parseInt(part, 16); - buffer.writeUInt16BE(value, partIndex * 2); - partIndex++; + const parts = normalizedAddress.split(":"); + for (let i = 0; i < parts.length; i++) { + buffer.writeUInt16BE(parseInt(parts[i], 16), i * 2); } } return buffer; @@ -9922,6 +10201,7 @@ var require_socks5_client = __commonJS({ var { debuglog } = require("node:util"); var { parseAddress } = require_socks5_utils(); var debug = debuglog("undici:socks5"); + var EMPTY_BUFFER = Buffer2.alloc(0); var SOCKS_VERSION = 5; var AUTH_METHODS = { NO_AUTH: 0, @@ -9954,6 +10234,7 @@ var require_socks5_client = __commonJS({ INITIAL: "initial", HANDSHAKING: "handshaking", AUTHENTICATING: "authenticating", + AUTHENTICATED: "authenticated", CONNECTING: "connecting", CONNECTED: "connected", ERROR: "error", @@ -9971,15 +10252,18 @@ var require_socks5_client = __commonJS({ this.socket = socket; this.options = options; this.state = STATES.INITIAL; - this.buffer = Buffer2.alloc(0); + this.buffer = EMPTY_BUFFER; + this.onSocketData = this.onData.bind(this); + this.onSocketError = this.onError.bind(this); + this.onSocketClose = this.onClose.bind(this); this.authMethods = []; if (options.username && options.password) { this.authMethods.push(AUTH_METHODS.USERNAME_PASSWORD); } this.authMethods.push(AUTH_METHODS.NO_AUTH); - this.socket.on("data", this.onData.bind(this)); - this.socket.on("error", this.onError.bind(this)); - this.socket.on("close", this.onClose.bind(this)); + this.socket.on("data", this.onSocketData); + this.socket.on("error", this.onSocketError); + this.socket.on("close", this.onSocketClose); } /** * Handle incoming data from the socket @@ -10028,6 +10312,10 @@ var require_socks5_client = __commonJS({ this.socket.destroy(); } } + markAuthenticated() { + this.state = STATES.AUTHENTICATED; + this.emit("authenticated"); + } /** * Start the SOCKS5 handshake */ @@ -10063,7 +10351,7 @@ var require_socks5_client = __commonJS({ this.buffer = this.buffer.subarray(2); debug("server selected auth method", method); if (method === AUTH_METHODS.NO_AUTH) { - this.emit("authenticated"); + this.markAuthenticated(); } else if (method === AUTH_METHODS.USERNAME_PASSWORD) { this.state = STATES.AUTHENTICATING; this.sendAuthRequest(); @@ -10110,7 +10398,7 @@ var require_socks5_client = __commonJS({ } this.buffer = this.buffer.subarray(2); debug("authentication successful"); - this.emit("authenticated"); + this.markAuthenticated(); } /** * Send CONNECT command @@ -10118,8 +10406,11 @@ var require_socks5_client = __commonJS({ * @param {number} port - Target port */ connect(address, port) { - if (this.state === STATES.CONNECTED) { - throw new InvalidArgumentError("Already connected"); + if (this.state === STATES.CONNECTING || this.state === STATES.CONNECTED) { + throw new InvalidArgumentError("Connection already in progress"); + } + if (this.state !== STATES.AUTHENTICATED) { + throw new InvalidArgumentError("Client must be authenticated before CONNECT"); } debug("connecting to", address, port); this.state = STATES.CONNECTING; @@ -10193,8 +10484,9 @@ var require_socks5_client = __commonJS({ offset += 16; } const boundPort = this.buffer.readUInt16BE(offset); - this.buffer = this.buffer.subarray(responseLength); + this.buffer = EMPTY_BUFFER; this.state = STATES.CONNECTED; + this.socket.removeListener("data", this.onSocketData); debug("connected, bound address:", boundAddress, "port:", boundPort); this.emit("connected", { address: boundAddress, port: boundPort }); } @@ -10244,7 +10536,7 @@ var require_socks5_proxy_agent = __commonJS({ var tls; var DispatcherBase = require_dispatcher_base(); var { InvalidArgumentError } = require_errors(); - var { Socks5Client } = require_socks5_client(); + var { Socks5Client, STATES } = require_socks5_client(); var { kDispatch, kClose, kDestroy } = require_symbols(); var Pool = require_pool(); var buildConnector = require_connect(); @@ -10253,7 +10545,7 @@ var require_socks5_proxy_agent = __commonJS({ var kProxyUrl = /* @__PURE__ */ Symbol("proxy url"); var kProxyHeaders = /* @__PURE__ */ Symbol("proxy headers"); var kProxyAuth = /* @__PURE__ */ Symbol("proxy auth"); - var kPool = /* @__PURE__ */ Symbol("pool"); + var kPools = /* @__PURE__ */ Symbol("pools"); var kConnector = /* @__PURE__ */ Symbol("connector"); var experimentalWarningEmitted = false; var Socks5ProxyAgent = class extends DispatcherBase { @@ -10286,7 +10578,7 @@ var require_socks5_proxy_agent = __commonJS({ ...options.proxyTls, servername: options.proxyTls?.servername || url.hostname }); - this[kPool] = null; + this[kPools] = /* @__PURE__ */ new Map(); } /** * Create a SOCKS5 connection to the proxy @@ -10331,7 +10623,7 @@ var require_socks5_proxy_agent = __commonJS({ socks5Client.removeListener("authenticated", onAuthenticated); authenticationReady.reject(err); }, "onAuthenticationError"); - if (socks5Client.state === "authenticated") { + if (socks5Client.state === STATES.AUTHENTICATED) { clearTimeout(authenticationTimeout); authenticationReady.resolve(); } else { @@ -10367,8 +10659,10 @@ var require_socks5_proxy_agent = __commonJS({ const { origin } = opts; debug("dispatching request to", origin, "via SOCKS5"); try { - if (!this[kPool] || this[kPool].destroyed || this[kPool].closed) { - this[kPool] = new Pool(origin, { + const originKey = String(origin); + let pool = this[kPools].get(originKey); + if (!pool || pool.destroyed || pool.closed) { + pool = new Pool(origin, { pipelining: opts.pipelining, connections: opts.connections, connect: /* @__PURE__ */ __name(async (connectOpts, callback) => { @@ -10401,8 +10695,9 @@ var require_socks5_proxy_agent = __commonJS({ } }, "connect") }); + this[kPools].set(originKey, pool); } - return this[kPool][kDispatch](opts, handler); + return pool[kDispatch](opts, handler); } catch (err) { debug("dispatch error:", err); if (typeof handler.onError === "function") { @@ -10413,14 +10708,20 @@ var require_socks5_proxy_agent = __commonJS({ } } async [kClose]() { - if (this[kPool]) { - await this[kPool].close(); + const closePromises = []; + for (const pool of this[kPools].values()) { + closePromises.push(pool.close()); } + this[kPools].clear(); + await Promise.all(closePromises); } async [kDestroy](err) { - if (this[kPool]) { - await this[kPool].destroy(err); + const destroyPromises = []; + for (const pool of this[kPools].values()) { + destroyPromises.push(pool.destroy(err)); } + this[kPools].clear(); + await Promise.all(destroyPromises); } }; module2.exports = Socks5ProxyAgent; @@ -10542,6 +10843,8 @@ var require_proxy_agent = __commonJS({ this[kProxyHeaders]["proxy-authorization"] = opts.token; } else if (username && password) { this[kProxyHeaders]["proxy-authorization"] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:${decodeURIComponent(password)}`).toString("base64")}`; + } else if (username) { + this[kProxyHeaders]["proxy-authorization"] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:`).toString("base64")}`; } const connect = buildConnector({ timeout: connectTimeout, ...opts.proxyTls }); this[kConnectEndpoint] = buildConnector({ timeout: connectTimeout, ...opts.requestTls }); @@ -12706,6 +13009,32 @@ var require_fetch = __commonJS({ var GET_OR_HEAD = ["GET", "HEAD"]; var defaultUserAgent = typeof __UNDICI_IS_NODE__ !== "undefined" || true ? "node" : "undici"; var resolveObjectURL; + function appendHeadersListFromResponseHeaders(headersList, headers, rawHeaders) { + if (Array.isArray(rawHeaders)) { + for (let i = 0; i < rawHeaders.length; i += 2) { + const nameStr = bufferToLowerCasedHeaderName(rawHeaders[i]); + const value = rawHeaders[i + 1]; + if (Array.isArray(value) && !Buffer.isBuffer(value)) { + for (const val of value) { + headersList.append(nameStr, val.toString("latin1"), true); + } + } else { + headersList.append(nameStr, value.toString("latin1"), true); + } + } + return; + } + for (const [name, value] of Object.entries(headers ?? {})) { + if (Array.isArray(value)) { + for (const entry of value) { + headersList.append(name, `${entry}`, true); + } + } else { + headersList.append(name, `${value}`, true); + } + } + } + __name(appendHeadersListFromResponseHeaders, "appendHeadersListFromResponseHeaders"); var Fetch = class extends EE { static { __name(this, "Fetch"); @@ -13148,7 +13477,7 @@ var require_fetch = __commonJS({ cacheState = ""; } let responseStatus = 0; - if (fetchParams.request.mode !== "navigator" || !response.hasCrossOriginRedirects) { + if (fetchParams.request.mode !== "navigate" || !response.hasCrossOriginRedirects) { responseStatus = response.status; const mimeType = extractMimeType(response.headersList); if (mimeType !== "failure") { @@ -13315,7 +13644,7 @@ var require_fetch = __commonJS({ if (contentLength != null) { contentLengthHeaderValue = isomorphicEncode(`${contentLength}`); } - if (contentLengthHeaderValue != null) { + if (contentLengthHeaderValue != null && !httpRequest.headersList.contains("content-length", true)) { httpRequest.headersList.append("content-length", contentLengthHeaderValue, true); } if (contentLength != null && httpRequest.keepalive) { @@ -13638,23 +13967,13 @@ var require_fetch = __commonJS({ onResponseStarted() { timingInfo.finalNetworkResponseStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability); }, - onResponseStart(controller, status, _headers, statusText) { + onResponseStart(controller, status, headers, statusText) { if (status < 200) { return; } const rawHeaders = controller?.rawHeaders ?? []; const headersList = new HeadersList(); - for (let i = 0; i < rawHeaders.length; i += 2) { - const nameStr = bufferToLowerCasedHeaderName(rawHeaders[i]); - const value = rawHeaders[i + 1]; - if (Array.isArray(value) && !Buffer.isBuffer(rawHeaders[i + 1])) { - for (const val of value) { - headersList.append(nameStr, val.toString("latin1"), true); - } - } else { - headersList.append(nameStr, value.toString("latin1"), true); - } - } + appendHeadersListFromResponseHeaders(headersList, headers, rawHeaders); const location = headersList.get("location", true); this.body = new Readable({ read: /* @__PURE__ */ __name(() => controller.resume(), "read") }); const willFollow = location && request.redirect === "follow" && redirectStatusSet.has(status); @@ -13740,23 +14059,13 @@ var require_fetch = __commonJS({ fetchParams.controller.terminate(error); reject(error); }, - onRequestUpgrade(controller, status, _headers, socket) { + onRequestUpgrade(controller, status, headers, socket) { if (socket.session != null && status !== 200 || socket.session == null && status !== 101) { return false; } const rawHeaders = controller?.rawHeaders ?? []; const headersList = new HeadersList(); - for (let i = 0; i < rawHeaders.length; i += 2) { - const nameStr = bufferToLowerCasedHeaderName(rawHeaders[i]); - const value = rawHeaders[i + 1]; - if (Array.isArray(value) && !Buffer.isBuffer(rawHeaders[i + 1])) { - for (const val of value) { - headersList.append(nameStr, val.toString("latin1"), true); - } - } else { - headersList.append(nameStr, value.toString("latin1"), true); - } - } + appendHeadersListFromResponseHeaders(headersList, headers, rawHeaders); resolve({ status, statusText: STATUS_CODES[status], @@ -14318,12 +14627,7 @@ var require_frame = __commonJS({ var BUFFER_SIZE = 8 * 1024; var buffer = null; var bufIdx = BUFFER_SIZE; - var randomFillSync = runtimeFeatures.has("crypto") ? require("node:crypto").randomFillSync : /* @__PURE__ */ __name(function randomFillSync2(buffer2, _offset, _size) { - for (let i = 0; i < buffer2.length; ++i) { - buffer2[i] = Math.random() * 255 | 0; - } - return buffer2; - }, "randomFillSync"); + var randomFillSync = runtimeFeatures.has("crypto") ? require("node:crypto").randomFillSync : null; function generateMask() { if (bufIdx === BUFFER_SIZE) { bufIdx = 0; @@ -15628,6 +15932,43 @@ var require_eventsource_stream = __commonJS({ var CR = 13; var COLON = 58; var SPACE = 32; + var DATA = Buffer.from("data"); + var EVENT = Buffer.from("event"); + var ID = Buffer.from("id"); + var RETRY = Buffer.from("retry"); + function isASCIINumberBytes(buffer, start) { + if (start >= buffer.length) { + return false; + } + for (let i = start; i < buffer.length; i++) { + if (buffer[i] < 48 || buffer[i] > 57) { + return false; + } + } + return true; + } + __name(isASCIINumberBytes, "isASCIINumberBytes"); + function isValidLastEventIdBytes(buffer, start) { + for (let i = start; i < buffer.length; i++) { + if (buffer[i] === 0) { + return false; + } + } + return true; + } + __name(isValidLastEventIdBytes, "isValidLastEventIdBytes"); + function isFieldName(line, length, field) { + if (length !== field.length) { + return false; + } + for (let i = 0; i < length; i++) { + if (line[i] !== field[i]) { + return false; + } + } + return true; + } + __name(isFieldName, "isFieldName"); var EventSourceStream = class extends Transform { static { __name(this, "EventSourceStream"); @@ -15650,10 +15991,13 @@ var require_eventsource_stream = __commonJS({ */ eventEndCheck = false; /** - * @type {Buffer|null} + * @type {Buffer[]} */ - buffer = null; + chunks = []; + chunkIndex = 0; pos = 0; + lineChunkIndex = 0; + linePos = 0; event = { data: void 0, event: void 0, @@ -15685,63 +16029,30 @@ var require_eventsource_stream = __commonJS({ callback(); return; } - if (this.buffer) { - this.buffer = Buffer.concat([this.buffer, chunk]); - } else { - this.buffer = chunk; - } + this.chunks.push(chunk); if (this.checkBOM) { - switch (this.buffer.length) { - case 1: - if (this.buffer[0] === BOM[0]) { - callback(); - return; - } - this.checkBOM = false; - callback(); - return; - case 2: - if (this.buffer[0] === BOM[0] && this.buffer[1] === BOM[1]) { - callback(); - return; - } - this.checkBOM = false; - break; - case 3: - if (this.buffer[0] === BOM[0] && this.buffer[1] === BOM[1] && this.buffer[2] === BOM[2]) { - this.buffer = Buffer.alloc(0); - this.checkBOM = false; - callback(); - return; - } - this.checkBOM = false; - break; - default: - if (this.buffer[0] === BOM[0] && this.buffer[1] === BOM[1] && this.buffer[2] === BOM[2]) { - this.buffer = this.buffer.subarray(3); - } - this.checkBOM = false; - break; + if (this.handleBOM()) { + callback(); + return; } } - while (this.pos < this.buffer.length) { + while (this.hasCurrentByte()) { + const byte = this.currentByte(); if (this.eventEndCheck) { if (this.crlfCheck) { - if (this.buffer[this.pos] === LF) { - this.buffer = this.buffer.subarray(this.pos + 1); - this.pos = 0; + if (byte === LF) { this.crlfCheck = false; + this.consumeCurrentByte(); continue; } this.crlfCheck = false; } - if (this.buffer[this.pos] === LF || this.buffer[this.pos] === CR) { - if (this.buffer[this.pos] === CR) { + if (byte === LF || byte === CR) { + if (byte === CR) { this.crlfCheck = true; } - this.buffer = this.buffer.subarray(this.pos + 1); - this.pos = 0; - if (this.event.data !== void 0 || this.event.event || this.event.id !== void 0 || this.event.retry) { + this.consumeCurrentByte(); + if (this.hasPendingEvent()) { this.processEvent(this.event); } this.clearEvent(); @@ -15750,17 +16061,16 @@ var require_eventsource_stream = __commonJS({ this.eventEndCheck = false; continue; } - if (this.buffer[this.pos] === LF || this.buffer[this.pos] === CR) { - if (this.buffer[this.pos] === CR) { + if (byte === LF || byte === CR) { + if (byte === CR) { this.crlfCheck = true; } - this.parseLine(this.buffer.subarray(0, this.pos), this.event); - this.buffer = this.buffer.subarray(this.pos + 1); - this.pos = 0; + this.parseLine(this.readLine(), this.event); + this.consumeCurrentByte(); this.eventEndCheck = true; continue; } - this.pos++; + this.advanceCursor(); } callback(); } @@ -15776,43 +16086,42 @@ var require_eventsource_stream = __commonJS({ if (colonPosition === 0) { return; } - let field = ""; - let value = ""; + let fieldLength = line.length; + let valueStart = line.length; if (colonPosition !== -1) { - field = line.subarray(0, colonPosition).toString("utf8"); - let valueStart = colonPosition + 1; + fieldLength = colonPosition; + valueStart = colonPosition + 1; if (line[valueStart] === SPACE) { ++valueStart; } - value = line.subarray(valueStart).toString("utf8"); - } else { - field = line.toString("utf8"); - value = ""; } - switch (field) { - case "data": - if (event[field] === void 0) { - event[field] = value; - } else { - event[field] += ` + if (isFieldName(line, fieldLength, DATA)) { + const value = line.toString("utf8", valueStart); + if (event.data === void 0) { + event.data = value; + } else { + event.data += ` ${value}`; - } - break; - case "retry": - if (isASCIINumber(value)) { - event[field] = value; - } - break; - case "id": - if (isValidLastEventId(value)) { - event[field] = value; - } - break; - case "event": - if (value.length > 0) { - event[field] = value; - } - break; + } + return; + } + if (isFieldName(line, fieldLength, RETRY)) { + if (isASCIINumberBytes(line, valueStart)) { + event.retry = line.toString("utf8", valueStart); + } + return; + } + if (isFieldName(line, fieldLength, ID)) { + if (isValidLastEventIdBytes(line, valueStart)) { + event.id = line.toString("utf8", valueStart); + } + return; + } + if (isFieldName(line, fieldLength, EVENT)) { + const value = line.toString("utf8", valueStart); + if (value.length > 0) { + event.event = value; + } } } /** @@ -15837,12 +16146,120 @@ ${value}`; } } clearEvent() { - this.event = { - data: void 0, - event: void 0, - id: void 0, - retry: void 0 - }; + this.event.data = void 0; + this.event.event = void 0; + this.event.id = void 0; + this.event.retry = void 0; + } + hasPendingEvent() { + return this.event.data !== void 0 || this.event.event !== void 0 || this.event.id !== void 0 || this.event.retry !== void 0; + } + hasCurrentByte() { + return this.chunkIndex < this.chunks.length && this.pos < this.chunks[this.chunkIndex].length; + } + currentByte() { + return this.chunks[this.chunkIndex][this.pos]; + } + consumeCurrentByte() { + this.advanceCursor(); + this.syncLineStartToCursor(); + } + advanceCursor() { + this.pos++; + while (this.chunkIndex < this.chunks.length && this.pos >= this.chunks[this.chunkIndex].length) { + this.chunkIndex++; + this.pos = 0; + } + } + syncLineStartToCursor() { + this.lineChunkIndex = this.chunkIndex; + this.linePos = this.pos; + this.dropConsumedChunks(); + } + dropConsumedChunks() { + while (this.lineChunkIndex > 0) { + this.chunks.shift(); + this.lineChunkIndex--; + this.chunkIndex--; + } + if (this.chunkIndex === this.chunks.length) { + this.chunks.length = 0; + this.chunkIndex = 0; + this.pos = 0; + this.lineChunkIndex = 0; + this.linePos = 0; + } + } + readLine() { + if (this.lineChunkIndex === this.chunkIndex) { + return this.chunks[this.chunkIndex].subarray(this.linePos, this.pos); + } + const chunks = []; + let length = 0; + for (let i = this.lineChunkIndex; i <= this.chunkIndex; i++) { + const chunk = this.chunks[i]; + const start = i === this.lineChunkIndex ? this.linePos : 0; + const end = i === this.chunkIndex ? this.pos : chunk.length; + const slice = chunk.subarray(start, end); + length += slice.length; + chunks.push(slice); + } + return Buffer.concat(chunks, length); + } + peekBufferedByte(offset) { + let chunkIndex = this.lineChunkIndex; + let pos = this.linePos; + while (chunkIndex < this.chunks.length) { + const chunk = this.chunks[chunkIndex]; + const remaining = chunk.length - pos; + if (offset < remaining) { + return chunk[pos + offset]; + } + offset -= remaining; + chunkIndex++; + pos = 0; + } + } + discardLeadingBytes(count) { + while (count > 0 && this.lineChunkIndex < this.chunks.length) { + const chunk = this.chunks[this.lineChunkIndex]; + const remaining = chunk.length - this.linePos; + if (count < remaining) { + this.linePos += count; + count = 0; + } else { + count -= remaining; + this.lineChunkIndex++; + this.linePos = 0; + } + } + this.chunkIndex = this.lineChunkIndex; + this.pos = this.linePos; + this.dropConsumedChunks(); + } + handleBOM() { + const first = this.peekBufferedByte(0); + const second = this.peekBufferedByte(1); + const third = this.peekBufferedByte(2); + if (second === void 0) { + if (first === BOM[0]) { + return true; + } + this.checkBOM = false; + return true; + } + if (third === void 0) { + if (first === BOM[0] && second === BOM[1]) { + return true; + } + this.checkBOM = false; + return false; + } + if (first === BOM[0] && second === BOM[1] && third === BOM[2]) { + this.discardLeadingBytes(3); + } + this.checkBOM = false; + return !this.hasCurrentByte(); } }; module2.exports = { @@ -16176,6 +16593,7 @@ var require_readable = __commonJS({ "lib/api/readable.js"(exports2, module2) { "use strict"; var assert = require("node:assert"); + var { addAbortListener } = require("node:events"); var { Readable } = require("node:stream"); var { RequestAbortedError, NotSupportedError, InvalidArgumentError, AbortError } = require_errors(); var util = require_util(); @@ -16404,9 +16822,9 @@ var require_readable = __commonJS({ const onAbort = /* @__PURE__ */ __name(() => { this.destroy(signal.reason ?? new AbortError()); }, "onAbort"); - signal.addEventListener("abort", onAbort); + const abortListener = addAbortListener(signal, onAbort); this.on("close", function() { - signal.removeEventListener("abort", onAbort); + abortListener[Symbol.dispose](); if (signal.aborted) { reject(signal.reason ?? new AbortError()); } else { @@ -16610,7 +17028,7 @@ var require_api_request = __commonJS({ if (typeof callback !== "function") { throw new InvalidArgumentError("invalid callback"); } - if (highWaterMark && (typeof highWaterMark !== "number" || highWaterMark < 0)) { + if (highWaterMark != null && (!Number.isFinite(highWaterMark) || highWaterMark < 0)) { throw new InvalidArgumentError("invalid highWaterMark"); } if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") { @@ -16669,7 +17087,7 @@ var require_api_request = __commonJS({ onResponseStart(controller, statusCode, headers, statusText) { const { callback, opaque, context, responseHeaders, highWaterMark } = this; const rawHeaders = controller?.rawHeaders; - const responseHeaderData = responseHeaders === "raw" ? Array.isArray(rawHeaders) ? util.parseRawHeaders(rawHeaders) : [] : headers; + const responseHeaderData = responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : headers; if (statusCode < 200) { if (this.onInfo) { this.onInfo({ statusCode, headers: responseHeaderData }); @@ -16920,7 +17338,7 @@ var require_api_stream = __commonJS({ onResponseStart(controller, statusCode, headers, _statusMessage) { const { factory, opaque, context, responseHeaders } = this; const rawHeaders = controller?.rawHeaders; - const responseHeaderData = responseHeaders === "raw" ? Array.isArray(rawHeaders) ? util.parseRawHeaders(rawHeaders) : [] : headers; + const responseHeaderData = responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : headers; if (statusCode < 200) { if (this.onInfo) { this.onInfo({ statusCode, headers: responseHeaderData }); @@ -17164,7 +17582,7 @@ var require_api_pipeline = __commonJS({ if (statusCode < 200) { if (this.onInfo) { const rawHeaders = controller?.rawHeaders; - const responseHeaders = this.responseHeaders === "raw" ? Array.isArray(rawHeaders) ? util.parseRawHeaders(rawHeaders) : [] : headers; + const responseHeaders = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : headers; this.onInfo({ statusCode, headers: responseHeaders }); } return; @@ -17174,7 +17592,7 @@ var require_api_pipeline = __commonJS({ try { this.handler = null; const rawHeaders = controller?.rawHeaders; - const responseHeaders = this.responseHeaders === "raw" ? Array.isArray(rawHeaders) ? util.parseRawHeaders(rawHeaders) : [] : headers; + const responseHeaders = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : headers; body = this.runInAsyncScope(handler, null, { statusCode, headers: responseHeaders, @@ -17284,12 +17702,17 @@ var require_api_upgrade = __commonJS({ throw new SocketError("bad upgrade", null); } onRequestUpgrade(controller, statusCode, headers, socket) { - assert(socket[kHTTP2Stream] === true ? statusCode === 200 : statusCode === 101); + const expectedStatusCode = socket[kHTTP2Stream] === true ? 200 : 101; + if (statusCode !== expectedStatusCode) { + const socketInfo = socket[kHTTP2Stream] === true ? null : util.getSocketInfo(socket); + controller.abort(new SocketError("bad upgrade", socketInfo)); + return; + } const { callback, opaque, context } = this; removeSignal(this); this.callback = null; const rawHeaders = controller?.rawHeaders; - const responseHeaders = this.responseHeaders === "raw" ? Array.isArray(rawHeaders) ? util.parseRawHeaders(rawHeaders) : [] : headers; + const responseHeaders = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : headers; this.runInAsyncScope(callback, null, null, { headers: responseHeaders, socket, @@ -17387,7 +17810,7 @@ var require_api_connect = __commonJS({ let responseHeaders = headers; const rawHeaders = controller?.rawHeaders; if (responseHeaders != null) { - responseHeaders = this.responseHeaders === "raw" ? Array.isArray(rawHeaders) ? util.parseRawHeaders(rawHeaders) : [] : headers; + responseHeaders = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : headers; } this.runInAsyncScope(callback, null, null, { statusCode, diff --git a/src/undici_version.h b/src/undici_version.h index aa33bd829f8307..7514ec8d4c236b 100644 --- a/src/undici_version.h +++ b/src/undici_version.h @@ -2,5 +2,5 @@ // Refer to tools/dep_updaters/update-undici.sh #ifndef SRC_UNDICI_VERSION_H_ #define SRC_UNDICI_VERSION_H_ -#define UNDICI_VERSION "8.1.0" +#define UNDICI_VERSION "8.2.0" #endif // SRC_UNDICI_VERSION_H_ From 480ee085f28c5915c3fb3b4cea3a723d9cf2ea26 Mon Sep 17 00:00:00 2001 From: Moshe Atlow Date: Tue, 5 May 2026 12:22:14 +0300 Subject: [PATCH 063/168] test_runner: fix failing suite hooks when marked with `todo` MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Moshe Atlow PR-URL: https://github.com/nodejs/node/pull/63097 Reviewed-By: Chemi Atlow Reviewed-By: Benjamin Gruenbaum Reviewed-By: Aviv Keller Reviewed-By: Jacob Smith Reviewed-By: Ulises Gascón --- lib/internal/test_runner/utils.js | 2 +- .../test-runner/todo-suite-failing-hook.mjs | 10 ++++++++ .../test-runner-todo-suite-hook-failure.js | 24 +++++++++++++++++++ 3 files changed, 35 insertions(+), 1 deletion(-) create mode 100644 test/fixtures/test-runner/todo-suite-failing-hook.mjs create mode 100644 test/parallel/test-runner-todo-suite-hook-failure.js diff --git a/lib/internal/test_runner/utils.js b/lib/internal/test_runner/utils.js index 831cb07d512e93..e62bdca8694bae 100644 --- a/lib/internal/test_runner/utils.js +++ b/lib/internal/test_runner/utils.js @@ -451,7 +451,7 @@ function countCompletedTest(test, harness = test.root.harness) { } if (test.reportedType === 'suite') { harness.counters.suites++; - if (!test.passed) { + if (!test.passed && !test.isTodo) { harness.success = false; } return; diff --git a/test/fixtures/test-runner/todo-suite-failing-hook.mjs b/test/fixtures/test-runner/todo-suite-failing-hook.mjs new file mode 100644 index 00000000000000..6c3291253cdc4a --- /dev/null +++ b/test/fixtures/test-runner/todo-suite-failing-hook.mjs @@ -0,0 +1,10 @@ +import { before, describe, it } from 'node:test'; + +describe('todo suite with failing before hook', { todo: 'evaluating' }, () => { + before(() => { + throw new Error('simulated cleanup failure'); + }); + + it('child 1', () => {}); + it('child 2', () => {}); +}); diff --git a/test/parallel/test-runner-todo-suite-hook-failure.js b/test/parallel/test-runner-todo-suite-hook-failure.js new file mode 100644 index 00000000000000..f0192da636a1c0 --- /dev/null +++ b/test/parallel/test-runner-todo-suite-hook-failure.js @@ -0,0 +1,24 @@ +'use strict'; +require('../common'); +const assert = require('assert'); +const { spawnSync } = require('child_process'); +const fixtures = require('../common/fixtures'); + +// A `before` hook failure inside a suite marked `todo` must not fail the run. +// The `todo` flag on a suite signals that its results are advisory, the same +// way it does on individual tests. Before this fix, the suite branch of +// `countCompletedTest` flipped `harness.success` for any non-passing suite +// regardless of `isTodo`, so a hook failure exited with code 1 even though +// no failing tests were reported. +const child = spawnSync(process.execPath, [ + '--test', + '--test-reporter=tap', + fixtures.path('test-runner', 'todo-suite-failing-hook.mjs'), +]); + +const stdout = child.stdout.toString(); +assert.strictEqual(child.signal, null); +assert.strictEqual(child.status, 0, + `expected exit 0, got ${child.status}\nstdout:\n${stdout}\nstderr:\n${child.stderr}`); +assert.match(stdout, /# fail 0/); +assert.match(stdout, /# todo 2/); From 9a076c8acbe62f274aa3689c91ac98c8c4d9b7c2 Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Tue, 5 May 2026 12:09:43 +0200 Subject: [PATCH 064/168] tools: use `npm ci` in Undici update script MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/63098 Refs: https://github.com/nodejs/undici/pull/5139 Reviewed-By: René Reviewed-By: Matthew Aitken Reviewed-By: Chemi Atlow Reviewed-By: Luigi Pinca Reviewed-By: Trivikram Kamat --- tools/dep_updaters/update-undici.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/dep_updaters/update-undici.sh b/tools/dep_updaters/update-undici.sh index 4ba532f99bf423..05d8fb9d8ecd24 100755 --- a/tools/dep_updaters/update-undici.sh +++ b/tools/dep_updaters/update-undici.sh @@ -75,7 +75,7 @@ mv "$DEPS_DIR/undici"/undici-* "$DEPS_DIR/undici/src" # Rebuild components from source rm lib/llhttp/llhttp*.* - "$NODE" "$NPM" install --ignore-scripts + "$NODE" "$NPM" ci --ignore-scripts "$NODE" "$NPM" run build:wasm > lib/llhttp/wasm_build_env.txt "$NODE" "$NPM" run build:node "$NODE" "$NPM" prune --production From 60e4f7b2528b933c0bba0c368e623953875b0186 Mon Sep 17 00:00:00 2001 From: David Thornton Date: Tue, 5 May 2026 22:16:04 +1000 Subject: [PATCH 065/168] doc: fix the TypeScript Execute (tsx) project link MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: David Thornton PR-URL: https://github.com/nodejs/node/pull/63093 Reviewed-By: Jacob Smith Reviewed-By: Luigi Pinca Reviewed-By: René --- doc/api/typescript.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/api/typescript.md b/doc/api/typescript.md index 19ddc75c105bb5..3babb2a11263fe 100644 --- a/doc/api/typescript.md +++ b/doc/api/typescript.md @@ -229,7 +229,7 @@ with `#`. [`--no-strip-types`]: cli.md#--no-strip-types [`ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX`]: errors.md#err_unsupported_typescript_syntax [`tsconfig` "paths"]: https://www.typescriptlang.org/tsconfig/#paths -[`tsx`]: https://tsx.is/ +[`tsx`]: https://tsx.hirok.io/ [`verbatimModuleSyntax`]: https://www.typescriptlang.org/tsconfig/#verbatimModuleSyntax [file extensions are mandatory]: esm.md#mandatory-file-extensions [full support]: #full-typescript-support From 6df4f7bf27ffd93d20a2ebade04f1de92d5231e3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ren=C3=A9?= Date: Tue, 5 May 2026 13:46:54 +0100 Subject: [PATCH 066/168] stream: remove redundant method check from iter.pipeToSync Signed-off-by: Renegade334 PR-URL: https://github.com/nodejs/node/pull/63099 Reviewed-By: Antoine du Hamel Reviewed-By: Matteo Collina Reviewed-By: James M Snell Reviewed-By: Luigi Pinca --- lib/internal/streams/iter/pull.js | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/lib/internal/streams/iter/pull.js b/lib/internal/streams/iter/pull.js index df5ca2826a9ac5..a228f052a8e433 100644 --- a/lib/internal/streams/iter/pull.js +++ b/lib/internal/streams/iter/pull.js @@ -764,7 +764,6 @@ function pipeToSync(source, ...args) { normalized; let totalBytes = 0; - const hasWriteSync = typeof writer.writeSync === 'function'; const hasWritevSync = typeof writer.writevSync === 'function'; const hasEndSync = typeof writer.endSync === 'function'; @@ -778,11 +777,7 @@ function pipeToSync(source, ...args) { } else { for (let i = 0; i < batch.length; i++) { const chunk = batch[i]; - if (hasWriteSync) { - writer.writeSync(chunk); - } else { - writer.write(chunk); - } + writer.writeSync(chunk); totalBytes += TypedArrayPrototypeGetByteLength(chunk); } } From 9e633f94ce1419870c8decf1a98863ee75518e4e Mon Sep 17 00:00:00 2001 From: RafaelGSS Date: Tue, 31 Mar 2026 16:19:47 -0300 Subject: [PATCH 067/168] 2026-05-05, Version 26.0.0 (Current) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit assert: * (SEMVER-MAJOR) allow printf-style messages as assertion error (Ruben Bridgewater) https://github.com/nodejs/node/pull/58849 build: * (SEMVER-MAJOR) bump GCC requirement to 13.2 (Michaël Zasso) https://github.com/nodejs/node/pull/62555 * (SEMVER-MAJOR) enable Temporal by default (Richard Lau) https://github.com/nodejs/node/pull/61806 * (SEMVER-MAJOR) enable V8_VERIFY_WRITE_BARRIERS in debug build (Joyee Cheung) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) reset embedder string to "-node.0" (Michaël Zasso) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) target Power 9 for AIX/IBM i (Richard Lau) https://github.com/nodejs/node/pull/62296 * (SEMVER-MAJOR) drop support for Python 3.9 (Mike McCready) https://github.com/nodejs/node/pull/61177 * (SEMVER-MAJOR) enable maglev for Linux on s390x (Richard Lau) https://github.com/nodejs/node/pull/60863 * (SEMVER-MAJOR) reset embedder string to "-node.0" (Michaël Zasso) https://github.com/nodejs/node/pull/60488 * (SEMVER-MAJOR) reset embedder string to "-node.0" (Michaël Zasso) https://github.com/nodejs/node/pull/60111 build,test: * (CVE-2026-21717) (SEMVER-MAJOR) test array index hash collision (Joyee Cheung) https://github.com/nodejs/node/pull/61898 build,win: * (SEMVER-MAJOR) fix Temporal build (StefanStojanovic) https://github.com/nodejs/node/pull/61806 crypto: * (SEMVER-MAJOR) unify asymmetric key import through KeyObjectHandle::Init (Filip Skokan) https://github.com/nodejs/node/pull/62499 * (SEMVER-MAJOR) runtime-deprecate DEP0203 and DEP0204 (Filip Skokan) https://github.com/nodejs/node/pull/62453 * (SEMVER-MAJOR) decorate async crypto job errors with OpenSSL error details (Filip Skokan) https://github.com/nodejs/node/pull/62348 * (SEMVER-MAJOR) default ML-KEM and ML-DSA pkcs8 export to seed-only format (Filip Skokan) https://github.com/nodejs/node/pull/62178 * (SEMVER-MAJOR) move DEP0182 to End-of-Life (Tobias Nießen) https://github.com/nodejs/node/pull/61084 * (SEMVER-MAJOR) fix DOMException name for non-extractable key error (Filip Skokan) https://github.com/nodejs/node/pull/60830 deps: * (SEMVER-MAJOR) V8: cherry-pick 0f024d4e66e0 (ishabi) https://github.com/nodejs/node/pull/62408 * (SEMVER-MAJOR) fix V8 race condition for AIX (Abdirahim Musse) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) V8: cherry-pick cd2c216e7658 (LuYahan) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) V8: backport 088b7112e7ab (Igor Sheludko) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) V8: cherry-pick 00f6e834029f (Joyee Cheung) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) V8: backport bef0d9c1bc90 (Joyee Cheung) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) V8: cherry-pick cf1bce40a5ef (Richard Lau) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) V8: cherry-pick daf4656ba85e (Milad Fa) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) V8: cherry-pick d83f479604c8 (Joyee Cheung) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) V8: cherry-pick edeb0a4fa181 (Joyee Cheung) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) V8: cherry-pick aa0b288f87cc (Richard Lau) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) patch V8 to fix Windows build (StefanStojanovic) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) V8: cherry-pick highway@989a498fdf3 (Richard Lau) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) support madvise(3C) across ALL illumos revisions (Dan McDonald) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) patch V8 for illumos (Dan McDonald) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) remove problematic comment from v8-internal (Michaël Zasso) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) define V8_PRESERVE_MOST as no-op on Windows (Stefan Stojanovic) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) patch V8 to avoid duplicated zlib symbol (Michaël Zasso) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) update V8 to 14.6.202.33 (Michaël Zasso) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) update undici to 8.0.2 (Node.js GitHub Bot) https://github.com/nodejs/node/pull/62384 * (SEMVER-MAJOR) V8: backport 151d0a44a1b2 (Abdirahim Musse) https://github.com/nodejs/node/pull/60488 * (SEMVER-MAJOR) V8: cherry-pick 47800791b35c (Jakob Kummerow) https://github.com/nodejs/node/pull/60488 * (SEMVER-MAJOR) patch V8 for illumos (Dan McDonald) https://github.com/nodejs/node/pull/59805 * (SEMVER-MAJOR) use std::map in MSVC STL for EphemeronRememberedSet (Joyee Cheung) https://github.com/nodejs/node/pull/58070 * (SEMVER-MAJOR) remove problematic comment from v8-internal (Michaël Zasso) https://github.com/nodejs/node/pull/58070 * (SEMVER-MAJOR) patch V8 to avoid duplicated zlib symbol (Michaël Zasso) https://github.com/nodejs/node/pull/54077 * (SEMVER-MAJOR) update V8 to 14.3.127.12 (Michaël Zasso) https://github.com/nodejs/node/pull/60488 * (SEMVER-MAJOR) V8: cherry-pick ff34ae20c8e3 (Chengzhong Wu) https://github.com/nodejs/node/pull/60111 * (SEMVER-MAJOR) V8: backport fed47445bbdd (Abdirahim Musse) https://github.com/nodejs/node/pull/60111 * (SEMVER-MAJOR) patch V8 for illumos (Dan McDonald) https://github.com/nodejs/node/pull/59805 * (SEMVER-MAJOR) use std::map in MSVC STL for EphemeronRememberedSet (Joyee Cheung) https://github.com/nodejs/node/pull/58070 * (SEMVER-MAJOR) remove problematic comment from v8-internal (Michaël Zasso) https://github.com/nodejs/node/pull/58070 * (SEMVER-MAJOR) patch V8 to avoid duplicated zlib symbol (Michaël Zasso) https://github.com/nodejs/node/pull/54077 * (SEMVER-MAJOR) update V8 to 14.2.231.9 (Michaël Zasso) https://github.com/nodejs/node/pull/60111 diagnostics_channel: * (SEMVER-MAJOR) ensure tracePromise consistency with non-Promises (René) https://github.com/nodejs/node/pull/61766 doc: * (SEMVER-MAJOR) remove extensionless CJS exception for type:module packages (Matteo Collina) https://github.com/nodejs/node/pull/62176 * (SEMVER-MAJOR) update supported Windows SDK version to 11 (Mike McCready) https://github.com/nodejs/node/pull/61973 * (SEMVER-MAJOR) drop p8 and z13 support (Milad Fa) https://github.com/nodejs/node/pull/61005 http: * (SEMVER-MAJOR) move writeHeader to end-of-life (Sebastian Beltran) https://github.com/nodejs/node/pull/60635 * (SEMVER-MAJOR) fix handling of HTTP upgrades with bodies (Tim Perry) https://github.com/nodejs/node/pull/60016 lib: * (SEMVER-MAJOR) return undefined for localStorage without file (Matteo Collina) https://github.com/nodejs/node/pull/61333 lib,src: * (SEMVER-MAJOR) implement QuotaExceededError as DOMException-derived interface (Filip Skokan) https://github.com/nodejs/node/pull/62293 module: * (SEMVER-MAJOR) runtime-deprecate module.register() (Geoffrey Booth) https://github.com/nodejs/node/pull/62401 * (SEMVER-MAJOR) remove --experimental-transform-types (Marco Ippolito) https://github.com/nodejs/node/pull/61803 src: * (SEMVER-MAJOR) replace uses of deprecated v8::External APIs (gahaas) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) stop using `v8::PropertyCallbackInfo::This()` (Igor Sheludko) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) avoid deprecated Wasm API (Clemens Backes) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) avoid deprecated `FixedArray::Get` (Clemens Backes) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) update NODE_MODULE_VERSION to 147 (Michaël Zasso) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) remove deprecated and unused isolate fields (Michaël Zasso) https://github.com/nodejs/node/pull/60488 * (SEMVER-MAJOR) update NODE_MODULE_VERSION to 144 (Michaël Zasso) https://github.com/nodejs/node/pull/60488 * (SEMVER-MAJOR) include `node_api_types.h` instead of `node_api.h` in `node.h` (Anna Henningsen) https://github.com/nodejs/node/pull/60496 * (SEMVER-MAJOR) update NODE_MODULE_VERSION to 142 (Michaël Zasso) https://github.com/nodejs/node/pull/60111 stream: * (SEMVER-MAJOR) promote DEP0201 to runtime deprecation (René) https://github.com/nodejs/node/pull/62173 * (SEMVER-MAJOR) move _stream_* to end-of-life (Sebastian Beltran) https://github.com/nodejs/node/pull/60657 * (SEMVER-MAJOR) readable read one buffer at a time (Robert Nagy) https://github.com/nodejs/node/pull/60441 * (SEMVER-MAJOR) preserve AsyncLocalStorage on finished only when needed (avcribl) https://github.com/nodejs/node/pull/59873 test: * (SEMVER-MAJOR) skip wasm allocation tests in workers (Michaël Zasso) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) update wpt Wasm jsapi expectations (Michaël Zasso) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) support presence of Temporal global (Michaël Zasso) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) add type tags to uses of v8::External (gahaas) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) fix test-linux-perf-logger for V8 14.3 (Michaël Zasso) https://github.com/nodejs/node/pull/60488 tools: * (SEMVER-MAJOR) remove v8_initializers_slow workaround from v8.gyp (Michaël Zasso) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) add Rust args to `tools/make-v8.sh` (Richard Lau) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) update V8 gypfiles for 14.6 (Michaël Zasso) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) update V8 gypfiles for 14.5 (Michaël Zasso) https://github.com/nodejs/node/pull/61898 * (SEMVER-MAJOR) update V8 gypfiles for 14.4 (Michaël Zasso) https://github.com/nodejs/node/pull/61898 util: * (SEMVER-MAJOR) mark proxied objects as such when inspecting them (Ruben Bridgewater) https://github.com/nodejs/node/pull/61029 * (SEMVER-MAJOR) reduce TextEncoder.encodeInto function size (Yagiz Nizipli) https://github.com/nodejs/node/pull/60339 PR-URL: https://github.com/nodejs/node/pull/62526 --- CHANGELOG.md | 5 + doc/api/assert.md | 22 +-- doc/api/async_context.md | 12 +- doc/api/cli.md | 6 +- doc/api/crypto.md | 26 +-- doc/api/deprecations.md | 16 +- doc/api/diagnostics_channel.md | 3 +- doc/api/fs.md | 12 +- doc/api/globals.md | 4 +- doc/api/http.md | 2 +- doc/api/module.md | 9 +- doc/api/process.md | 10 +- doc/api/quic.md | 1 + doc/api/repl.md | 4 +- doc/api/stream_iter.md | 104 ++++++++--- doc/api/typescript.md | 2 +- doc/api/webcrypto.md | 46 +++-- doc/api/zlib_iter.md | 254 ++++++++++++++++++++++++++ doc/changelogs/CHANGELOG_ARCHIVE.md | 1 + doc/changelogs/CHANGELOG_IOJS.md | 1 + doc/changelogs/CHANGELOG_V010.md | 1 + doc/changelogs/CHANGELOG_V012.md | 1 + doc/changelogs/CHANGELOG_V10.md | 1 + doc/changelogs/CHANGELOG_V11.md | 1 + doc/changelogs/CHANGELOG_V12.md | 1 + doc/changelogs/CHANGELOG_V13.md | 1 + doc/changelogs/CHANGELOG_V14.md | 1 + doc/changelogs/CHANGELOG_V15.md | 1 + doc/changelogs/CHANGELOG_V16.md | 1 + doc/changelogs/CHANGELOG_V17.md | 1 + doc/changelogs/CHANGELOG_V18.md | 1 + doc/changelogs/CHANGELOG_V19.md | 1 + doc/changelogs/CHANGELOG_V20.md | 1 + doc/changelogs/CHANGELOG_V21.md | 1 + doc/changelogs/CHANGELOG_V22.md | 1 + doc/changelogs/CHANGELOG_V23.md | 1 + doc/changelogs/CHANGELOG_V24.md | 1 + doc/changelogs/CHANGELOG_V25.md | 1 + doc/changelogs/CHANGELOG_V26.md | 270 ++++++++++++++++++++++++++++ doc/changelogs/CHANGELOG_V4.md | 1 + doc/changelogs/CHANGELOG_V5.md | 1 + doc/changelogs/CHANGELOG_V6.md | 1 + doc/changelogs/CHANGELOG_V7.md | 1 + doc/changelogs/CHANGELOG_V8.md | 1 + doc/changelogs/CHANGELOG_V9.md | 1 + 45 files changed, 746 insertions(+), 88 deletions(-) create mode 100644 doc/api/zlib_iter.md create mode 100644 doc/changelogs/CHANGELOG_V26.md diff --git a/CHANGELOG.md b/CHANGELOG.md index cfdf29cf9c4104..a6f69fa6f6b1ec 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,7 @@ Select a Node.js version below to view the changelog history: +* [Node.js 26](doc/changelogs/CHANGELOG_V26.md) **Current** * [Node.js 25](doc/changelogs/CHANGELOG_V25.md) **Current** * [Node.js 24](doc/changelogs/CHANGELOG_V24.md) **Long Term Support** * [Node.js 23](doc/changelogs/CHANGELOG_V23.md) End-of-Life @@ -34,6 +35,7 @@ release. + @@ -41,6 +43,9 @@ release. +
26 (Current) 25 (Current) 24 (LTS) 22 (LTS)
+26.0.0
+ 		25.9.0
25.8.2
25.8.1
diff --git a/doc/api/assert.md b/doc/api/assert.md index 1b4e6352449262..0ca4d54ea5100e 100644 --- a/doc/api/assert.md +++ b/doc/api/assert.md @@ -327,7 +327,7 @@ destructuring and call methods directly on the instance. @@ -342,7 +342,7 @@ An alias of [`assert.ok()`][]. > Stability: 1 - Experimental @@ -527,7 +529,9 @@ probably responsible for the context loss. ## Class: `RunScope` > Stability: 1 - Experimental @@ -543,7 +547,9 @@ exits, whether through normal completion or by throwing an error. ### `scope.dispose()` Explicitly ends the scope and restores the previous store value. This method diff --git a/doc/api/cli.md b/doc/api/cli.md index b5428453787e4a..1bfe15a7c0567d 100644 --- a/doc/api/cli.md +++ b/doc/api/cli.md @@ -786,7 +786,7 @@ added: - v20.15.0 changes: - version: - - REPLACEME + - v26.0.0 pr-url: https://github.com/nodejs/node/pull/62132 description: Node.js now automatically disables the trap handler when there is not enough virtual memory available at startup to allocate one cage. @@ -1325,7 +1325,9 @@ Enable experimental support for storage inspection ### `--experimental-stream-iter` > Stability: 1 - Experimental diff --git a/doc/api/crypto.md b/doc/api/crypto.md index 71c93264216efb..1d0f081834318f 100644 --- a/doc/api/crypto.md +++ b/doc/api/crypto.md @@ -1193,7 +1193,7 @@ When passing a string as the `buffer`, please consider @@ -2399,11 +2399,11 @@ type, value, and parameters. This method is not These channels are emitted for each [`locks.request()`][] call. See diff --git a/doc/api/fs.md b/doc/api/fs.md index b2231bd20cc420..4953ef60accfd0 100644 --- a/doc/api/fs.md +++ b/doc/api/fs.md @@ -380,7 +380,9 @@ added: v10.0.0 #### `filehandle.pull([...transforms][, options])` > Stability: 1 - Experimental @@ -457,7 +459,9 @@ run().catch(console.error); #### `filehandle.pullSync([...transforms][, options])` > Stability: 1 - Experimental @@ -1012,7 +1016,9 @@ the end of the file. #### `filehandle.writer([options])` > Stability: 1 - Experimental diff --git a/doc/api/globals.md b/doc/api/globals.md index 6c0caca06d3dbb..a70442f1bb91ec 100644 --- a/doc/api/globals.md +++ b/doc/api/globals.md @@ -661,7 +661,7 @@ A browser-compatible implementation of {Headers}. The WHATWG {QuotaExceededError} class. Extends {DOMException}. diff --git a/doc/api/http.md b/doc/api/http.md index 11a64c646642b3..0c7cfa5a858977 100644 --- a/doc/api/http.md +++ b/doc/api/http.md @@ -1691,7 +1691,7 @@ per connection (in the case of HTTP Keep-Alive connections). diff --git a/doc/api/process.md b/doc/api/process.md index 634ae87496a41f..bcb920a11b5614 100644 --- a/doc/api/process.md +++ b/doc/api/process.md @@ -739,7 +739,9 @@ This feature is not available in [`Worker`][] threads. ## `process.addUncaughtExceptionCaptureCallback(fn)` > Stability: 1 - Experimental @@ -2056,7 +2058,7 @@ added: - v23.0.0 - v22.10.0 changes: - - version: REPLACEME + - version: v26.0.0 pr-url: https://github.com/nodejs/node/pull/61803 description: Removed `transform` value. - version: @@ -4077,7 +4079,9 @@ This implies calling `module.setSourceMapsSupport()` with an option diff --git a/doc/api/repl.md b/doc/api/repl.md index 3c61adb450fd71..5152e807e88286 100644 --- a/doc/api/repl.md +++ b/doc/api/repl.md @@ -709,7 +709,9 @@ npx codemod@latest @nodejs/repl-builtin-modules * `input` {string|ArrayBuffer|ArrayBufferView|Iterable|AsyncIterable|Object} @@ -561,7 +563,9 @@ run().catch(console.error); ### `fromSync(input)` * `input` {string|ArrayBuffer|ArrayBufferView|Iterable|Object} @@ -591,7 +595,9 @@ console.log(textSync(fromSync('hello'))); // 'hello' ### `pipeTo(source[, ...transforms], writer[, options])` * `source` {AsyncIterable|Iterable} The data source. @@ -648,7 +654,9 @@ run().catch(console.error); ### `pipeToSync(source[, ...transforms], writer[, options])` * `source` {Iterable} The sync data source. @@ -668,7 +676,9 @@ The `writer` must have the `*Sync` methods (`writeSync`, `writevSync`, ### `pull(source[, ...transforms][, options])` * `source` {AsyncIterable|Iterable} The data source. @@ -739,7 +749,9 @@ ac.abort(); // Pipeline throws AbortError on next iteration ### `pullSync(source[, ...transforms])` * `source` {Iterable} The sync data source. @@ -753,7 +765,9 @@ Synchronous version of [`pull()`][]. All transforms must be synchronous. ### `push([...transforms][, options])` * `...transforms` {Function|Object} Optional transforms applied to the @@ -817,7 +831,9 @@ The writer returned by `push()` conforms to the \[Writer interface]\[]. ### `duplex([options])` * `options` {Object} @@ -895,7 +911,9 @@ run().catch(console.error); ### `array(source[, options])` * `source` {AsyncIterable\|Iterable\} @@ -910,7 +928,9 @@ Collect all chunks as an array of `Uint8Array` values (without concatenating). ### `arrayBuffer(source[, options])` * `source` {AsyncIterable\|Iterable\} @@ -925,7 +945,9 @@ Collect all bytes into an `ArrayBuffer`. ### `arrayBufferSync(source[, options])` * `source` {Iterable\} @@ -939,7 +961,9 @@ Synchronous version of [`arrayBuffer()`][]. ### `arraySync(source[, options])` * `source` {Iterable\} @@ -953,7 +977,9 @@ Synchronous version of [`array()`][]. ### `bytes(source[, options])` * `source` {AsyncIterable\|Iterable\} @@ -986,7 +1012,9 @@ run().catch(console.error); ### `bytesSync(source[, options])` * `source` {Iterable\} @@ -1000,7 +1028,9 @@ Synchronous version of [`bytes()`][]. ### `text(source[, options])` * `source` {AsyncIterable\|Iterable\} @@ -1032,7 +1062,9 @@ run().catch(console.error); ### `textSync(source[, options])` * `source` {Iterable\} @@ -1049,7 +1081,9 @@ Synchronous version of [`text()`][]. ### `ondrain(drainable)` * `drainable` {Object} An object implementing the drainable protocol. @@ -1104,7 +1138,9 @@ run().catch(console.error); ### `merge(...sources[, options])` * `...sources` {AsyncIterable\|Iterable\} Two or more iterables. @@ -1137,7 +1173,9 @@ run().catch(console.error); ### `tap(callback)` * `callback` {Function} `(chunks) => void` Called with each batch. @@ -1176,7 +1214,9 @@ chunks by the tapping callback; but return values are ignored. ### `tapSync(callback)` * `callback` {Function} @@ -1189,7 +1229,9 @@ Synchronous version of [`tap()`][]. ### `broadcast([options])` * `options` {Object} @@ -1290,7 +1332,9 @@ Alias for `broadcast.cancel()`. ### `Broadcast.from(input[, options])` * `input` {AsyncIterable|Iterable|Broadcastable} @@ -1303,7 +1347,9 @@ automatically and pushed to all subscribers. ### `share(source[, options])` * `source` {AsyncIterable} The source to share. @@ -1384,7 +1430,9 @@ Alias for `share.cancel()`. ### `Share.from(input[, options])` * `input` {AsyncIterable|Shareable} @@ -1396,7 +1444,9 @@ Create a {Share} from an existing source. ### `shareSync(source[, options])` * `source` {Iterable} The sync source to share. @@ -1411,7 +1461,9 @@ Synchronous version of [`share()`][]. ### `SyncShare.fromSync(input[, options])` * `input` {Iterable|SyncShareable} diff --git a/doc/api/typescript.md b/doc/api/typescript.md index 3babb2a11263fe..3959fd58b56c84 100644 --- a/doc/api/typescript.md +++ b/doc/api/typescript.md @@ -2,7 +2,7 @@ @@ -1923,6 +1928,7 @@ added: v24.7.0 added: - v25.9.0 - v24.15.0 + - v26.0.0 --> * Type: {number} represents the requested output length in bits. @@ -2351,13 +2357,17 @@ added: v15.0.0 ### Class: `KangarooTwelveParams` #### `kangarooTwelveParams.customization` * Type: {ArrayBuffer|TypedArray|DataView|Buffer|undefined} @@ -2367,7 +2377,9 @@ The optional customization string for KangarooTwelve. #### `kangarooTwelveParams.name` * Type: {string} Must be `'KT128'`[^modern-algos] or `'KT256'`[^modern-algos]. @@ -2375,7 +2387,9 @@ added: v25.9.0 #### `kangarooTwelveParams.outputLength` * Type: {number} represents the requested output length in bits. @@ -2463,6 +2477,7 @@ changes: - version: - v25.9.0 - v24.15.0 + - v26.0.0 pr-url: https://github.com/nodejs/node/pull/61875 description: Renamed `kmacParams.length` to `kmacParams.outputLength`. --> @@ -2481,6 +2496,7 @@ added: v24.8.0 added: - v25.9.0 - v24.15.0 + - v26.0.0 --> * Type: {number} @@ -2757,13 +2773,17 @@ The length (in bytes) of the random salt to use. ### Class: `TurboShakeParams` #### `turboShakeParams.domainSeparation` * Type: {number|undefined} @@ -2773,7 +2793,9 @@ The optional domain separation byte (0x01-0x7f). Defaults to `0x1f`. #### `turboShakeParams.name` * Type: {string} Must be `'TurboSHAKE128'`[^modern-algos] or `'TurboSHAKE256'`[^modern-algos]. @@ -2781,7 +2803,9 @@ added: v25.9.0 #### `turboShakeParams.outputLength` * Type: {number} represents the requested output length in bits. diff --git a/doc/api/zlib_iter.md b/doc/api/zlib_iter.md new file mode 100644 index 00000000000000..ae9ad3bb59faea --- /dev/null +++ b/doc/api/zlib_iter.md @@ -0,0 +1,254 @@ +# Iterable Compression + + + +> Stability: 1 - Experimental + + + +The `node:zlib/iter` module provides compression and decompression transforms +for use with the [`node:stream/iter`][] iterable streams API. + +This module is available only when the `--experimental-stream-iter` CLI flag +is enabled. + +Each algorithm has both an async variant (stateful async generator, for use +with [`pull()`][] and [`pipeTo()`][]) and a sync variant (stateful sync +generator, for use with `pullSync()` and `pipeToSync()`). + +The async transforms run compression on the libuv threadpool, overlapping +I/O with JavaScript execution. The sync transforms run compression directly +on the main thread. + +> Note: The defaults for these transforms are tuned for streaming throughput, +> and differ from the defaults in `node:zlib`. In particular, gzip/deflate +> default to level 4 (not 6) and memLevel 9 (not 8), and Brotli defaults to +> quality 6 (not 11). These choices match common HTTP server configurations +> and provide significantly faster compression with only a small reduction in +> compression ratio. All defaults can be overridden via options. + +```mjs +import { from, pull, bytes, text } from 'node:stream/iter'; +import { compressGzip, decompressGzip } from 'node:zlib/iter'; + +// Async round-trip +const compressed = await bytes(pull(from('hello'), compressGzip())); +const original = await text(pull(from(compressed), decompressGzip())); +console.log(original); // 'hello' +``` + +```cjs +const { from, pull, bytes, text } = require('node:stream/iter'); +const { compressGzip, decompressGzip } = require('node:zlib/iter'); + +async function run() { + const compressed = await bytes(pull(from('hello'), compressGzip())); + const original = await text(pull(from(compressed), decompressGzip())); + console.log(original); // 'hello' +} + +run().catch(console.error); +``` + +```mjs +import { fromSync, pullSync, textSync } from 'node:stream/iter'; +import { compressGzipSync, decompressGzipSync } from 'node:zlib/iter'; + +// Sync round-trip +const compressed = pullSync(fromSync('hello'), compressGzipSync()); +const original = textSync(pullSync(compressed, decompressGzipSync())); +console.log(original); // 'hello' +``` + +```cjs +const { fromSync, pullSync, textSync } = require('node:stream/iter'); +const { compressGzipSync, decompressGzipSync } = require('node:zlib/iter'); + +const compressed = pullSync(fromSync('hello'), compressGzipSync()); +const original = textSync(pullSync(compressed, decompressGzipSync())); +console.log(original); // 'hello' +``` + +## `compressBrotli([options])` + +## `compressBrotliSync([options])` + + + +* `options` {Object} + * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). + * `params` {Object} Key-value object where keys and values are + `zlib.constants` entries. The most important compressor parameters are: + * `BROTLI_PARAM_MODE` -- `BROTLI_MODE_GENERIC` (default), + `BROTLI_MODE_TEXT`, or `BROTLI_MODE_FONT`. + * `BROTLI_PARAM_QUALITY` -- ranges from `BROTLI_MIN_QUALITY` to + `BROTLI_MAX_QUALITY`. **Default:** `6` (not `BROTLI_DEFAULT_QUALITY` + which is 11). Quality 6 is appropriate for streaming; quality 11 is + intended for offline/build-time compression. + * `BROTLI_PARAM_SIZE_HINT` -- expected input size. **Default:** `0` + (unknown). + * `BROTLI_PARAM_LGWIN` -- window size (log2). **Default:** `20` (1 MB). + The Brotli library default is 22 (4 MB); the reduced default saves + memory without significant compression impact for streaming workloads. + * `BROTLI_PARAM_LGBLOCK` -- input block size (log2). + See the [Brotli compressor options][] in the zlib documentation for the + full list. + * `dictionary` {Buffer|TypedArray|DataView} +* Returns: {Object} A stateful transform. + +Create a Brotli compression transform. Output is compatible with +`zlib.brotliDecompress()` and `decompressBrotli()`/`decompressBrotliSync()`. + +## `compressDeflate([options])` + +## `compressDeflateSync([options])` + + + +* `options` {Object} + * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). + * `level` {number} Compression level (`0`-`9`). **Default:** `4`. + * `windowBits` {number} **Default:** `Z_DEFAULT_WINDOWBITS` (15). + * `memLevel` {number} **Default:** `9`. + * `strategy` {number} **Default:** `Z_DEFAULT_STRATEGY`. + * `dictionary` {Buffer|TypedArray|DataView} +* Returns: {Object} A stateful transform. + +Create a deflate compression transform. Output is compatible with +`zlib.inflate()` and `decompressDeflate()`/`decompressDeflateSync()`. + +## `compressGzip([options])` + +## `compressGzipSync([options])` + + + +* `options` {Object} + * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). + * `level` {number} Compression level (`0`-`9`). **Default:** `4`. + * `windowBits` {number} **Default:** `Z_DEFAULT_WINDOWBITS` (15). + * `memLevel` {number} **Default:** `9`. + * `strategy` {number} **Default:** `Z_DEFAULT_STRATEGY`. + * `dictionary` {Buffer|TypedArray|DataView} +* Returns: {Object} A stateful transform. + +Create a gzip compression transform. Output is compatible with `zlib.gunzip()` +and `decompressGzip()`/`decompressGzipSync()`. + +## `compressZstd([options])` + +## `compressZstdSync([options])` + + + +* `options` {Object} + * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). + * `params` {Object} Key-value object where keys and values are + `zlib.constants` entries. The most important compressor parameters are: + * `ZSTD_c_compressionLevel` -- **Default:** `ZSTD_CLEVEL_DEFAULT` (3). + * `ZSTD_c_checksumFlag` -- generate a checksum. **Default:** `0`. + * `ZSTD_c_strategy` -- compression strategy. Values include + `ZSTD_fast`, `ZSTD_dfast`, `ZSTD_greedy`, `ZSTD_lazy`, + `ZSTD_lazy2`, `ZSTD_btlazy2`, `ZSTD_btopt`, `ZSTD_btultra`, + `ZSTD_btultra2`. + See the [Zstd compressor options][] in the zlib documentation for the + full list. + * `pledgedSrcSize` {number} Expected uncompressed size (optional hint). + * `dictionary` {Buffer|TypedArray|DataView} +* Returns: {Object} A stateful transform. + +Create a Zstandard compression transform. Output is compatible with +`zlib.zstdDecompress()` and `decompressZstd()`/`decompressZstdSync()`. + +## `decompressBrotli([options])` + +## `decompressBrotliSync([options])` + + + +* `options` {Object} + * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). + * `params` {Object} Key-value object where keys and values are + `zlib.constants` entries. Available decompressor parameters: + * `BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION` -- boolean + flag affecting internal memory allocation. + * `BROTLI_DECODER_PARAM_LARGE_WINDOW` -- boolean flag enabling "Large + Window Brotli" mode (not compatible with [RFC 7932][]). + See the [Brotli decompressor options][] in the zlib documentation for + details. + * `dictionary` {Buffer|TypedArray|DataView} +* Returns: {Object} A stateful transform. + +Create a Brotli decompression transform. + +## `decompressDeflate([options])` + +## `decompressDeflateSync([options])` + + + +* `options` {Object} + * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). + * `windowBits` {number} **Default:** `Z_DEFAULT_WINDOWBITS` (15). + * `dictionary` {Buffer|TypedArray|DataView} +* Returns: {Object} A stateful transform. + +Create a deflate decompression transform. + +## `decompressGzip([options])` + +## `decompressGzipSync([options])` + + + +* `options` {Object} + * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). + * `windowBits` {number} **Default:** `Z_DEFAULT_WINDOWBITS` (15). + * `dictionary` {Buffer|TypedArray|DataView} +* Returns: {Object} A stateful transform. + +Create a gzip decompression transform. + +## `decompressZstd([options])` + +## `decompressZstdSync([options])` + + + +* `options` {Object} + * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). + * `params` {Object} Key-value object where keys and values are + `zlib.constants` entries. Available decompressor parameters: + * `ZSTD_d_windowLogMax` -- maximum window size (log2) the decompressor + will allocate. Limits memory usage against malicious input. + See the [Zstd decompressor options][] in the zlib documentation for + details. + * `dictionary` {Buffer|TypedArray|DataView} +* Returns: {Object} A stateful transform. + +Create a Zstandard decompression transform. + +[Brotli compressor options]: zlib.md#compressor-options +[Brotli decompressor options]: zlib.md#decompressor-options +[RFC 7932]: https://www.rfc-editor.org/rfc/rfc7932 +[Zstd compressor options]: zlib.md#compressor-options-1 +[Zstd decompressor options]: zlib.md#decompressor-options-1 +[`node:stream/iter`]: stream_iter.md +[`pipeTo()`]: stream_iter.md#pipetosource-transforms-writer-options +[`pull()`]: stream_iter.md#pullsource-transforms-options diff --git a/doc/changelogs/CHANGELOG_ARCHIVE.md b/doc/changelogs/CHANGELOG_ARCHIVE.md index e525d97bc87464..38be98ddb1e528 100644 --- a/doc/changelogs/CHANGELOG_ARCHIVE.md +++ b/doc/changelogs/CHANGELOG_ARCHIVE.md @@ -156,6 +156,7 @@
* Other Versions + * [26.x](CHANGELOG_V26.md) * [25.x](CHANGELOG_V25.md) * [24.x](CHANGELOG_V24.md) * [23.x](CHANGELOG_V23.md) diff --git a/doc/changelogs/CHANGELOG_IOJS.md b/doc/changelogs/CHANGELOG_IOJS.md index 3217c3b165cc28..db0af594f60f0f 100644 --- a/doc/changelogs/CHANGELOG_IOJS.md +++ b/doc/changelogs/CHANGELOG_IOJS.md @@ -62,6 +62,7 @@ * Other Versions + * [26.x](CHANGELOG_V26.md) * [25.x](CHANGELOG_V25.md) * [24.x](CHANGELOG_V24.md) * [23.x](CHANGELOG_V23.md) diff --git a/doc/changelogs/CHANGELOG_V010.md b/doc/changelogs/CHANGELOG_V010.md index 6e9c4654c4780d..bc243ad748c95a 100644 --- a/doc/changelogs/CHANGELOG_V010.md +++ b/doc/changelogs/CHANGELOG_V010.md @@ -64,6 +64,7 @@ * Other Versions + * [26.x](CHANGELOG_V26.md) * [25.x](CHANGELOG_V25.md) * [24.x](CHANGELOG_V24.md) * [23.x](CHANGELOG_V23.md) diff --git a/doc/changelogs/CHANGELOG_V012.md b/doc/changelogs/CHANGELOG_V012.md index 4c9af8c79cc1a7..4c8abcccf4a8b1 100644 --- a/doc/changelogs/CHANGELOG_V012.md +++ b/doc/changelogs/CHANGELOG_V012.md @@ -32,6 +32,7 @@ * Other Versions + * [26.x](CHANGELOG_V26.md) * [25.x](CHANGELOG_V25.md) * [24.x](CHANGELOG_V24.md) * [23.x](CHANGELOG_V23.md) diff --git a/doc/changelogs/CHANGELOG_V10.md b/doc/changelogs/CHANGELOG_V10.md index 66cc03efeaf67d..8739adb6905a46 100644 --- a/doc/changelogs/CHANGELOG_V10.md +++ b/doc/changelogs/CHANGELOG_V10.md @@ -58,6 +58,7 @@ * Other Versions + * [26.x](CHANGELOG_V26.md) * [25.x](CHANGELOG_V25.md) * [24.x](CHANGELOG_V24.md) * [23.x](CHANGELOG_V23.md) diff --git a/doc/changelogs/CHANGELOG_V11.md b/doc/changelogs/CHANGELOG_V11.md index 4106ddb17fc0ed..a3d53f6c99b671 100644 --- a/doc/changelogs/CHANGELOG_V11.md +++ b/doc/changelogs/CHANGELOG_V11.md @@ -30,6 +30,7 @@ * Other Versions + * [26.x](CHANGELOG_V26.md) * [25.x](CHANGELOG_V25.md) * [24.x](CHANGELOG_V24.md) * [23.x](CHANGELOG_V23.md) diff --git a/doc/changelogs/CHANGELOG_V12.md b/doc/changelogs/CHANGELOG_V12.md index 2a6ee6ce7cf76d..921c77aedd498f 100644 --- a/doc/changelogs/CHANGELOG_V12.md +++ b/doc/changelogs/CHANGELOG_V12.md @@ -67,6 +67,7 @@ * Other Versions + * [26.x](CHANGELOG_V26.md) * [25.x](CHANGELOG_V25.md) * [24.x](CHANGELOG_V24.md) * [23.x](CHANGELOG_V23.md) diff --git a/doc/changelogs/CHANGELOG_V13.md b/doc/changelogs/CHANGELOG_V13.md index ffe99466d5174c..58b27accd24e83 100644 --- a/doc/changelogs/CHANGELOG_V13.md +++ b/doc/changelogs/CHANGELOG_V13.md @@ -30,6 +30,7 @@ * Other Versions + * [26.x](CHANGELOG_V26.md) * [25.x](CHANGELOG_V25.md) * [24.x](CHANGELOG_V24.md) * [23.x](CHANGELOG_V23.md) diff --git a/doc/changelogs/CHANGELOG_V14.md b/doc/changelogs/CHANGELOG_V14.md index 7294530721a051..356fe7ec2acbd6 100644 --- a/doc/changelogs/CHANGELOG_V14.md +++ b/doc/changelogs/CHANGELOG_V14.md @@ -62,6 +62,7 @@ * Other Versions + * [26.x](CHANGELOG_V26.md) * [25.x](CHANGELOG_V25.md) * [24.x](CHANGELOG_V24.md) * [23.x](CHANGELOG_V23.md) diff --git a/doc/changelogs/CHANGELOG_V15.md b/doc/changelogs/CHANGELOG_V15.md index 7e1606efa03ddd..27275533bf6fde 100644 --- a/doc/changelogs/CHANGELOG_V15.md +++ b/doc/changelogs/CHANGELOG_V15.md @@ -31,6 +31,7 @@ * Other Versions + * [26.x](CHANGELOG_V26.md) * [25.x](CHANGELOG_V25.md) * [24.x](CHANGELOG_V24.md) * [23.x](CHANGELOG_V23.md) diff --git a/doc/changelogs/CHANGELOG_V16.md b/doc/changelogs/CHANGELOG_V16.md index 667ee30099ac0c..3bcb3f2d1b430b 100644 --- a/doc/changelogs/CHANGELOG_V16.md +++ b/doc/changelogs/CHANGELOG_V16.md @@ -53,6 +53,7 @@ * Other Versions + * [26.x](CHANGELOG_V26.md) * [25.x](CHANGELOG_V25.md) * [24.x](CHANGELOG_V24.md) * [23.x](CHANGELOG_V23.md) diff --git a/doc/changelogs/CHANGELOG_V17.md b/doc/changelogs/CHANGELOG_V17.md index 04d5da4f1e187c..4e6e435ea6c3a2 100644 --- a/doc/changelogs/CHANGELOG_V17.md +++ b/doc/changelogs/CHANGELOG_V17.md @@ -28,6 +28,7 @@ * Other Versions + * [26.x](CHANGELOG_V26.md) * [25.x](CHANGELOG_V25.md) * [24.x](CHANGELOG_V24.md) * [23.x](CHANGELOG_V23.md) diff --git a/doc/changelogs/CHANGELOG_V18.md b/doc/changelogs/CHANGELOG_V18.md index b680c46f348f69..8233cba99ee705 100644 --- a/doc/changelogs/CHANGELOG_V18.md +++ b/doc/changelogs/CHANGELOG_V18.md @@ -54,6 +54,7 @@ * Other Versions + * [26.x](CHANGELOG_V26.md) * [25.x](CHANGELOG_V25.md) * [24.x](CHANGELOG_V24.md) * [23.x](CHANGELOG_V23.md) diff --git a/doc/changelogs/CHANGELOG_V19.md b/doc/changelogs/CHANGELOG_V19.md index 5080e08e94c4ed..d536d8827e7dc7 100644 --- a/doc/changelogs/CHANGELOG_V19.md +++ b/doc/changelogs/CHANGELOG_V19.md @@ -26,6 +26,7 @@ * Other Versions + * [26.x](CHANGELOG_V26.md) * [25.x](CHANGELOG_V25.md) * [24.x](CHANGELOG_V24.md) * [23.x](CHANGELOG_V23.md) diff --git a/doc/changelogs/CHANGELOG_V20.md b/doc/changelogs/CHANGELOG_V20.md index a091c0a06d5c89..a5a43972a0bed4 100644 --- a/doc/changelogs/CHANGELOG_V20.md +++ b/doc/changelogs/CHANGELOG_V20.md @@ -57,6 +57,7 @@ * Other Versions + * [26.x](CHANGELOG_V26.md) * [25.x](CHANGELOG_V25.md) * [24.x](CHANGELOG_V24.md) * [23.x](CHANGELOG_V23.md) diff --git a/doc/changelogs/CHANGELOG_V21.md b/doc/changelogs/CHANGELOG_V21.md index 1bb7c810fc5327..a4fcd49b4f3f45 100644 --- a/doc/changelogs/CHANGELOG_V21.md +++ b/doc/changelogs/CHANGELOG_V21.md @@ -26,6 +26,7 @@ * Other Versions + * [26.x](CHANGELOG_V26.md) * [25.x](CHANGELOG_V25.md) * [24.x](CHANGELOG_V24.md) * [23.x](CHANGELOG_V23.md) diff --git a/doc/changelogs/CHANGELOG_V22.md b/doc/changelogs/CHANGELOG_V22.md index 31d0fd9dcecf1a..8942a59f041948 100644 --- a/doc/changelogs/CHANGELOG_V22.md +++ b/doc/changelogs/CHANGELOG_V22.md @@ -47,6 +47,7 @@ * Other Versions + * [26.x](CHANGELOG_V26.md) * [25.x](CHANGELOG_V25.md) * [24.x](CHANGELOG_V24.md) * [23.x](CHANGELOG_V23.md) diff --git a/doc/changelogs/CHANGELOG_V23.md b/doc/changelogs/CHANGELOG_V23.md index 15f05b00a2b09e..a13d9a8011718d 100644 --- a/doc/changelogs/CHANGELOG_V23.md +++ b/doc/changelogs/CHANGELOG_V23.md @@ -27,6 +27,7 @@ * Other Versions + * [26.x](CHANGELOG_V26.md) * [25.x](CHANGELOG_V25.md) * [24.x](CHANGELOG_V24.md) * [22.x](CHANGELOG_V22.md) diff --git a/doc/changelogs/CHANGELOG_V24.md b/doc/changelogs/CHANGELOG_V24.md index f2b0be871fc810..f0e903b3349c0a 100644 --- a/doc/changelogs/CHANGELOG_V24.md +++ b/doc/changelogs/CHANGELOG_V24.md @@ -38,6 +38,7 @@ * Other Versions + * [26.x](CHANGELOG_V26.md) * [25.x](CHANGELOG_V25.md) * [23.x](CHANGELOG_V23.md) * [22.x](CHANGELOG_V22.md) diff --git a/doc/changelogs/CHANGELOG_V25.md b/doc/changelogs/CHANGELOG_V25.md index 2c2b5bdbbe58d8..af2efd87dc1a64 100644 --- a/doc/changelogs/CHANGELOG_V25.md +++ b/doc/changelogs/CHANGELOG_V25.md @@ -27,6 +27,7 @@ * Other Versions + * [26.x](CHANGELOG_V26.md) * [24.x](CHANGELOG_V24.md) * [23.x](CHANGELOG_V23.md) * [22.x](CHANGELOG_V22.md) diff --git a/doc/changelogs/CHANGELOG_V26.md b/doc/changelogs/CHANGELOG_V26.md new file mode 100644 index 00000000000000..d1330129b284e5 --- /dev/null +++ b/doc/changelogs/CHANGELOG_V26.md @@ -0,0 +1,270 @@ +# Node.js 26 ChangeLog + + + + + + + + + + +
Current
+26.0.0
+
+ +* Other Versions + * [25.x](CHANGELOG_V25.md) + * [24.x](CHANGELOG_V24.md) + * [23.x](CHANGELOG_V23.md) + * [22.x](CHANGELOG_V22.md) + * [21.x](CHANGELOG_V21.md) + * [20.x](CHANGELOG_V20.md) + * [19.x](CHANGELOG_V19.md) + * [18.x](CHANGELOG_V18.md) + * [17.x](CHANGELOG_V17.md) + * [16.x](CHANGELOG_V16.md) + * [15.x](CHANGELOG_V15.md) + * [14.x](CHANGELOG_V14.md) + * [13.x](CHANGELOG_V13.md) + * [12.x](CHANGELOG_V12.md) + * [11.x](CHANGELOG_V11.md) + * [10.x](CHANGELOG_V10.md) + * [9.x](CHANGELOG_V9.md) + * [8.x](CHANGELOG_V8.md) + * [7.x](CHANGELOG_V7.md) + * [6.x](CHANGELOG_V6.md) + * [5.x](CHANGELOG_V5.md) + * [4.x](CHANGELOG_V4.md) + * [0.12.x](CHANGELOG_V012.md) + * [0.10.x](CHANGELOG_V010.md) + * [io.js](CHANGELOG_IOJS.md) + * [Archive](CHANGELOG_ARCHIVE.md) + + + +## 2026-05-05, Version 26.0.0 (Current), @RafaelGSS + +We're excited to announce the release of Node.js 26! Highlights include the Temporal API enabled by default, +updates to the V8 JavaScript engine to 14.6, Undici to 8.0, and several important deprecations and removals +as we continue to modernize the platform. + +As a reminder, Node.js 26 will enter long-term support (LTS) in October, but until then, it will be the "Current" release for the next six months. +We encourage you to explore the new features and benefits offered by this latest release and evaluate their potential impact on your applications. + +### Notable Changes + +#### Temporal API + +The Temporal API is now enabled by default in Node.js 26. Temporal is a modern date/time API for JavaScript +that provides a more robust and feature-rich alternative to the legacy `Date` object. + +Contributed by Richard Lau in [#61806](https://github.com/nodejs/node/pull/61806). + +#### V8 14.6 + +The V8 engine is updated to version 14.6.202.33, which is part of Chromium 134. + +This version also includes: + +* Upsert (): `[Weak]Map.prototype.getOrInsert()`, `[Weak]Map.prototype.getOrInsertComputed()` +* Iterator sequencing (): `Iterator.concat()` + +Contributed by Michaël Zasso in [#61898](https://github.com/nodejs/node/pull/61898). + +#### Undici 8 + +Undici has been updated to version 8.0.2, bringing new features and improvements to Node.js's HTTP client implementation. + +#### Deprecations and Removals + +* \[[`dff46c07c3`](https://github.com/nodejs/node/commit/dff46c07c3)] - **(SEMVER-MAJOR)** **crypto**: move DEP0182 to End-of-Life (Tobias Nießen) [#61084](https://github.com/nodejs/node/pull/61084) +* \[[`93c25815ee`](https://github.com/nodejs/node/commit/93c25815ee)] - **(SEMVER-MAJOR)** **http**: move writeHeader to end-of-life (Sebastian Beltran) [#60635](https://github.com/nodejs/node/pull/60635) + +`http.Server.prototype.writeHeader()` is now fully removed. Use `http.Server.prototype.writeHead()` instead. + +* \[[`c755b0113c`](https://github.com/nodejs/node/commit/c755b0113c)] - **(SEMVER-MAJOR)** **stream**: move \_stream\_\* to end-of-life (Sebastian Beltran) [#60657](https://github.com/nodejs/node/pull/60657) + +The legacy `_stream_wrap`, `_stream_readable`, `_stream_writable`, `_stream_duplex`, `_stream_transform`, and `_stream_passthrough` modules are now fully removed. + +* \[[`adac077484`](https://github.com/nodejs/node/commit/adac077484)] - **(SEMVER-MAJOR)** **crypto**: runtime-deprecate DEP0203 and DEP0204 (Filip Skokan) [#62453](https://github.com/nodejs/node/pull/62453) +* \[[`ac6375417a`](https://github.com/nodejs/node/commit/ac6375417a)] - **(SEMVER-MAJOR)** **stream**: promote DEP0201 to runtime deprecation (René) [#62173](https://github.com/nodejs/node/pull/62173) +* \[[`98907f560f`](https://github.com/nodejs/node/commit/98907f560f)] - **(SEMVER-MAJOR)** **module**: runtime-deprecate module.register() (Geoffrey Booth) [#62401](https://github.com/nodejs/node/pull/62401) +* \[[`89f4b6cddb`](https://github.com/nodejs/node/commit/89f4b6cddb)] - **(SEMVER-MAJOR)** **module**: remove --experimental-transform-types (Marco Ippolito) [#61803](https://github.com/nodejs/node/pull/61803) + +### Semver-Major Commits + +* \[[`d3f79aa65d`](https://github.com/nodejs/node/commit/d3f79aa65d)] - **(SEMVER-MAJOR)** **assert**: allow printf-style messages as assertion error (Ruben Bridgewater) [#58849](https://github.com/nodejs/node/pull/58849) +* \[[`f6ce381fec`](https://github.com/nodejs/node/commit/f6ce381fec)] - **(SEMVER-MAJOR)** **build**: bump GCC requirement to 13.2 (Michaël Zasso) [#62555](https://github.com/nodejs/node/pull/62555) +* \[[`bff81fca46`](https://github.com/nodejs/node/commit/bff81fca46)] - **(SEMVER-MAJOR)** **build**: enable Temporal by default (Richard Lau) [#61806](https://github.com/nodejs/node/pull/61806) +* \[[`6ddb1643e1`](https://github.com/nodejs/node/commit/6ddb1643e1)] - **(SEMVER-MAJOR)** **build**: enable V8\_VERIFY\_WRITE\_BARRIERS in debug build (Joyee Cheung) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`a8ab08b373`](https://github.com/nodejs/node/commit/a8ab08b373)] - **(SEMVER-MAJOR)** **build**: reset embedder string to "-node.0" (Michaël Zasso) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`0998c37eb6`](https://github.com/nodejs/node/commit/0998c37eb6)] - **(SEMVER-MAJOR)** **build**: target Power 9 for AIX/IBM i (Richard Lau) [#62296](https://github.com/nodejs/node/pull/62296) +* \[[`d73c49e849`](https://github.com/nodejs/node/commit/d73c49e849)] - **(SEMVER-MAJOR)** **build**: drop support for Python 3.9 (Mike McCready) [#61177](https://github.com/nodejs/node/pull/61177) +* \[[`3c92ee1008`](https://github.com/nodejs/node/commit/3c92ee1008)] - **(SEMVER-MAJOR)** **build**: enable maglev for Linux on s390x (Richard Lau) [#60863](https://github.com/nodejs/node/pull/60863) +* \[[`908c468828`](https://github.com/nodejs/node/commit/908c468828)] - **(SEMVER-MAJOR)** **build**: reset embedder string to "-node.0" (Michaël Zasso) [#60488](https://github.com/nodejs/node/pull/60488) +* \[[`6380fbb5ee`](https://github.com/nodejs/node/commit/6380fbb5ee)] - **(SEMVER-MAJOR)** **build**: reset embedder string to "-node.0" (Michaël Zasso) [#60111](https://github.com/nodejs/node/pull/60111) +* \[[`089d6c77e7`](https://github.com/nodejs/node/commit/089d6c77e7)] - **(SEMVER-MAJOR)** **(CVE-2026-21717)** **build,test**: test array index hash collision (Joyee Cheung) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`f9bd0165c4`](https://github.com/nodejs/node/commit/f9bd0165c4)] - **(SEMVER-MAJOR)** **build,win**: fix Temporal build (StefanStojanovic) [#61806](https://github.com/nodejs/node/pull/61806) +* \[[`6cc4cf8fe8`](https://github.com/nodejs/node/commit/6cc4cf8fe8)] - **(SEMVER-MAJOR)** **crypto**: unify asymmetric key import through KeyObjectHandle::Init (Filip Skokan) [#62499](https://github.com/nodejs/node/pull/62499) +* \[[`adac077484`](https://github.com/nodejs/node/commit/adac077484)] - **(SEMVER-MAJOR)** **crypto**: runtime-deprecate DEP0203 and DEP0204 (Filip Skokan) [#62453](https://github.com/nodejs/node/pull/62453) +* \[[`74509b166a`](https://github.com/nodejs/node/commit/74509b166a)] - **(SEMVER-MAJOR)** **crypto**: decorate async crypto job errors with OpenSSL error details (Filip Skokan) [#62348](https://github.com/nodejs/node/pull/62348) +* \[[`da5843b91d`](https://github.com/nodejs/node/commit/da5843b91d)] - **(SEMVER-MAJOR)** **crypto**: default ML-KEM and ML-DSA pkcs8 export to seed-only format (Filip Skokan) [#62178](https://github.com/nodejs/node/pull/62178) +* \[[`dff46c07c3`](https://github.com/nodejs/node/commit/dff46c07c3)] - **(SEMVER-MAJOR)** **crypto**: move DEP0182 to End-of-Life (Tobias Nießen) [#61084](https://github.com/nodejs/node/pull/61084) +* \[[`94cd600542`](https://github.com/nodejs/node/commit/94cd600542)] - **(SEMVER-MAJOR)** **crypto**: fix DOMException name for non-extractable key error (Filip Skokan) [#60830](https://github.com/nodejs/node/pull/60830) +* \[[`dae2219cca`](https://github.com/nodejs/node/commit/dae2219cca)] - **(SEMVER-MAJOR)** **deps**: V8: cherry-pick 0f024d4e66e0 (ishabi) [#62408](https://github.com/nodejs/node/pull/62408) +* \[[`15d406c1b1`](https://github.com/nodejs/node/commit/15d406c1b1)] - **(SEMVER-MAJOR)** **deps**: fix V8 race condition for AIX (Abdirahim Musse) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`46852d2d7a`](https://github.com/nodejs/node/commit/46852d2d7a)] - **(SEMVER-MAJOR)** **deps**: V8: cherry-pick cd2c216e7658 (LuYahan) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`784431d6fc`](https://github.com/nodejs/node/commit/784431d6fc)] - **(SEMVER-MAJOR)** **deps**: V8: backport 088b7112e7ab (Igor Sheludko) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`3839c4a756`](https://github.com/nodejs/node/commit/3839c4a756)] - **(SEMVER-MAJOR)** **deps**: V8: cherry-pick 00f6e834029f (Joyee Cheung) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`44f64f1dd9`](https://github.com/nodejs/node/commit/44f64f1dd9)] - **(SEMVER-MAJOR)** **deps**: V8: backport bef0d9c1bc90 (Joyee Cheung) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`1f8f288e22`](https://github.com/nodejs/node/commit/1f8f288e22)] - **(SEMVER-MAJOR)** **deps**: V8: cherry-pick cf1bce40a5ef (Richard Lau) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`d7eccac9ad`](https://github.com/nodejs/node/commit/d7eccac9ad)] - **(SEMVER-MAJOR)** **deps**: V8: cherry-pick daf4656ba85e (Milad Fa) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`3ee1ea7d0b`](https://github.com/nodejs/node/commit/3ee1ea7d0b)] - **(SEMVER-MAJOR)** **deps**: V8: cherry-pick d83f479604c8 (Joyee Cheung) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`80907c0239`](https://github.com/nodejs/node/commit/80907c0239)] - **(SEMVER-MAJOR)** **deps**: V8: cherry-pick edeb0a4fa181 (Joyee Cheung) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`5e0dc169e9`](https://github.com/nodejs/node/commit/5e0dc169e9)] - **(SEMVER-MAJOR)** **deps**: V8: cherry-pick aa0b288f87cc (Richard Lau) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`8c1f7adbcd`](https://github.com/nodejs/node/commit/8c1f7adbcd)] - **(SEMVER-MAJOR)** **deps**: patch V8 to fix Windows build (StefanStojanovic) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`3cbd3404d9`](https://github.com/nodejs/node/commit/3cbd3404d9)] - **(SEMVER-MAJOR)** **deps**: V8: cherry-pick highway\@989a498fdf3 (Richard Lau) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`9f2b7d4031`](https://github.com/nodejs/node/commit/9f2b7d4031)] - **(SEMVER-MAJOR)** **deps**: support madvise(3C) across ALL illumos revisions (Dan McDonald) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`947ec32118`](https://github.com/nodejs/node/commit/947ec32118)] - **(SEMVER-MAJOR)** **deps**: patch V8 for illumos (Dan McDonald) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`0660b942b2`](https://github.com/nodejs/node/commit/0660b942b2)] - **(SEMVER-MAJOR)** **deps**: remove problematic comment from v8-internal (Michaël Zasso) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`bef7b31a3f`](https://github.com/nodejs/node/commit/bef7b31a3f)] - **(SEMVER-MAJOR)** **deps**: define V8\_PRESERVE\_MOST as no-op on Windows (Stefan Stojanovic) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`a10bf1e6ce`](https://github.com/nodejs/node/commit/a10bf1e6ce)] - **(SEMVER-MAJOR)** **deps**: patch V8 to avoid duplicated zlib symbol (Michaël Zasso) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`cc547428e1`](https://github.com/nodejs/node/commit/cc547428e1)] - **(SEMVER-MAJOR)** **deps**: update V8 to 14.6.202.33 (Michaël Zasso) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`b81d2cbcae`](https://github.com/nodejs/node/commit/b81d2cbcae)] - **(SEMVER-MAJOR)** **deps**: update undici to 8.0.2 (Node.js GitHub Bot) [#62384](https://github.com/nodejs/node/pull/62384) +* \[[`bf5c6a8bd4`](https://github.com/nodejs/node/commit/bf5c6a8bd4)] - **(SEMVER-MAJOR)** **deps**: V8: backport 151d0a44a1b2 (Abdirahim Musse) [#60488](https://github.com/nodejs/node/pull/60488) +* \[[`b59af772dc`](https://github.com/nodejs/node/commit/b59af772dc)] - **(SEMVER-MAJOR)** **deps**: V8: cherry-pick 47800791b35c (Jakob Kummerow) [#60488](https://github.com/nodejs/node/pull/60488) +* \[[`5e41e5228a`](https://github.com/nodejs/node/commit/5e41e5228a)] - **(SEMVER-MAJOR)** **deps**: patch V8 for illumos (Dan McDonald) [#59805](https://github.com/nodejs/node/pull/59805) +* \[[`2243e58e43`](https://github.com/nodejs/node/commit/2243e58e43)] - **(SEMVER-MAJOR)** **deps**: use std::map in MSVC STL for EphemeronRememberedSet (Joyee Cheung) [#58070](https://github.com/nodejs/node/pull/58070) +* \[[`4157964c42`](https://github.com/nodejs/node/commit/4157964c42)] - **(SEMVER-MAJOR)** **deps**: remove problematic comment from v8-internal (Michaël Zasso) [#58070](https://github.com/nodejs/node/pull/58070) +* \[[`7c8483a4e9`](https://github.com/nodejs/node/commit/7c8483a4e9)] - **(SEMVER-MAJOR)** **deps**: patch V8 to avoid duplicated zlib symbol (Michaël Zasso) [#54077](https://github.com/nodejs/node/pull/54077) +* \[[`53379f3706`](https://github.com/nodejs/node/commit/53379f3706)] - **(SEMVER-MAJOR)** **deps**: update V8 to 14.3.127.12 (Michaël Zasso) [#60488](https://github.com/nodejs/node/pull/60488) +* \[[`f819aec288`](https://github.com/nodejs/node/commit/f819aec288)] - **(SEMVER-MAJOR)** **deps**: V8: cherry-pick ff34ae20c8e3 (Chengzhong Wu) [#60111](https://github.com/nodejs/node/pull/60111) +* \[[`1acd8df36f`](https://github.com/nodejs/node/commit/1acd8df36f)] - **(SEMVER-MAJOR)** **deps**: V8: backport fed47445bbdd (Abdirahim Musse) [#60111](https://github.com/nodejs/node/pull/60111) +* \[[`46f72577a4`](https://github.com/nodejs/node/commit/46f72577a4)] - **(SEMVER-MAJOR)** **deps**: patch V8 for illumos (Dan McDonald) [#59805](https://github.com/nodejs/node/pull/59805) +* \[[`39eb88eaa8`](https://github.com/nodejs/node/commit/39eb88eaa8)] - **(SEMVER-MAJOR)** **deps**: use std::map in MSVC STL for EphemeronRememberedSet (Joyee Cheung) [#58070](https://github.com/nodejs/node/pull/58070) +* \[[`ea3d14eadb`](https://github.com/nodejs/node/commit/ea3d14eadb)] - **(SEMVER-MAJOR)** **deps**: remove problematic comment from v8-internal (Michaël Zasso) [#58070](https://github.com/nodejs/node/pull/58070) +* \[[`7bc0f245b4`](https://github.com/nodejs/node/commit/7bc0f245b4)] - **(SEMVER-MAJOR)** **deps**: patch V8 to avoid duplicated zlib symbol (Michaël Zasso) [#54077](https://github.com/nodejs/node/pull/54077) +* \[[`c2843b722c`](https://github.com/nodejs/node/commit/c2843b722c)] - **(SEMVER-MAJOR)** **deps**: update V8 to 14.2.231.9 (Michaël Zasso) [#60111](https://github.com/nodejs/node/pull/60111) +* \[[`b4ea323833`](https://github.com/nodejs/node/commit/b4ea323833)] - **(SEMVER-MAJOR)** **diagnostics\_channel**: ensure tracePromise consistency with non-Promises (René) [#61766](https://github.com/nodejs/node/pull/61766) +* \[[`0c08835f71`](https://github.com/nodejs/node/commit/0c08835f71)] - **(SEMVER-MAJOR)** **doc**: remove extensionless CJS exception for type:module packages (Matteo Collina) [#62176](https://github.com/nodejs/node/pull/62176) +* \[[`ef0f0b0865`](https://github.com/nodejs/node/commit/ef0f0b0865)] - **(SEMVER-MAJOR)** **doc**: update supported Windows SDK version to 11 (Mike McCready) [#61973](https://github.com/nodejs/node/pull/61973) +* \[[`a00d95c73d`](https://github.com/nodejs/node/commit/a00d95c73d)] - **(SEMVER-MAJOR)** **doc**: drop p8 and z13 support (Milad Fa) [#61005](https://github.com/nodejs/node/pull/61005) +* \[[`93c25815ee`](https://github.com/nodejs/node/commit/93c25815ee)] - **(SEMVER-MAJOR)** **http**: move writeHeader to end-of-life (Sebastian Beltran) [#60635](https://github.com/nodejs/node/pull/60635) +* \[[`4346c0f7a7`](https://github.com/nodejs/node/commit/4346c0f7a7)] - **(SEMVER-MAJOR)** **http**: fix handling of HTTP upgrades with bodies (Tim Perry) [#60016](https://github.com/nodejs/node/pull/60016) +* \[[`fa70327610`](https://github.com/nodejs/node/commit/fa70327610)] - **(SEMVER-MAJOR)** **lib**: return undefined for localStorage without file (Matteo Collina) [#61333](https://github.com/nodejs/node/pull/61333) +* \[[`b328bf74bd`](https://github.com/nodejs/node/commit/b328bf74bd)] - **(SEMVER-MAJOR)** **lib,src**: implement QuotaExceededError as DOMException-derived interface (Filip Skokan) [#62293](https://github.com/nodejs/node/pull/62293) +* \[[`98907f560f`](https://github.com/nodejs/node/commit/98907f560f)] - **(SEMVER-MAJOR)** **module**: runtime-deprecate module.register() (Geoffrey Booth) [#62401](https://github.com/nodejs/node/pull/62401) +* \[[`89f4b6cddb`](https://github.com/nodejs/node/commit/89f4b6cddb)] - **(SEMVER-MAJOR)** **module**: remove --experimental-transform-types (Marco Ippolito) [#61803](https://github.com/nodejs/node/pull/61803) +* \[[`5334433437`](https://github.com/nodejs/node/commit/5334433437)] - **(SEMVER-MAJOR)** **src**: replace uses of deprecated v8::External APIs (gahaas) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`46e75f4874`](https://github.com/nodejs/node/commit/46e75f4874)] - **(SEMVER-MAJOR)** **src**: stop using `v8::PropertyCallbackInfo::This()` (Igor Sheludko) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`54fefda0aa`](https://github.com/nodejs/node/commit/54fefda0aa)] - **(SEMVER-MAJOR)** **src**: avoid deprecated Wasm API (Clemens Backes) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`840f509bd1`](https://github.com/nodejs/node/commit/840f509bd1)] - **(SEMVER-MAJOR)** **src**: avoid deprecated `FixedArray::Get` (Clemens Backes) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`75c3bcc3ec`](https://github.com/nodejs/node/commit/75c3bcc3ec)] - **(SEMVER-MAJOR)** **src**: update NODE\_MODULE\_VERSION to 147 (Michaël Zasso) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`8480f87375`](https://github.com/nodejs/node/commit/8480f87375)] - **(SEMVER-MAJOR)** **src**: remove deprecated and unused isolate fields (Michaël Zasso) [#60488](https://github.com/nodejs/node/pull/60488) +* \[[`70b6bd8e19`](https://github.com/nodejs/node/commit/70b6bd8e19)] - **(SEMVER-MAJOR)** **src**: update NODE\_MODULE\_VERSION to 144 (Michaël Zasso) [#60488](https://github.com/nodejs/node/pull/60488) +* \[[`7d2bc5249b`](https://github.com/nodejs/node/commit/7d2bc5249b)] - **(SEMVER-MAJOR)** **src**: include `node_api_types.h` instead of `node_api.h` in `node.h` (Anna Henningsen) [#60496](https://github.com/nodejs/node/pull/60496) +* \[[`91ab1101bc`](https://github.com/nodejs/node/commit/91ab1101bc)] - **(SEMVER-MAJOR)** **src**: update NODE\_MODULE\_VERSION to 142 (Michaël Zasso) [#60111](https://github.com/nodejs/node/pull/60111) +* \[[`ac6375417a`](https://github.com/nodejs/node/commit/ac6375417a)] - **(SEMVER-MAJOR)** **stream**: promote DEP0201 to runtime deprecation (René) [#62173](https://github.com/nodejs/node/pull/62173) +* \[[`c755b0113c`](https://github.com/nodejs/node/commit/c755b0113c)] - **(SEMVER-MAJOR)** **stream**: move \_stream\_\* to end-of-life (Sebastian Beltran) [#60657](https://github.com/nodejs/node/pull/60657) +* \[[`fadb214d95`](https://github.com/nodejs/node/commit/fadb214d95)] - **(SEMVER-MAJOR)** **stream**: readable read one buffer at a time (Robert Nagy) [#60441](https://github.com/nodejs/node/pull/60441) +* \[[`4fe325d93d`](https://github.com/nodejs/node/commit/4fe325d93d)] - **(SEMVER-MAJOR)** **stream**: preserve AsyncLocalStorage on finished only when needed (avcribl) [#59873](https://github.com/nodejs/node/pull/59873) +* \[[`7682e7e9c5`](https://github.com/nodejs/node/commit/7682e7e9c5)] - **(SEMVER-MAJOR)** **test**: skip wasm allocation tests in workers (Michaël Zasso) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`ebfaf25870`](https://github.com/nodejs/node/commit/ebfaf25870)] - **(SEMVER-MAJOR)** **test**: update wpt Wasm jsapi expectations (Michaël Zasso) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`ece6a17574`](https://github.com/nodejs/node/commit/ece6a17574)] - **(SEMVER-MAJOR)** **test**: support presence of Temporal global (Michaël Zasso) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`75b8d7a912`](https://github.com/nodejs/node/commit/75b8d7a912)] - **(SEMVER-MAJOR)** **test**: add type tags to uses of v8::External (gahaas) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`092a448ad0`](https://github.com/nodejs/node/commit/092a448ad0)] - **(SEMVER-MAJOR)** **test**: fix test-linux-perf-logger for V8 14.3 (Michaël Zasso) [#60488](https://github.com/nodejs/node/pull/60488) +* \[[`8eb9c8f794`](https://github.com/nodejs/node/commit/8eb9c8f794)] - **(SEMVER-MAJOR)** **tools**: remove v8\_initializers\_slow workaround from v8.gyp (Michaël Zasso) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`a34fe77fe7`](https://github.com/nodejs/node/commit/a34fe77fe7)] - **(SEMVER-MAJOR)** **tools**: add Rust args to `tools/make-v8.sh` (Richard Lau) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`f4666bd6e3`](https://github.com/nodejs/node/commit/f4666bd6e3)] - **(SEMVER-MAJOR)** **tools**: update V8 gypfiles for 14.6 (Michaël Zasso) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`3c23d217a6`](https://github.com/nodejs/node/commit/3c23d217a6)] - **(SEMVER-MAJOR)** **tools**: update V8 gypfiles for 14.5 (Michaël Zasso) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`e508489e37`](https://github.com/nodejs/node/commit/e508489e37)] - **(SEMVER-MAJOR)** **tools**: update V8 gypfiles for 14.4 (Michaël Zasso) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`dc97b507d0`](https://github.com/nodejs/node/commit/dc97b507d0)] - **(SEMVER-MAJOR)** **util**: mark proxied objects as such when inspecting them (Ruben Bridgewater) [#61029](https://github.com/nodejs/node/pull/61029) +* \[[`ddbe1365ff`](https://github.com/nodejs/node/commit/ddbe1365ff)] - **(SEMVER-MAJOR)** **util**: reduce TextEncoder.encodeInto function size (Yagiz Nizipli) [#60339](https://github.com/nodejs/node/pull/60339) + +### Semver-Minor Commits + +* \[[`d4fa60cf9f`](https://github.com/nodejs/node/commit/d4fa60cf9f)] - **(SEMVER-MINOR)** **crypto**: add raw key formats support to the KeyObject APIs (Filip Skokan) [#62240](https://github.com/nodejs/node/pull/62240) + +### Semver-Patch Commits + +* \[[`4d8834fbef`](https://github.com/nodejs/node/commit/4d8834fbef)] - **build**: add rust target for macOS cross compiles (Richard Lau) [#63015](https://github.com/nodejs/node/pull/63015) +* \[[`a4edab8dfb`](https://github.com/nodejs/node/commit/a4edab8dfb)] - **build**: use `CARGO` environment variable if set (Richard Lau) [#62421](https://github.com/nodejs/node/pull/62421) +* \[[`ecf8721076`](https://github.com/nodejs/node/commit/ecf8721076)] - **build**: add weak symbol detection to export script (Abdirahim Musse) [#62656](https://github.com/nodejs/node/pull/62656) +* \[[`5b9f811662`](https://github.com/nodejs/node/commit/5b9f811662)] - **build**: filter hidden visibility symbols on AIX (Abdirahim Musse) [#62656](https://github.com/nodejs/node/pull/62656) +* \[[`2e724793e6`](https://github.com/nodejs/node/commit/2e724793e6)] - **build**: aix add conditonal flags for clang builds (Abdirahim Musse) [#62656](https://github.com/nodejs/node/pull/62656) +* \[[`f212aee483`](https://github.com/nodejs/node/commit/f212aee483)] - **build**: enable temporal on GHA macOS build (Chengzhong Wu) [#61691](https://github.com/nodejs/node/pull/61691) +* \[[`159ae48f8c`](https://github.com/nodejs/node/commit/159ae48f8c)] - **build**: add `cargo` and `rustc` checks for Temporal (Richard Lau) [#61467](https://github.com/nodejs/node/pull/61467) +* \[[`a004535617`](https://github.com/nodejs/node/commit/a004535617)] - **build**: add temporal to linux GHA build (Chengzhong Wu) [#60942](https://github.com/nodejs/node/pull/60942) +* \[[`9df9b66c18`](https://github.com/nodejs/node/commit/9df9b66c18)] - **crypto**: add support for Ed25519 context parameter (Filip Skokan) [#62474](https://github.com/nodejs/node/pull/62474) +* \[[`c3042c605b`](https://github.com/nodejs/node/commit/c3042c605b)] - **crypto**: recognize raw formats in keygen (Filip Skokan) [#62480](https://github.com/nodejs/node/pull/62480) +* \[[`ce0f498def`](https://github.com/nodejs/node/commit/ce0f498def)] - **deps**: V8: cherry-pick fcf8b990c73c (Abdirahim Musse) [#62894](https://github.com/nodejs/node/pull/62894) +* \[[`b7fab70d56`](https://github.com/nodejs/node/commit/b7fab70d56)] - _**Revert**_ "**deps**: V8: cherry-pick 7107287" (Richard Lau) [#62894](https://github.com/nodejs/node/pull/62894) +* \[[`d936c30fb4`](https://github.com/nodejs/node/commit/d936c30fb4)] - **deps**: V8: cherry-pick 7107287 (Abdirahim Musse) [#62656](https://github.com/nodejs/node/pull/62656) +* \[[`c91d00b6d4`](https://github.com/nodejs/node/commit/c91d00b6d4)] - **deps**: fix aix implicit declaration in OpenSSL (Abdirahim Musse) [#62656](https://github.com/nodejs/node/pull/62656) +* \[[`0474a27c06`](https://github.com/nodejs/node/commit/0474a27c06)] - **deps**: libuv: revert 3a9a6e3e6b (Antoine du Hamel) [#62511](https://github.com/nodejs/node/pull/62511) +* \[[`7547e795ef`](https://github.com/nodejs/node/commit/7547e795ef)] - **deps**: update icu to 78.3 (Node.js GitHub Bot) [#62324](https://github.com/nodejs/node/pull/62324) +* \[[`5bebd7eaea`](https://github.com/nodejs/node/commit/5bebd7eaea)] - **deps**: update libuv to 1.52.1 (Node.js GitHub Bot) [#61829](https://github.com/nodejs/node/pull/61829) +* \[[`87d7db1918`](https://github.com/nodejs/node/commit/87d7db1918)] - **deps**: patch V8 to 14.3.127.18 (Node.js GitHub Bot) [#61421](https://github.com/nodejs/node/pull/61421) +* \[[`9d27d9a393`](https://github.com/nodejs/node/commit/9d27d9a393)] - **deps**: patch V8 to 14.3.127.17 (Node.js GitHub Bot) [#61058](https://github.com/nodejs/node/pull/61058) +* \[[`bfc729cf19`](https://github.com/nodejs/node/commit/bfc729cf19)] - **deps**: patch V8 to 14.3.127.16 (Node.js GitHub Bot) [#60819](https://github.com/nodejs/node/pull/60819) +* \[[`8716146d5b`](https://github.com/nodejs/node/commit/8716146d5b)] - **deps**: patch V8 to 14.3.127.14 (Node.js GitHub Bot) [#60743](https://github.com/nodejs/node/pull/60743) +* \[[`da71ab6895`](https://github.com/nodejs/node/commit/da71ab6895)] - **deps**: V8: cherry-pick highway\@989a498fdf3 (Richard Lau) [#60682](https://github.com/nodejs/node/pull/60682) +* \[[`72d719dc00`](https://github.com/nodejs/node/commit/72d719dc00)] - **deps**: support madvise(3C) across ALL illumos revisions (Dan McDonald) [#58237](https://github.com/nodejs/node/pull/58237) +* \[[`ecca2b0d64`](https://github.com/nodejs/node/commit/ecca2b0d64)] - **deps**: define V8\_PRESERVE\_MOST as no-op on Windows (Stefan Stojanovic) [#56238](https://github.com/nodejs/node/pull/56238) +* \[[`baefd4d5e2`](https://github.com/nodejs/node/commit/baefd4d5e2)] - **deps**: patch V8 to 14.2.231.17 (Node.js GitHub Bot) [#60647](https://github.com/nodejs/node/pull/60647) +* \[[`76d6be5fc5`](https://github.com/nodejs/node/commit/76d6be5fc5)] - **deps**: patch V8 to 14.2.231.16 (Node.js GitHub Bot) [#60544](https://github.com/nodejs/node/pull/60544) +* \[[`e0ca993514`](https://github.com/nodejs/node/commit/e0ca993514)] - **deps**: patch V8 to 14.2.231.14 (Node.js GitHub Bot) [#60413](https://github.com/nodejs/node/pull/60413) +* \[[`de8386de4d`](https://github.com/nodejs/node/commit/de8386de4d)] - **deps**: V8: cherry-pick f93055fbd5aa (Olivier Flückiger) [#60105](https://github.com/nodejs/node/pull/60105) +* \[[`710105bab5`](https://github.com/nodejs/node/commit/710105bab5)] - **deps**: support madvise(3C) across ALL illumos revisions (Dan McDonald) [#58237](https://github.com/nodejs/node/pull/58237) +* \[[`6e5f3b9fe1`](https://github.com/nodejs/node/commit/6e5f3b9fe1)] - **deps**: define V8\_PRESERVE\_MOST as no-op on Windows (Stefan Stojanovic) [#56238](https://github.com/nodejs/node/pull/56238) +* \[[`b2c5235254`](https://github.com/nodejs/node/commit/b2c5235254)] - **doc**: fix stray carriage return in packages.md (Filip Skokan) [#62350](https://github.com/nodejs/node/pull/62350) +* \[[`f38a739623`](https://github.com/nodejs/node/commit/f38a739623)] - **doc**: reserve NMV 146 for Electron 42 (Niklas Wenzel) [#62124](https://github.com/nodejs/node/pull/62124) +* \[[`a57893b799`](https://github.com/nodejs/node/commit/a57893b799)] - **doc**: add Temporal section to Table of Contents (Richard Lau) [#61805](https://github.com/nodejs/node/pull/61805) +* \[[`d4cc54b8c8`](https://github.com/nodejs/node/commit/d4cc54b8c8)] - **doc**: fix v24 changelog after security release (Marco Ippolito) [#61371](https://github.com/nodejs/node/pull/61371) +* \[[`659fd01b3e`](https://github.com/nodejs/node/commit/659fd01b3e)] - **doc**: fix v22 changelog after security release (Marco Ippolito) [#61371](https://github.com/nodejs/node/pull/61371) +* \[[`6c96a63891`](https://github.com/nodejs/node/commit/6c96a63891)] - **doc**: fix v20 changelog after security release (Marco Ippolito) [#61371](https://github.com/nodejs/node/pull/61371) +* \[[`a18f8c1693`](https://github.com/nodejs/node/commit/a18f8c1693)] - **doc**: reserve NMV 145 for Electron 41 (Niklas Wenzel) [#61291](https://github.com/nodejs/node/pull/61291) +* \[[`253b16fe14`](https://github.com/nodejs/node/commit/253b16fe14)] - **doc**: add note about rust toolchain version requirement (Chengzhong Wu) [#60942](https://github.com/nodejs/node/pull/60942) +* \[[`0177491df2`](https://github.com/nodejs/node/commit/0177491df2)] - **doc**: restore REPLACEME on assert change (Michaël Zasso) [#60848](https://github.com/nodejs/node/pull/60848) +* \[[`dec0213c83`](https://github.com/nodejs/node/commit/dec0213c83)] - **doc**: add known issue to v24.11.0 release notes (Richard Lau) [#60467](https://github.com/nodejs/node/pull/60467) +* \[[`f7ca0ae765`](https://github.com/nodejs/node/commit/f7ca0ae765)] - **doc**: remove Corepack documentation page (Antoine du Hamel) [#57663](https://github.com/nodejs/node/pull/57663) +* \[[`a7d9c49490`](https://github.com/nodejs/node/commit/a7d9c49490)] - **doc**: reserve NMV 143 for Electron 40 (Shelley Vohr) [#60386](https://github.com/nodejs/node/pull/60386) +* \[[`04a086a1f4`](https://github.com/nodejs/node/commit/04a086a1f4)] - **esm**: use wasm version of cjs-module-lexer (Joyee Cheung) [#60663](https://github.com/nodejs/node/pull/60663) +* \[[`a27052f2e0`](https://github.com/nodejs/node/commit/a27052f2e0)] - _**Revert**_ "**inspector**: fix compressed responses" (Antoine du Hamel) [#61502](https://github.com/nodejs/node/pull/61502) +* \[[`186c7a9c74`](https://github.com/nodejs/node/commit/186c7a9c74)] - **inspector**: fix compressed responses (Ruben Nogueira) [#61226](https://github.com/nodejs/node/pull/61226) +* \[[`012bf70908`](https://github.com/nodejs/node/commit/012bf70908)] - **process**: optimize asyncHandledRejections by using FixedQueue (Gürgün Dayıoğlu) [#60854](https://github.com/nodejs/node/pull/60854) +* \[[`1a88acbfa2`](https://github.com/nodejs/node/commit/1a88acbfa2)] - **quic**: fixup linting/formatting issues (James M Snell) [#62387](https://github.com/nodejs/node/pull/62387) +* \[[`79b960a2bc`](https://github.com/nodejs/node/commit/79b960a2bc)] - **quic**: update http3 impl details (James M Snell) [#62387](https://github.com/nodejs/node/pull/62387) +* \[[`57186e5827`](https://github.com/nodejs/node/commit/57186e5827)] - **quic**: fix a handful of bugs and missing functionality (James M Snell) [#62387](https://github.com/nodejs/node/pull/62387) +* \[[`637bda0238`](https://github.com/nodejs/node/commit/637bda0238)] - **sqlite**: enable Percentile extension (Jurj Andrei George) [#61295](https://github.com/nodejs/node/pull/61295) +* \[[`e619adfb86`](https://github.com/nodejs/node/commit/e619adfb86)] - **src**: workaround AIX libc++ std::filesystem bug (Richard Lau) [#62788](https://github.com/nodejs/node/pull/62788) +* \[[`79262ff860`](https://github.com/nodejs/node/commit/79262ff860)] - **src**: do not enable wasm trap handler if there's not enough vmem (Joyee Cheung) [#62132](https://github.com/nodejs/node/pull/62132) +* \[[`2422ed8b5b`](https://github.com/nodejs/node/commit/2422ed8b5b)] - **src**: remove redundant `experimental_transform_types` from node\_options.h (沈鸿飞) [#62058](https://github.com/nodejs/node/pull/62058) +* \[[`a86db6be70`](https://github.com/nodejs/node/commit/a86db6be70)] - **src**: simplify handling of kNoAuthTagLength (Tobias Nießen) [#61192](https://github.com/nodejs/node/pull/61192) +* \[[`d546e7fd0b`](https://github.com/nodejs/node/commit/d546e7fd0b)] - **src**: tag more v8 aligned pointer slots (Chengzhong Wu) [#60666](https://github.com/nodejs/node/pull/60666) +* \[[`b8e264d3c3`](https://github.com/nodejs/node/commit/b8e264d3c3)] - **src**: tag v8 aligned pointer slots with embedder data type tags (Chengzhong Wu) [#60602](https://github.com/nodejs/node/pull/60602) +* \[[`cd391b5f11`](https://github.com/nodejs/node/commit/cd391b5f11)] - **test**: wpt for Wasm jsapi including new ESM Integration tests (Guy Bedford) [#59034](https://github.com/nodejs/node/pull/59034) +* \[[`1baafcc882`](https://github.com/nodejs/node/commit/1baafcc882)] - **test**: update WPT resources, interfaces and WebCryptoAPI (Node.js GitHub Bot) [#62389](https://github.com/nodejs/node/pull/62389) +* \[[`6a84d4a17c`](https://github.com/nodejs/node/commit/6a84d4a17c)] - **tools**: update nixpkgs-unstable to 832efc09b4caf6b4569fbf9dc01bec3082a (Node.js GitHub Bot) [#62486](https://github.com/nodejs/node/pull/62486) +* \[[`a98d9f6ad7`](https://github.com/nodejs/node/commit/a98d9f6ad7)] - **tools**: update nixpkgs-unstable to 9cf7092bdd603554bd8b63c216e8943cf9b (Node.js GitHub Bot) [#62383](https://github.com/nodejs/node/pull/62383) +* \[[`f6d02af01f`](https://github.com/nodejs/node/commit/f6d02af01f)] - **tools**: update nixpkgs-unstable to f82ce7af0b79ac154b12e27ed800aeb9741 (Node.js GitHub Bot) [#62258](https://github.com/nodejs/node/pull/62258) +* \[[`5b5f069a27`](https://github.com/nodejs/node/commit/5b5f069a27)] - **tools**: bump nixpkgs-unstable pin to e38213b91d3786389a446dfce4ff5a8aaf6 (Node.js GitHub Bot) [#62052](https://github.com/nodejs/node/pull/62052) +* \[[`13eb80f3b7`](https://github.com/nodejs/node/commit/13eb80f3b7)] - **tools**: update nixpkgs-unstable to d1c15b7d5806069da59e819999d70e1cec0 (Node.js GitHub Bot) [#61931](https://github.com/nodejs/node/pull/61931) +* \[[`4d1557a744`](https://github.com/nodejs/node/commit/4d1557a744)] - **tools**: update nixpkgs-unstable to 2343bbb58f99267223bc2aac4fc9ea301a1 (Node.js GitHub Bot) [#61831](https://github.com/nodejs/node/pull/61831) +* \[[`ecd979c95a`](https://github.com/nodejs/node/commit/ecd979c95a)] - **tools**: update nixpkgs-unstable to ae67888ff7ef9dff69b3cf0cc0fbfbcd3a7 (Node.js GitHub Bot) [#61733](https://github.com/nodejs/node/pull/61733) +* \[[`7de56bdee2`](https://github.com/nodejs/node/commit/7de56bdee2)] - **tools**: update nixpkgs-unstable to 6308c3b21396534d8aaeac46179c14c439a (Node.js GitHub Bot) [#61606](https://github.com/nodejs/node/pull/61606) +* \[[`e33ce7a6fe`](https://github.com/nodejs/node/commit/e33ce7a6fe)] - **tools**: update nixpkgs-unstable to ab9fbbcf4858bd6d40ba2bbec37ceb4ab6e (Node.js GitHub Bot) [#61513](https://github.com/nodejs/node/pull/61513) +* \[[`ba05a66774`](https://github.com/nodejs/node/commit/ba05a66774)] - **tools**: update nixpkgs-unstable to be5afa0fcb31f0a96bf9ecba05a516c66fc (Node.js GitHub Bot) [#61420](https://github.com/nodejs/node/pull/61420) +* \[[`bb5d066989`](https://github.com/nodejs/node/commit/bb5d066989)] - **tools**: update nixpkgs-unstable to 3146c6aa9995e7351a398e17470e15305e6 (Node.js GitHub Bot) [#61340](https://github.com/nodejs/node/pull/61340) +* \[[`d050aa87e8`](https://github.com/nodejs/node/commit/d050aa87e8)] - **tools**: update nixpkgs-unstable to 16c7794d0a28b5a37904d55bcca36003b91 (Node.js GitHub Bot) [#61272](https://github.com/nodejs/node/pull/61272) +* \[[`2696391b18`](https://github.com/nodejs/node/commit/2696391b18)] - **tools**: update nixpkgs-unstable to 3edc4a30ed3903fdf6f90c837f961fa6b49 (Node.js GitHub Bot) [#61188](https://github.com/nodejs/node/pull/61188) +* \[[`c5d3f5f9c8`](https://github.com/nodejs/node/commit/c5d3f5f9c8)] - **tools**: update nixpkgs-unstable to 7d853e518814cca2a657b72eeba67ae20eb (Node.js GitHub Bot) [#61137](https://github.com/nodejs/node/pull/61137) +* \[[`dcb9573d0f`](https://github.com/nodejs/node/commit/dcb9573d0f)] - **tools**: update nixpkgs-unstable to f997fa0f94fb1ce55bccb97f60d41412ae8 (Node.js GitHub Bot) [#61057](https://github.com/nodejs/node/pull/61057) +* \[[`bd426739dc`](https://github.com/nodejs/node/commit/bd426739dc)] - **tools**: update nixpkgs-unstable to a672be65651c80d3f592a89b3945466584a (Node.js GitHub Bot) [#60980](https://github.com/nodejs/node/pull/60980) +* \[[`85852a3221`](https://github.com/nodejs/node/commit/85852a3221)] - **tools**: update nixpkgs-unstable to 59b6c96beacc898566c9be1052ae806f383 (Node.js GitHub Bot) [#60900](https://github.com/nodejs/node/pull/60900) +* \[[`1e7eb90b39`](https://github.com/nodejs/node/commit/1e7eb90b39)] - **tools**: update nixpkgs-unstable to a8d610af3f1a5fb71e23e08434d8d61a466 (Node.js GitHub Bot) [#60818](https://github.com/nodejs/node/pull/60818) +* \[[`fb6b83c9ef`](https://github.com/nodejs/node/commit/fb6b83c9ef)] - **tools**: lint Temporal global (René) [#60793](https://github.com/nodejs/node/pull/60793) +* \[[`adb40439ca`](https://github.com/nodejs/node/commit/adb40439ca)] - **tools**: update nixpkgs-unstable to 71cf367cc2c168b0c2959835659c38f0a34 (Node.js GitHub Bot) [#60742](https://github.com/nodejs/node/pull/60742) +* \[[`8a76958005`](https://github.com/nodejs/node/commit/8a76958005)] - **tools**: update nixpkgs-unstable to ffcdcf99d65c61956d882df249a9be53e59 (Node.js GitHub Bot) [#60315](https://github.com/nodejs/node/pull/60315) +* \[[`9120924de1`](https://github.com/nodejs/node/commit/9120924de1)] - **util**: fix nested proxy inspection (Ruben Bridgewater) [#61077](https://github.com/nodejs/node/pull/61077) diff --git a/doc/changelogs/CHANGELOG_V4.md b/doc/changelogs/CHANGELOG_V4.md index 352466099270ce..faa5d758fd41c0 100644 --- a/doc/changelogs/CHANGELOG_V4.md +++ b/doc/changelogs/CHANGELOG_V4.md @@ -56,6 +56,7 @@ * Other Versions + * [26.x](CHANGELOG_V26.md) * [25.x](CHANGELOG_V25.md) * [24.x](CHANGELOG_V24.md) * [23.x](CHANGELOG_V23.md) diff --git a/doc/changelogs/CHANGELOG_V5.md b/doc/changelogs/CHANGELOG_V5.md index 13246aea265a5b..73cce56ce41109 100644 --- a/doc/changelogs/CHANGELOG_V5.md +++ b/doc/changelogs/CHANGELOG_V5.md @@ -32,6 +32,7 @@ * Other Versions + * [26.x](CHANGELOG_V26.md) * [25.x](CHANGELOG_V25.md) * [24.x](CHANGELOG_V24.md) * [23.x](CHANGELOG_V23.md) diff --git a/doc/changelogs/CHANGELOG_V6.md b/doc/changelogs/CHANGELOG_V6.md index 155654b659f68c..7c2ee2052232ed 100644 --- a/doc/changelogs/CHANGELOG_V6.md +++ b/doc/changelogs/CHANGELOG_V6.md @@ -61,6 +61,7 @@ * Other Versions + * [26.x](CHANGELOG_V26.md) * [25.x](CHANGELOG_V25.md) * [24.x](CHANGELOG_V24.md) * [23.x](CHANGELOG_V23.md) diff --git a/doc/changelogs/CHANGELOG_V7.md b/doc/changelogs/CHANGELOG_V7.md index fe5768c3d4b0ac..0612e8632845b1 100644 --- a/doc/changelogs/CHANGELOG_V7.md +++ b/doc/changelogs/CHANGELOG_V7.md @@ -30,6 +30,7 @@ * Other Versions + * [26.x](CHANGELOG_V26.md) * [25.x](CHANGELOG_V25.md) * [24.x](CHANGELOG_V24.md) * [23.x](CHANGELOG_V23.md) diff --git a/doc/changelogs/CHANGELOG_V8.md b/doc/changelogs/CHANGELOG_V8.md index b7d8d5ac68675a..314919baa0f7dc 100644 --- a/doc/changelogs/CHANGELOG_V8.md +++ b/doc/changelogs/CHANGELOG_V8.md @@ -52,6 +52,7 @@ * Other Versions + * [26.x](CHANGELOG_V26.md) * [25.x](CHANGELOG_V25.md) * [24.x](CHANGELOG_V24.md) * [23.x](CHANGELOG_V23.md) diff --git a/doc/changelogs/CHANGELOG_V9.md b/doc/changelogs/CHANGELOG_V9.md index 30f69f96ccc687..521e0c59b330ab 100644 --- a/doc/changelogs/CHANGELOG_V9.md +++ b/doc/changelogs/CHANGELOG_V9.md @@ -31,6 +31,7 @@ * Other Versions + * [26.x](CHANGELOG_V26.md) * [25.x](CHANGELOG_V25.md) * [24.x](CHANGELOG_V24.md) * [23.x](CHANGELOG_V23.md) From a641226c9187c9748a3100d18c3a511462dfafae Mon Sep 17 00:00:00 2001 From: Rafael Gonzaga Date: Tue, 5 May 2026 13:14:46 -0300 Subject: [PATCH 068/168] doc: fix lint-md Signed-off-by: RafaelGSS PR-URL: https://github.com/nodejs/node/pull/63127 Reviewed-By: Jacob Smith Reviewed-By: Antoine du Hamel Reviewed-By: Marco Ippolito Reviewed-By: Filip Skokan --- doc/api/async_context.md | 6 +- doc/api/cli.md | 2 +- doc/api/diagnostics_channel.md | 2 +- doc/api/fs.md | 6 +- doc/api/module.md | 2 +- doc/api/process.md | 4 +- doc/api/quic.md | 2 +- doc/api/repl.md | 2 +- doc/api/stream_iter.md | 52 +++---- doc/api/webcrypto.md | 28 ++-- doc/api/zlib_iter.md | 254 --------------------------------- 11 files changed, 53 insertions(+), 307 deletions(-) delete mode 100644 doc/api/zlib_iter.md diff --git a/doc/api/async_context.md b/doc/api/async_context.md index 86c55f6ae11b08..5b18c8efdc0513 100644 --- a/doc/api/async_context.md +++ b/doc/api/async_context.md @@ -390,8 +390,8 @@ try { > Stability: 1 - Experimental @@ -530,8 +530,8 @@ probably responsible for the context loss. > Stability: 1 - Experimental @@ -548,8 +548,8 @@ exits, whether through normal completion or by throwing an error. Explicitly ends the scope and restores the previous store value. This method diff --git a/doc/api/cli.md b/doc/api/cli.md index 1bfe15a7c0567d..12c3e3b4151250 100644 --- a/doc/api/cli.md +++ b/doc/api/cli.md @@ -1326,8 +1326,8 @@ Enable experimental support for storage inspection > Stability: 1 - Experimental diff --git a/doc/api/diagnostics_channel.md b/doc/api/diagnostics_channel.md index b7dc3b67548936..661866bb261720 100644 --- a/doc/api/diagnostics_channel.md +++ b/doc/api/diagnostics_channel.md @@ -1859,9 +1859,9 @@ Emitted when [`process.execve()`][] is invoked. These channels are emitted for each [`locks.request()`][] call. See diff --git a/doc/api/fs.md b/doc/api/fs.md index 4953ef60accfd0..03f4a77989c9af 100644 --- a/doc/api/fs.md +++ b/doc/api/fs.md @@ -381,8 +381,8 @@ added: v10.0.0 > Stability: 1 - Experimental @@ -460,8 +460,8 @@ run().catch(console.error); > Stability: 1 - Experimental @@ -1017,8 +1017,8 @@ the end of the file. > Stability: 1 - Experimental diff --git a/doc/api/module.md b/doc/api/module.md index 19fc1a7d6eff76..902b8dc0672265 100644 --- a/doc/api/module.md +++ b/doc/api/module.md @@ -179,9 +179,9 @@ added: - v20.6.0 - v18.19.0 deprecated: + - v26.0.0 - v25.9.0 - v24.15.0 - - v26.0.0 changes: - version: v26.0.0 pr-url: https://github.com/nodejs/node/pull/62401 diff --git a/doc/api/process.md b/doc/api/process.md index bcb920a11b5614..616dcbd933cdb3 100644 --- a/doc/api/process.md +++ b/doc/api/process.md @@ -740,8 +740,8 @@ This feature is not available in [`Worker`][] threads. > Stability: 1 - Experimental @@ -4080,8 +4080,8 @@ This implies calling `module.setSourceMapsSupport()` with an option added: v9.3.0 changes: - version: - - v25.9.0 - v26.0.0 + - v25.9.0 pr-url: https://github.com/nodejs/node/pull/61227 description: Use `process.addUncaughtExceptionCaptureCallback()` to register multiple callbacks. diff --git a/doc/api/quic.md b/doc/api/quic.md index e6b351a5439c6e..b370735d6be53a 100644 --- a/doc/api/quic.md +++ b/doc/api/quic.md @@ -1250,9 +1250,9 @@ True to enable TLS keylogging output. added: v23.8.0 changes: - version: + - v26.0.0 - v25.9.0 - v24.15.0 - - v26.0.0 pr-url: https://github.com/nodejs/node/pull/62335 description: CryptoKey is no longer accepted. --> diff --git a/doc/api/repl.md b/doc/api/repl.md index 5152e807e88286..67d4b8fe538fd8 100644 --- a/doc/api/repl.md +++ b/doc/api/repl.md @@ -710,8 +710,8 @@ npx codemod@latest @nodejs/repl-builtin-modules added: v0.1.91 changes: - version: - - v25.9.0 - v26.0.0 + - v25.9.0 pr-url: https://github.com/nodejs/node/pull/62188 description: The `handleError` parameter has been added. - version: v24.1.0 diff --git a/doc/api/stream_iter.md b/doc/api/stream_iter.md index d4199a40502a3d..a9916c287b9ef3 100644 --- a/doc/api/stream_iter.md +++ b/doc/api/stream_iter.md @@ -522,8 +522,8 @@ Including the `node:` prefix on the module specifier is optional. * `input` {string|ArrayBuffer|ArrayBufferView|Iterable|AsyncIterable|Object} @@ -564,8 +564,8 @@ run().catch(console.error); * `input` {string|ArrayBuffer|ArrayBufferView|Iterable|Object} @@ -596,8 +596,8 @@ console.log(textSync(fromSync('hello'))); // 'hello' * `source` {AsyncIterable|Iterable} The data source. @@ -655,8 +655,8 @@ run().catch(console.error); * `source` {Iterable} The sync data source. @@ -677,8 +677,8 @@ The `writer` must have the `*Sync` methods (`writeSync`, `writevSync`, * `source` {AsyncIterable|Iterable} The data source. @@ -750,8 +750,8 @@ ac.abort(); // Pipeline throws AbortError on next iteration * `source` {Iterable} The sync data source. @@ -766,8 +766,8 @@ Synchronous version of [`pull()`][]. All transforms must be synchronous. * `...transforms` {Function|Object} Optional transforms applied to the @@ -832,8 +832,8 @@ The writer returned by `push()` conforms to the \[Writer interface]\[]. * `options` {Object} @@ -912,8 +912,8 @@ run().catch(console.error); * `source` {AsyncIterable\|Iterable\} @@ -929,8 +929,8 @@ Collect all chunks as an array of `Uint8Array` values (without concatenating). * `source` {AsyncIterable\|Iterable\} @@ -946,8 +946,8 @@ Collect all bytes into an `ArrayBuffer`. * `source` {Iterable\} @@ -962,8 +962,8 @@ Synchronous version of [`arrayBuffer()`][]. * `source` {Iterable\} @@ -978,8 +978,8 @@ Synchronous version of [`array()`][]. * `source` {AsyncIterable\|Iterable\} @@ -1013,8 +1013,8 @@ run().catch(console.error); * `source` {Iterable\} @@ -1029,8 +1029,8 @@ Synchronous version of [`bytes()`][]. * `source` {AsyncIterable\|Iterable\} @@ -1063,8 +1063,8 @@ run().catch(console.error); * `source` {Iterable\} @@ -1082,8 +1082,8 @@ Synchronous version of [`text()`][]. * `drainable` {Object} An object implementing the drainable protocol. @@ -1139,8 +1139,8 @@ run().catch(console.error); * `...sources` {AsyncIterable\|Iterable\} Two or more iterables. @@ -1174,8 +1174,8 @@ run().catch(console.error); * `callback` {Function} `(chunks) => void` Called with each batch. @@ -1215,8 +1215,8 @@ chunks by the tapping callback; but return values are ignored. * `callback` {Function} @@ -1230,8 +1230,8 @@ Synchronous version of [`tap()`][]. * `options` {Object} @@ -1333,8 +1333,8 @@ Alias for `broadcast.cancel()`. * `input` {AsyncIterable|Iterable|Broadcastable} @@ -1348,8 +1348,8 @@ automatically and pushed to all subscribers. * `source` {AsyncIterable} The source to share. @@ -1431,8 +1431,8 @@ Alias for `share.cancel()`. * `input` {AsyncIterable|Shareable} @@ -1445,8 +1445,8 @@ Create a {Share} from an existing source. * `source` {Iterable} The sync source to share. @@ -1462,8 +1462,8 @@ Synchronous version of [`share()`][]. * `input` {Iterable|SyncShareable} diff --git a/doc/api/webcrypto.md b/doc/api/webcrypto.md index af7ad622e9f7e1..3645e0f263328c 100644 --- a/doc/api/webcrypto.md +++ b/doc/api/webcrypto.md @@ -3,8 +3,8 @@ @@ -1926,9 +1926,9 @@ added: v24.7.0 * Type: {number} represents the requested output length in bits. @@ -2358,16 +2358,16 @@ added: v15.0.0 #### `kangarooTwelveParams.customization` * Type: {ArrayBuffer|TypedArray|DataView|Buffer|undefined} @@ -2378,8 +2378,8 @@ The optional customization string for KangarooTwelve. * Type: {string} Must be `'KT128'`[^modern-algos] or `'KT256'`[^modern-algos]. @@ -2388,8 +2388,8 @@ added: * Type: {number} represents the requested output length in bits. @@ -2475,9 +2475,9 @@ added: v24.8.0 added: v24.8.0 changes: - version: + - v26.0.0 - v25.9.0 - v24.15.0 - - v26.0.0 pr-url: https://github.com/nodejs/node/pull/61875 description: Renamed `kmacParams.length` to `kmacParams.outputLength`. --> @@ -2494,9 +2494,9 @@ added: v24.8.0 * Type: {number} @@ -2774,16 +2774,16 @@ The length (in bytes) of the random salt to use. #### `turboShakeParams.domainSeparation` * Type: {number|undefined} @@ -2794,8 +2794,8 @@ The optional domain separation byte (0x01-0x7f). Defaults to `0x1f`. * Type: {string} Must be `'TurboSHAKE128'`[^modern-algos] or `'TurboSHAKE256'`[^modern-algos]. @@ -2804,8 +2804,8 @@ added: * Type: {number} represents the requested output length in bits. diff --git a/doc/api/zlib_iter.md b/doc/api/zlib_iter.md deleted file mode 100644 index ae9ad3bb59faea..00000000000000 --- a/doc/api/zlib_iter.md +++ /dev/null @@ -1,254 +0,0 @@ -# Iterable Compression - - - -> Stability: 1 - Experimental - - - -The `node:zlib/iter` module provides compression and decompression transforms -for use with the [`node:stream/iter`][] iterable streams API. - -This module is available only when the `--experimental-stream-iter` CLI flag -is enabled. - -Each algorithm has both an async variant (stateful async generator, for use -with [`pull()`][] and [`pipeTo()`][]) and a sync variant (stateful sync -generator, for use with `pullSync()` and `pipeToSync()`). - -The async transforms run compression on the libuv threadpool, overlapping -I/O with JavaScript execution. The sync transforms run compression directly -on the main thread. - -> Note: The defaults for these transforms are tuned for streaming throughput, -> and differ from the defaults in `node:zlib`. In particular, gzip/deflate -> default to level 4 (not 6) and memLevel 9 (not 8), and Brotli defaults to -> quality 6 (not 11). These choices match common HTTP server configurations -> and provide significantly faster compression with only a small reduction in -> compression ratio. All defaults can be overridden via options. - -```mjs -import { from, pull, bytes, text } from 'node:stream/iter'; -import { compressGzip, decompressGzip } from 'node:zlib/iter'; - -// Async round-trip -const compressed = await bytes(pull(from('hello'), compressGzip())); -const original = await text(pull(from(compressed), decompressGzip())); -console.log(original); // 'hello' -``` - -```cjs -const { from, pull, bytes, text } = require('node:stream/iter'); -const { compressGzip, decompressGzip } = require('node:zlib/iter'); - -async function run() { - const compressed = await bytes(pull(from('hello'), compressGzip())); - const original = await text(pull(from(compressed), decompressGzip())); - console.log(original); // 'hello' -} - -run().catch(console.error); -``` - -```mjs -import { fromSync, pullSync, textSync } from 'node:stream/iter'; -import { compressGzipSync, decompressGzipSync } from 'node:zlib/iter'; - -// Sync round-trip -const compressed = pullSync(fromSync('hello'), compressGzipSync()); -const original = textSync(pullSync(compressed, decompressGzipSync())); -console.log(original); // 'hello' -``` - -```cjs -const { fromSync, pullSync, textSync } = require('node:stream/iter'); -const { compressGzipSync, decompressGzipSync } = require('node:zlib/iter'); - -const compressed = pullSync(fromSync('hello'), compressGzipSync()); -const original = textSync(pullSync(compressed, decompressGzipSync())); -console.log(original); // 'hello' -``` - -## `compressBrotli([options])` - -## `compressBrotliSync([options])` - - - -* `options` {Object} - * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). - * `params` {Object} Key-value object where keys and values are - `zlib.constants` entries. The most important compressor parameters are: - * `BROTLI_PARAM_MODE` -- `BROTLI_MODE_GENERIC` (default), - `BROTLI_MODE_TEXT`, or `BROTLI_MODE_FONT`. - * `BROTLI_PARAM_QUALITY` -- ranges from `BROTLI_MIN_QUALITY` to - `BROTLI_MAX_QUALITY`. **Default:** `6` (not `BROTLI_DEFAULT_QUALITY` - which is 11). Quality 6 is appropriate for streaming; quality 11 is - intended for offline/build-time compression. - * `BROTLI_PARAM_SIZE_HINT` -- expected input size. **Default:** `0` - (unknown). - * `BROTLI_PARAM_LGWIN` -- window size (log2). **Default:** `20` (1 MB). - The Brotli library default is 22 (4 MB); the reduced default saves - memory without significant compression impact for streaming workloads. - * `BROTLI_PARAM_LGBLOCK` -- input block size (log2). - See the [Brotli compressor options][] in the zlib documentation for the - full list. - * `dictionary` {Buffer|TypedArray|DataView} -* Returns: {Object} A stateful transform. - -Create a Brotli compression transform. Output is compatible with -`zlib.brotliDecompress()` and `decompressBrotli()`/`decompressBrotliSync()`. - -## `compressDeflate([options])` - -## `compressDeflateSync([options])` - - - -* `options` {Object} - * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). - * `level` {number} Compression level (`0`-`9`). **Default:** `4`. - * `windowBits` {number} **Default:** `Z_DEFAULT_WINDOWBITS` (15). - * `memLevel` {number} **Default:** `9`. - * `strategy` {number} **Default:** `Z_DEFAULT_STRATEGY`. - * `dictionary` {Buffer|TypedArray|DataView} -* Returns: {Object} A stateful transform. - -Create a deflate compression transform. Output is compatible with -`zlib.inflate()` and `decompressDeflate()`/`decompressDeflateSync()`. - -## `compressGzip([options])` - -## `compressGzipSync([options])` - - - -* `options` {Object} - * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). - * `level` {number} Compression level (`0`-`9`). **Default:** `4`. - * `windowBits` {number} **Default:** `Z_DEFAULT_WINDOWBITS` (15). - * `memLevel` {number} **Default:** `9`. - * `strategy` {number} **Default:** `Z_DEFAULT_STRATEGY`. - * `dictionary` {Buffer|TypedArray|DataView} -* Returns: {Object} A stateful transform. - -Create a gzip compression transform. Output is compatible with `zlib.gunzip()` -and `decompressGzip()`/`decompressGzipSync()`. - -## `compressZstd([options])` - -## `compressZstdSync([options])` - - - -* `options` {Object} - * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). - * `params` {Object} Key-value object where keys and values are - `zlib.constants` entries. The most important compressor parameters are: - * `ZSTD_c_compressionLevel` -- **Default:** `ZSTD_CLEVEL_DEFAULT` (3). - * `ZSTD_c_checksumFlag` -- generate a checksum. **Default:** `0`. - * `ZSTD_c_strategy` -- compression strategy. Values include - `ZSTD_fast`, `ZSTD_dfast`, `ZSTD_greedy`, `ZSTD_lazy`, - `ZSTD_lazy2`, `ZSTD_btlazy2`, `ZSTD_btopt`, `ZSTD_btultra`, - `ZSTD_btultra2`. - See the [Zstd compressor options][] in the zlib documentation for the - full list. - * `pledgedSrcSize` {number} Expected uncompressed size (optional hint). - * `dictionary` {Buffer|TypedArray|DataView} -* Returns: {Object} A stateful transform. - -Create a Zstandard compression transform. Output is compatible with -`zlib.zstdDecompress()` and `decompressZstd()`/`decompressZstdSync()`. - -## `decompressBrotli([options])` - -## `decompressBrotliSync([options])` - - - -* `options` {Object} - * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). - * `params` {Object} Key-value object where keys and values are - `zlib.constants` entries. Available decompressor parameters: - * `BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION` -- boolean - flag affecting internal memory allocation. - * `BROTLI_DECODER_PARAM_LARGE_WINDOW` -- boolean flag enabling "Large - Window Brotli" mode (not compatible with [RFC 7932][]). - See the [Brotli decompressor options][] in the zlib documentation for - details. - * `dictionary` {Buffer|TypedArray|DataView} -* Returns: {Object} A stateful transform. - -Create a Brotli decompression transform. - -## `decompressDeflate([options])` - -## `decompressDeflateSync([options])` - - - -* `options` {Object} - * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). - * `windowBits` {number} **Default:** `Z_DEFAULT_WINDOWBITS` (15). - * `dictionary` {Buffer|TypedArray|DataView} -* Returns: {Object} A stateful transform. - -Create a deflate decompression transform. - -## `decompressGzip([options])` - -## `decompressGzipSync([options])` - - - -* `options` {Object} - * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). - * `windowBits` {number} **Default:** `Z_DEFAULT_WINDOWBITS` (15). - * `dictionary` {Buffer|TypedArray|DataView} -* Returns: {Object} A stateful transform. - -Create a gzip decompression transform. - -## `decompressZstd([options])` - -## `decompressZstdSync([options])` - - - -* `options` {Object} - * `chunkSize` {number} Output buffer size. **Default:** `65536` (64 KB). - * `params` {Object} Key-value object where keys and values are - `zlib.constants` entries. Available decompressor parameters: - * `ZSTD_d_windowLogMax` -- maximum window size (log2) the decompressor - will allocate. Limits memory usage against malicious input. - See the [Zstd decompressor options][] in the zlib documentation for - details. - * `dictionary` {Buffer|TypedArray|DataView} -* Returns: {Object} A stateful transform. - -Create a Zstandard decompression transform. - -[Brotli compressor options]: zlib.md#compressor-options -[Brotli decompressor options]: zlib.md#decompressor-options -[RFC 7932]: https://www.rfc-editor.org/rfc/rfc7932 -[Zstd compressor options]: zlib.md#compressor-options-1 -[Zstd decompressor options]: zlib.md#decompressor-options-1 -[`node:stream/iter`]: stream_iter.md -[`pipeTo()`]: stream_iter.md#pipetosource-transforms-writer-options -[`pull()`]: stream_iter.md#pullsource-transforms-options From 18f938d25481f595128b504d1fa7b439a4aadca9 Mon Sep 17 00:00:00 2001 From: Rafael Gonzaga Date: Tue, 5 May 2026 15:17:44 -0300 Subject: [PATCH 069/168] src: bump NODE_MAJOR_VERSION to 27 Signed-off-by: RafaelGSS PR-URL: https://github.com/nodejs/node/pull/63128 Reviewed-By: Filip Skokan Reviewed-By: Antoine du Hamel Reviewed-By: Luigi Pinca --- src/node_version.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/node_version.h b/src/node_version.h index 0c4ca944325a22..4c18037fc8c88a 100644 --- a/src/node_version.h +++ b/src/node_version.h @@ -22,7 +22,7 @@ #ifndef SRC_NODE_VERSION_H_ #define SRC_NODE_VERSION_H_ -#define NODE_MAJOR_VERSION 26 +#define NODE_MAJOR_VERSION 27 #define NODE_MINOR_VERSION 0 #define NODE_PATCH_VERSION 0 From 2b112e70fe0ad3b70025ac31a039bed0802cc74d Mon Sep 17 00:00:00 2001 From: Rafael Gonzaga Date: Tue, 5 May 2026 18:05:27 -0300 Subject: [PATCH 070/168] doc: fix changelog for chromium numbering MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: RafaelGSS PR-URL: https://github.com/nodejs/node/pull/63133 Reviewed-By: René Reviewed-By: Antoine du Hamel Reviewed-By: Filip Skokan --- doc/changelogs/CHANGELOG_V26.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/changelogs/CHANGELOG_V26.md b/doc/changelogs/CHANGELOG_V26.md index d1330129b284e5..28571fcd6f73a9 100644 --- a/doc/changelogs/CHANGELOG_V26.md +++ b/doc/changelogs/CHANGELOG_V26.md @@ -63,7 +63,7 @@ Contributed by Richard Lau in [#61806](https://github.com/nodejs/node/pull/61806 #### V8 14.6 -The V8 engine is updated to version 14.6.202.33, which is part of Chromium 134. +The V8 engine is updated to version 14.6.202.33, which is part of Chromium 146. This version also includes: From cf91d181fbd00899790852c510bcf4522e8084ea Mon Sep 17 00:00:00 2001 From: James M Snell Date: Tue, 21 Apr 2026 09:24:46 -0700 Subject: [PATCH 071/168] quic: complete the internal implementation of QUIC Signed-off-by: James M Snell Assisted-by: Opencode:Opus 4.6 PR-URL: https://github.com/nodejs/node/pull/62876 Reviewed-By: Matteo Collina Reviewed-By: Filip Skokan Reviewed-By: Paolo Insogna Reviewed-By: Robert Nagy --- deps/ngtcp2/ngtcp2.gyp | 11 +- doc/api/errors.md | 27 + doc/api/quic.md | 1893 ++++++++- lib/internal/blob.js | 72 +- lib/internal/errors.js | 3 + lib/internal/fs/promises.js | 2 + lib/internal/perf/observe.js | 3 + lib/internal/quic/diagnostics.js | 71 + lib/internal/quic/quic.js | 3475 ++++++++++++++--- lib/internal/quic/state.js | 366 +- lib/internal/quic/stats.js | 104 +- lib/internal/quic/symbols.js | 24 +- lib/quic.js | 2 + node.gyp | 4 +- src/dataqueue/queue.cc | 36 +- src/debug_utils.h | 3 +- src/node_blob.cc | 50 +- src/node_blob.h | 18 +- src/node_file.h | 1 + src/node_perf_common.h | 13 +- src/node_sockaddr.cc | 357 +- src/node_sockaddr.h | 80 +- src/node_util.cc | 11 + src/quic/README.md | 418 ++ src/quic/application.cc | 410 +- src/quic/application.h | 169 +- src/quic/bindingdata.cc | 216 +- src/quic/bindingdata.h | 61 +- src/quic/data.cc | 92 +- src/quic/data.h | 46 +- src/quic/defs.h | 50 +- src/quic/endpoint.cc | 468 ++- src/quic/endpoint.h | 86 +- src/quic/http3.cc | 787 +++- src/quic/http3.h | 7 + src/quic/logstream.cc | 140 - src/quic/logstream.h | 84 - src/quic/packet.cc | 20 +- src/quic/packet.h | 9 + src/quic/session.cc | 1341 +++++-- src/quic/session.h | 85 +- src/quic/session_manager.cc | 170 + src/quic/session_manager.h | 109 + src/quic/sessionticket.cc | 25 +- src/quic/sessionticket.h | 8 +- src/quic/streams.cc | 371 +- src/quic/streams.h | 35 +- src/quic/tlscontext.cc | 39 +- src/quic/tlscontext.h | 9 + src/quic/tokens.cc | 43 +- src/quic/tokens.h | 27 +- src/quic/transportparams.cc | 68 +- src/quic/transportparams.h | 9 +- test/cctest/test_dataqueue.cc | 24 +- test/cctest/test_quic_tokens.cc | 79 +- test/cctest/test_sockaddr.cc | 92 +- test/common/quic.mjs | 57 + test/fixtures/keys/Makefile | 25 +- test/fixtures/keys/ca2-crl-agent3.pem | 13 + .../parallel/test-quic-address-validation.mjs | 48 + test/parallel/test-quic-alpn-h3.mjs | 34 +- test/parallel/test-quic-alpn-mismatch.mjs | 50 + test/parallel/test-quic-alpn.mjs | 36 +- .../test-quic-callback-error-onblocked.mjs | 45 + ...t-quic-callback-error-ondatagram-async.mjs | 46 + .../test-quic-callback-error-ondatagram.mjs | 48 + ...t-quic-callback-error-ondatagramstatus.mjs | 40 + ...est-quic-callback-error-onerror-option.mjs | 36 + ...quic-callback-error-onerror-validation.mjs | 62 + .../test-quic-callback-error-onerror.mjs | 76 + .../test-quic-callback-error-onhandshake.mjs | 36 + .../test-quic-callback-error-onnewtoken.mjs | 42 + ...t-quic-callback-error-onpathvalidation.mjs | 53 + .../test-quic-callback-error-onreset.mjs | 66 + ...st-quic-callback-error-onsessionticket.mjs | 41 + ...est-quic-callback-error-onstream-async.mjs | 46 + .../test-quic-callback-error-onstream.mjs | 49 + ...est-quic-callback-error-stream-onerror.mjs | 83 + ...t-quic-callback-error-suppressed-async.mjs | 53 + .../test-quic-callback-error-suppressed.mjs | 52 + test/parallel/test-quic-cc-algorithm.mjs | 52 + .../test-quic-connection-concurrent.mjs | 56 + test/parallel/test-quic-connection-limits.mjs | 76 + .../parallel/test-quic-datagram-abandoned.mjs | 64 + .../test-quic-datagram-drop-newest.mjs | 82 + .../test-quic-datagram-drop-oldest.mjs | 83 + test/parallel/test-quic-datagram-echo.mjs | 70 + .../test-quic-datagram-edge-cases.mjs | 93 + ...st-quic-datagram-frame-size-validation.mjs | 58 + test/parallel/test-quic-datagram-multiple.mjs | 84 + .../parallel/test-quic-datagram-no-detach.mjs | 72 + .../test-quic-datagram-size-limits.mjs | 64 + test/parallel/test-quic-datagram-sources.mjs | 220 ++ test/parallel/test-quic-datagram-status.mjs | 76 + test/parallel/test-quic-datagram-utf8.mjs | 46 + test/parallel/test-quic-datagram.mjs | 62 + .../test-quic-default-stream-limits.mjs | 55 + .../test-quic-diagnostics-channel-busy.mjs | 44 + ...ic-diagnostics-channel-datagram-status.mjs | 48 + ...test-quic-diagnostics-channel-datagram.mjs | 52 + .../test-quic-diagnostics-channel-error.mjs | 50 + .../test-quic-diagnostics-channel-path.mjs | 59 + .../test-quic-diagnostics-channel-session.mjs | 49 + .../test-quic-diagnostics-channel-stream.mjs | 67 + .../test-quic-diagnostics-channel-token.mjs | 54 + .../test-quic-diagnostics-channel.mjs | 106 + test/parallel/test-quic-draining-period.mjs | 103 + test/parallel/test-quic-edge-closing-ops.mjs | 50 + .../test-quic-edge-concurrent-close.mjs | 41 + .../parallel/test-quic-edge-destroyed-ops.mjs | 55 + ...test-quic-edge-endpoint-destroy-active.mjs | 55 + test/parallel/test-quic-edge-idempotent.mjs | 53 + ...test-quic-edge-session-close-immediate.mjs | 27 + ...st-quic-edge-session-destroy-immediate.mjs | 37 + test/parallel/test-quic-enable-early-data.mjs | 58 + .../test-quic-endpoint-async-dispose.mjs | 39 + .../test-quic-endpoint-bind-failure.mjs | 49 + test/parallel/test-quic-endpoint-bind.mjs | 55 + test/parallel/test-quic-endpoint-busy.mjs | 71 + .../test-quic-endpoint-close-destroy.mjs | 79 + ...test-quic-endpoint-destroy-after-close.mjs | 66 + ...c-endpoint-destroy-cascade-close-frame.mjs | 86 + .../test-quic-endpoint-idle-timeout.mjs | 77 + .../test-quic-endpoint-onsession-throws.mjs | 74 + test/parallel/test-quic-endpoint-reuse.mjs | 89 + .../test-quic-endpoint-state-transitions.mjs | 84 + test/parallel/test-quic-error-class.mjs | 160 + ...st-quic-error-destroy-rejects-promises.mjs | 59 + test/parallel/test-quic-exports-constants.mjs | 49 + test/parallel/test-quic-exports.mjs | 50 +- test/parallel/test-quic-flow-control-blob.mjs | 50 + .../test-quic-flow-control-block-resume.mjs | 52 + .../test-quic-flow-control-params.mjs | 72 + test/parallel/test-quic-flow-control-uni.mjs | 58 + .../parallel/test-quic-h3-callback-errors.mjs | 278 ++ test/parallel/test-quic-h3-close-behavior.mjs | 94 + .../test-quic-h3-concurrent-requests.mjs | 90 + test/parallel/test-quic-h3-datagram.mjs | 171 + test/parallel/test-quic-h3-error-codes.mjs | 122 + test/parallel/test-quic-h3-goaway-non-h3.mjs | 65 + test/parallel/test-quic-h3-goaway.mjs | 148 + .../test-quic-h3-header-validation.mjs | 157 + .../parallel/test-quic-h3-headers-support.mjs | 95 + .../test-quic-h3-informational-headers.mjs | 115 + test/parallel/test-quic-h3-origin.mjs | 185 + test/parallel/test-quic-h3-pending-stream.mjs | 87 + .../parallel/test-quic-h3-post-filehandle.mjs | 96 + test/parallel/test-quic-h3-post-request.mjs | 101 + test/parallel/test-quic-h3-priority.mjs | 239 ++ test/parallel/test-quic-h3-qpack-settings.mjs | 119 + .../test-quic-h3-request-response.mjs | 114 + test/parallel/test-quic-h3-settings.mjs | 185 + ...st-quic-h3-stream-destroy-with-headers.mjs | 58 + .../test-quic-h3-trailing-headers.mjs | 122 + .../test-quic-h3-zero-rtt-bogus-ticket.mjs | 38 + ...est-quic-h3-zero-rtt-rejected-settings.mjs | 177 + test/parallel/test-quic-h3-zero-rtt.mjs | 131 + .../test-quic-handshake-ipv6-only.mjs | 32 +- test/parallel/test-quic-handshake-timeout.mjs | 33 + test/parallel/test-quic-handshake.mjs | 26 +- ...quic-internal-endpoint-listen-defaults.mjs | 61 +- .../test-quic-internal-endpoint-options.mjs | 18 +- ...est-quic-internal-endpoint-stats-state.mjs | 218 +- .../test-quic-internal-setcallbacks.mjs | 10 +- test/parallel/test-quic-keepalive.mjs | 68 + test/parallel/test-quic-key-update-peer.mjs | 50 + test/parallel/test-quic-key-update.mjs | 50 + test/parallel/test-quic-max-payload-size.mjs | 58 + test/parallel/test-quic-max-window.mjs | 77 + test/parallel/test-quic-module-exports.mjs | 61 + test/parallel/test-quic-new-token.mjs | 55 + test/parallel/test-quic-perf-hooks.mjs | 98 + .../test-quic-preferred-address-ignore.mjs | 60 + test/parallel/test-quic-qlog.mjs | 94 + .../test-quic-reject-unauthorized.mjs | 54 + .../test-quic-session-close-error-code.mjs | 159 + .../test-quic-session-close-graceful.mjs | 90 + .../test-quic-session-close-sends-frame.mjs | 44 + test/parallel/test-quic-session-close.mjs | 77 + .../test-quic-session-destroy-reentrant.mjs | 188 + ...-quic-session-destroy-validate-options.mjs | 133 + test/parallel/test-quic-session-destroy.mjs | 103 + .../test-quic-session-idle-timeout.mjs | 37 + ...test-quic-session-opened-early-destroy.mjs | 146 + .../test-quic-session-opened-info.mjs | 72 + .../test-quic-session-opened-validation.mjs | 43 + ...-quic-session-preferred-address-ignore.mjs | 69 + ...st-quic-session-preferred-address-ipv6.mjs | 124 + .../test-quic-session-preferred-address.mjs | 102 + .../parallel/test-quic-session-properties.mjs | 88 + .../test-quic-session-stats-datagram.mjs | 58 + .../test-quic-session-stats-detailed.mjs | 65 + test/parallel/test-quic-session-stats.mjs | 72 + .../test-quic-session-stream-lifecycle.mjs | 121 +- ...test-quic-shared-endpoint-stream-close.mjs | 92 + test/parallel/test-quic-sni-mismatch.mjs | 61 + test/parallel/test-quic-sni-multi-entry.mjs | 81 + test/parallel/test-quic-sni-setcontexts.mjs | 72 + test/parallel/test-quic-sni.mjs | 38 +- test/parallel/test-quic-stateless-reset.mjs | 232 ++ .../test-quic-stats-tojson-inspect.mjs | 67 + test/parallel/test-quic-stream-bidi-basic.mjs | 60 + .../test-quic-stream-bidi-concurrent.mjs | 65 + test/parallel/test-quic-stream-bidi-echo.mjs | 54 + .../test-quic-stream-bidi-halfclose.mjs | 60 + test/parallel/test-quic-stream-bidi-large.mjs | 88 + ...test-quic-stream-bidi-server-initiated.mjs | 57 + .../test-quic-stream-bidi-setbody.mjs | 59 + .../parallel/test-quic-stream-bidi-writer.mjs | 63 + .../test-quic-stream-body-async-error.mjs | 46 + .../test-quic-stream-body-async-iterable.mjs | 51 + test/parallel/test-quic-stream-body-error.mjs | 51 + .../test-quic-stream-body-filehandle.mjs | 122 + .../test-quic-stream-body-pooled-buffer.mjs | 51 + .../test-quic-stream-body-promise-error.mjs | 38 + .../test-quic-stream-body-promise-reject.mjs | 51 + .../test-quic-stream-body-promise.mjs | 71 + .../test-quic-stream-body-readable-stream.mjs | 66 + .../test-quic-stream-body-sources.mjs | 88 + test/parallel/test-quic-stream-body-state.mjs | 85 + ...test-quic-stream-body-string-shorthand.mjs | 106 + .../parallel/test-quic-stream-body-string.mjs | 43 + .../test-quic-stream-body-sync-iterable.mjs | 45 + .../test-quic-stream-closed-promise.mjs | 40 + .../test-quic-stream-closed-rejects.mjs | 55 + .../test-quic-stream-destroy-emits-reset.mjs | 69 + ...quic-stream-destroy-emits-stop-sending.mjs | 83 + .../test-quic-stream-destroy-options-code.mjs | 55 + ...t-quic-stream-destroy-options-validate.mjs | 73 + .../test-quic-stream-error-graceful-close.mjs | 52 + .../parallel/test-quic-stream-id-ordering.mjs | 56 + .../test-quic-stream-iteration-batching.mjs | 66 + .../test-quic-stream-iteration-break.mjs | 58 + .../test-quic-stream-iteration-destroyed.mjs | 39 + .../test-quic-stream-iteration-double.mjs | 59 + ...test-quic-stream-iteration-nonreadable.mjs | 46 + .../test-quic-stream-iteration-pipeto.mjs | 48 + .../test-quic-stream-iteration-pull.mjs | 52 + .../test-quic-stream-iteration-reset.mjs | 66 + test/parallel/test-quic-stream-iteration.mjs | 81 + .../test-quic-stream-limits-pending.mjs | 71 + test/parallel/test-quic-stream-limits-uni.mjs | 56 + test/parallel/test-quic-stream-many-rapid.mjs | 58 + test/parallel/test-quic-stream-onblocked.mjs | 73 + test/parallel/test-quic-stream-pending.mjs | 57 + test/parallel/test-quic-stream-priority.mjs | 95 + .../test-quic-stream-reset-after-data.mjs | 67 + .../test-quic-stream-reset-before-data.mjs | 83 + .../test-quic-stream-reset-mid-transfer.mjs | 66 + test/parallel/test-quic-stream-reset-stop.mjs | 65 + .../test-quic-stream-setbody-errors.mjs | 63 + .../test-quic-stream-slow-consumer.mjs | 58 + test/parallel/test-quic-stream-stats.mjs | 73 + ...t-quic-stream-stop-sending-interaction.mjs | 78 + .../test-quic-stream-stop-sending.mjs | 54 + test/parallel/test-quic-stream-uni-basic.mjs | 65 + .../test-quic-stream-uni-server-initiated.mjs | 58 + .../test-quic-stream-write-partial-view.mjs | 75 + test/parallel/test-quic-stream-writer-api.mjs | 144 + .../test-quic-stream-writer-dispose.mjs | 50 + ...est-quic-stream-writer-fail-error-code.mjs | 102 + .../parallel/test-quic-stream-zero-length.mjs | 42 + test/parallel/test-quic-test-client.mjs | 5 + test/parallel/test-quic-test-server.mjs | 5 + test/parallel/test-quic-tls-ca.mjs | 49 + test/parallel/test-quic-tls-crl.mjs | 78 + test/parallel/test-quic-tls-keylog.mjs | 66 + test/parallel/test-quic-tls-options.mjs | 83 + test/parallel/test-quic-tls-trace.mjs | 33 + test/parallel/test-quic-tls-verify-client.mjs | 87 + test/parallel/test-quic-token-distinct.mjs | 50 + test/parallel/test-quic-token-expired.mjs | 68 + test/parallel/test-quic-token-reuse.mjs | 62 + test/parallel/test-quic-token-secret.mjs | 90 + .../test-quic-transport-params-validation.mjs | 76 + .../test-quic-version-negotiation.mjs | 79 + test/parallel/test-quic-version.mjs | 45 + .../test-quic-writer-abort-signal.mjs | 52 + .../test-quic-writer-async-dispose-ended.mjs | 46 + .../test-quic-writer-backpressure.mjs | 81 + .../test-quic-writer-stop-sending.mjs | 59 + .../test-quic-writer-write-rejects.mjs | 65 + test/parallel/test-quic-zero-rtt-datagram.mjs | 81 + .../test-quic-zero-rtt-disabled-client.mjs | 60 + .../test-quic-zero-rtt-disabled-server.mjs | 93 + .../test-quic-zero-rtt-rejected-settings.mjs | 111 + test/parallel/test-quic-zero-rtt.mjs | 111 + 287 files changed, 26484 insertions(+), 2666 deletions(-) create mode 100644 lib/internal/quic/diagnostics.js create mode 100644 src/quic/README.md delete mode 100644 src/quic/logstream.cc delete mode 100644 src/quic/logstream.h create mode 100644 src/quic/session_manager.cc create mode 100644 src/quic/session_manager.h create mode 100644 test/common/quic.mjs create mode 100644 test/fixtures/keys/ca2-crl-agent3.pem create mode 100644 test/parallel/test-quic-address-validation.mjs create mode 100644 test/parallel/test-quic-alpn-mismatch.mjs create mode 100644 test/parallel/test-quic-callback-error-onblocked.mjs create mode 100644 test/parallel/test-quic-callback-error-ondatagram-async.mjs create mode 100644 test/parallel/test-quic-callback-error-ondatagram.mjs create mode 100644 test/parallel/test-quic-callback-error-ondatagramstatus.mjs create mode 100644 test/parallel/test-quic-callback-error-onerror-option.mjs create mode 100644 test/parallel/test-quic-callback-error-onerror-validation.mjs create mode 100644 test/parallel/test-quic-callback-error-onerror.mjs create mode 100644 test/parallel/test-quic-callback-error-onhandshake.mjs create mode 100644 test/parallel/test-quic-callback-error-onnewtoken.mjs create mode 100644 test/parallel/test-quic-callback-error-onpathvalidation.mjs create mode 100644 test/parallel/test-quic-callback-error-onreset.mjs create mode 100644 test/parallel/test-quic-callback-error-onsessionticket.mjs create mode 100644 test/parallel/test-quic-callback-error-onstream-async.mjs create mode 100644 test/parallel/test-quic-callback-error-onstream.mjs create mode 100644 test/parallel/test-quic-callback-error-stream-onerror.mjs create mode 100644 test/parallel/test-quic-callback-error-suppressed-async.mjs create mode 100644 test/parallel/test-quic-callback-error-suppressed.mjs create mode 100644 test/parallel/test-quic-cc-algorithm.mjs create mode 100644 test/parallel/test-quic-connection-concurrent.mjs create mode 100644 test/parallel/test-quic-connection-limits.mjs create mode 100644 test/parallel/test-quic-datagram-abandoned.mjs create mode 100644 test/parallel/test-quic-datagram-drop-newest.mjs create mode 100644 test/parallel/test-quic-datagram-drop-oldest.mjs create mode 100644 test/parallel/test-quic-datagram-echo.mjs create mode 100644 test/parallel/test-quic-datagram-edge-cases.mjs create mode 100644 test/parallel/test-quic-datagram-frame-size-validation.mjs create mode 100644 test/parallel/test-quic-datagram-multiple.mjs create mode 100644 test/parallel/test-quic-datagram-no-detach.mjs create mode 100644 test/parallel/test-quic-datagram-size-limits.mjs create mode 100644 test/parallel/test-quic-datagram-sources.mjs create mode 100644 test/parallel/test-quic-datagram-status.mjs create mode 100644 test/parallel/test-quic-datagram-utf8.mjs create mode 100644 test/parallel/test-quic-datagram.mjs create mode 100644 test/parallel/test-quic-default-stream-limits.mjs create mode 100644 test/parallel/test-quic-diagnostics-channel-busy.mjs create mode 100644 test/parallel/test-quic-diagnostics-channel-datagram-status.mjs create mode 100644 test/parallel/test-quic-diagnostics-channel-datagram.mjs create mode 100644 test/parallel/test-quic-diagnostics-channel-error.mjs create mode 100644 test/parallel/test-quic-diagnostics-channel-path.mjs create mode 100644 test/parallel/test-quic-diagnostics-channel-session.mjs create mode 100644 test/parallel/test-quic-diagnostics-channel-stream.mjs create mode 100644 test/parallel/test-quic-diagnostics-channel-token.mjs create mode 100644 test/parallel/test-quic-diagnostics-channel.mjs create mode 100644 test/parallel/test-quic-draining-period.mjs create mode 100644 test/parallel/test-quic-edge-closing-ops.mjs create mode 100644 test/parallel/test-quic-edge-concurrent-close.mjs create mode 100644 test/parallel/test-quic-edge-destroyed-ops.mjs create mode 100644 test/parallel/test-quic-edge-endpoint-destroy-active.mjs create mode 100644 test/parallel/test-quic-edge-idempotent.mjs create mode 100644 test/parallel/test-quic-edge-session-close-immediate.mjs create mode 100644 test/parallel/test-quic-edge-session-destroy-immediate.mjs create mode 100644 test/parallel/test-quic-enable-early-data.mjs create mode 100644 test/parallel/test-quic-endpoint-async-dispose.mjs create mode 100644 test/parallel/test-quic-endpoint-bind-failure.mjs create mode 100644 test/parallel/test-quic-endpoint-bind.mjs create mode 100644 test/parallel/test-quic-endpoint-busy.mjs create mode 100644 test/parallel/test-quic-endpoint-close-destroy.mjs create mode 100644 test/parallel/test-quic-endpoint-destroy-after-close.mjs create mode 100644 test/parallel/test-quic-endpoint-destroy-cascade-close-frame.mjs create mode 100644 test/parallel/test-quic-endpoint-idle-timeout.mjs create mode 100644 test/parallel/test-quic-endpoint-onsession-throws.mjs create mode 100644 test/parallel/test-quic-endpoint-reuse.mjs create mode 100644 test/parallel/test-quic-endpoint-state-transitions.mjs create mode 100644 test/parallel/test-quic-error-class.mjs create mode 100644 test/parallel/test-quic-error-destroy-rejects-promises.mjs create mode 100644 test/parallel/test-quic-exports-constants.mjs create mode 100644 test/parallel/test-quic-flow-control-blob.mjs create mode 100644 test/parallel/test-quic-flow-control-block-resume.mjs create mode 100644 test/parallel/test-quic-flow-control-params.mjs create mode 100644 test/parallel/test-quic-flow-control-uni.mjs create mode 100644 test/parallel/test-quic-h3-callback-errors.mjs create mode 100644 test/parallel/test-quic-h3-close-behavior.mjs create mode 100644 test/parallel/test-quic-h3-concurrent-requests.mjs create mode 100644 test/parallel/test-quic-h3-datagram.mjs create mode 100644 test/parallel/test-quic-h3-error-codes.mjs create mode 100644 test/parallel/test-quic-h3-goaway-non-h3.mjs create mode 100644 test/parallel/test-quic-h3-goaway.mjs create mode 100644 test/parallel/test-quic-h3-header-validation.mjs create mode 100644 test/parallel/test-quic-h3-headers-support.mjs create mode 100644 test/parallel/test-quic-h3-informational-headers.mjs create mode 100644 test/parallel/test-quic-h3-origin.mjs create mode 100644 test/parallel/test-quic-h3-pending-stream.mjs create mode 100644 test/parallel/test-quic-h3-post-filehandle.mjs create mode 100644 test/parallel/test-quic-h3-post-request.mjs create mode 100644 test/parallel/test-quic-h3-priority.mjs create mode 100644 test/parallel/test-quic-h3-qpack-settings.mjs create mode 100644 test/parallel/test-quic-h3-request-response.mjs create mode 100644 test/parallel/test-quic-h3-settings.mjs create mode 100644 test/parallel/test-quic-h3-stream-destroy-with-headers.mjs create mode 100644 test/parallel/test-quic-h3-trailing-headers.mjs create mode 100644 test/parallel/test-quic-h3-zero-rtt-bogus-ticket.mjs create mode 100644 test/parallel/test-quic-h3-zero-rtt-rejected-settings.mjs create mode 100644 test/parallel/test-quic-h3-zero-rtt.mjs create mode 100644 test/parallel/test-quic-handshake-timeout.mjs create mode 100644 test/parallel/test-quic-keepalive.mjs create mode 100644 test/parallel/test-quic-key-update-peer.mjs create mode 100644 test/parallel/test-quic-key-update.mjs create mode 100644 test/parallel/test-quic-max-payload-size.mjs create mode 100644 test/parallel/test-quic-max-window.mjs create mode 100644 test/parallel/test-quic-module-exports.mjs create mode 100644 test/parallel/test-quic-new-token.mjs create mode 100644 test/parallel/test-quic-perf-hooks.mjs create mode 100644 test/parallel/test-quic-preferred-address-ignore.mjs create mode 100644 test/parallel/test-quic-qlog.mjs create mode 100644 test/parallel/test-quic-reject-unauthorized.mjs create mode 100644 test/parallel/test-quic-session-close-error-code.mjs create mode 100644 test/parallel/test-quic-session-close-graceful.mjs create mode 100644 test/parallel/test-quic-session-close-sends-frame.mjs create mode 100644 test/parallel/test-quic-session-close.mjs create mode 100644 test/parallel/test-quic-session-destroy-reentrant.mjs create mode 100644 test/parallel/test-quic-session-destroy-validate-options.mjs create mode 100644 test/parallel/test-quic-session-destroy.mjs create mode 100644 test/parallel/test-quic-session-idle-timeout.mjs create mode 100644 test/parallel/test-quic-session-opened-early-destroy.mjs create mode 100644 test/parallel/test-quic-session-opened-info.mjs create mode 100644 test/parallel/test-quic-session-opened-validation.mjs create mode 100644 test/parallel/test-quic-session-preferred-address-ignore.mjs create mode 100644 test/parallel/test-quic-session-preferred-address-ipv6.mjs create mode 100644 test/parallel/test-quic-session-preferred-address.mjs create mode 100644 test/parallel/test-quic-session-properties.mjs create mode 100644 test/parallel/test-quic-session-stats-datagram.mjs create mode 100644 test/parallel/test-quic-session-stats-detailed.mjs create mode 100644 test/parallel/test-quic-session-stats.mjs create mode 100644 test/parallel/test-quic-shared-endpoint-stream-close.mjs create mode 100644 test/parallel/test-quic-sni-mismatch.mjs create mode 100644 test/parallel/test-quic-sni-multi-entry.mjs create mode 100644 test/parallel/test-quic-sni-setcontexts.mjs create mode 100644 test/parallel/test-quic-stateless-reset.mjs create mode 100644 test/parallel/test-quic-stats-tojson-inspect.mjs create mode 100644 test/parallel/test-quic-stream-bidi-basic.mjs create mode 100644 test/parallel/test-quic-stream-bidi-concurrent.mjs create mode 100644 test/parallel/test-quic-stream-bidi-echo.mjs create mode 100644 test/parallel/test-quic-stream-bidi-halfclose.mjs create mode 100644 test/parallel/test-quic-stream-bidi-large.mjs create mode 100644 test/parallel/test-quic-stream-bidi-server-initiated.mjs create mode 100644 test/parallel/test-quic-stream-bidi-setbody.mjs create mode 100644 test/parallel/test-quic-stream-bidi-writer.mjs create mode 100644 test/parallel/test-quic-stream-body-async-error.mjs create mode 100644 test/parallel/test-quic-stream-body-async-iterable.mjs create mode 100644 test/parallel/test-quic-stream-body-error.mjs create mode 100644 test/parallel/test-quic-stream-body-filehandle.mjs create mode 100644 test/parallel/test-quic-stream-body-pooled-buffer.mjs create mode 100644 test/parallel/test-quic-stream-body-promise-error.mjs create mode 100644 test/parallel/test-quic-stream-body-promise-reject.mjs create mode 100644 test/parallel/test-quic-stream-body-promise.mjs create mode 100644 test/parallel/test-quic-stream-body-readable-stream.mjs create mode 100644 test/parallel/test-quic-stream-body-sources.mjs create mode 100644 test/parallel/test-quic-stream-body-state.mjs create mode 100644 test/parallel/test-quic-stream-body-string-shorthand.mjs create mode 100644 test/parallel/test-quic-stream-body-string.mjs create mode 100644 test/parallel/test-quic-stream-body-sync-iterable.mjs create mode 100644 test/parallel/test-quic-stream-closed-promise.mjs create mode 100644 test/parallel/test-quic-stream-closed-rejects.mjs create mode 100644 test/parallel/test-quic-stream-destroy-emits-reset.mjs create mode 100644 test/parallel/test-quic-stream-destroy-emits-stop-sending.mjs create mode 100644 test/parallel/test-quic-stream-destroy-options-code.mjs create mode 100644 test/parallel/test-quic-stream-destroy-options-validate.mjs create mode 100644 test/parallel/test-quic-stream-error-graceful-close.mjs create mode 100644 test/parallel/test-quic-stream-id-ordering.mjs create mode 100644 test/parallel/test-quic-stream-iteration-batching.mjs create mode 100644 test/parallel/test-quic-stream-iteration-break.mjs create mode 100644 test/parallel/test-quic-stream-iteration-destroyed.mjs create mode 100644 test/parallel/test-quic-stream-iteration-double.mjs create mode 100644 test/parallel/test-quic-stream-iteration-nonreadable.mjs create mode 100644 test/parallel/test-quic-stream-iteration-pipeto.mjs create mode 100644 test/parallel/test-quic-stream-iteration-pull.mjs create mode 100644 test/parallel/test-quic-stream-iteration-reset.mjs create mode 100644 test/parallel/test-quic-stream-iteration.mjs create mode 100644 test/parallel/test-quic-stream-limits-pending.mjs create mode 100644 test/parallel/test-quic-stream-limits-uni.mjs create mode 100644 test/parallel/test-quic-stream-many-rapid.mjs create mode 100644 test/parallel/test-quic-stream-onblocked.mjs create mode 100644 test/parallel/test-quic-stream-pending.mjs create mode 100644 test/parallel/test-quic-stream-priority.mjs create mode 100644 test/parallel/test-quic-stream-reset-after-data.mjs create mode 100644 test/parallel/test-quic-stream-reset-before-data.mjs create mode 100644 test/parallel/test-quic-stream-reset-mid-transfer.mjs create mode 100644 test/parallel/test-quic-stream-reset-stop.mjs create mode 100644 test/parallel/test-quic-stream-setbody-errors.mjs create mode 100644 test/parallel/test-quic-stream-slow-consumer.mjs create mode 100644 test/parallel/test-quic-stream-stats.mjs create mode 100644 test/parallel/test-quic-stream-stop-sending-interaction.mjs create mode 100644 test/parallel/test-quic-stream-stop-sending.mjs create mode 100644 test/parallel/test-quic-stream-uni-basic.mjs create mode 100644 test/parallel/test-quic-stream-uni-server-initiated.mjs create mode 100644 test/parallel/test-quic-stream-write-partial-view.mjs create mode 100644 test/parallel/test-quic-stream-writer-api.mjs create mode 100644 test/parallel/test-quic-stream-writer-dispose.mjs create mode 100644 test/parallel/test-quic-stream-writer-fail-error-code.mjs create mode 100644 test/parallel/test-quic-stream-zero-length.mjs create mode 100644 test/parallel/test-quic-tls-ca.mjs create mode 100644 test/parallel/test-quic-tls-crl.mjs create mode 100644 test/parallel/test-quic-tls-keylog.mjs create mode 100644 test/parallel/test-quic-tls-options.mjs create mode 100644 test/parallel/test-quic-tls-trace.mjs create mode 100644 test/parallel/test-quic-tls-verify-client.mjs create mode 100644 test/parallel/test-quic-token-distinct.mjs create mode 100644 test/parallel/test-quic-token-expired.mjs create mode 100644 test/parallel/test-quic-token-reuse.mjs create mode 100644 test/parallel/test-quic-token-secret.mjs create mode 100644 test/parallel/test-quic-transport-params-validation.mjs create mode 100644 test/parallel/test-quic-version-negotiation.mjs create mode 100644 test/parallel/test-quic-version.mjs create mode 100644 test/parallel/test-quic-writer-abort-signal.mjs create mode 100644 test/parallel/test-quic-writer-async-dispose-ended.mjs create mode 100644 test/parallel/test-quic-writer-backpressure.mjs create mode 100644 test/parallel/test-quic-writer-stop-sending.mjs create mode 100644 test/parallel/test-quic-writer-write-rejects.mjs create mode 100644 test/parallel/test-quic-zero-rtt-datagram.mjs create mode 100644 test/parallel/test-quic-zero-rtt-disabled-client.mjs create mode 100644 test/parallel/test-quic-zero-rtt-disabled-server.mjs create mode 100644 test/parallel/test-quic-zero-rtt-rejected-settings.mjs create mode 100644 test/parallel/test-quic-zero-rtt.mjs diff --git a/deps/ngtcp2/ngtcp2.gyp b/deps/ngtcp2/ngtcp2.gyp index 74c8ce60456347..7ad8997b0005e3 100644 --- a/deps/ngtcp2/ngtcp2.gyp +++ b/deps/ngtcp2/ngtcp2.gyp @@ -206,6 +206,7 @@ 'defines': [ 'BUILDING_NGHTTP3', 'NGHTTP3_STATICLIB', + 'DEBUGBUILD', ], 'dependencies': [ 'ngtcp2' @@ -247,7 +248,10 @@ }, { 'target_name': 'ngtcp2_test_server', - 'type': 'executable', + # Disabled: ngtcp2 examples now require C++23 (, , + # std::println, std::expected) which is not yet supported on all + # Node.js platforms. Re-enable when C++23 is available. + 'type': 'none', 'cflags': [ '-Wno-everything' ], 'include_dirs': [ '', @@ -305,7 +309,10 @@ }, { 'target_name': 'ngtcp2_test_client', - 'type': 'executable', + # Disabled: ngtcp2 examples now require C++23 (, , + # std::println, std::expected) which is not yet supported on all + # Node.js platforms. Re-enable when C++23 is available. + 'type': 'none', 'cflags': [ '-Wno-everything' ], 'include_dirs': [ '', diff --git a/doc/api/errors.md b/doc/api/errors.md index 540e8122b9f876..cc7c668267fd6b 100644 --- a/doc/api/errors.md +++ b/doc/api/errors.md @@ -2651,6 +2651,32 @@ added: Opening a QUIC stream failed. + + +### `ERR_QUIC_STREAM_ABORTED` + + + +> Stability: 1 - Experimental + +The Node.js error code for a [`QuicError`][] thrown to abort a QUIC stream +or session with an explicit application or transport error code. + + + +### `ERR_QUIC_STREAM_RESET` + + + +> Stability: 1 - Experimental + +A QUIC stream was reset by the peer. The error includes the reset code +provided by the peer. + ### `ERR_QUIC_TRANSPORT_ERROR` @@ -4436,6 +4462,7 @@ An error occurred trying to allocate memory. This should never happen. [`MessagePort`]: worker_threads.md#class-messageport [`Object.getPrototypeOf`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getPrototypeOf [`Object.setPrototypeOf`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/setPrototypeOf +[`QuicError`]: quic.md#class-quicerror [`REPL`]: repl.md [`ServerResponse`]: http.md#class-httpserverresponse [`Writable`]: stream.md#class-streamwritable diff --git a/doc/api/quic.md b/doc/api/quic.md index b370735d6be53a..ddf0c9331ef533 100644 --- a/doc/api/quic.md +++ b/doc/api/quic.md @@ -210,6 +210,32 @@ True if `endpoint.destroy()` has been called. Read only. True if the endpoint is actively listening for incoming connections. Read only. +### `endpoint.maxConnectionsPerHost` + + + +* Type: {number} + +The maximum number of concurrent connections allowed per remote IP address. +`0` means unlimited (default). Can be set at construction time via the +`maxConnectionsPerHost` option and changed dynamically at any time. +The valid range is `0` to `65535`. + +### `endpoint.maxConnectionsTotal` + + + +* Type: {number} + +The maximum total number of concurrent connections across all remote +addresses. `0` means unlimited (default). Can be set at construction time via +the `maxConnectionsTotal` option and changed dynamically at any time. +The valid range is `0` to `65535`. + ### `endpoint.setSNIContexts(entries[, options])` +* `options` {Object} + * `code` {bigint|number} The error code to include in the `CONNECTION_CLOSE` + frame sent to the peer. Defaults to `0` (no error). **Default:** `0`. + * `type` {string} Either `'transport'` or `'application'`. Determines the + error code namespace used in the `CONNECTION_CLOSE` frame. When `'transport'` + (the default), the frame type is `0x1c` and the code is interpreted as a QUIC + transport error. When `'application'`, the frame type is `0x1d` and the code + is application-specific. **Default:** `'transport'`. + * `reason` {string} An optional human-readable reason string included in + the `CONNECTION_CLOSE` frame. Per RFC 9000, this is for diagnostic purposes + only and should not be used for machine-readable error descriptions. * Returns: {Promise} Initiate a graceful close of the session. Existing streams will be allowed to complete but no new streams will be opened. Once all streams have closed, the session will be destroyed. The returned promise will be fulfilled once -the session has been destroyed. +the session has been destroyed. If a non-zero `code` is specified, the +promise will reject with an `ERR_QUIC_TRANSPORT_ERROR` or +`ERR_QUIC_APPLICATION_ERROR` depending on the `type`. + +### `session.opened` + + + +* Type: {Promise} for an {Object} + * `local` {net.SocketAddress} The local socket address. + * `remote` {net.SocketAddress} The remote socket address. + * `servername` {string} The SNI server name negotiated during the handshake. + * `protocol` {string} The ALPN protocol negotiated during the handshake. + * `cipher` {string} The name of the negotiated TLS cipher suite. + * `cipherVersion` {string} The TLS protocol version of the cipher suite + (e.g., `'TLSv1.3'`). + * `validationErrorReason` {string} If certificate validation failed, the + reason string. Empty string if validation succeeded. + * `validationErrorCode` {number} If certificate validation failed, the + error code. `0` if validation succeeded. + * `earlyDataAttempted` {boolean} Whether 0-RTT early data was attempted. + * `earlyDataAccepted` {boolean} Whether 0-RTT early data was accepted by + the server. + +A promise that is fulfilled once the TLS handshake completes successfully. +The resolved value contains information about the established session +including the negotiated protocol, cipher suite, certificate validation +status, and 0-RTT early data status. + +If the handshake fails or the session is destroyed before the handshake +completes, the promise will be rejected. ### `session.closed` @@ -401,16 +470,27 @@ added: v23.8.0 A promise that is fulfilled once the session is destroyed. -### `session.destroy([error])` +### `session.destroy([error[, options]])` * `error` {any} - -Immediately destroy the session. All streams will be destroys and the -session will be closed. +* `options` {Object} + * `code` {bigint|number} The error code to include in the `CONNECTION_CLOSE` + frame sent to the peer. **Default:** `0`. + * `type` {string} Either `'transport'` or `'application'`. **Default:** + `'transport'`. + * `reason` {string} An optional human-readable reason string included in + the `CONNECTION_CLOSE` frame. + +Immediately destroy the session. All streams will be destroyed and the +session will be closed. If `error` is provided and [`session.onerror`][] is +set, the `onerror` callback is invoked before destruction. The +`session.closed` promise will reject with the error. If `options` is +provided, the `CONNECTION_CLOSE` frame sent to the peer will include the +specified error code, type, and reason. ### `session.destroyed` @@ -432,6 +512,20 @@ added: v23.8.0 The endpoint that created this session. Read only. +### `session.onerror` + +* Type: {Function|undefined} + +An optional callback invoked when the session is destroyed with an error. +This includes errors caused by user callbacks that throw or reject (see +[Callback error handling][]). The callback receives a single argument: the +error that triggered the destruction. If the `onerror` callback itself throws +or returns a promise that rejects, the error is surfaced as an uncaught +exception. Read/write. + +Can also be set via the `onerror` option in [`quic.connect()`][] or +[`quic.listen()`][]. + ### `session.onstream` + +* Type: {quic.OnNewTokenCallback} + +The callback to invoke when a NEW\_TOKEN token is received from the server. +The token can be passed as the `token` option on a future connection to +the same server to skip address validation. Read/write. + +### `session.onorigin` + + + +* Type: {quic.OnOriginCallback} + +The callback to invoke when an ORIGIN frame (RFC 9412) is received from +the server, indicating which origins the server is authoritative for. +Read/write. + +### `session.ongoaway` + + + +* Type: {Function} + +The callback to invoke when the peer sends an HTTP/3 GOAWAY frame, +indicating it is initiating a graceful shutdown. The callback receives +`(lastStreamId)` where `lastStreamId` is a `{bigint}`: + +* When `lastStreamId` is `-1n`, the peer sent a shutdown notice (intent + to close) without specifying a stream boundary. All existing streams + may still be processed. +* When `lastStreamId` is `>= 0n`, it is the highest stream ID the peer + may have processed. Streams with IDs above this value were NOT + processed and can be safely retried on a new connection. + +After GOAWAY is received, `session.createBidirectionalStream()` will +throw `ERR_INVALID_STATE`. Existing streams continue until they +complete or the session closes. + +This callback is only relevant for HTTP/3 sessions. Read/write. + +### `session.onkeylog` + + + +* Type: {quic.OnKeylogCallback} + +The callback to invoke when TLS key material is available. Requires +[`sessionOptions.keylog`][] to be `true`. Each invocation receives a single +line of [NSS Key Log Format][] text (including a trailing newline). This is +useful for decrypting packet captures with tools like Wireshark. Read/write. + +Can also be set via the `onkeylog` option in [`quic.connect()`][] or +[`quic.listen()`][]. + +### `session.onqlog` + + + +* Type: {quic.OnQlogCallback} + +The callback to invoke when qlog data is available. Requires +[`sessionOptions.qlog`][] to be `true`. The callback receives a string +chunk of [JSON-SEQ][] formatted qlog data and a boolean `fin` flag. When +`fin` is `true`, the chunk is the final qlog output for this session and +the concatenated chunks form a complete qlog trace. Read/write. + +Qlog data arrives during the connection lifecycle. The first chunk contains +the qlog header with format metadata. Subsequent chunks contain trace +events. The final chunk (with `fin` set to `true`) is emitted during +session destruction and completes the JSON-SEQ output. + +Can also be set via the `onqlog` option in [`quic.connect()`][] or +[`quic.listen()`][]. + ### `session.createBidirectionalStream([options])` * `options` {Object} - * `body` {ArrayBuffer | ArrayBufferView | Blob} - * `sendOrder` {number} + * `body` {string | ArrayBuffer | SharedArrayBuffer | ArrayBufferView | + Blob | FileHandle | AsyncIterable | Iterable | Promise | null} + The outbound body source. See [`stream.setBody()`][] for details on + supported types. When omitted, the stream starts half-closed (writable + side open, no body queued). + * `headers` {Object} Initial request or response headers to send. Only + used when the session supports headers (e.g. HTTP/3). If `body` is not + specified and `headers` is provided, the stream is treated as + headers-only (terminal). + * `priority` {string} The priority level of the stream. One of `'high'`, + `'default'`, or `'low'`. **Default:** `'default'`. + * `incremental` {boolean} When `true`, data from this stream may be + interleaved with data from other streams of the same priority level. + When `false`, the stream should be completed before same-priority peers. + **Default:** `false`. + * `highWaterMark` {number} The maximum number of bytes that the writer + will buffer before `writeSync()` returns `false`. When the buffered + data exceeds this limit, the caller should wait for drain before + writing more. **Default:** `65536` (64 KB). + * `onheaders` {Function} Callback for received initial response headers. + Called with `(headers)`. + * `ontrailers` {Function} Callback for received trailing headers. + Called with `(trailers)`. + * `oninfo` {Function} Callback for received informational (1xx) headers. + Called with `(headers)`. + * `onwanttrailers` {Function} Callback when trailers should be sent. + Called with no arguments; use [`stream.sendTrailers()`][] within the + callback. * Returns: {Promise} for a {quic.QuicStream} Open a new bidirectional stream. If the `body` option is not specified, -the outgoing stream will be half-closed. +the outgoing stream will be half-closed. The `priority` and `incremental` +options are only used when the session supports priority (e.g. HTTP/3). +The `headers`, `onheaders`, `ontrailers`, `oninfo`, and `onwanttrailers` +options are only used when the session supports headers (e.g. HTTP/3). ### `session.createUnidirectionalStream([options])` @@ -523,12 +746,29 @@ added: v23.8.0 --> * `options` {Object} - * `body` {ArrayBuffer | ArrayBufferView | Blob} - * `sendOrder` {number} + * `body` {string | ArrayBuffer | SharedArrayBuffer | ArrayBufferView | + Blob | FileHandle | AsyncIterable | Iterable | Promise | null} + The outbound body source. See [`stream.setBody()`][] for details on + supported types. When omitted, the stream is closed immediately. + * `headers` {Object} Initial request headers to send. + * `priority` {string} The priority level of the stream. One of `'high'`, + `'default'`, or `'low'`. **Default:** `'default'`. + * `incremental` {boolean} When `true`, data from this stream may be + interleaved with data from other streams of the same priority level. + When `false`, the stream should be completed before same-priority peers. + **Default:** `false`. + * `onheaders` {Function} Callback for received initial response headers. + Called with `(headers)`. + * `ontrailers` {Function} Callback for received trailing headers. + Called with `(trailers)`. + * `oninfo` {Function} Callback for received informational (1xx) headers. + Called with `(headers)`. + * `onwanttrailers` {Function} Callback when trailers should be sent. * Returns: {Promise} for a {quic.QuicStream} Open a new unidirectional stream. If the `body` option is not specified, -the outgoing stream will be closed. +the outgoing stream will be closed. The `priority` and `incremental` +options are only used when the session supports priority (e.g. HTTP/3). ### `session.path` @@ -542,18 +782,121 @@ added: v23.8.0 The local and remote socket addresses associated with the session. Read only. -### `session.sendDatagram(datagram)` +### `session.sendDatagram(datagram[, encoding])` -* `datagram` {string|ArrayBufferView} -* Returns: {bigint} +* `datagram` {string|ArrayBufferView|Promise} +* `encoding` {string} The encoding to use if `datagram` is a string. + **Default:** `'utf8'`. +* Returns: {Promise} for a {bigint} datagram ID. + +Sends an unreliable datagram to the remote peer, returning a promise for +the datagram ID. + +If `datagram` is a string, it will be encoded using the specified `encoding`. + +If `datagram` is an `ArrayBufferView`, the bytes are copied into an +internal buffer; the caller's source buffer is unchanged and may be reused +or mutated immediately after the call returns. Callers that want to ensure +their source cannot be mutated after the call (for example, when handing +the buffer off to another async consumer) can call +`ArrayBuffer.prototype.transfer()` themselves before passing the buffer. + +If `datagram` is a `Promise`, it will be awaited before sending. If the +session closes while awaiting, `0n` is returned silently (datagrams are +inherently unreliable). + +If the datagram payload is zero-length (empty string after encoding, detached +buffer, or zero-length view), `0n` is returned and no datagram is sent. + +For HTTP/3 sessions, the peer must advertise `SETTINGS_H3_DATAGRAM=1` +(via `application: { enableDatagrams: true }`) for datagrams to be sent. +If the peer's setting is `0`, `sendDatagram()` returns `0n` (per RFC 9297 +§3, an endpoint MUST NOT send HTTP Datagrams unless the peer indicated +support). + +Datagrams cannot be fragmented — each must fit within a single QUIC packet. +The maximum datagram size is determined by the peer's +`maxDatagramFrameSize` transport parameter (which the peer advertises during +the handshake). If the peer sets this to `0`, datagrams are not supported +and `0n` will be returned. If the datagram exceeds the peer's limit, it +will be silently dropped and `0n` returned. The local +`maxDatagramFrameSize` transport parameter (default: `1200` bytes) controls +what this endpoint advertises to the peer as its own maximum. + +### `session.certificate` + + + +* Type: {Object|undefined} + +The local certificate as an object with properties such as `subject`, +`issuer`, `valid_from`, `valid_to`, `fingerprint`, etc. Returns `undefined` +if the session is destroyed or no certificate is available. + +### `session.peerCertificate` + + + +* Type: {Object|undefined} + +The peer's certificate as an object with properties such as `subject`, +`issuer`, `valid_from`, `valid_to`, `fingerprint`, etc. Returns `undefined` +if the session is destroyed or the peer did not present a certificate. + +### `session.ephemeralKeyInfo` + + + +* Type: {Object|undefined} + +The ephemeral key information for the session, with properties such as +`type`, `name`, and `size`. Only available on client sessions. Returns +`undefined` for server sessions or if the session is destroyed. + +### `session.maxDatagramSize` + + + +* Type: {number} + +The maximum datagram payload size in bytes that the peer will accept. +This is derived from the peer's `maxDatagramFrameSize` transport +parameter minus the DATAGRAM frame overhead (type byte and variable-length +integer encoding). Returns `0` if the peer does not support datagrams or +if the handshake has not yet completed. Datagrams larger than this value +will not be sent. + +### `session.maxPendingDatagrams` + + + +* Type: {number} +* **Default:** `128` + +The maximum number of datagrams that can be queued for sending. Datagrams +are queued when `sendDatagram()` is called and sent opportunistically +alongside stream data by the packet serialization loop. When the queue +is full, the [`sessionOptions.datagramDropPolicy`][] determines whether +the oldest or newest datagram is dropped. Dropped datagrams are reported +as lost via the `ondatagramstatus` callback. -Sends an unreliable datagram to the remote peer, returning the datagram ID. -If the datagram payload is specified as an `ArrayBufferView`, then ownership of -that view will be transferred to the underlying stream. +This property can be changed dynamically to adjust queue capacity +based on application activity or memory pressure. The valid range +is `0` to `65535`. ### `session.stats` @@ -668,7 +1011,7 @@ added: v23.8.0 * Type: {bigint} -### `sessionStats.maxBytesInFlights` +### `sessionStats.maxBytesInFlight` + +> Stability: 1 - Experimental + +A `QuicError` is an `Error` subclass that carries an explicit numeric +QUIC error code. Use it to abort a QUIC stream or session with a +specific application-protocol-defined error code rather than letting +the implementation pick a generic fallback. + +The class is exported from `node:quic`: + +```mjs +import { QuicError } from 'node:quic'; +``` + +```cjs +const { QuicError } = require('node:quic'); +``` + +When a `QuicError` is supplied to APIs that emit a wire frame +([`writer.fail()`][], [`stream.destroy()`][]), the QUIC stack uses +[`error.errorCode`][] as the wire code for the resulting frame. +When any other value is supplied (for example a plain `Error`), the +implementation falls back to the negotiated application protocol's +"internal error" code (`H3_INTERNAL_ERROR` (`0x102`) for HTTP/3, or +the QUIC transport-layer `INTERNAL_ERROR` (`0x1`) for raw QUIC). + +The Node.js error code (`error.code`) defaults to +`'ERR_QUIC_STREAM_ABORTED'`. Callers who need a more specific code +string can override it via `options.code` — the numeric QUIC code +is unaffected. + +The Node.js error code is fixed at `'ERR_QUIC_STREAM_ABORTED'` so that +catch blocks can distinguish a `QuicError` from other Node.js errors +without checking the prototype chain. The numeric QUIC code lives on +the separate [`error.errorCode`][] property to avoid colliding with +the Node.js convention that `error.code` is a string. + +### `new QuicError(message, options)` + + + +* `message` {string} A human-readable description of the error. +* `options` {Object} + * `errorCode` {bigint | number} The numeric QUIC error code. Numbers + are coerced to `BigInt`. Must be a non-negative 62-bit unsigned + varint (`0n <= errorCode <= 2n ** 62n - 1n`). + * `code` {string} The Node.js-style error code string assigned to + `error.code`. Defaults to `'ERR_QUIC_STREAM_ABORTED'`. + * `type` {string} Either `'application'` (default) or `'transport'`. + Indicates whether the code is defined by the negotiated + application protocol (e.g. RFC 9114 for HTTP/3) or by the QUIC + transport layer (RFC 9000). Stream resets always carry application + codes, so the default is `'application'`. + +```mjs +import { QuicError } from 'node:quic'; + +const err = new QuicError('rejecting stream', { errorCode: 0x10cn }); +console.log(err.code); // 'ERR_QUIC_STREAM_ABORTED' +console.log(err.errorCode); // 268n +console.log(err.type); // 'application' + +const custom = new QuicError('custom failure', { + errorCode: 0x10cn, + code: 'ERR_MY_QUIC_FAILURE', +}); +console.log(custom.code); // 'ERR_MY_QUIC_FAILURE' +``` + +### `error.errorCode` + + + +* Type: {bigint} + +The numeric QUIC error code carried by this error. + +### `error.type` + + + +* Type: {string} + +Either `'application'` or `'transport'`. Indicates the namespace of +[`error.errorCode`][]. + ## Class: `QuicStream` * `error` {any} - -Immediately and abruptly destroys the stream. +* `options` {Object} + * `code` {bigint|number} The application error code to include in the + `RESET_STREAM` and `STOP_SENDING` frames sent to the peer. Numbers are + coerced to `BigInt`. When omitted, the wire code is derived from `error` + (see below). + * `reason` {string} An optional human-readable reason string. Accepted for + symmetry with [`session.close()`][] and [`session.destroy()`][], but + **not transmitted on the wire** — neither `RESET_STREAM` nor + `STOP_SENDING` carry a reason field. Provided for application logging + and for use by the [`stream.onerror`][] callback. + +Immediately and abruptly destroys the stream. If `error` is provided and +[`stream.onerror`][] is set, the `onerror` callback is invoked before +destruction. The `stream.closed` promise rejects with the error. + +When the stream is destroyed with an `error` (or with an explicit +`options.code`), the QUIC stack signals the abort to the peer: + +* If the writable side is still open, a `RESET_STREAM` frame is sent. +* If the readable side is still open (a bidirectional stream, or a + remote-initiated unidirectional stream), a `STOP_SENDING` frame is sent. + +Both frames carry the same wire code, resolved with the following +precedence: + +1. `options.code`, when explicitly provided. +2. [`error.errorCode`][], when `error` is a [`QuicError`][]. +3. The negotiated application protocol's "internal error" code + (`H3_INTERNAL_ERROR` (`0x102`) for HTTP/3, or the QUIC transport-layer + `INTERNAL_ERROR` (`0x1`) for raw QUIC). + +A clean destroy — no `error` and no `options.code` — does not emit +`RESET_STREAM` or `STOP_SENDING`; the stream's existing close machinery +handles teardown. + +See [Aborting a stream][] for an overview of the available stream-abort +APIs. ### `stream.destroyed` @@ -808,6 +1291,40 @@ added: v23.8.0 True if `stream.destroy()` has been called. +### Aborting a stream + +A QuicStream can be aborted in three ways, each producing different +wire-frame side effects: + +* [`writer.fail(reason)`][] — Aborts only the writable side. Sends + `RESET_STREAM` to the peer. The readable side is unaffected; any data + already buffered for read remains available. +* [`stream.destroy()`][] with an `error` argument — Tears the stream + down completely. Sends `RESET_STREAM` on any still-open writable side + **and** `STOP_SENDING` on any still-open readable side. The wire code + is derived from `error` (see [`stream.destroy()`][] for the precedence + rules). +* [`stream.destroy()`][] with an explicit `options.code` — Same as the + previous form but with a caller-supplied wire code, which takes + precedence over any code carried by `error`. + +When `error` is a [`QuicError`][], its [`error.errorCode`][] is used as +the wire code for both `writer.fail()` and `stream.destroy()`. Otherwise +the implementation falls back to the negotiated application protocol's +"internal error" code (see [`QuicError`][]). + +### `stream.early` + +* Type: {boolean} + +True if any data on this stream was received as 0-RTT (early data) +before the TLS handshake completed. Early data is less secure and +could potentially be replayed by an attacker. Applications should +treat early data with appropriate caution. + +This property is only meaningful on the server side. On the client +side, it is always `false`. + ### `stream.direction` + +* Type: {number} + +The maximum number of bytes that the writer will buffer before +`writeSync()` returns `false`. When the buffered data exceeds this limit, +the caller should wait for the `drainableProtocol` promise to resolve +before writing more. + +The value can be changed dynamically at any time. This is particularly +useful for streams received via the `onstream` callback, where the +default (65536) may need to be adjusted based on application needs. +The valid range is `0` to `4294967295`. + ### `stream.id` -* Type: {ReadableStream} +* Type: {Object|undefined} + +The buffered initial headers received on this stream, or `undefined` if the +application does not support headers or no headers have been received yet. +For server-side streams, this contains the request headers (e.g., `:method`, +`:path`, `:scheme`). For client-side streams, this contains the response +headers (e.g., `:status`). -### `stream.session` +Header names are lowercase strings. Multi-value headers are represented as +arrays. The object has `__proto__: null`. + +### `stream.onheaders` -* Type: {quic.QuicSession} +* Type: {Function} -The session that created this stream. Read only. +The callback to invoke when initial headers are received on the stream. The +callback receives `(headers)` where `headers` is an object (same format as +`stream.headers`). For HTTP/3, this delivers request pseudo-headers on the +server side and response headers on the client side. Throws +`ERR_INVALID_STATE` if set on a session that does not support headers. +Read/write. -### `stream.stats` +### `stream.ontrailers` -* Type: {quic.QuicStream.Stats} +* Type: {Function} -The current statistics for the stream. Read only. +The callback to invoke when trailing headers are received from the peer. +The callback receives `(trailers)` where `trailers` is an object in the +same format as `stream.headers`. Throws `ERR_INVALID_STATE` if set on a +session that does not support headers. Read/write. -## Class: `QuicStream.Stats` +### `stream.oninfo` -### `streamStats.ackedAt` +* Type: {Function} + +The callback to invoke when informational (1xx) headers are received from +the server. The callback receives `(headers)` where `headers` is an object +in the same format as `stream.headers`. Informational headers are sent +before the final response (e.g., 103 Early Hints). Throws +`ERR_INVALID_STATE` if set on a session that does not support headers. +Read/write. + +### `stream.onwanttrailers` -* Type: {bigint} +* Type: {Function} -### `streamStats.bytesReceived` +The callback to invoke when the application is ready for trailing headers +to be sent. This is called synchronously — the user must call +[`stream.sendTrailers()`][] within this callback. Throws +`ERR_INVALID_STATE` if set on a session that does not support headers. +Read/write. + +### `stream.pendingTrailers` -* Type: {bigint} +* Type: {Object|undefined} -### `streamStats.bytesSent` +Set trailing headers to be sent automatically when the application requests +them. This is an alternative to the [`stream.onwanttrailers`][] callback +for cases where the trailers are known before the body completes. Throws +`ERR_INVALID_STATE` if set on a session that does not support headers. +Read/write. + +### `stream.sendHeaders(headers[, options])` -* Type: {bigint} +* `headers` {Object} Header object with string keys and string or + string-array values. Pseudo-headers (`:method`, `:path`, etc.) must + appear before regular headers. +* `options` {Object} + * `terminal` {boolean} If `true`, the stream is closed for sending + after the headers (no body will follow). **Default:** `false`. +* Returns: {boolean} -### `streamStats.createdAt` +Sends initial or response headers on the stream. For client-side streams, +this sends request headers. For server-side streams, this sends response +headers. Throws `ERR_INVALID_STATE` if the session does not support headers. + +### `stream.sendInformationalHeaders(headers)` -* Type: {bigint} +* `headers` {Object} Header object. Must include `:status` with a 1xx + value (e.g., `{ ':status': '103', 'link': '; rel=preload' }`). +* Returns: {boolean} -### `streamStats.destroyedAt` +Sends informational (1xx) response headers. Server only. Throws +`ERR_INVALID_STATE` if the session does not support headers. + +### `stream.sendTrailers(headers)` -* Type: {bigint} +* `headers` {Object} Trailing header object. Pseudo-headers must not be + included in trailers. +* Returns: {boolean} -### `streamStats.finalSize` +Sends trailing headers on the stream. Must be called synchronously during +the [`stream.onwanttrailers`][] callback, or set ahead of time via +[`stream.pendingTrailers`][]. Throws `ERR_INVALID_STATE` if the session +does not support headers. + +### `stream.priority` -* Type: {bigint} +* Type: {Object|null} + * `level` {string} One of `'high'`, `'default'`, or `'low'`. + * `incremental` {boolean} Whether the stream data should be interleaved + with other streams of the same priority level. -### `streamStats.isConnected` +The current priority of the stream. Returns `null` if the session does not +support priority (e.g. non-HTTP/3) or if the stream has been destroyed. +Read only. Use [`stream.setPriority()`][] to change the priority. + +On client-side HTTP/3 sessions, the value reflects what was set via +[`stream.setPriority()`][]. On server-side HTTP/3 sessions, the value +reflects the peer's requested priority (e.g., from `PRIORITY_UPDATE` frames). + +### `stream.setPriority([options])` -* Type: {bigint} +* `options` {Object} + * `level` {string} The priority level. One of `'high'`, `'default'`, or + `'low'`. **Default:** `'default'`. + * `incremental` {boolean} When `true`, data from this stream may be + interleaved with data from other streams of the same priority level. + **Default:** `false`. -### `streamStats.maxOffset` +Sets the priority of the stream. Throws `ERR_INVALID_STATE` if the session +does not support priority (e.g. non-HTTP/3). Has no effect if the stream +has been destroyed. + +### `stream[Symbol.asyncIterator]()` -* Type: {bigint} +* Returns: {AsyncIterableIterator} yielding {Uint8Array\[]} + +The stream implements `Symbol.asyncIterator`, making it directly usable +in `for await...of` loops. Each iteration yields a batch of `Uint8Array` +chunks. + +Only one async iterator can be obtained per stream. A second call throws +`ERR_INVALID_STATE`. Non-readable streams (outbound-only unidirectional +or closed) return an immediately-finished iterator. + +```mjs +for await (const chunks of stream) { + for (const chunk of chunks) { + // Process each Uint8Array chunk + } +} +``` + +Compatible with stream/iter utilities: + +```mjs +import Stream from 'node:stream/iter'; +const body = await Stream.bytes(stream); +const text = await Stream.text(stream); +await Stream.pipeTo(stream, someWriter); +``` + +### `stream.writer` + + + +* Type: {Object} + +Returns a Writer object for pushing data to the stream incrementally. +The Writer implements the stream/iter Writer interface with the +try-sync-fallback-to-async pattern. + +Only available when no `body` source was provided at creation time or via +[`stream.setBody()`][]. Non-writable streams return an already-closed +Writer. Throws `ERR_INVALID_STATE` if the outbound is already configured. + +The Writer has the following methods: + +* `writeSync(chunk)` — Synchronous write. Returns `true` if accepted, + `false` if flow-controlled. Data is NOT accepted on `false`. +* `write(chunk[, options])` — Async write with drain wait. `options.signal` + is checked at entry but not observed during the write. +* `writevSync(chunks)` — Synchronous vectored write. All-or-nothing. +* `writev(chunks[, options])` — Async vectored write. +* `endSync()` — Synchronous close. Returns total bytes or `-1`. +* `end([options])` — Async close. +* `fail(reason)` — Errors the stream (sends `RESET_STREAM` to peer). + When `reason` is a [`QuicError`][], its [`error.errorCode`][] is used + as the wire code on the resulting `RESET_STREAM` frame; otherwise + the wire code falls back to the negotiated application protocol's + "internal error" code (`H3_INTERNAL_ERROR` (`0x102`) for HTTP/3, or + the QUIC transport-layer `INTERNAL_ERROR` (`0x1`) for raw QUIC). + See [`stream.destroy()`][] for a full-stream abort that also resets + the readable side via `STOP_SENDING`. +* `desiredSize` — Available capacity in bytes, or `null` if closed/errored. + +The bytes from each `writeSync()` / `writevSync()` / `write()` / `writev()` +input chunk are copied into an internal buffer, so the caller's source +buffer is unchanged and may be reused or mutated immediately after the +call returns. Callers that want to ensure a source buffer cannot be +mutated after handing it off can call `ArrayBuffer.prototype.transfer()` +themselves before passing the buffer. + +### `stream.setBody(body)` + + + +* `body` {string | ArrayBuffer | SharedArrayBuffer | ArrayBufferView | + Blob | FileHandle | AsyncIterable | Iterable | Promise | null} + +Sets the outbound body source for the stream. Can only be called once. +Mutually exclusive with [`stream.writer`][]. + +The following body source types are supported: + +* `null` — The writable side is closed immediately (FIN sent with no data). +* `string` — UTF-8 encoded and sent as a single chunk. +* `ArrayBuffer`, `SharedArrayBuffer`, `ArrayBufferView` — Sent as a single + chunk. The bytes are copied into an internal buffer, so the caller's + source buffer is unchanged and may be reused or mutated immediately + after the call returns. Callers wanting to ensure their source cannot + be mutated after handing it off can call + `ArrayBuffer.prototype.transfer()` themselves before passing the buffer. +* `Blob` — Sent from the Blob's underlying data queue. +* {FileHandle} — The file contents are read asynchronously via an + fd-backed data source. The `FileHandle` must be opened for reading + (e.g. via [`fs.promises.open(path, 'r')`][]). Once passed as a body, the + `FileHandle` is locked and cannot be used as a body for another stream. + The `FileHandle` is automatically closed when the stream finishes. +* `AsyncIterable`, `Iterable` — Each yielded chunk (string or + `Uint8Array`) is written incrementally in streaming mode. +* `Promise` — Awaited; the resolved value is used as the body (subject + to the same type rules). + +Throws `ERR_INVALID_STATE` if the outbound is already configured or if +the writer has been accessed. + +### `stream.session` + + + +* Type: {quic.QuicSession} + +The session that created this stream. Read only. + +### `stream.stats` + + + +* Type: {quic.QuicStream.Stats} + +The current statistics for the stream. Read only. + +## Class: `QuicStream.Stats` + + + +### `streamStats.ackedAt` + + + +* Type: {bigint} + +### `streamStats.bytesReceived` + + + +* Type: {bigint} + +### `streamStats.bytesSent` + + + +* Type: {bigint} + +### `streamStats.createdAt` + + + +* Type: {bigint} + +### `streamStats.destroyedAt` + + + +* Type: {bigint} + +### `streamStats.finalSize` + + + +* Type: {bigint} + +### `streamStats.isConnected` + + + +* Type: {bigint} + +### `streamStats.maxOffset` + + + +* Type: {bigint} ### `streamStats.maxOffsetAcknowledged` @@ -1013,6 +1845,37 @@ performance optimization. This option sets the maximum number of addresses that are cache. This is an advanced option that users typically won't have need to specify. +#### `endpointOptions.disableStatelessReset` + + + +* Type: {boolean} + +When `true`, the endpoint will not send stateless reset packets in response +to packets from unknown connections. Stateless resets allow a peer to detect +that a connection has been lost even when the server has no state for it. +Disabling them may be useful in testing or when stateless resets are handled +at a different layer. + +#### `endpointOptions.idleTimeout` + + + +* Type: {number} +* Default: `0` + +The number of seconds an endpoint will remain alive after all sessions have +closed and it is no longer listening. A value of `0` (default) means the +endpoint is only destroyed when explicitly closed via `endpoint.close()` or +`endpoint.destroy()`. A positive value starts an idle timer when the endpoint +becomes idle; if no new sessions are created before the timer fires, the +endpoint is automatically destroyed. This is useful for connection pooling +where endpoints should linger briefly for reuse by future `connect()` calls. + #### `endpointOptions.ipv6Only` -* Type: {bigint|number} +* Type: {number} +* Default: `0` (unlimited) -Specifies the maximum number of concurrent sessions allowed per remote peer address. +Specifies the maximum number of concurrent sessions allowed per remote IP +address (ignoring port). When the limit is reached, new connections from the +same IP are refused with `CONNECTION_REFUSED`. A value of `0` disables the +limit. The maximum value is `65535`. + +This limit can also be changed dynamically after construction via +[`endpoint.maxConnectionsPerHost`][]. #### `endpointOptions.maxConnectionsTotal` @@ -1039,9 +1909,16 @@ Specifies the maximum number of concurrent sessions allowed per remote peer addr added: v23.8.0 --> -* Type: {bigint|number} +* Type: {number} +* Default: `0` (unlimited) + +Specifies the maximum total number of concurrent sessions across all remote +addresses. When the limit is reached, new connections are refused with +`CONNECTION_REFUSED`. A value of `0` disables the limit. The maximum value is +`65535`. -Specifies the maximum total number of concurrent sessions. +This limit can also be changed dynamically after construction via +[`endpoint.maxConnectionsTotal`][]. #### `endpointOptions.maxRetries` @@ -1168,6 +2045,50 @@ application; all other values select the default application. Default: `'h3'` +#### `sessionOptions.application` + + + +* Type: {Object} + +HTTP/3 application-specific options. These only apply when the negotiated +ALPN selects the HTTP/3 application (`'h3'`). + +* `maxHeaderPairs` {number} Maximum number of header name-value pairs + accepted per header block. Headers beyond this limit are silently + dropped. **Default:** `128` +* `maxHeaderLength` {number} Maximum total byte length of all header + names and values combined per header block. Headers that would push + the total over this limit are silently dropped. **Default:** `8192` +* `maxFieldSectionSize` {number} Maximum size of a compressed header + field section (QPACK). `0` means unlimited. **Default:** `0` +* `qpackMaxDTableCapacity` {number} QPACK dynamic table capacity in + bytes. Set to `0` to disable the dynamic table. **Default:** `4096` +* `qpackEncoderMaxDTableCapacity` {number} QPACK encoder maximum + dynamic table capacity. **Default:** `4096` +* `qpackBlockedStreams` {number} Maximum number of streams that can + be blocked waiting for QPACK dynamic table updates. + **Default:** `100` +* `enableConnectProtocol` {boolean} Enable the extended CONNECT + protocol (RFC 9220). **Default:** `false` +* `enableDatagrams` {boolean} Enable HTTP/3 datagrams (RFC 9297). + **Default:** `false` + +```mjs +const { listen } = await import('node:quic'); + +await listen((session) => { /* ... */ }, { + application: { + maxHeaderPairs: 64, + qpackMaxDTableCapacity: 8192, + enableDatagrams: true, + }, + // ... other session options +}); +``` + #### `sessionOptions.ca` (client only) + +* Type: {boolean} **Default:** `true` + +When `true`, enables TLS 0-RTT early data for this session. Early data +allows the client to send application data before the TLS handshake +completes, reducing latency on reconnection when a valid session ticket +is available. Set to `false` to disable early data support. + #### `sessionOptions.groups` + +* Type: {string} +* **Default:** `'drop-oldest'` + +Controls which datagram to drop when the pending datagram queue +(sized by [`session.maxPendingDatagrams`][]) is full. Must be one of +`'drop-oldest'` (discard the oldest queued datagram to make room) or +`'drop-newest'` (reject the incoming datagram). Dropped datagrams are +reported as lost via the `ondatagramstatus` callback. + +This option is immutable after session creation. + +#### `sessionOptions.maxDatagramSendAttempts` + +* Type: {number} +* **Default:** `5` + +The maximum number of `SendPendingData` cycles a datagram can survive +without being sent before it is abandoned. When a datagram cannot be +sent due to congestion control or packet size constraints, it remains +in the queue and the attempt counter increments. Once the limit is +reached, the datagram is dropped and reported as `'abandoned'` via the +`ondatagramstatus` callback. Valid range: `1` to `255`. + +#### `sessionOptions.drainingPeriodMultiplier` + + + +* Type: {number} +* **Default:** `3` + +A multiplier applied to the Probe Timeout (PTO) to compute the draining +period duration after receiving a `CONNECTION_CLOSE` frame from the peer. +RFC 9000 Section 10.2 requires the draining period to persist for at least +three times the current PTO. The valid range is `3` to `255`. Values below +`3` are clamped to `3`. + #### `sessionOptions.handshakeTimeout` + +* Type: {bigint|number} +* **Default:** `0` (disabled) + +Specifies the keep-alive timeout in milliseconds. When set to a non-zero +value, PING frames will be sent automatically to keep the connection alive +before the idle timeout fires. The value should be less than the effective +idle timeout (`maxIdleTimeout` transport parameter) to be useful. + #### `sessionOptions.servername` (client only) + +* Type: {ArrayBufferView} + +An opaque address validation token previously received from the server +via the [`session.onnewtoken`][] callback. Providing a valid token on +reconnection allows the client to skip the server's address validation, +reducing handshake latency. + #### `sessionOptions.transportParams` + +* Type: {boolean} **Default:** `true` + +If `true`, the peer certificate is verified against the list of supplied CAs. +An error is emitted if verification fails; the error can be inspected via +the `validationErrorReason` and `validationErrorCode` fields in the +handshake callback. If `false`, peer certificate verification errors are +ignored. + +#### `sessionOptions.reuseEndpoint` + + + +* Type: {boolean} +* Default: `true` + +When `true` (the default), `connect()` will attempt to reuse an existing +endpoint rather than creating a new one for each session. This provides +connection pooling behavior — multiple sessions can share a single UDP +socket. The reuse logic will not return an endpoint that is listening on +the same address as the connect target (to prevent CID routing conflicts). + +Set to `false` to force creation of a new endpoint for the session. This +is useful when endpoint isolation is required (e.g., testing stateless +reset behavior where source port identity matters). + #### `sessionOptions.verifyClient` -* Type: {net.SocketAddress} The preferred IPv4 address to advertise. +* Type: {net.SocketAddress} The preferred IPv4 address to advertise (only + used by servers). #### `transportParams.preferredAddressIpv6` @@ -1477,7 +2529,8 @@ added: v23.8.0 added: v23.8.0 --> -* Type: {net.SocketAddress} The preferred IPv6 address to advertise. +* Type: {net.SocketAddress} The preferred IPv6 address to advertise (only + used by servers) #### `transportParams.initialMaxStreamDataBidiLocal` @@ -1566,9 +2619,39 @@ added: v23.8.0 --> * Type: {bigint|number} +* **Default:** `1200` + +The maximum size in bytes of a DATAGRAM frame payload that this endpoint +is willing to receive. Set to `0` to disable datagram support. The peer +will not send datagrams larger than this value. The actual maximum size of +a datagram that can be _sent_ is determined by the peer's +`maxDatagramFrameSize`, not this endpoint's value. ## Callbacks +### Callback error handling + +All session and stream callbacks may be synchronous functions or async +functions. If a callback throws synchronously or returns a promise that +rejects, the error is caught and the owning session or stream is destroyed +with that error: + +* Stream callbacks (`onblocked`, `onreset`, `onheaders`, `ontrailers`, + `oninfo`, `onwanttrailers`): the stream is destroyed. +* Session callbacks (`onstream`, `ondatagram`, `ondatagramstatus`, + `onpathvalidation`, `onsessionticket`, `onnewtoken`, + `onversionnegotiation`, `onorigin`, `ongoaway`, `onhandshake`, + `onkeylog`, `onqlog`): the session is destroyed along with all of its + streams. + +Before destruction, the optional [`session.onerror`][] or +[`stream.onerror`][] callback is invoked (if set), giving the application a +chance to observe or log the error. The `session.closed` or `stream.closed` +promise will reject with the error. + +If the `onerror` callback itself throws or returns a promise that rejects, +the error from `onerror` is surfaced as an uncaught exception. + ### Callback: `OnSessionCallback` * `this` {quic.QuicSession} -* `version` {number} -* `requestedVersions` {number\[]} -* `supportedVersions` {number\[]} +* `version` {number} The QUIC version that was configured for this session + (the version that the server did not support). +* `requestedVersions` {number\[]} The versions advertised by the server in + the Version Negotiation packet. These are the versions the server supports. +* `supportedVersions` {number\[]} The versions supported locally, expressed + as a two-element array `[minVersion, maxVersion]`. + +Called when the server responds to the client's Initial packet with a +Version Negotiation packet, indicating that the version used by the client +is not supported. The session is always destroyed immediately after this +callback returns. ### Callback: `OnHandshakeCallback` @@ -1656,8 +2755,59 @@ added: v23.8.0 * `cipherVersion` {string} * `validationErrorReason` {string} * `validationErrorCode` {number} +* `earlyDataAttempted` {boolean} * `earlyDataAccepted` {boolean} +### Callback: `OnNewTokenCallback` + + + +* `this` {quic.QuicSession} +* `token` {Buffer} The NEW\_TOKEN token data. +* `address` {SocketAddress} The remote address the token is associated with. + +### Callback: `OnOriginCallback` + + + +* `this` {quic.QuicSession} +* `origins` {string\[]} The list of origins the server is authoritative for. + +### Callback: `OnKeylogCallback` + + + +* `this` {quic.QuicSession} +* `line` {string} A single line of [NSS Key Log Format][] text, including + a trailing newline character. + +Called when TLS key material is available. Only fires when +[`sessionOptions.keylog`][] is `true`. Multiple lines are emitted during the +TLS 1.3 handshake, each containing a secret label, the client random, and +the secret value. + +### Callback: `OnQlogCallback` + + + +* `this` {quic.QuicSession} +* `data` {string} A chunk of [JSON-SEQ][] formatted [qlog][] data. +* `fin` {boolean} `true` if this is the final qlog chunk for the session. + +Called when qlog diagnostic data is available. Only fires when +[`sessionOptions.qlog`][] is `true`. The `data` chunks should be +concatenated in order to produce the complete qlog output. When `fin` is +`true`, no more chunks will be emitted and the concatenated result is a +complete JSON-SEQ document. + ### Callback: `OnBlockedCallback` + +* `this` {quic.QuicStream} +* `headers` {Object} Header object with lowercase string keys and + string or string-array values. + +Called when initial request or response headers are received. For HTTP/3, +this delivers request pseudo-headers on the server and response headers +on the client. + +### Callback: `OnTrailersCallback` + + + +* `this` {quic.QuicStream} +* `trailers` {Object} Trailing header object. + +Called when trailing headers are received from the peer. + +### Callback: `OnInfoCallback` + + + +* `this` {quic.QuicStream} +* `headers` {Object} Informational header object. + +Called when informational (1xx) headers are received from the server +(e.g., 103 Early Hints). + +## HTTP/3 support + + + +When the negotiated ALPN identifier is `'h3'` (or one of the `'h3-*'` +draft variants), the QUIC session runs the HTTP/3 application backed +by `nghttp3`. `'h3'` is the default ALPN for `quic.connect()` and +`quic.listen()`, so HTTP/3 is what you get unless you select a +different ALPN explicitly. + +Selecting the HTTP/3 application enables a number of stream- and +session-level capabilities that are not available to non-HTTP/3 +applications: + +* **Headers and trailers** — request and response header blocks + (including pseudo-headers such as `:method`, `:path`, `:scheme`, + `:authority`, and `:status`), trailing headers, and informational + (`1xx`) responses. See [`stream.sendHeaders()`][], + [`stream.sendTrailers()`][], and + [`stream.sendInformationalHeaders()`][]. +* **Stream priority (RFC 9218)** — per-stream urgency and + incremental flags. See [`stream.priority`][] and + [`stream.setPriority()`][]. +* **HTTP/3 datagrams (RFC 9297)** — unreliable application-layer + datagrams. The peer must advertise `SETTINGS_H3_DATAGRAM=1`, which + is enabled by setting [`application.enableDatagrams`][] to `true` + on both peers. See [`session.sendDatagram()`][] and + [`session.ondatagram`][]. +* **ORIGIN frame (RFC 9412)** — servers automatically advertise the + hostnames in their [`sessionOptions.sni`][] map (entries with + `authoritative: true`); clients receive the list via + [`session.onorigin`][]. +* **GOAWAY** — graceful shutdown. The server emits `GOAWAY` as part + of [`session.close()`][]; the client observes it via + [`session.ongoaway`][] and stops opening new bidirectional streams. +* **Extended CONNECT settings (RFC 9220)** — the + `SETTINGS_ENABLE_CONNECT_PROTOCOL` setting can be enabled via + [`application.enableConnectProtocol`][]. The setting is exchanged + but the application is responsible for handling the `:protocol` + pseudo-header and any payload framing on top. +* **QPACK tuning** — dynamic-table size and blocked-streams limits + via [`application.qpackMaxDTableCapacity`][] and friends. + +### Minimal HTTP/3 client + +```mjs +import { connect } from 'node:quic'; +import process from 'node:process'; + +const session = await connect('example.com:443', { + // ALPN defaults to 'h3'. + servername: 'example.com', +}); +await session.opened; + +const stream = await session.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/', + ':scheme': 'https', + ':authority': 'example.com', + }, + onheaders(headers) { + console.log('status:', headers[':status']); + }, +}); + +const decoder = new TextDecoder(); +for await (const chunk of stream) { + process.stdout.write(decoder.decode(chunk, { stream: true })); +} + +await session.close(); +``` + +A few things to note: + +* `session.createBidirectionalStream({ headers })` automatically + marks the HEADERS frame as terminal when no `body` is provided — + the request is `HEADERS` followed by `END_STREAM`. +* The `onheaders` callback receives the response pseudo-headers and + regular headers in a single object with lowercase string keys. + After the callback returns, the same object is also accessible + via [`stream.headers`][]. +* Reading `for await (const chunk of stream)` consumes the response + body as `Uint8Array` chunks. +* HTTP semantic helpers (URL parsing, method/status validation, + redirects, content negotiation, and so on) are intentionally not + built in. The caller is responsible for any HTTP-level handling + beyond the wire framing. + +### Minimal HTTP/3 server + +```mjs +import { listen } from 'node:quic'; + +const encoder = new TextEncoder(); + +const endpoint = await listen((session) => { + // The session.onstream callback fires for each new client-initiated stream. +}, { + sni: { '*': { keys: [defaultKey], certs: [defaultCert] } }, + // ALPN defaults to 'h3'. + onheaders(headers) { + // `this` is the QuicStream. Pseudo-headers are available on the + // request header block (`:method`, `:path`, `:scheme`, + // `:authority`). + if (headers[':path'] === '/health') { + this.sendHeaders({ ':status': '200', 'content-type': 'text/plain' }); + const w = this.writer; + w.writeSync(encoder.encode('ok\n')); + w.endSync(); + } else { + this.sendHeaders({ ':status': '404' }, { terminal: true }); + } + }, +}); + +console.log('listening on', endpoint.address); +``` + +Server-side notes: + +* Setting `onheaders` at the [`listen()`][`quic.listen()`] level + applies it to every incoming stream (it is wired up before + `onstream` fires). Setting it inside `onstream` is too late for + HTTP/3, where the request HEADERS frame is the first thing that + arrives on the stream. +* `this.sendHeaders(headers, { terminal: true })` marks the + response HEADERS frame as terminal (no body follows). +* For body responses, send headers first, then write to + `this.writer` and call `endSync()` to send the body and close the + stream cleanly. + +### What is not implemented + +* **Server push** — `PUSH_PROMISE` and the related push-stream + machinery are not implemented and are not on the near-term + roadmap. Server push has limited deployment in practice, and most + use cases are better served by Early Hints (`103`) or by direct + fetches from the client. +* **WebTransport / extended-CONNECT helpers** — the + `SETTINGS_ENABLE_CONNECT_PROTOCOL` setting can be negotiated but + there is no built-in support for the `:protocol` pseudo-header, + WebTransport datagram demultiplexing, or capsule framing. +* **Higher-level HTTP semantics** — there is no built-in + request/response router, URL parsing, content-encoding + negotiation, body-type coercion, redirect following, or + cookie handling. These are deliberately left to higher-level + libraries built on top of `node:quic`. + +## Performance measurement + + + +QUIC sessions, streams, and endpoints emit [`PerformanceEntry`][] objects +with `entryType` set to `'quic'`. These entries are only created when a +[`PerformanceObserver`][] is observing the `'quic'` entry type, ensuring +zero overhead when not in use. + +Each entry provides: + +* `name` {string} One of `'QuicEndpoint'`, `'QuicSession'`, or `'QuicStream'`. +* `entryType` {string} Always `'quic'`. +* `startTime` {number} High-resolution timestamp (ms) when the object was created. +* `duration` {number} Lifetime in milliseconds from creation to destruction. +* `detail` {Object} Entry-specific metadata (see below). + +### `QuicEndpoint` entries + +* `detail.stats` {QuicEndpointStats} The endpoint's statistics object + (frozen at destruction time). + +### `QuicSession` entries + +* `detail.stats` {QuicSessionStats} The session's statistics object + (frozen at destruction time). Includes bytes sent/received, RTT + measurements, congestion window, packet counts, and more. +* `detail.handshake` {Object|undefined} Timing-relevant handshake metadata, + or `undefined` if the handshake did not complete before destruction. + * `servername` {string} The negotiated SNI server name. + * `protocol` {string} The negotiated ALPN protocol. + * `earlyDataAttempted` {boolean} Whether 0-RTT early data was attempted. + * `earlyDataAccepted` {boolean} Whether 0-RTT early data was accepted. +* `detail.path` {Object|undefined} The session's network path, or + `undefined` if not yet established. + * `local` {net.SocketAddress} + * `remote` {net.SocketAddress} + +### `QuicStream` entries + +* `detail.stats` {QuicStreamStats} The stream's statistics object + (frozen at destruction time). Includes bytes sent/received, timing + timestamps, and offset tracking. +* `detail.direction` {string} Either `'bidi'` or `'uni'`. + +### Example + +```mjs +import { PerformanceObserver } from 'node:perf_hooks'; + +const obs = new PerformanceObserver((list) => { + for (const entry of list.getEntries()) { + console.log(`${entry.name}: ${entry.duration.toFixed(1)}ms`); + if (entry.name === 'QuicSession') { + const { stats, handshake } = entry.detail; + console.log(` protocol: ${handshake?.protocol}`); + console.log(` bytes sent: ${stats.bytesSent}`); + console.log(` smoothed RTT: ${stats.smoothedRtt}ns`); + } + } +}); +obs.observe({ entryTypes: ['quic'] }); +``` + ## Diagnostic Channels ### Channel: `quic.endpoint.created` @@ -1686,6 +3092,8 @@ added: v23.8.0 * `endpoint` {quic.QuicEndpoint} * `config` {quic.EndpointOptions} +Published when a new endpoint is created. + ### Channel: `quic.endpoint.listen` * `endpoint` {quic.QuicEndpoint} -* `optoins` {quic.SessionOptions} +* `options` {quic.SessionOptions} + +Published when an endpoint begins listening for incoming connections. + +### Channel: `quic.endpoint.connect` + + + +* `endpoint` {quic.QuicEndpoint} +* `address` {net.SocketAddress} The target server address. +* `options` {quic.SessionOptions} + +Published when [`quic.connect()`][] is about to create a client session. +Fires before the ngtcp2 connection is established, allowing diagnostic +subscribers to observe the connection intent. ### Channel: `quic.endpoint.closing` @@ -1704,6 +3128,8 @@ added: v23.8.0 * `endpoint` {quic.QuicEndpoint} * `hasPendingError` {boolean} +Published when an endpoint begins gracefully closing. + ### Channel: `quic.endpoint.closed` * `endpoint` {quic.QuicEndpoint} +* `stats` {quic.QuicEndpoint.Stats} Final endpoint statistics. + +Published when an endpoint has finished closing and is destroyed. ### Channel: `quic.endpoint.error` @@ -1721,6 +3150,8 @@ added: v23.8.0 * `endpoint` {quic.QuicEndpoint} * `error` {any} +Published when an endpoint encounters an error that causes it to close. + ### Channel: `quic.endpoint.busy.change` +* `endpoint` {quic.QuicEndpoint} +* `session` {quic.QuicSession} +* `address` {net.SocketAddress} The remote server address. +* `options` {quic.SessionOptions} + +Published when a client-initiated session is created. + ### Channel: `quic.session.created.server` +* `endpoint` {quic.QuicEndpoint} +* `session` {quic.QuicSession} +* `address` {net.SocketAddress|undefined} The remote peer address. + +Published when a server-side session is created for an incoming connection. + ### Channel: `quic.session.open.stream` +* `stream` {quic.QuicStream} +* `session` {quic.QuicSession} +* `direction` {string} Either `'bidi'` or `'uni'`. + +Published when a locally-initiated stream is opened. + ### Channel: `quic.session.received.stream` +* `stream` {quic.QuicStream} +* `session` {quic.QuicSession} +* `direction` {string} Either `'bidi'` or `'uni'`. + +Published when a remotely-initiated stream is received. + ### Channel: `quic.session.send.datagram` +* `id` {bigint} The datagram ID. +* `length` {number} The datagram payload size in bytes. +* `session` {quic.QuicSession} + +Published when a datagram is queued for sending. + ### Channel: `quic.session.update.key` +* `session` {quic.QuicSession} + +Published when a TLS key update is initiated. + ### Channel: `quic.session.closing` +* `session` {quic.QuicSession} + +Published when a session begins gracefully closing (including when a +GOAWAY frame is received from the peer). + ### Channel: `quic.session.closed` +* `session` {quic.QuicSession} +* `error` {any} The error that caused the close, or `undefined` if clean. +* `stats` {quic.QuicSession.Stats} Final session statistics. + +Published when a session is destroyed. The `stats` object is a snapshot +of the final statistics at the time of destruction. + +### Channel: `quic.session.error` + + + +* `session` {quic.QuicSession} +* `error` {any} The error that caused the session to be destroyed. + +Published when a session is destroyed due to an error. Fires before the +`onerror` callback and before streams are torn down. Unlike +`quic.session.closed` (which fires for both clean and error closes), this +channel fires only when an error is present, making it suitable for +error-only alerting. + ### Channel: `quic.session.receive.datagram` +* `length` {number} The datagram payload size in bytes. +* `early` {boolean} Whether the datagram was received as 0-RTT early data. +* `session` {quic.QuicSession} + +Published when a datagram is received from the remote peer. + ### Channel: `quic.session.receive.datagram.status` +* `id` {bigint} The datagram ID. +* `status` {string} One of `'acknowledged'`, `'lost'`, or `'abandoned'`. +* `session` {quic.QuicSession} + +Published when the delivery status of a sent datagram is updated. + ### Channel: `quic.session.path.validation` +* `result` {string} One of `'success'`, `'failure'`, or `'aborted'`. +* `newLocalAddress` {net.SocketAddress} +* `newRemoteAddress` {net.SocketAddress} +* `oldLocalAddress` {net.SocketAddress|null} +* `oldRemoteAddress` {net.SocketAddress|null} +* `preferredAddress` {boolean} +* `session` {quic.QuicSession} + +Published when a path validation attempt completes. + +### Channel: `quic.session.new.token` + + + +* `token` {Buffer} The NEW\_TOKEN token data. +* `address` {net.SocketAddress} The remote server address. +* `session` {quic.QuicSession} + +Published when a client session receives a NEW\_TOKEN frame from the +server. + ### Channel: `quic.session.ticket` +* `ticket` {Object} The opaque session ticket. +* `session` {quic.QuicSession} + +Published when a new TLS session ticket is received. + ### Channel: `quic.session.version.negotiation` +* `version` {number} The QUIC version that was configured for this session. +* `requestedVersions` {number\[]} The versions advertised by the server. +* `supportedVersions` {number\[]} The versions supported locally. +* `session` {quic.QuicSession} + +Published when the client receives a Version Negotiation packet from the +server. The session is always destroyed immediately after. + +### Channel: `quic.session.receive.origin` + + + +* `origins` {string\[]} The list of origins the server is authoritative for. +* `session` {quic.QuicSession} + +Published when the session receives an ORIGIN frame (RFC 9412) from +the peer. + ### Channel: `quic.session.handshake` +* `session` {quic.QuicSession} +* `servername` {string} +* `protocol` {string} +* `cipher` {string} +* `cipherVersion` {string} +* `validationErrorReason` {string} +* `validationErrorCode` {number} +* `earlyDataAttempted` {boolean} +* `earlyDataAccepted` {boolean} + +Published when the TLS handshake completes. + +### Channel: `quic.session.goaway` + + + +* `session` {quic.QuicSession} +* `lastStreamId` {bigint} The highest stream ID the peer may have processed. + +Published when the peer sends an HTTP/3 GOAWAY frame. Streams with IDs +above `lastStreamId` were not processed and can be retried on a new +connection. A `lastStreamId` of `-1n` indicates a shutdown notice without +a stream boundary. + +### Channel: `quic.session.early.rejected` + + + +* `session` {quic.QuicSession} + +Published when the server rejects 0-RTT early data. All streams that were +opened during the 0-RTT phase have been destroyed. Useful for diagnosing +latency regressions when 0-RTT is expected to succeed. + +### Channel: `quic.stream.closed` + + + +* `stream` {quic.QuicStream} +* `session` {quic.QuicSession} +* `error` {any} The error that caused the close, or `undefined` if clean. +* `stats` {quic.QuicStream.Stats} Final stream statistics. + +Published when a stream is destroyed. The `stats` object is a snapshot +of the final statistics at the time of destruction. + +### Channel: `quic.stream.headers` + + + +* `stream` {quic.QuicStream} +* `session` {quic.QuicSession} +* `headers` {Object} The initial request or response headers. + +Published when initial headers are received on a stream. For HTTP/3 +server-side streams, this contains request pseudo-headers (`:method`, +`:path`, etc.). For client-side streams, this contains response headers +(`:status`, etc.). + +### Channel: `quic.stream.trailers` + + + +* `stream` {quic.QuicStream} +* `session` {quic.QuicSession} +* `trailers` {Object} The trailing headers. + +Published when trailing headers are received on a stream. + +### Channel: `quic.stream.info` + + + +* `stream` {quic.QuicStream} +* `session` {quic.QuicSession} +* `headers` {Object} The informational headers. + +Published when informational (1xx) headers are received on a stream +(e.g., 103 Early Hints). + +### Channel: `quic.stream.reset` + + + +* `stream` {quic.QuicStream} +* `session` {quic.QuicSession} +* `error` {any} The QUIC error associated with the reset. + +Published when a stream receives a STOP\_SENDING or RESET\_STREAM frame +from the peer, indicating the peer has aborted the stream. This is a +key signal for diagnosing application-level issues such as cancelled +requests. + +### Channel: `quic.stream.blocked` + + + +* `stream` {quic.QuicStream} +* `session` {quic.QuicSession} + +Published when a stream is flow-control blocked and cannot send data +until the peer increases the flow control window. Useful for diagnosing +throughput issues caused by flow control. + +[Aborting a stream]: #aborting-a-stream +[Callback error handling]: #callback-error-handling +[JSON-SEQ]: https://www.rfc-editor.org/rfc/rfc7464 +[NSS Key Log Format]: https://udn.realityripple.com/docs/Mozilla/Projects/NSS/Key_Log_Format +[`PerformanceEntry`]: perf_hooks.md#class-performanceentry +[`PerformanceObserver`]: perf_hooks.md#class-performanceobserver +[`QuicError`]: #class-quicerror +[`application.enableConnectProtocol`]: #sessionoptionsapplication +[`application.enableDatagrams`]: #sessionoptionsapplication +[`application.qpackMaxDTableCapacity`]: #sessionoptionsapplication +[`endpoint.maxConnectionsPerHost`]: #endpointmaxconnectionsperhost +[`endpoint.maxConnectionsTotal`]: #endpointmaxconnectionstotal +[`error.errorCode`]: #errorerrorcode +[`fs.promises.open(path, 'r')`]: fs.md#fspromisesopenpath-flags-mode +[`quic.connect()`]: #quicconnectaddress-options +[`quic.listen()`]: #quiclistencallback-options +[`session.close()`]: #sessioncloseoptions +[`session.destroy()`]: #sessiondestroyerror-options +[`session.maxPendingDatagrams`]: #sessionmaxpendingdatagrams +[`session.ondatagram`]: #sessionondatagram +[`session.onerror`]: #sessiononerror +[`session.ongoaway`]: #sessionongoaway +[`session.onkeylog`]: #sessiononkeylog +[`session.onnewtoken`]: #sessiononnewtoken +[`session.onorigin`]: #sessiononorigin +[`session.onqlog`]: #sessiononqlog +[`session.sendDatagram()`]: #sessionsenddatagramdatagram-encoding +[`sessionOptions.datagramDropPolicy`]: #sessionoptionsdatagramdroppolicy +[`sessionOptions.keylog`]: #sessionoptionskeylog +[`sessionOptions.qlog`]: #sessionoptionsqlog [`sessionOptions.sni`]: #sessionoptionssni-server-only +[`stream.destroy()`]: #streamdestroyerror-options +[`stream.headers`]: #streamheaders +[`stream.onerror`]: #streamonerror +[`stream.onwanttrailers`]: #streamonwanttrailers +[`stream.pendingTrailers`]: #streampendingtrailers +[`stream.priority`]: #streampriority +[`stream.sendHeaders()`]: #streamsendheadersheaders-options +[`stream.sendInformationalHeaders()`]: #streamsendinformationalheadersheaders +[`stream.sendTrailers()`]: #streamsendtrailersheaders +[`stream.setBody()`]: #streamsetbodybody +[`stream.setPriority()`]: #streamsetpriorityoptions +[`stream.writer`]: #streamwriter +[`writer.fail()`]: #streamwriter +[`writer.fail(reason)`]: #streamwriter +[qlog]: https://datatracker.ietf.org/doc/draft-ietf-quic-qlog-main-schema/ +[qvis]: https://qvis.quictools.info/ diff --git a/lib/internal/blob.js b/lib/internal/blob.js index 7eb3341076aec5..f16e520e197cdd 100644 --- a/lib/internal/blob.js +++ b/lib/internal/blob.js @@ -1,6 +1,7 @@ 'use strict'; const { + ArrayPrototypePush, MathMax, MathMin, ObjectDefineProperties, @@ -536,13 +537,82 @@ function createBlobReaderStream(reader) { }, { highWaterMark: 0 }); } +// Maximum number of chunks to collect in a single batch to prevent +// unbounded memory growth when the DataQueue has a large burst of data. +const kMaxBatchChunks = 16; + +async function* createBlobReaderIterable(reader, options = {}) { + const { getReadError } = options; + let wakeup = PromiseWithResolvers(); + reader.setWakeup(wakeup.resolve); + + try { + while (true) { + const batch = []; + let blocked = false; + let eos = false; + let error = null; + + // Pull as many chunks as available synchronously. + // reader.pull(callback) calls the callback synchronously via + // MakeCallback, so we can collect multiple chunks per iteration + // step without any async overhead. + while (true) { + let pullResult; + reader.pull((status, buffer) => { + pullResult = { status, buffer }; + }); + + if (pullResult.status === 0) { + eos = true; + break; + } + if (pullResult.status < 0) { + error = typeof getReadError === 'function' ? + getReadError(pullResult.status) : + new ERR_INVALID_STATE('The reader is not readable'); + break; + } + if (pullResult.status === 2) { + blocked = true; + break; + } + ArrayPrototypePush(batch, new Uint8Array(pullResult.buffer)); + if (batch.length >= kMaxBatchChunks) break; + } + + if (batch.length > 0) { + yield batch; + } + + if (eos) return; + if (error) throw error; + + if (blocked) { + const fin = await wakeup.promise; + wakeup = PromiseWithResolvers(); + reader.setWakeup(wakeup.resolve); + // If the wakeup was triggered by FIN (EndReadable), the DataQueue + // is capped. Continue the loop to pull again -- the next pull will + // return EOS. Without this, a race between the data notification + // and the FIN notification can leave the iterator waiting for a + // wakeup that will never come. + if (fin) continue; + } + } + } finally { + reader.setWakeup(undefined); + } +} + module.exports = { Blob, createBlob, createBlobFromFilePath, + createBlobReaderIterable, + createBlobReaderStream, isBlob, kHandle, resolveObjectURL, TransferableBlob, - createBlobReaderStream, }; diff --git a/lib/internal/errors.js b/lib/internal/errors.js index c40eed86bca834..1d31e2b43dc2bd 100644 --- a/lib/internal/errors.js +++ b/lib/internal/errors.js @@ -1691,6 +1691,9 @@ E('ERR_QUIC_APPLICATION_ERROR', 'A QUIC application error occurred. %d [%s]', Er E('ERR_QUIC_CONNECTION_FAILED', 'QUIC connection failed', Error); E('ERR_QUIC_ENDPOINT_CLOSED', 'QUIC endpoint closed: %s (%d)', Error); E('ERR_QUIC_OPEN_STREAM_FAILED', 'Failed to open QUIC stream', Error); +E('ERR_QUIC_STREAM_ABORTED', '%s', Error); +E('ERR_QUIC_STREAM_RESET', + 'The QUIC stream was reset by the peer with error code %d', Error); E('ERR_QUIC_TRANSPORT_ERROR', 'A QUIC transport error occurred. %d [%s]', Error); E('ERR_QUIC_VERSION_NEGOTIATION_ERROR', 'The QUIC session requires version negotiation', Error); E('ERR_REQUIRE_ASYNC_MODULE', function(filename, parentFilename) { diff --git a/lib/internal/fs/promises.js b/lib/internal/fs/promises.js index 40de890c6eb2d3..720bd1319b381f 100644 --- a/lib/internal/fs/promises.js +++ b/lib/internal/fs/promises.js @@ -1994,6 +1994,8 @@ module.exports = { }, FileHandle, + kHandle, + kLocked, kRef, kUnref, }; diff --git a/lib/internal/perf/observe.js b/lib/internal/perf/observe.js index 58eca95d9de710..e519a35b5396e5 100644 --- a/lib/internal/perf/observe.js +++ b/lib/internal/perf/observe.js @@ -27,6 +27,7 @@ const { NODE_PERFORMANCE_ENTRY_TYPE_HTTP, NODE_PERFORMANCE_ENTRY_TYPE_NET, NODE_PERFORMANCE_ENTRY_TYPE_DNS, + NODE_PERFORMANCE_ENTRY_TYPE_QUIC, }, installGarbageCollectionTracking, observerCounts, @@ -87,6 +88,7 @@ const kSupportedEntryTypes = ObjectFreeze([ 'mark', 'measure', 'net', + 'quic', 'resource', ]); @@ -131,6 +133,7 @@ function getObserverType(type) { case 'http': return NODE_PERFORMANCE_ENTRY_TYPE_HTTP; case 'net': return NODE_PERFORMANCE_ENTRY_TYPE_NET; case 'dns': return NODE_PERFORMANCE_ENTRY_TYPE_DNS; + case 'quic': return NODE_PERFORMANCE_ENTRY_TYPE_QUIC; } } diff --git a/lib/internal/quic/diagnostics.js b/lib/internal/quic/diagnostics.js new file mode 100644 index 00000000000000..7e11de4ef36ae1 --- /dev/null +++ b/lib/internal/quic/diagnostics.js @@ -0,0 +1,71 @@ +'use strict'; + +const dc = require('diagnostics_channel'); + +const onEndpointCreatedChannel = dc.channel('quic.endpoint.created'); +const onEndpointListeningChannel = dc.channel('quic.endpoint.listen'); +const onEndpointClosingChannel = dc.channel('quic.endpoint.closing'); +const onEndpointClosedChannel = dc.channel('quic.endpoint.closed'); +const onEndpointErrorChannel = dc.channel('quic.endpoint.error'); +const onEndpointBusyChangeChannel = dc.channel('quic.endpoint.busy.change'); +const onEndpointClientSessionChannel = dc.channel('quic.session.created.client'); +const onEndpointServerSessionChannel = dc.channel('quic.session.created.server'); +const onSessionOpenStreamChannel = dc.channel('quic.session.open.stream'); +const onSessionReceivedStreamChannel = dc.channel('quic.session.received.stream'); +const onSessionSendDatagramChannel = dc.channel('quic.session.send.datagram'); +const onSessionUpdateKeyChannel = dc.channel('quic.session.update.key'); +const onSessionClosingChannel = dc.channel('quic.session.closing'); +const onSessionClosedChannel = dc.channel('quic.session.closed'); +const onSessionReceiveDatagramChannel = dc.channel('quic.session.receive.datagram'); +const onSessionReceiveDatagramStatusChannel = dc.channel('quic.session.receive.datagram.status'); +const onSessionPathValidationChannel = dc.channel('quic.session.path.validation'); +const onSessionNewTokenChannel = dc.channel('quic.session.new.token'); +const onSessionTicketChannel = dc.channel('quic.session.ticket'); +const onSessionVersionNegotiationChannel = dc.channel('quic.session.version.negotiation'); +const onSessionOriginChannel = dc.channel('quic.session.receive.origin'); +const onSessionHandshakeChannel = dc.channel('quic.session.handshake'); +const onSessionGoawayChannel = dc.channel('quic.session.goaway'); +const onSessionEarlyRejectedChannel = dc.channel('quic.session.early.rejected'); +const onStreamClosedChannel = dc.channel('quic.stream.closed'); +const onStreamHeadersChannel = dc.channel('quic.stream.headers'); +const onStreamTrailersChannel = dc.channel('quic.stream.trailers'); +const onStreamInfoChannel = dc.channel('quic.stream.info'); +const onStreamResetChannel = dc.channel('quic.stream.reset'); +const onStreamBlockedChannel = dc.channel('quic.stream.blocked'); +const onSessionErrorChannel = dc.channel('quic.session.error'); +const onEndpointConnectChannel = dc.channel('quic.endpoint.connect'); + +module.exports = { + onEndpointCreatedChannel, + onEndpointListeningChannel, + onEndpointClosingChannel, + onEndpointClosedChannel, + onEndpointErrorChannel, + onEndpointBusyChangeChannel, + onEndpointClientSessionChannel, + onEndpointServerSessionChannel, + onSessionOpenStreamChannel, + onSessionReceivedStreamChannel, + onSessionSendDatagramChannel, + onSessionUpdateKeyChannel, + onSessionClosingChannel, + onSessionClosedChannel, + onSessionReceiveDatagramChannel, + onSessionReceiveDatagramStatusChannel, + onSessionPathValidationChannel, + onSessionNewTokenChannel, + onSessionTicketChannel, + onSessionVersionNegotiationChannel, + onSessionOriginChannel, + onSessionHandshakeChannel, + onSessionGoawayChannel, + onSessionEarlyRejectedChannel, + onStreamClosedChannel, + onStreamHeadersChannel, + onStreamTrailersChannel, + onStreamInfoChannel, + onStreamResetChannel, + onStreamBlockedChannel, + onSessionErrorChannel, + onEndpointConnectChannel, +}; diff --git a/lib/internal/quic/quic.js b/lib/internal/quic/quic.js index a24ba4d39c6e69..b9cbc8feb62e20 100644 --- a/lib/internal/quic/quic.js +++ b/lib/internal/quic/quic.js @@ -5,14 +5,24 @@ /* c8 ignore start */ const { - ArrayBufferPrototypeTransfer, ArrayIsArray, ArrayPrototypePush, BigInt, + DataViewPrototypeGetByteLength, + FunctionPrototypeBind, + Number, ObjectDefineProperties, ObjectKeys, + PromisePrototypeThen, + PromiseResolve, + PromiseWithResolvers, SafeSet, + Symbol, SymbolAsyncDispose, + SymbolAsyncIterator, + SymbolDispose, + SymbolIterator, + TypedArrayPrototypeGetByteLength, Uint8Array, } = primordials; @@ -55,11 +65,29 @@ const { CLOSECONTEXT_RECEIVE_FAILURE: kCloseContextReceiveFailure, CLOSECONTEXT_SEND_FAILURE: kCloseContextSendFailure, CLOSECONTEXT_START_FAILURE: kCloseContextStartFailure, + QUIC_STREAM_HEADERS_KIND_INITIAL: kHeadersKindInitial, + QUIC_STREAM_HEADERS_KIND_HINTS: kHeadersKindHints, + QUIC_STREAM_HEADERS_KIND_TRAILING: kHeadersKindTrailing, + QUIC_STREAM_HEADERS_FLAGS_NONE: kHeadersFlagsNone, + QUIC_STREAM_HEADERS_FLAGS_TERMINAL: kHeadersFlagsTerminal, } = internalBinding('quic'); +// Maps the numeric HeadersKind constants from C++ to user-facing strings. +// Indexed by the enum value (HINTS=0, INITIAL=1, TRAILING=2). +const kHeadersKindName = []; +kHeadersKindName[kHeadersKindHints] = 'hints'; +kHeadersKindName[kHeadersKindInitial] = 'initial'; +kHeadersKindName[kHeadersKindTrailing] = 'trailing'; + +const { + markPromiseAsHandled, +} = internalBinding('util'); + const { isArrayBuffer, isArrayBufferView, + isDataView, + isPromise, isSharedArrayBuffer, } = require('util/types'); @@ -75,10 +103,13 @@ const { ERR_INVALID_STATE, ERR_INVALID_THIS, ERR_MISSING_ARGS, + ERR_OUT_OF_RANGE, ERR_QUIC_APPLICATION_ERROR, ERR_QUIC_CONNECTION_FAILED, ERR_QUIC_ENDPOINT_CLOSED, ERR_QUIC_OPEN_STREAM_FAILED, + ERR_QUIC_STREAM_ABORTED, + ERR_QUIC_STREAM_RESET, ERR_QUIC_TRANSPORT_ERROR, ERR_QUIC_VERSION_NEGOTIATION_ERROR, }, @@ -91,19 +122,41 @@ const { } = require('internal/socketaddress'); const { - createBlobReaderStream, + createBlobReaderIterable, isBlob, kHandle: kBlobHandle, } = require('internal/blob'); +const { + drainableProtocol, + kValidatedSource, +} = require('internal/streams/iter/types'); + +const { + toUint8Array, + convertChunks, +} = require('internal/streams/iter/utils'); + +const { + from: streamFrom, + fromSync: streamFromSync, +} = require('internal/streams/iter/from'); + const { isKeyObject, } = require('internal/crypto/keys'); const { + FileHandle, + kHandle: kFileHandle, + kLocked: kFileLocked, +} = require('internal/fs/promises'); + +const { + validateAbortSignal, validateBoolean, validateFunction, - validateNumber, + validateInteger, validateObject, validateOneOf, validateString, @@ -117,21 +170,29 @@ const { const kEmptyObject = { __proto__: null }; const { + kAttachFileHandle, kBlocked, kConnect, kDatagram, kDatagramStatus, + kDrain, + kEarlyDataRejected, kFinishClose, + kGoaway, kHandshake, + kHandshakeCompleted, kHeaders, kOwner, kRemoveSession, + kKeylog, kListen, kNewSession, + kQlog, kRemoveStream, kNewStream, - kOnHeaders, - kOnTrailers, + kNewToken, + kOrigin, + kStreamCallbacks, kPathValidation, kPrivateConstructor, kReset, @@ -159,27 +220,55 @@ const { const assert = require('internal/assert'); -const dc = require('diagnostics_channel'); -const onEndpointCreatedChannel = dc.channel('quic.endpoint.created'); -const onEndpointListeningChannel = dc.channel('quic.endpoint.listen'); -const onEndpointClosingChannel = dc.channel('quic.endpoint.closing'); -const onEndpointClosedChannel = dc.channel('quic.endpoint.closed'); -const onEndpointErrorChannel = dc.channel('quic.endpoint.error'); -const onEndpointBusyChangeChannel = dc.channel('quic.endpoint.busy.change'); -const onEndpointClientSessionChannel = dc.channel('quic.session.created.client'); -const onEndpointServerSessionChannel = dc.channel('quic.session.created.server'); -const onSessionOpenStreamChannel = dc.channel('quic.session.open.stream'); -const onSessionReceivedStreamChannel = dc.channel('quic.session.received.stream'); -const onSessionSendDatagramChannel = dc.channel('quic.session.send.datagram'); -const onSessionUpdateKeyChannel = dc.channel('quic.session.update.key'); -const onSessionClosingChannel = dc.channel('quic.session.closing'); -const onSessionClosedChannel = dc.channel('quic.session.closed'); -const onSessionReceiveDatagramChannel = dc.channel('quic.session.receive.datagram'); -const onSessionReceiveDatagramStatusChannel = dc.channel('quic.session.receive.datagram.status'); -const onSessionPathValidationChannel = dc.channel('quic.session.path.validation'); -const onSessionTicketChannel = dc.channel('quic.session.ticket'); -const onSessionVersionNegotiationChannel = dc.channel('quic.session.version.negotiation'); -const onSessionHandshakeChannel = dc.channel('quic.session.handshake'); +const { + hasObserver, + startPerf, + stopPerf, +} = require('internal/perf/observe'); + +const kPerfEntry = Symbol('kPerfEntry'); + +const { + onEndpointCreatedChannel, + onEndpointListeningChannel, + onEndpointClosingChannel, + onEndpointClosedChannel, + onEndpointErrorChannel, + onEndpointBusyChangeChannel, + onEndpointClientSessionChannel, + onEndpointServerSessionChannel, + onSessionOpenStreamChannel, + onSessionReceivedStreamChannel, + onSessionSendDatagramChannel, + onSessionUpdateKeyChannel, + onSessionClosingChannel, + onSessionClosedChannel, + onSessionReceiveDatagramChannel, + onSessionReceiveDatagramStatusChannel, + onSessionPathValidationChannel, + onSessionNewTokenChannel, + onSessionTicketChannel, + onSessionVersionNegotiationChannel, + onSessionOriginChannel, + onSessionHandshakeChannel, + onSessionGoawayChannel, + onSessionEarlyRejectedChannel, + onStreamClosedChannel, + onStreamHeadersChannel, + onStreamTrailersChannel, + onStreamInfoChannel, + onStreamResetChannel, + onStreamBlockedChannel, + onSessionErrorChannel, + onEndpointConnectChannel, +} = require('internal/quic/diagnostics'); + +const kNilDatagramId = 0n; + +// Module-level registry of all live QuicEndpoint instances. Used by +// connect() and listen() to find existing endpoints for reuse instead +// of creating a new one per session. +const endpointRegistry = new SafeSet(); /** * @typedef {import('../socketaddress.js').SocketAddress} SocketAddress @@ -188,14 +277,32 @@ const onSessionHandshakeChannel = dc.channel('quic.session.handshake'); /** * @typedef {object} OpenStreamOptions - * @property {ArrayBuffer|ArrayBufferView|Blob} [body] The outbound payload - * @property {number} [sendOrder] The ordering of this stream relative to others in the same session. + * @property {string|ArrayBuffer|SharedArrayBuffer|ArrayBufferView|Blob| + * FileHandle|AsyncIterable|Iterable|Promise|null} [body] The outbound + * body source. See the public docs for `stream.setBody()` for details + * on supported types. When omitted, the stream is closed immediately. + * @property {object} [headers] Initial request or response headers to + * send. Only used when the negotiated application supports headers + * (e.g. HTTP/3). + * @property {'high'|'default'|'low'} [priority] The priority level of the stream. + * @property {boolean} [incremental] Whether to interleave data with same-priority streams. + * @property {number} [highWaterMark] The high water mark for write + * backpressure, in bytes. **Default:** `65536`. + * @property {OnHeadersCallback} [onheaders] Callback for incoming initial headers + * @property {OnTrailersCallback} [ontrailers] Callback for incoming trailing headers + * @property {OnInfoCallback} [oninfo] Callback for informational (1xx) headers + * @property {OnWantTrailersCallback} [onwanttrailers] Callback fired when the + * transport is ready to send trailers for this stream. */ /** + * Provides the configuration options for a QuicEndpoint. * @typedef {object} EndpointOptions - * @property {string|SocketAddress} [address] The local address to bind to + * @property {SocketAddress|string} [address] The local address to bind to * @property {bigint|number} [addressLRUSize] The size of the address LRU cache + * @property {'reno'|'cubic'|'bbr'} [cc] The congestion control algorithm + * @property {boolean} [disableStatelessReset] When true, the endpoint will not send stateless resets + * @property {bigint|number} [idleTimeout] The default idle timeout for sessions on this endpoint * @property {boolean} [ipv6Only] Use IPv6 only * @property {bigint|number} [maxConnectionsPerHost] The maximum number of connections per host * @property {bigint|number} [maxConnectionsTotal] The maximum number of total connections @@ -203,8 +310,10 @@ const onSessionHandshakeChannel = dc.channel('quic.session.handshake'); * @property {bigint|number} [maxStatelessResetsPerHost] The maximum number of stateless resets per host * @property {ArrayBufferView} [resetTokenSecret] The reset token secret * @property {bigint|number} [retryTokenExpiration] The retry token expiration + * @property {number} [rxDiagnosticLoss] The receive diagnostic loss probability (range 0.0-1.0) * @property {bigint|number} [tokenExpiration] The token expiration * @property {ArrayBufferView} [tokenSecret] The token secret + * @property {number} [txDiagnosticLoss] The transmit diagnostic loss probability (range 0.0-1.0) * @property {number} [udpReceiveBufferSize] The UDP receive buffer size * @property {number} [udpSendBufferSize] The UDP send buffer size * @property {number} [udpTTL] The UDP TTL @@ -240,34 +349,94 @@ const onSessionHandshakeChannel = dc.channel('quic.session.handshake'); * @property {boolean} [enableDatagrams] Enable datagrams */ +/** + * Per-identity TLS options. Used as the values in the `sni` map of + * `SessionOptions` for server endpoints. + * @typedef {object} IdentityOptions + * @property {KeyObject|KeyObject[]} keys The TLS private keys. + * @property {ArrayBuffer|ArrayBufferView|Array} certs The TLS certificates. + * @property {boolean} [verifyPrivateKey] Verify the private key. + * **Default:** `false`. + * @property {number} [port] The port to advertise in HTTP/3 ORIGIN frames + * for this host name. **Default:** `443`. + * @property {boolean} [authoritative] Whether to include this host name + * in HTTP/3 ORIGIN frames. **Default:** `true`. Wildcard (`'*'`) + * entries are always excluded regardless of this setting. + */ + /** * @typedef {object} SessionOptions * @property {EndpointOptions|QuicEndpoint} [endpoint] An endpoint to use. - * @property {number} [version] The version - * @property {number} [minVersion] The minimum version + * @property {boolean} [reuseEndpoint] When `true` (default), `connect()` + * will attempt to reuse an existing endpoint rather than create a new + * one. Has no effect for server sessions. + * @property {number} [version] The QUIC version + * @property {number} [minVersion] The minimum acceptable QUIC version * @property {'use'|'ignore'|'default'} [preferredAddressPolicy] The preferred address policy * @property {ApplicationOptions} [application] The application options * @property {TransportParams} [transportParams] The transport parameters - * @property {string} [servername] The server name identifier - * @property {string} [protocol] The application layer protocol negotiation - * @property {string} [ciphers] The ciphers - * @property {string} [groups] The groups - * @property {boolean} [keylog] Enable key logging - * @property {boolean} [verifyClient] Verify the client + * @property {string} [servername] The server name identifier (client only) + * @property {string|string[]} [alpn] The ALPN protocol identifier(s). + * For client sessions, a single string. For server sessions, an array + * of protocol names in preference order. + * @property {string} [ciphers] The TLS ciphers + * @property {string} [groups] The TLS key-exchange groups + * @property {boolean} [keylog] Enable TLS key logging + * @property {boolean} [verifyClient] Verify the client certificate (server only) * @property {boolean} [tlsTrace] Enable TLS tracing - * @property {boolean} [verifyPrivateKey] Verify the private key - * @property {KeyObject|KeyObject[]} [keys] The keys - * @property {ArrayBuffer|ArrayBufferView|Array} [certs] The certificates + * @property {boolean} [enableEarlyData] Enable 0-RTT early data. + * **Default:** `true`. + * @property {boolean} [rejectUnauthorized] Verify the peer certificate + * against the supplied CAs. **Default:** `true`. + * @property {boolean} [verifyPrivateKey] Verify the private key (client only) + * @property {KeyObject|KeyObject[]} [keys] The TLS private keys (client only) + * @property {ArrayBuffer|ArrayBufferView|Array} [certs] The TLS certificates (client only) * @property {ArrayBuffer|ArrayBufferView|Array} [ca] The certificate authority * @property {ArrayBuffer|ArrayBufferView|Array} [crl] The certificate revocation list + * @property {{[key: string]: IdentityOptions}} [sni] Map of host names to + * per-identity TLS options for Server Name Indication. Required for + * server sessions. The special key `'*'` specifies the optional + * default/fallback identity. * @property {boolean} [qlog] Enable qlog - * @property {ArrayBufferView} [sessionTicket] The session ticket + * @property {ArrayBufferView} [sessionTicket] A session ticket from a + * prior session, used to resume that session (client only). + * @property {ArrayBufferView} [token] An opaque address validation token + * previously received from the server via `onnewtoken` (client only). * @property {bigint|number} [handshakeTimeout] The handshake timeout + * @property {bigint|number} [keepAlive] The keep-alive timeout in milliseconds. When set, + * PING frames will be sent automatically to prevent idle timeout. * @property {bigint|number} [maxStreamWindow] The maximum stream window - * @property {bigint|number} [maxWindow] The maximum window + * @property {bigint|number} [maxWindow] The maximum connection window * @property {bigint|number} [maxPayloadSize] The maximum payload size * @property {bigint|number} [unacknowledgedPacketThreshold] The unacknowledged packet threshold * @property {'reno'|'cubic'|'bbr'} [cc] The congestion control algorithm + * @property {'drop-oldest'|'drop-newest'} [datagramDropPolicy] The + * policy used when the pending datagram queue is full. + * **Default:** `'drop-oldest'`. + * @property {number} [drainingPeriodMultiplier] Multiplier applied to the + * draining period (3 * PTO) used by ngtcp2. Range `3..255`. + * **Default:** `3`. + * @property {number} [maxDatagramSendAttempts] Maximum number of times a + * datagram is retried before being abandoned. Range `1..255`. + * **Default:** `5`. + * @property {OnSessionErrorCallback} [onerror] Session error callback. + * @property {OnStreamCallback} [onstream] Incoming stream callback. + * @property {OnDatagramCallback} [ondatagram] Incoming datagram callback. + * @property {OnDatagramStatusCallback} [ondatagramstatus] Outgoing datagram status callback. + * @property {OnPathValidationCallback} [onpathvalidation] Path validation callback. + * @property {OnSessionTicketCallback} [onsessionticket] New session-ticket callback. + * @property {OnVersionNegotiationCallback} [onversionnegotiation] Version negotiation callback. + * @property {OnHandshakeCallback} [onhandshake] Handshake-completed callback. + * @property {OnNewTokenCallback} [onnewtoken] NEW_TOKEN frame callback (client only). + * @property {OnOriginCallback} [onorigin] ORIGIN frame callback (client only). + * @property {OnGoawayCallback} [ongoaway] GOAWAY frame callback. + * @property {OnKeylogCallback} [onkeylog] TLS key-log callback. + * @property {OnQlogCallback} [onqlog] qlog data callback. + * @property {OnHeadersCallback} [onheaders] Default per-stream initial-headers callback. + * @property {OnTrailersCallback} [ontrailers] Default per-stream trailing-headers callback. + * @property {OnInfoCallback} [oninfo] Default per-stream informational-headers callback. + * @property {OnWantTrailersCallback} [onwanttrailers] Default per-stream + * want-trailers callback. */ /** @@ -282,6 +451,18 @@ const onSessionHandshakeChannel = dc.channel('quic.session.handshake'); * @property {SocketAddress} remote The remote address */ +/** + * @typedef {object} QuicSessionInfo + * @property {SocketAddress} local The local address + * @property {SocketAddress} remote The remote address + * @property {string} protocol The alpn protocol identifier negotiated for this session + * @property {string} servername The servername identifier for this session + * @property {string} cipher The cipher suite negotiated for this session + * @property {string} cipherVersion The version of the cipher suite negotiated for this session + * @property {string} [validationErrorReason] The reason the session failed validation (if any) + * @property {string} [validationErrorCode] The error code for the validation failure (if any) + */ + /** * Called when the Endpoint receives a new server-side Session. * @callback OnSessionCallback @@ -290,6 +471,14 @@ const onSessionHandshakeChannel = dc.channel('quic.session.handshake'); * @returns {void} */ +/** + * Called when a session is destroyed with an error. + * @callback OnSessionErrorCallback + * @this {QuicSession} + * @param {any} error + * @returns {void} + */ + /** * @callback OnStreamCallback * @this {QuicSession} @@ -305,6 +494,29 @@ const onSessionHandshakeChannel = dc.channel('quic.session.handshake'); * @returns {void} */ +/** + * Called when the status of a previously sent datagram is reported. + * @callback OnDatagramStatusCallback + * @this {QuicSession} + * @param {bigint} id The datagram id + * @param {'acknowledged'|'lost'|'abandoned'} status + * @returns {void} + */ + +/** + * Called when QUIC path validation completes (or fails). + * @callback OnPathValidationCallback + * @this {QuicSession} + * @param {'success'|'failure'|'aborted'} result + * @param {SocketAddress} newLocalAddress + * @param {SocketAddress} newRemoteAddress + * @param {SocketAddress|null} oldLocalAddress + * @param {SocketAddress|null} oldRemoteAddress + * @param {boolean} [preferredAddress] `true` if the validation was triggered + * by a preferred-address migration on the client side. + * @returns {void} + */ + /** * @callback OnSessionTicketCallback * @this {QuicSession} @@ -312,6 +524,76 @@ const onSessionHandshakeChannel = dc.channel('quic.session.handshake'); * @returns {void} */ +/** + * Called when the server responds with a Version Negotiation packet. + * The session is destroyed immediately after this returns. + * @callback OnVersionNegotiationCallback + * @this {QuicSession} + * @param {number} version The QUIC version configured for this session + * @param {number[]} requestedVersions The versions advertised by the server + * @param {number[]} supportedVersions A `[minVersion, maxVersion]` pair + * @returns {void} + */ + +/** + * Called when the TLS handshake completes successfully. + * @callback OnHandshakeCallback + * @this {QuicSession} + * @param {string} sni + * @param {string} alpn + * @param {string} cipher + * @param {string} cipherVersion + * @param {string} [validationErrorReason] + * @param {number} [validationErrorCode] + * @param {boolean} earlyDataAttempted + * @param {boolean} earlyDataAccepted + * @returns {void} + */ + +/** + * Called when the server issues a NEW_TOKEN frame to the client. + * @callback OnNewTokenCallback + * @this {QuicSession} + * @param {Buffer} token The opaque token data + * @param {SocketAddress} address The remote server address + * @returns {void} + */ + +/** + * Called when the server sends an ORIGIN frame. + * @callback OnOriginCallback + * @this {QuicSession} + * @param {string[]} origins The list of origins the server claims authority for + * @returns {void} + */ + +/** + * Called when the peer sends a GOAWAY frame (HTTP/3 only). + * @callback OnGoawayCallback + * @this {QuicSession} + * @param {bigint} lastStreamId The highest stream ID the peer may have processed + * @returns {void} + */ + +/** + * Called when TLS key-log material is available. Only fires when + * `sessionOptions.keylog` is `true`. + * @callback OnKeylogCallback + * @this {QuicSession} + * @param {string} line A single NSS Key Log Format line, including trailing newline. + * @returns {void} + */ + +/** + * Called when qlog diagnostic data is available. Only fires when + * `sessionOptions.qlog` is `true`. + * @callback OnQlogCallback + * @this {QuicSession} + * @param {string} data A chunk of JSON-SEQ formatted qlog data + * @param {boolean} fin `true` if this is the final qlog chunk for the session. + * @returns {void} + */ + /** * @callback OnBlockedCallback * @this {QuicStream} @@ -326,51 +608,38 @@ const onSessionHandshakeChannel = dc.channel('quic.session.handshake'); */ /** + * Called when initial request or response headers are received. * @callback OnHeadersCallback * @this {QuicStream} - * @param {object} headers - * @param {string} kind + * @param {object} headers Header object with lowercase string keys and + * string or string-array values. * @returns {void} */ /** + * Called when trailing headers are received from the peer. * @callback OnTrailersCallback * @this {QuicStream} + * @param {object} trailers Trailing header object. * @returns {void} */ /** - * Provides the callback configuration for the Endpoint|undefined. - * @typedef {object} EndpointOptions - * @property {SocketAddress | string} [address] The local address to bind to - * @property {bigint|number} [retryTokenExpiration] The retry token expiration - * @property {bigint|number} [tokenExpiration] The token expiration - * @property {bigint|number} [maxConnectionsPerHost] The maximum number of connections per host - * @property {bigint|number} [maxConnectionsTotal] The maximum number of total connections - * @property {bigint|number} [maxStatelessResetsPerHost] The maximum number of stateless resets per host - * @property {bigint|number} [addressLRUSize] The size of the address LRU cache - * @property {bigint|number} [maxRetries] The maximum number of retriesw - * @property {number} [rxDiagnosticLoss] The receive diagnostic loss probability (range 0.0-1.0) - * @property {number} [txDiagnosticLoss] The transmit diagnostic loss probability (range 0.0-1.0) - * @property {number} [udpReceiveBufferSize] The UDP receive buffer size - * @property {number} [udpSendBufferSize] The UDP send buffer size - * @property {number} [udpTTL] The UDP TTL - * @property {boolean} [validateAddress] Validate the address - * @property {boolean} [ipv6Only] Use IPv6 only - * @property {ArrayBufferView} [resetTokenSecret] The reset token secret - * @property {ArrayBufferView} [tokenSecret] The token secret + * Called when informational (1xx) headers are received from the server + * (e.g. 103 Early Hints). + * @callback OnInfoCallback + * @this {QuicStream} + * @param {object} headers Informational header object. + * @returns {void} */ /** - * @typedef {object} QuicSessionInfo - * @property {SocketAddress} local The local address - * @property {SocketAddress} remote The remote address - * @property {string} protocol The alpn protocol identifier negotiated for this session - * @property {string} servername The servername identifier for this session - * @property {string} cipher The cipher suite negotiated for this session - * @property {string} cipherVersion The version of the cipher suite negotiated for this session - * @property {string} [validationErrorReason] The reason the session failed validation (if any) - * @property {string} [validationErrorCode] The error code for the validation failure (if any) + * Called when the transport is ready to send trailers for this stream. + * The handler should call `stream.sendTrailers(...)` (or + * `stream.sendTrailers()` with previously-set trailers) to provide them. + * @callback OnWantTrailersCallback + * @this {QuicStream} + * @returns {void} */ setCallbacks({ @@ -409,13 +678,23 @@ setCallbacks({ this[kOwner][kFinishClose](errorType, code, reason); }, + /** + * Called when the peer sends a GOAWAY frame (HTTP/3 only). + * @param {bigint} lastStreamId The highest stream ID the peer may have + * processed. Streams above this ID were not processed and can be retried. + */ + onSessionGoaway(lastStreamId) { + debug('session goaway callback', lastStreamId); + this[kOwner][kGoaway](lastStreamId); + }, + /** * Called when a datagram is received on this session. * @param {Uint8Array} uint8Array * @param {boolean} early */ onSessionDatagram(uint8Array, early) { - debug('session datagram callback', uint8Array.byteLength, early); + debug('session datagram callback', TypedArrayPrototypeGetByteLength(uint8Array), early); this[kOwner][kDatagram](uint8Array, early); }, @@ -437,14 +716,20 @@ setCallbacks({ * @param {string} cipherVersion * @param {string} validationErrorReason * @param {number} validationErrorCode + * @param {boolean} earlyDataAttempted + * @param {boolean} earlyDataAccepted */ onSessionHandshake(servername, protocol, cipher, cipherVersion, validationErrorReason, - validationErrorCode) { + validationErrorCode, + earlyDataAttempted, + earlyDataAccepted) { debug('session handshake callback', servername, protocol, cipher, cipherVersion, - validationErrorReason, validationErrorCode); + validationErrorReason, validationErrorCode, + earlyDataAttempted, earlyDataAccepted); this[kOwner][kHandshake](servername, protocol, cipher, cipherVersion, - validationErrorReason, validationErrorCode); + validationErrorReason, validationErrorCode, + earlyDataAttempted, earlyDataAccepted); }, /** @@ -459,11 +744,8 @@ setCallbacks({ onSessionPathValidation(result, newLocalAddress, newRemoteAddress, oldLocalAddress, oldRemoteAddress, preferredAddress) { debug('session path validation callback', this[kOwner]); - this[kOwner][kPathValidation](result, - new InternalSocketAddress(newLocalAddress), - new InternalSocketAddress(newRemoteAddress), - new InternalSocketAddress(oldLocalAddress), - new InternalSocketAddress(oldRemoteAddress), + this[kOwner][kPathValidation](result, newLocalAddress, newRemoteAddress, + oldLocalAddress, oldRemoteAddress, preferredAddress); }, @@ -485,7 +767,26 @@ setCallbacks({ */ onSessionNewToken(token, address) { debug('session new token callback', this[kOwner]); - // TODO(@jasnell): Emit to JS for storage and future reconnection use + this[kOwner][kNewToken](token, address); + }, + + /** + * Called when the server rejects 0-RTT early data. All streams + * opened during the 0-RTT phase have been destroyed. The + * application should re-open streams if needed. + */ + onSessionEarlyDataRejected() { + debug('session early data rejected callback', this[kOwner]); + this[kOwner][kEarlyDataRejected](); + }, + + /** + * Called when the session receives an ORIGIN frame from the peer (RFC 9412). + * @param {string[]} origins The list of origins the peer claims authority for + */ + onSessionOrigin(origins) { + debug('session origin callback', this[kOwner]); + this[kOwner][kOrigin](origins); }, /** @@ -504,6 +805,23 @@ setCallbacks({ // session will be destroyed. }, + onSessionKeyLog(line) { + debug('session key log callback', line, this[kOwner]); + this[kOwner][kKeylog](line); + }, + + onSessionQlog(data, fin) { + if (this[kOwner] === undefined) { + // Qlog data can arrive during ngtcp2_conn creation, before the + // QuicSession JS wrapper exists. Cache until the wrapper is ready. + this._pendingQlog ??= []; + this._pendingQlog.push(data, fin); + return; + } + debug('session qlog callback', this[kOwner]); + this[kOwner][kQlog](data, fin); + }, + /** * Called when a new stream has been received for the session * @param {object} stream The QuicStream C++ handle @@ -527,14 +845,28 @@ setCallbacks({ this[kOwner][kBlocked](); }, + onStreamDrain() { + // Called when the stream's outbound buffer has capacity for more data. + debug('stream drain callback', this[kOwner]); + this[kOwner][kDrain](); + }, + onStreamClose(error) { - // Called when the stream C++ handle has been closed. + // Called when the stream C++ handle has been closed. The error is + // either undefined (clean close) or a raw array [type, code, reason] + // from QuicError::ToV8Value. Convert to a proper Node.js Error. + if (error !== undefined) { + error = convertQuicError(error); + } debug(`stream ${this[kOwner].id} closed callback with error: ${error}`); this[kOwner][kFinishClose](error); }, onStreamReset(error) { // Called when the stream C++ handle has received a stream reset. + if (error !== undefined) { + error = convertQuicError(error); + } debug('stream reset callback', this[kOwner], error); this[kOwner][kReset](error); }, @@ -552,124 +884,656 @@ setCallbacks({ }, }); +// QUIC error codes are 62-bit varints (RFC 9000 section 16). The +// maximum representable code is 2**62 - 1. +const kMaxQuicErrorCode = (1n << 62n) - 1n; + +/** + * An Error subclass that carries an explicit numeric QUIC error code. + * Use this when destroying a stream or aborting an outbound writer to + * communicate a specific application-protocol-defined error code to + * the peer. When a `QuicError` is supplied, the QUIC stack uses + * `errorCode` as the wire code for the resulting RESET_STREAM / + * STOP_SENDING / CONNECTION_CLOSE frame; otherwise the negotiated + * application's "internal error" code is used (see + * `QuicSessionState.internalErrorCode`). + * + * The Node.js error code (`error.code`) defaults to + * `'ERR_QUIC_STREAM_ABORTED'` but can be overridden via + * `options.code`. The numeric QUIC code lives on the separate + * `errorCode` property to avoid colliding with Node.js's convention + * that `error.code` is a string. + */ +class QuicError extends Error { + /** @type {bigint} */ + #errorCode; + /** @type {'transport' | 'application'} */ + #type; + + /** + * @param {string} message + * @param {object} options + * @param {bigint|number} options.errorCode The numeric QUIC error + * code. Numbers are coerced to BigInt. Must be a non-negative + * 62-bit unsigned varint + * (`0n <= errorCode <= 2n ** 62n - 1n`). + * @param {string} [options.code] The Node.js-style error code + * string assigned to `error.code`. Defaults to + * `'ERR_QUIC_STREAM_ABORTED'`. + * @param {'transport'|'application'} [options.type] Whether the + * code is a transport-layer code (defined by RFC 9000) or an + * application-layer code (defined by the negotiated ALPN, e.g. + * RFC 9114 for HTTP/3). Defaults to `'application'`. Stream + * resets always carry application codes; this option is exposed + * for use sites that may target either layer. + */ + constructor(message, options = kEmptyObject) { + validateString(message, 'message'); + validateObject(options, 'options'); + const { + errorCode, + code = 'ERR_QUIC_STREAM_ABORTED', + type = 'application', + } = options; + if (errorCode === undefined) { + throw new ERR_MISSING_ARGS('options.errorCode'); + } + if (typeof errorCode !== 'bigint' && typeof errorCode !== 'number') { + throw new ERR_INVALID_ARG_TYPE('options.errorCode', + ['bigint', 'number'], errorCode); + } + validateString(code, 'options.code'); + validateOneOf(type, 'options.type', ['transport', 'application']); + const numericCode = BigInt(errorCode); + if (numericCode < 0n || numericCode > kMaxQuicErrorCode) { + throw new ERR_OUT_OF_RANGE('options.errorCode', + `>= 0 and <= ${kMaxQuicErrorCode}`, + errorCode); + } + super(message); + this.code = code; + this.#errorCode = numericCode; + this.#type = type; + } + + /** @type {bigint} */ + get errorCode() { + return this.#errorCode; + } + + /** @type {'transport' | 'application'} */ + get type() { + return this.#type; + } +} + +// Converts a raw QuicError array [type, code, reason] from C++ into a +// proper Node.js Error object. +function convertQuicError(error) { + const type = error[0]; + const code = error[1]; + const reason = error[2]; + switch (type) { + case 'transport': + return new ERR_QUIC_TRANSPORT_ERROR(code, reason); + case 'application': + return new ERR_QUIC_APPLICATION_ERROR(code, reason); + case 'version_negotiation': + return new ERR_QUIC_VERSION_NEGOTIATION_ERROR(); + default: + return new ERR_QUIC_TRANSPORT_ERROR(code, reason); + } +} + +// Convert a JavaScript error into close options suitable for +// `session.close()` / `session.destroy(error, options)`. The returned +// shape is `{ code, type, reason }` matching what `validateCloseOptions` +// expects (and what the native side reads via `MaybeSetCloseError`). +// +// Used so that destroying a session with an error actually emits a +// CONNECTION_CLOSE frame on the wire, instead of dropping the connection +// silently and leaving the peer waiting on its idle timer. +// +// Returns `undefined` when no error was supplied (caller falls back to +// a clean / silent close). +function errorToCloseOptions(error) { + if (error === undefined || error === null) return undefined; + // Generic mapping for now: any error becomes a transport-level + // INTERNAL_ERROR (NGTCP2_INTERNAL_ERROR == 0x1) with the original + // error message used as the human-readable reason. Future work could + // detect specific `ERR_QUIC_*` subclasses and round-trip their + // original code/type back onto the wire. + const reason = typeof error === 'object' && error !== null && error.message ? + `${error.message}` : + `${error}`; + return { code: 0x1n, type: 'transport', reason }; +} + +/** + * Safely invoke a user-supplied callback. If the callback throws + * synchronously, the owning object is destroyed with the error. If the + * callback returns a promise that rejects, the rejection is caught and the + * owning object is destroyed. Sync callbacks that do not throw incur no + * promise allocation overhead. + * @param {Function} fn The callback to invoke. + * @param {object} owner The QuicSession or QuicStream that owns the callback. + * @param {...any} args Arguments forwarded to the callback. + */ +function safeCallbackInvoke(fn, owner, ...args) { + try { + const result = fn(...args, owner); + if (isPromise(result)) { + // Block body - do NOT return the result of `owner.destroy(err)`. + // For some owners (e.g. `QuicEndpoint`), `destroy(err)` returns the + // owner's `closed` promise which itself eventually rejects with + // the same error. If we let that propagate through the `.then()` + // chain promise, nobody is awaiting that chain and we surface the + // rejection as unhandled. + PromisePrototypeThen(result, undefined, (err) => { + owner.destroy(err); + }); + } + } catch (err) { + owner.destroy(err); + } +} + +/** + * Invoke an onerror callback. If the callback itself throws synchronously + * or returns a promise that rejects, a SuppressedError wrapping both the + * onerror failure and the original error is surfaced as an uncaught exception. + * @param {Function} fn The onerror callback. + * @param {any} error The original error that triggered destruction. + */ +function invokeOnerror(fn, error) { + try { + const result = fn(error); + if (isPromise(result)) { + PromisePrototypeThen(result, undefined, (err) => { + process.nextTick(() => { + // eslint-disable-next-line no-restricted-syntax + throw new SuppressedError(err, error, err?.message); + }); + }); + } + } catch (err) { + process.nextTick(() => { + // eslint-disable-next-line no-restricted-syntax + throw new SuppressedError(err, error, err?.message); + }); + } +} + function validateBody(body) { - // TODO(@jasnell): Support streaming sources if (body === undefined) return body; - // Transfer ArrayBuffers... - if (isArrayBuffer(body)) { - return ArrayBufferPrototypeTransfer(body); - } - // With a SharedArrayBuffer, we always copy. We cannot transfer - // and it's likely unsafe to use the underlying buffer directly. - if (isSharedArrayBuffer(body)) { - return new Uint8Array(body).slice(); - } - if (isArrayBufferView(body)) { - const size = body.byteLength; - const offset = body.byteOffset; - // We have to be careful in this case. If the ArrayBufferView is a - // subset of the underlying ArrayBuffer, transferring the entire - // ArrayBuffer could be incorrect if other views are also using it. - // So if offset > 0 or size != buffer.byteLength, we'll copy the - // subset into a new ArrayBuffer instead of transferring. - if (isSharedArrayBuffer(body.buffer) || - offset !== 0 || size !== body.buffer.byteLength) { - return new Uint8Array(body, offset, size).slice(); - } - // It's still possible that the ArrayBuffer is being used elsewhere, - // but we really have no way of knowing. We'll just have to trust - // the caller in this case. - return new Uint8Array(ArrayBufferPrototypeTransfer(body.buffer), offset, size); + // ArrayBuffers, SharedArrayBuffers, and ArrayBufferViews are passed + // through to the C++ layer which copies the bytes into its own + // BackingStore. Callers can therefore safely reuse or mutate their + // input buffers after the call returns. Callers that want to ensure + // their buffer cannot be mutated after handing it off (for example, + // when sharing the source with another async consumer) can call + // ArrayBuffer.prototype.transfer() themselves before passing the + // buffer. + if (isArrayBuffer(body) || + isSharedArrayBuffer(body) || + isArrayBufferView(body)) { + return body; } if (isBlob(body)) return body[kBlobHandle]; + // Strings are encoded as UTF-8. + if (typeof body === 'string') { + return Buffer.from(body, 'utf8'); + } + + // FileHandle -- lock it and pass the C++ handle to GetDataQueueFromSource + // which creates an fd-backed DataQueue entry from the file path. + if (body instanceof FileHandle) { + if (body[kFileLocked]) { + throw new ERR_INVALID_STATE('FileHandle is locked'); + } + body[kFileLocked] = true; + return body[kFileHandle]; + } + throw new ERR_INVALID_ARG_TYPE('options.body', [ + 'string', 'ArrayBuffer', 'ArrayBufferView', 'Blob', + 'FileHandle', ], body); } -// Functions used specifically for internal testing purposes only. -let getQuicStreamState; -let getQuicSessionState; -let getQuicEndpointState; - -class QuicStream { - /** @type {object} */ - #handle; - /** @type {QuicSession} */ - #session; - /** @type {QuicStreamStats} */ - #stats; - /** @type {QuicStreamState} */ - #state; - /** @type {number} */ - #direction = undefined; - /** @type {OnBlockedCallback|undefined} */ - #onblocked = undefined; - /** @type {OnStreamErrorCallback|undefined} */ - #onreset = undefined; - /** @type {OnHeadersCallback|undefined} */ - #onheaders = undefined; - /** @type {OnTrailersCallback|undefined} */ - #ontrailers = undefined; - /** @type {Promise} */ - #pendingClose = Promise.withResolvers(); // eslint-disable-line node-core/prefer-primordials - #reader; - /** @type {ReadableStream} */ - #readable; +/** + * Parses an alternating [name, value, name, value, ...] array from C++ + * into a plain header object. Multi-value headers become arrays. + * @param {string[]} pairs + * @returns {object} + */ +function parseHeaderPairs(pairs) { + assert(ArrayIsArray(pairs)); + assert(pairs.length % 2 === 0); + const block = { __proto__: null }; + for (let n = 0; n + 1 < pairs.length; n += 2) { + if (block[pairs[n]] !== undefined) { + if (ArrayIsArray(block[pairs[n]])) { + ArrayPrototypePush(block[pairs[n]], pairs[n + 1]); + } else { + block[pairs[n]] = [block[pairs[n]], pairs[n + 1]]; + } + } else { + block[pairs[n]] = pairs[n + 1]; + } + } + return block; +} - static { - getQuicStreamState = function(stream) { - QuicStream.#assertIsQuicStream(stream); - return stream.#state; +/** + * Applies session and stream callbacks from an options object to a session. + * @param {QuicSession} session + * @param {object} cbs + */ +function applyCallbacks(session, cbs) { + if (cbs.onerror) session.onerror = cbs.onerror; + if (cbs.onstream) session.onstream = cbs.onstream; + if (cbs.ondatagram) session.ondatagram = cbs.ondatagram; + if (cbs.ondatagramstatus) session.ondatagramstatus = cbs.ondatagramstatus; + if (cbs.onpathvalidation) session.onpathvalidation = cbs.onpathvalidation; + if (cbs.onsessionticket) session.onsessionticket = cbs.onsessionticket; + if (cbs.onversionnegotiation) session.onversionnegotiation = cbs.onversionnegotiation; + if (cbs.onhandshake) session.onhandshake = cbs.onhandshake; + if (cbs.onnewtoken) session.onnewtoken = cbs.onnewtoken; + if (cbs.onearlyrejected) session.onearlyrejected = cbs.onearlyrejected; + if (cbs.onorigin) session.onorigin = cbs.onorigin; + if (cbs.ongoaway) session.ongoaway = cbs.ongoaway; + if (cbs.onkeylog) session.onkeylog = cbs.onkeylog; + if (cbs.onqlog) session.onqlog = cbs.onqlog; + if (cbs.onheaders || cbs.ontrailers || cbs.oninfo || cbs.onwanttrailers) { + session[kStreamCallbacks] = { + __proto__: null, + onheaders: cbs.onheaders, + ontrailers: cbs.ontrailers, + oninfo: cbs.oninfo, + onwanttrailers: cbs.onwanttrailers, }; } +} - static #assertIsQuicStream(val) { - if (val == null || !(#handle in val)) { - throw new ERR_INVALID_THIS('QuicStream'); - } +/** + * Configures the outbound data source for a stream. Detects the source + * type and calls the appropriate C++ method. + * @param {object} handle The C++ stream handle + * @param {QuicStream} stream The JS stream object + * @param {*} body The body source + */ +const kDefaultHighWaterMark = 65536; +const kDefaultMaxPendingDatagrams = 128; + +function configureOutbound(handle, stream, body) { + // body: null - close writable side immediately (FIN) + if (body === null) { + handle.initStreamingSource(); + handle.endWrite(); + return; } - /** - * @param {symbol} privateSymbol - * @param {object} handle - * @param {QuicSession} session - * @param {number} direction - */ - constructor(privateSymbol, handle, session, direction) { - if (privateSymbol !== kPrivateConstructor) { - throw new ERR_ILLEGAL_CONSTRUCTOR(); - } + // Handle Promise - await and recurse. Native promises auto-flatten, + // so the resolved value will never itself be a promise. + if (isPromise(body)) { + PromisePrototypeThen( + body, + (resolved) => configureOutbound(handle, stream, resolved), + (err) => { + if (!stream.destroyed) { + stream.destroy(err); + } + }, + ); + return; + } - this.#handle = handle; - this.#handle[kOwner] = this; - this.#session = session; - this.#direction = direction; - this.#stats = new QuicStreamStats(kPrivateConstructor, this.#handle.stats); - this.#state = new QuicStreamState(kPrivateConstructor, this.#handle.state); - this.#reader = this.#handle.getReader(); + // Tier: One-shot - string (checked before sync iterable since + // strings are iterable but we want the one-shot path). + // Buffer.from may return a pooled buffer whose ArrayBuffer cannot + // be transferred, so run it through validateBody which copies when + // the buffer is a partial view of a larger ArrayBuffer. + if (typeof body === 'string') { + handle.attachSource(validateBody(Buffer.from(body, 'utf8'))); + return; + } - if (this.pending) { - debug(`pending ${this.direction} stream created`); - } else { - debug(`${this.direction} stream ${this.id} created`); + // Tier: One-shot - FileHandle. The C++ layer creates an fd-backed + // DataQueue entry from the file path. The FileHandle is locked to + // prevent concurrent use and closed automatically when the stream + // finishes. + if (body instanceof FileHandle) { + if (body[kFileLocked]) { + throw new ERR_INVALID_STATE('FileHandle is locked'); } + body[kFileLocked] = true; + handle.attachSource(body[kFileHandle]); + return; } - /** - * Returns a ReadableStream to consume incoming data on the stream. - * @type {ReadableStream} - */ - get readable() { + // Tier: One-shot - ArrayBuffer, SharedArrayBuffer, TypedArray, + // DataView, Blob. validateBody handles transfer-vs-copy logic, + // SharedArrayBuffer copying, and partial view safety. + if (isArrayBuffer(body) || isSharedArrayBuffer(body) || + isArrayBufferView(body) || isBlob(body)) { + handle.attachSource(validateBody(body)); + return; + } + + // Tier: Streaming - AsyncIterable (ReadableStream, stream.Readable, + // async generators, etc.). Checked before sync iterable because some + // objects implement both protocols and we prefer async. + if (isAsyncIterable(body)) { + consumeAsyncSource(handle, stream, body); + return; + } + + // Tier: Sync iterable - consumed synchronously + if (isSyncIterable(body)) { + consumeSyncSource(handle, stream, body); + return; + } + + throw new ERR_INVALID_ARG_TYPE( + 'body', + ['string', 'ArrayBuffer', 'SharedArrayBuffer', 'TypedArray', + 'Blob', 'Iterable', 'AsyncIterable', 'Promise', 'null'], + body, + ); +} + +// Sets the high water mark and initial writeDesiredSize for a streaming +// outbound source. Called after handle.initStreamingSource() for both +// body-source and writer paths. One-shot body sources (string, Uint8Array, +// Blob, FileHandle, etc.) do not use this -- they go through attachSource +// and are not subject to backpressure. +function initStreamingBackpressure(stream) { + const state = getQuicStreamState(stream); + // Only set defaults if the user hasn't already configured them + // (e.g., via createBidirectionalStream({ highWaterMark: N })). + if (state.highWaterMark === 0) { + state.highWaterMark = kDefaultHighWaterMark; + } + if (state.writeDesiredSize === 0) { + state.writeDesiredSize = state.highWaterMark; + } +} + +// Waits for the stream's drain callback to fire, indicating the +// outbound has capacity for more data. +function waitForDrain(stream) { + const { promise, resolve } = PromiseWithResolvers(); + const prevDrain = stream[kDrain]; + stream[kDrain] = () => { + stream[kDrain] = prevDrain; + resolve(); + }; + return promise; +} + +// Writes a batch to the handle, awaiting drain if backpressured. +// Returns true if the stream was destroyed during the wait. +// Checks writeDesiredSize before writing to enforce backpressure +// against the outbound DataQueue's uncommitted bytes. +async function writeBatchWithDrain(handle, stream, batch) { + const state = getQuicStreamState(stream); + + // Calculate total batch size for the capacity check. + let len = 0; + for (const chunk of batch) len += TypedArrayPrototypeGetByteLength(chunk); + + // If insufficient capacity, wait for the C++ drain signal which + // fires when writeDesiredSize transitions from 0 to > 0 (i.e., + // ngtcp2 has consumed data from the outbound DataQueue). + if (len > state.writeDesiredSize) { + await waitForDrain(stream); + if (stream.destroyed) return true; + } + + // Write the batch. The return value is the total queued byte count + // on success, or undefined on failure (e.g., DataQueue append + // rejected). Guard against silent data loss. + const result = handle.write(batch); + if (result === undefined) { + if (!stream.destroyed) { + stream.destroy(new ERR_INVALID_STATE('Stream write failed')); + } + return true; + } + return false; +} + +async function consumeAsyncSource(handle, stream, source) { + handle.initStreamingSource(); + initStreamingBackpressure(stream); + try { + // Normalize to AsyncIterable + const normalized = streamFrom(source); + for await (const batch of normalized) { + if (stream.destroyed) return; + if (await writeBatchWithDrain(handle, stream, batch)) return; + } + handle.endWrite(); + } catch (err) { + if (!stream.destroyed) { + stream.destroy(err); + } else { + throw err; + } + } +} + +async function consumeSyncSource(handle, stream, source) { + handle.initStreamingSource(); + initStreamingBackpressure(stream); + // Normalize to Iterable. Manually iterate so we can + // pause between next() calls when backpressure hits. + const normalized = streamFromSync(source); + const iter = normalized[SymbolIterator](); + try { + while (true) { + if (stream.destroyed) return; + const { value: batch, done } = iter.next(); + if (done) break; + if (await writeBatchWithDrain(handle, stream, batch)) return; + } + handle.endWrite(); + } catch (err) { + if (!stream.destroyed) { + stream.destroy(err); + } else { + // If the stream is already destroyed, rethrow the error to avoid + // silently swallowing it. Tho in practice this shouldn't happen. + throw err; + } + } +} + +function isAsyncIterable(obj) { + return obj != null && typeof obj[SymbolAsyncIterator] === 'function'; +} + +function isSyncIterable(obj) { + return obj != null && typeof obj[SymbolIterator] === 'function'; +} + +// Functions used specifically for internal or assertion purposes only. +let getQuicStreamState; +let getQuicSessionState; +let getQuicEndpointState; +let assertIsQuicEndpoint; +let assertEndpointNotClosedOrClosing; +let assertEndpointIsNotBusy; + +function maybeGetCloseError(context, status, pendingError) { + switch (context) { + case kCloseContextClose: { + return pendingError; + } + case kCloseContextBindFailure: { + return new ERR_QUIC_ENDPOINT_CLOSED('Bind failure', status); + } + case kCloseContextListenFailure: { + return new ERR_QUIC_ENDPOINT_CLOSED('Listen failure', status); + } + case kCloseContextReceiveFailure: { + return new ERR_QUIC_ENDPOINT_CLOSED('Receive failure', status); + } + case kCloseContextSendFailure: { + return new ERR_QUIC_ENDPOINT_CLOSED('Send failure', status); + } + case kCloseContextStartFailure: { + return new ERR_QUIC_ENDPOINT_CLOSED('Start failure', status); + } + } + // Otherwise return undefined. +} + +class QuicStream { + /** @type {object} */ + #handle; + /** + * Flag set at the top of `destroy()` to make the method safely + * re-entrant. Distinct from `#handle === undefined` (which signals + * "fully destroyed" and is set inside `[kFinishClose]`) so that + * `[kFinishClose]`'s own destroyed-guard does not bail before the + * cleanup work runs. + * @type {boolean} + */ + #destroying = false; + /** @type {QuicSession} */ + #session; + /** @type {QuicStreamStats} */ + #stats; + /** @type {QuicStreamState} */ + #state; + /** @type {number} */ + #direction = undefined; + /** @type {Function|undefined} */ + #onerror = undefined; + /** @type {OnBlockedCallback|undefined} */ + #onblocked = undefined; + /** @type {OnStreamErrorCallback|undefined} */ + #onreset = undefined; + /** @type {Function|undefined} */ + #onheaders = undefined; + /** @type {Function|undefined} */ + #ontrailers = undefined; + /** @type {Function|undefined} */ + #oninfo = undefined; + /** @type {Function|undefined} */ + #onwanttrailers = undefined; + /** @type {object|undefined} */ + #headers = undefined; + /** @type {object|undefined} */ + #pendingTrailers = undefined; + /** @type {Promise} */ + #pendingClose = PromiseWithResolvers(); + #reader; + #iteratorLocked = false; + #writer = undefined; + #outboundSet = false; + /** @type {FileHandle|undefined} */ + #fileHandle = undefined; + + static { + getQuicStreamState = function(stream) { + QuicStream.#assertIsQuicStream(stream); + return stream.#state; + }; + } + + static #assertIsQuicStream(val) { + if (val == null || !(#handle in val)) { + throw new ERR_INVALID_THIS('QuicStream'); + } + } + + #assertHeadersSupported() { + if (getQuicSessionState(this.#session).headersSupported === 2) { + throw new ERR_INVALID_STATE( + 'The negotiated QUIC application protocol does not support headers'); + } + } + + /** + * @param {symbol} privateSymbol + * @param {object} handle + * @param {QuicSession} session + * @param {number} direction + */ + constructor(privateSymbol, handle, session, direction) { + if (privateSymbol !== kPrivateConstructor) { + throw new ERR_ILLEGAL_CONSTRUCTOR(); + } + + this.#handle = handle; + this.#handle[kOwner] = this; + this.#session = session; + this.#direction = direction; + this.#stats = new QuicStreamStats(kPrivateConstructor, this.#handle.stats); + this.#state = new QuicStreamState(kPrivateConstructor, this.#handle.state); + this.#reader = this.#handle.getReader(); + + if (hasObserver('quic')) { + startPerf(this, kPerfEntry, { type: 'quic', name: 'QuicStream' }); + } + + if (this.pending) { + debug(`pending ${this.direction} stream created`); + } else { + debug(`${this.direction} stream ${this.id} created`); + } + } + + get [kValidatedSource]() { return true; } + + /** + * Returns an AsyncIterator that yields Uint8Array[] batches of + * incoming data. Only one iterator can be obtained per stream. + * Non-readable streams return an immediately-finished iterator. + * @yields {Uint8Array[]} + */ + async *[SymbolAsyncIterator]() { QuicStream.#assertIsQuicStream(this); - if (this.#readable === undefined) { - assert(this.#reader); - this.#readable = createBlobReaderStream(this.#reader); + if (this.#iteratorLocked) { + throw new ERR_INVALID_STATE('Stream is already being read'); } - return this.#readable; + this.#iteratorLocked = true; + + // Non-readable stream (outbound-only unidirectional, or closed) + if (!this.#reader) return; + + yield* createBlobReaderIterable(this.#reader, { + getReadError: () => { + // The read side ends for one of three reasons: + // * Clean FIN received from the peer (state.finReceived + // === true). The iterator stops without calling this; + // fall through to the generic state error if it does. + // * Peer sent us a RESET_STREAM. The C++ side records the + // code in state.resetCode regardless of whether the JS + // onreset handler was attached. state.finReceived stays + // false because no FIN was seen. + // * We aborted locally via stream.resetStream() or + // stream.stopSending(). Both paths run EndReadable in + // C++, setting state.readEnded without setting + // state.finReceived. There is no peer code to surface. + if (this.#state.readEnded && !this.#state.finReceived) { + const peerResetCode = this.#state.resetCode; + if (peerResetCode !== undefined && peerResetCode > 0n) { + return new ERR_QUIC_STREAM_RESET(Number(peerResetCode)); + } + return new ERR_QUIC_STREAM_ABORTED( + 'Stream aborted before FIN was received'); + } + return new ERR_INVALID_STATE('The stream is not readable'); + }, + }); } /** @@ -682,6 +1546,56 @@ class QuicStream { return this.#state.pending; } + /** + * True if any data on this stream was received as 0-RTT (early data) + * before the TLS handshake completed. Early data is less secure and + * could be replayed by an attacker. + * @type {boolean} + */ + get early() { + QuicStream.#assertIsQuicStream(this); + return this.#state.early; + } + + /** + * The high water mark for write backpressure. When the total queued + * outbound bytes exceeds this value, writeSync returns false and + * desiredSize drops to 0. Default is 65536 (64KB). + * @type {number} + */ + get highWaterMark() { + QuicStream.#assertIsQuicStream(this); + return this.#state.highWaterMark; + } + + set highWaterMark(val) { + QuicStream.#assertIsQuicStream(this); + validateInteger(val, 'highWaterMark', 0, 0xFFFFFFFF); + this.#state.highWaterMark = val; + // If writeDesiredSize hasn't been set yet (still 0 from initialization), + // initialize it to the highWaterMark so the first write can proceed. + if (this.#state.writeDesiredSize === 0 && val > 0) { + this.#state.writeDesiredSize = val; + } + } + + /** @type {Function|undefined} */ + get onerror() { + QuicStream.#assertIsQuicStream(this); + return this.#onerror; + } + + set onerror(fn) { + QuicStream.#assertIsQuicStream(this); + if (fn === undefined) { + this.#onerror = undefined; + } else { + validateFunction(fn, 'onerror'); + this.#onerror = FunctionPrototypeBind(fn, this); + markPromiseAsHandled(this.#pendingClose.promise); + } + } + /** @type {OnBlockedCallback} */ get onblocked() { QuicStream.#assertIsQuicStream(this); @@ -695,7 +1609,7 @@ class QuicStream { this.#state.wantsBlock = false; } else { validateFunction(fn, 'onblocked'); - this.#onblocked = fn.bind(this); + this.#onblocked = FunctionPrototypeBind(fn, this); this.#state.wantsBlock = true; } } @@ -713,41 +1627,117 @@ class QuicStream { this.#state.wantsReset = false; } else { validateFunction(fn, 'onreset'); - this.#onreset = fn.bind(this); + this.#onreset = FunctionPrototypeBind(fn, this); this.#state.wantsReset = true; } } /** @type {OnHeadersCallback} */ - get [kOnHeaders]() { + get onheaders() { + QuicStream.#assertIsQuicStream(this); return this.#onheaders; } - set [kOnHeaders](fn) { + set onheaders(fn) { + QuicStream.#assertIsQuicStream(this); if (fn === undefined) { this.#onheaders = undefined; this.#state[kWantsHeaders] = false; } else { + this.#assertHeadersSupported(); validateFunction(fn, 'onheaders'); - this.#onheaders = fn.bind(this); + this.#onheaders = FunctionPrototypeBind(fn, this); this.#state[kWantsHeaders] = true; } } - /** @type {OnTrailersCallback} */ - get [kOnTrailers]() { return this.#ontrailers; } + /** @type {Function|undefined} */ + get oninfo() { + QuicStream.#assertIsQuicStream(this); + return this.#oninfo; + } - set [kOnTrailers](fn) { + set oninfo(fn) { + QuicStream.#assertIsQuicStream(this); + if (fn === undefined) { + this.#oninfo = undefined; + } else { + this.#assertHeadersSupported(); + validateFunction(fn, 'oninfo'); + this.#oninfo = FunctionPrototypeBind(fn, this); + } + } + + /** @type {Function|undefined} */ + get ontrailers() { + QuicStream.#assertIsQuicStream(this); + return this.#ontrailers; + } + + set ontrailers(fn) { + QuicStream.#assertIsQuicStream(this); if (fn === undefined) { this.#ontrailers = undefined; - this.#state[kWantsTrailers] = false; } else { + this.#assertHeadersSupported(); validateFunction(fn, 'ontrailers'); - this.#ontrailers = fn.bind(this); + this.#ontrailers = FunctionPrototypeBind(fn, this); + } + } + + /** @type {Function|undefined} */ + get onwanttrailers() { + QuicStream.#assertIsQuicStream(this); + return this.#onwanttrailers; + } + + set onwanttrailers(fn) { + QuicStream.#assertIsQuicStream(this); + if (fn === undefined) { + this.#onwanttrailers = undefined; + this.#state[kWantsTrailers] = false; + } else { + this.#assertHeadersSupported(); + validateFunction(fn, 'onwanttrailers'); + this.#onwanttrailers = FunctionPrototypeBind(fn, this); this.#state[kWantsTrailers] = true; } } + /** + * The buffered initial headers received on this stream, or undefined + * if the application does not support headers or no headers have + * been received yet. + * @type {object|undefined} + */ + get headers() { + QuicStream.#assertIsQuicStream(this); + return this.#headers; + } + + /** + * Set trailing headers to be sent when nghttp3 asks for them. + * @type {object|undefined} + */ + get pendingTrailers() { + QuicStream.#assertIsQuicStream(this); + return this.#pendingTrailers; + } + + set pendingTrailers(headers) { + QuicStream.#assertIsQuicStream(this); + if (headers === undefined) { + this.#pendingTrailers = undefined; + return; + } + if (getQuicSessionState(this.#session).headersSupported === 2) { + throw new ERR_INVALID_STATE( + 'The negotiated QUIC application protocol does not support headers'); + } + validateObject(headers, 'headers'); + this.#pendingTrailers = headers; + } + /** * The statistics collected for this stream. * @type {QuicStreamStats} @@ -792,7 +1782,7 @@ class QuicStream { /** * True if the stream has been destroyed. - * @returns {boolean} + * @type {boolean} */ get destroyed() { QuicStream.#assertIsQuicStream(this); @@ -809,14 +1799,103 @@ class QuicStream { } /** - * Immediately destroys the stream. Any queued data is discarded. If an - * error is given, the closed promise will be rejected with that error. - * If no error is given, the closed promise will be resolved. + * Immediately destroys the stream. Any queued data is discarded. If + * an error is given, the closed promise will be rejected with that + * error. If no error is given, the closed promise will be resolved. + * When destroying with an error, RESET_STREAM and/or STOP_SENDING + * are emitted to the peer for any still-open writable / readable + * side of the stream. The wire code is resolved as: + * `options.code` -> `error.errorCode` (when `error` is a + * `QuicError`) -> the negotiated application's "internal error" + * code from `QuicSessionState.internalErrorCode`. * @param {any} error + * @param {object} [options] + * @param {bigint|number} [options.code] An explicit application + * error code to send on the resulting `RESET_STREAM` / + * `STOP_SENDING` frames. Numbers are coerced to `BigInt`. When + * omitted, the code is derived from `error` per the precedence + * above. + * @param {string} [options.reason] Optional human-readable reason. + * Accepted for symmetry with `session.close()` / + * `session.destroy()`; QUIC `RESET_STREAM` and `STOP_SENDING` + * frames do not themselves carry a reason field over the wire. */ - destroy(error) { + destroy(error, options = kEmptyObject) { QuicStream.#assertIsQuicStream(this); - if (this.destroyed) return; + // Two distinct guards: + // * `#destroying` flips synchronously here so any re-entrant call + // from inside this method's user callbacks hits the guard and + // returns immediately. + // * `destroyed` (i.e. `#handle === undefined`) catches the case + // where the C++ side already finished cleanup via the + // `onStreamClose -> [kFinishClose]` path - which does NOT go + // through `destroy()` and therefore never sets `#destroying`. + // `[kFinishClose]` clears `#handle` at the end of its work. + if (this.#destroying || this.destroyed) return; + // Validate options up front so a malformed `options` argument + // throws before any side effects (mutating `#destroying`, + // emitting wire frames, invoking `onerror`, settling the closed + // promise). The caller may retry with valid options. + validateObject(options, 'options'); + const { code: optionCode, reason } = options; + if (optionCode !== undefined && + typeof optionCode !== 'bigint' && + typeof optionCode !== 'number') { + throw new ERR_INVALID_ARG_TYPE('options.code', + ['bigint', 'number'], optionCode); + } + if (reason !== undefined) { + validateString(reason, 'options.reason'); + } + this.#destroying = true; + // Resolve the wire error code for any RESET_STREAM / STOP_SENDING + // frames emitted below. + let abortCode; + if (optionCode !== undefined) { + abortCode = BigInt(optionCode); + } else if (error !== undefined) { + abortCode = error instanceof QuicError ? + error.errorCode : + getQuicSessionState(this.#session).internalErrorCode; + } + // When destroying with an error, ensure the peer stops sending + // data we are about to discard by emitting STOP_SENDING. The + // condition gates the emission to error-path destroys with a + // still-open readable side. Direction model for the readable + // side: + // * bidi: always has a readable side. + // * uni + #reader !== undefined: remote-initiated, read-only. + // * uni + #reader === undefined: locally-initiated, write-only; + // no readable side to stop. + if (abortCode !== undefined && + !this.#state.readEnded && + (this.#direction === kStreamDirectionBidirectional || + this.#reader !== undefined)) { + this.#handle.stopSending(abortCode); + } + // When destroying with an error, ensure the peer learns about + // it via RESET_STREAM. The writer.fail path inside [kFinishClose] + // emits RESET_STREAM only when a writer has been created; + // streams that destroy without ever accessing stream.writer + // (e.g. used setBody or never wrote at all) need an explicit + // RESET_STREAM here so the write side does not dangle on the + // wire. The condition gates the emission to error-path destroys + // with a still-open writable side. + // Direction model for the writable side: + // * bidi: always has a writable side. + // * uni + #reader === undefined: locally-initiated, write-only. + // * uni + #reader !== undefined: remote-initiated, read-only; + // no writable side to reset. + if (abortCode !== undefined && + this.#writer === undefined && + !this.#state.writeEnded && + (this.#direction === kStreamDirectionBidirectional || + this.#reader === undefined)) { + this.#handle.resetStream(abortCode); + } + if (error !== undefined && typeof this.#onerror === 'function') { + invokeOnerror(this.#onerror, error); + } const handle = this.#handle; this[kFinishClose](error); handle.destroy(); @@ -830,15 +1909,365 @@ class QuicStream { * be thrown. * @param {ArrayBuffer|SharedArrayBuffer|ArrayBufferView|Blob} outbound */ - setOutbound(outbound) { + setOutbound(outbound) { + QuicStream.#assertIsQuicStream(this); + if (this.destroyed) { + throw new ERR_INVALID_STATE('Stream is destroyed'); + } + if (this.#state.hasOutbound) { + throw new ERR_INVALID_STATE('Stream already has an outbound data source'); + } + this.#handle.attachSource(validateBody(outbound)); + } + + /** + * Send initial or response headers on this stream. Throws if the + * application does not support headers. + * @param {object} headers + * @param {{ terminal?: boolean }} [options] + * @returns {boolean} + */ + sendHeaders(headers, options = kEmptyObject) { + QuicStream.#assertIsQuicStream(this); + if (this.destroyed) return false; + if (getQuicSessionState(this.#session).headersSupported === 2) { + throw new ERR_INVALID_STATE( + 'The negotiated QUIC application protocol does not support headers'); + } + validateObject(headers, 'headers'); + const { terminal = false } = options; + const headerString = buildNgHeaderString( + headers, assertValidPseudoHeader, true); + const flags = terminal ? kHeadersFlagsTerminal : kHeadersFlagsNone; + return this.#handle.sendHeaders(kHeadersKindInitial, headerString, flags); + } + + /** + * Send informational (1xx) headers on this stream. Server only. + * Throws if the application does not support headers. + * @param {object} headers + * @returns {boolean} + */ + sendInformationalHeaders(headers) { + QuicStream.#assertIsQuicStream(this); + if (this.destroyed) return false; + if (getQuicSessionState(this.#session).headersSupported === 2) { + throw new ERR_INVALID_STATE( + 'The negotiated QUIC application protocol does not support headers'); + } + validateObject(headers, 'headers'); + const headerString = buildNgHeaderString( + headers, assertValidPseudoHeader, true); + return this.#handle.sendHeaders( + kHeadersKindHints, headerString, kHeadersFlagsNone); + } + + /** + * Send trailing headers on this stream. Must be called synchronously + * during the onwanttrailers callback, or set via pendingTrailers before + * the body completes. Throws if the application does not support headers. + * @param {object} headers + * @returns {boolean} + */ + sendTrailers(headers) { + QuicStream.#assertIsQuicStream(this); + if (this.destroyed) return false; + if (getQuicSessionState(this.#session).headersSupported === 2) { + throw new ERR_INVALID_STATE( + 'The negotiated QUIC application protocol does not support headers'); + } + validateObject(headers, 'headers'); + const headerString = buildNgHeaderString(headers); + return this.#handle.sendHeaders( + kHeadersKindTrailing, headerString, kHeadersFlagsNone); + } + + /** + * Returns a Writer for pushing data to this stream incrementally. + * Only available when no body source was provided at creation time + * or via setBody(). Non-writable streams return an already-closed Writer. + * @type {object} + */ + get writer() { + QuicStream.#assertIsQuicStream(this); + if (this.#writer !== undefined) return this.#writer; + if (this.#outboundSet) { + throw new ERR_INVALID_STATE( + 'Stream outbound already configured with a body source'); + } + + const handle = this.#handle; + const stream = this; + let closed = false; + let errored = false; + let error = null; + let totalBytesWritten = 0; + let drainWakeup = null; + + // Drain callback - C++ fires this when send buffer has space + stream[kDrain] = () => { + if (drainWakeup) { + drainWakeup.resolve(true); + drainWakeup = null; + } + }; + + // A note on backpressure handling: per the stream/iter spec, the default + // backpressure policy for writers is strict, meaning that if the stream + // signals backpressure additional writes are rejected until the buffer has + // capacity again. + + function writeSync(chunk) { + // If the stream is closed, errored, or write-ended, we cannot accept + // more data. Refuse the sync write. + // If a drain is already pending, another operation is waiting + // for capacity. Refuse the sync write. + if (closed || errored || stream.#state.writeEnded || drainWakeup != null) { + return false; + } + chunk = toUint8Array(chunk); + const len = TypedArrayPrototypeGetByteLength(chunk); + if (len === 0) return true; + // Refuse the write if the chunk doesn't fit in the available + // buffer capacity. The caller should wait for drain and retry. + if (len > stream.#state.writeDesiredSize) return false; + const result = handle.write([chunk]); + if (result === undefined) return false; + totalBytesWritten += len; + return true; + } + + async function write(chunk, options = kEmptyObject) { + validateObject(options, 'options'); + const { signal } = options; + if (signal !== undefined) { + validateAbortSignal(signal, 'options.signal'); + signal.throwIfAborted(); + } + if (errored) throw error; + if (closed || stream.#state.writeEnded) { + throw new ERR_INVALID_STATE('Writer is closed'); + } + // If a drain is already pending, another operation is waiting + // for capacity. Under strict policy, reject immediately. + // Later, if we add support for other backpressure policies, + // we could instead await the existing drain before proceeding. + if (drainWakeup != null) { + throw new ERR_INVALID_STATE('Stream write buffer is full'); + } + + if (!writeSync(chunk)) { + throw new ERR_INVALID_STATE('Stream write buffer is full'); + } + } + + function writevSync(chunks) { + if (closed || errored || stream.#state.writeEnded || drainWakeup != null) { + return false; + } + chunks = convertChunks(chunks); + let len = 0; + for (const c of chunks) len += TypedArrayPrototypeGetByteLength(c); + if (len === 0) return true; + if (len > stream.#state.writeDesiredSize) return false; + const result = handle.write(chunks); + if (result === undefined) return false; + totalBytesWritten += len; + return true; + } + + async function writev(chunks, options = kEmptyObject) { + validateObject(options, 'options'); + const { signal } = options; + if (signal !== undefined) { + validateAbortSignal(signal, 'options.signal'); + signal.throwIfAborted(); + } + + if (errored) throw error; + if (closed || stream.#state.writeEnded) { + throw new ERR_INVALID_STATE('Writer is closed'); + } + + // If a drain is already pending, another operation is waiting + // for capacity. Under strict policy, reject immediately. + // Later, if we add support for other backpressure policies, + // we could instead await the existing drain before proceeding. + if (drainWakeup != null) { + throw new ERR_INVALID_STATE('Stream write buffer is full'); + } + + if (!writevSync(chunks)) { + throw new ERR_INVALID_STATE('Stream write buffer is full'); + } + } + + function endSync() { + // Per the streams/iter spec, endSync and end follow a try-fallback + // pattern. That is, callers should try endSync first and if it returns + // -1, then they should call and await end(). This is a signal that sync + // end is not currently possible. However, we always support sync end + // here unless the stream is already errored. + if (errored) return -1; + + // If we're already closed, just return the total bytes written. + if (closed) return totalBytesWritten; + + // If we are waiting for drain to complete, we cannot end synchronously. + if (drainWakeup != null) return -1; + + // Fantastic, we can end synchronously! + handle.endWrite(); + closed = true; + return totalBytesWritten; + } + + async function end(options = kEmptyObject) { + validateObject(options, 'options'); + const { signal } = options; + if (signal !== undefined) { + validateAbortSignal(signal, 'options.signal'); + signal.throwIfAborted(); + // TODO(@jasnell): The stream/iter spec allows individual sync end + // calls to be canceled via an AbortSignal. We currently do not support + // this, but we can add before the impl is graduated from experimental. + // At most we do here is check for signal abort at the start of the call. + } + + // Per the streams/iter spec, endSync and end follow a try-fallback + // pattern. That is, callers should try endSync first and if it returns + // -1, then they should call and await end(). This is a signal that sync + // end is not currently possible. However, we always support sync end + // here unless the stream is already errored. + // While the user should have already called endSync, we call it again + // here to actually process the end request. At worst it's called twice. + const n = endSync(); + + // A return value of -1 indicates that endSync was not yet able to + // process the end request, either because we are errored or because we + // are awaiting drain. If we're errored, throw the error. If we're waiting + // for drain, await it and then try ending again. + + if (n >= 0) return n; + if (errored) throw error; + + drainWakeup ??= PromiseWithResolvers(); + try { + await drainWakeup.promise; + } finally { + drainWakeup = null; + } + return endSync(); + } + + function fail(reason) { + if (closed || errored) return; + errored = true; + error = reason ?? new ERR_INVALID_STATE('Failed'); + // `writer.fail()` is always an error path, so the wire code on + // RESET_STREAM must never be `0n` (which means "no error" in + // most application protocols). Resolve the code in priority + // order: + // 1. If `reason` is a `QuicError`, use its explicit + // `errorCode`. + // 2. Otherwise fall back to the negotiated application's + // "internal error" code, surfaced via + // `QuicSessionState.internalErrorCode`. For HTTP/3 this is + // `H3_INTERNAL_ERROR` (0x102); for raw QUIC applications + // it falls back to the QUIC transport-layer + // `INTERNAL_ERROR` (0x1). + const code = error instanceof QuicError ? + error.errorCode : + getQuicSessionState(stream.#session).internalErrorCode; + handle.resetStream(code); + if (drainWakeup != null) { + drainWakeup.reject(error); + drainWakeup = null; + } + } + + const writer = { + __proto__: null, + get desiredSize() { + if (closed || errored || stream.#state.writeEnded) return null; + return stream.#state.writeDesiredSize; + }, + writeSync, + write, + writevSync, + writev, + endSync, + end, + fail, + [drainableProtocol]() { + if (closed || errored) return null; + // If a drain is already pending, return the existing promise. + if (drainWakeup != null) return drainWakeup.promise; + if (stream.#state.writeDesiredSize > 0) return null; + drainWakeup = PromiseWithResolvers(); + return drainWakeup.promise; + }, + [SymbolAsyncDispose]() { + if (!closed && !errored) fail(); + return PromiseResolve(); + }, + [SymbolDispose]() { + if (!closed && !errored) fail(); + }, + }; + + // Non-writable stream - return a pre-closed writer. + // A readable unidirectional stream is a remote uni (read-only). + if (!handle || this.destroyed || this.#state.writeEnded || + (this.#direction === kStreamDirectionUnidirectional && + this.#reader !== undefined)) { + closed = true; + this.#writer = writer; + return this.#writer; + } + + // Initialize the outbound DataQueue for streaming writes + handle.initStreamingSource(); + initStreamingBackpressure(this); + + this.#writer = writer; + return this.#writer; + } + + /** + * Sets the outbound body source for this stream. Accepts all body + * source types (string, TypedArray, Blob, AsyncIterable, Promise, null). + * Can only be called once. Mutually exclusive with stream.writer. + * @param {*} body + */ + setBody(body) { QuicStream.#assertIsQuicStream(this); if (this.destroyed) { throw new ERR_INVALID_STATE('Stream is destroyed'); } - if (this.#state.hasOutbound) { - throw new ERR_INVALID_STATE('Stream already has an outbound data source'); + if (this.#outboundSet) { + throw new ERR_INVALID_STATE('Stream outbound already configured'); } - this.#handle.attachSource(validateBody(outbound)); + if (this.#writer !== undefined) { + throw new ERR_INVALID_STATE('Stream writer already accessed'); + } + this.#outboundSet = true; + // If the body is a FileHandle, store it so it is closed + // automatically when the stream finishes. + if (body instanceof FileHandle) { + this.#fileHandle = body; + } + configureOutbound(this.#handle, this, body); + } + + /** + * Associates a FileHandle with this stream so it is closed automatically + * when the stream finishes. Called internally when a FileHandle is used + * as a body source. + * @param {FileHandle} fh + */ + [kAttachFileHandle](fh) { + this.#fileHandle = fh; } /** @@ -871,24 +2300,42 @@ class QuicStream { * The priority of the stream. If the stream is destroyed or if * the session does not support priority, `null` will be * returned. - * @type {'default' | 'low' | 'high' | null} + * @type {{ level: 'default' | 'low' | 'high', incremental: boolean } | null} */ get priority() { QuicStream.#assertIsQuicStream(this); - if (this.destroyed || !this.session.state.isPrioritySupported) return null; - const priority = this.#handle.getPriority(); - return priority < 3 ? 'high' : priority > 3 ? 'low' : 'default'; + if (this.destroyed || + !getQuicSessionState(this.#session).isPrioritySupported) return null; + const packed = this.#handle.getPriority(); + const urgency = packed >> 1; + const incremental = !!(packed & 1); + const level = urgency < 3 ? 'high' : urgency > 3 ? 'low' : 'default'; + return { level, incremental }; } - set priority(val) { + /** + * Sets the priority of the stream. + * @param {{ + * level?: 'default' | 'low' | 'high', + * incremental?: boolean, + * }} options + */ + setPriority(options = kEmptyObject) { QuicStream.#assertIsQuicStream(this); - if (this.destroyed || !this.session.state.isPrioritySupported) return; - validateOneOf(val, 'priority', ['default', 'low', 'high']); - switch (val) { - case 'default': this.#handle.setPriority(3, 1); break; - case 'low': this.#handle.setPriority(7, 1); break; - case 'high': this.#handle.setPriority(0, 1); break; + if (this.destroyed) return; + if (!getQuicSessionState(this.#session).isPrioritySupported) { + throw new ERR_INVALID_STATE( + 'The session does not support stream priority'); } + validateObject(options, 'options'); + const { + level = 'default', + incremental = false, + } = options; + validateOneOf(level, 'options.level', ['default', 'low', 'high']); + validateBoolean(incremental, 'options.incremental'); + const urgency = level === 'high' ? 0 : level === 'low' ? 7 : 3; + this.#handle.setPriority((urgency << 1) | (incremental ? 1 : 0)); } /** @@ -903,8 +2350,13 @@ class QuicStream { * @param {object} headers * @returns {boolean} true if the headers were scheduled to be sent. */ - [kSendHeaders](headers) { + [kSendHeaders](headers, kind = kHeadersKindInitial, + flags = kHeadersFlagsTerminal) { validateObject(headers, 'headers'); + if (getQuicSessionState(this.#session).headersSupported === 2) { + throw new ERR_INVALID_STATE( + 'The negotiated QUIC application protocol does not support headers'); + } if (this.pending) { debug('pending stream enqueuing headers', headers); } else { @@ -915,8 +2367,7 @@ class QuicStream { assertValidPseudoHeader, true, // This could become an option in future ); - // TODO(@jasnell): Support differentiating between early headers, primary headers, etc - return this.#handle.sendHeaders(1, headerString, 1); + return this.#handle.sendHeaders(kind, headerString, flags); } [kFinishClose](error) { @@ -936,58 +2387,141 @@ class QuicStream { } this.#pendingClose.resolve(); } + if (onStreamClosedChannel.hasSubscribers) { + onStreamClosedChannel.publish({ + __proto__: null, + stream: this, + session: this.#session, + error, + stats: this.stats, + }); + } + if (this[kPerfEntry] && hasObserver('quic')) { + stopPerf(this, kPerfEntry, { + detail: { + stats: this.stats, + direction: this.direction, + }, + }); + } this.#stats[kFinishClose](); this.#state[kFinishClose](); this.#session[kRemoveStream](this); + if (this.#writer !== undefined) { + this.#writer.fail(error); + } this.#session = undefined; this.#pendingClose.reject = undefined; this.#pendingClose.resolve = undefined; this.#onblocked = undefined; this.#onreset = undefined; this.#onheaders = undefined; + this.#onerror = undefined; this.#ontrailers = undefined; + this.#oninfo = undefined; + this.#onwanttrailers = undefined; + this.#headers = undefined; + this.#pendingTrailers = undefined; this.#handle = undefined; + if (this.#fileHandle !== undefined) { + // Close the FileHandle that was used as a body source. The close + // may fail if the user already closed it -- that's expected and + // harmless, so mark the promise as handled. + markPromiseAsHandled(this.#fileHandle.close()); + this.#fileHandle = undefined; + } } [kBlocked]() { // The blocked event should only be called if the stream was created with // an onblocked callback. The callback should always exist here. assert(this.#onblocked, 'Unexpected stream blocked event'); - this.#onblocked(); + if (onStreamBlockedChannel.hasSubscribers) { + onStreamBlockedChannel.publish({ + __proto__: null, + stream: this, + session: this.#session, + }); + } + safeCallbackInvoke(this.#onblocked, this); + } + + [kDrain]() { + // No-op by default. Overridden by the writer closure when + // stream.writer is accessed. } [kReset](error) { // The reset event should only be called if the stream was created with // an onreset callback. The callback should always exist here. assert(this.#onreset, 'Unexpected stream reset event'); - this.#onreset(error); + if (onStreamResetChannel.hasSubscribers) { + onStreamResetChannel.publish({ + __proto__: null, + stream: this, + session: this.#session, + error, + }); + } + safeCallbackInvoke(this.#onreset, this, error); } [kHeaders](headers, kind) { - // The headers event should only be called if the stream was created with - // an onheaders callback. The callback should always exist here. - assert(this.#onheaders, 'Unexpected stream headers event'); - assert(ArrayIsArray(headers)); - assert(headers.length % 2 === 0); - const block = { - __proto__: null, - }; - for (let n = 0; n + 1 < headers.length; n += 2) { - if (block[headers[n]] !== undefined) { - block[headers[n]] = [block[headers[n]], headers[n + 1]]; - } else { - block[headers[n]] = headers[n + 1]; - } + const block = parseHeaderPairs(headers); + const kindName = kHeadersKindName[kind] ?? kind; + + switch (kindName) { + case 'initial': + assert(this.#onheaders, 'Unexpected stream headers event'); + if (this.#headers === undefined) this.#headers = block; + if (onStreamHeadersChannel.hasSubscribers) { + onStreamHeadersChannel.publish({ + __proto__: null, + stream: this, + session: this.#session, + headers: block, + }); + } + safeCallbackInvoke(this.#onheaders, this, block); + break; + case 'trailing': + if (onStreamTrailersChannel.hasSubscribers) { + onStreamTrailersChannel.publish({ + __proto__: null, + stream: this, + session: this.#session, + trailers: block, + }); + } + if (this.#ontrailers) + safeCallbackInvoke(this.#ontrailers, this, block); + break; + case 'hints': + if (onStreamInfoChannel.hasSubscribers) { + onStreamInfoChannel.publish({ + __proto__: null, + stream: this, + session: this.#session, + headers: block, + }); + } + if (this.#oninfo) + safeCallbackInvoke(this.#oninfo, this, block); + break; } - - this.#onheaders(block, kind); } [kTrailers]() { - // The trailers event should only be called if the stream was created with - // an ontrailers callback. The callback should always exist here. - assert(this.#ontrailers, 'Unexpected stream trailers event'); - this.#ontrailers(); + if (this.destroyed) return; + + // nghttp3 is asking us to provide trailers to send. + // Check for pre-set pendingTrailers first, then the callback. + if (this.#pendingTrailers) { + this.sendTrailers(this.#pendingTrailers); + this.#pendingTrailers = undefined; + } else if (this.#onwanttrailers) { + safeCallbackInvoke(this.#onwanttrailers, this); + } } [kInspect](depth, options) { @@ -995,11 +2529,12 @@ class QuicStream { return this; const opts = { + __proto__: null, ...options, depth: options.depth == null ? null : options.depth - 1, }; - return `Stream ${inspect({ + return `QuicStream ${inspect({ __proto__: null, id: this.id, direction: this.direction, @@ -1016,24 +2551,76 @@ class QuicSession { #endpoint = undefined; /** @type {boolean} */ #isPendingClose = false; + /** @type {boolean} */ + #selfInitiatedClose = false; + /** + * Flag set at the top of `destroy()` to make the method safely + * re-entrant. Distinct from `#handle === undefined` so callbacks + * that fire from C++ during teardown (e.g. `onSessionClose` -> + * `[kFinishClose]`) still see a live `#handle` and can complete + * their work. + * @type {boolean} + */ + #destroying = false; + /** + * Set to `true` once the TLS handshake has completed successfully + * (i.e. `[kHandshake]` has fired). Used to gate operations that only + * make sense for a fully-opened session - notably, attempting to + * send a `CONNECTION_CLOSE` from `endpoint.destroy(error)` cascade. + * The C++ side cannot create a valid `CONNECTION_CLOSE` packet + * before handshake completion and falls back to a path that + * re-enters JS `destroy()` and trips our `#destroying` guard, + * leaving the C++ side asserting an inconsistent state. + * @type {boolean} + */ + #handshakeCompleted = false; /** @type {object|undefined} */ #handle; /** @type {PromiseWithResolvers} */ - #pendingClose = Promise.withResolvers(); // eslint-disable-line node-core/prefer-primordials + #pendingClose = PromiseWithResolvers(); /** @type {PromiseWithResolvers} */ - #pendingOpen = Promise.withResolvers(); // eslint-disable-line node-core/prefer-primordials + #pendingOpen = PromiseWithResolvers(); /** @type {QuicSessionState} */ #state; /** @type {QuicSessionStats} */ #stats; /** @type {Set} */ #streams = new SafeSet(); + /** @type {Function|undefined} */ + #onerror = undefined; /** @type {OnStreamCallback} */ #onstream = undefined; /** @type {OnDatagramCallback|undefined} */ #ondatagram = undefined; - /** @type {object|undefined} */ - #sessionticket = undefined; + /** @type {OnDatagramStatusCallback|undefined} */ + #ondatagramstatus = undefined; + /** @type {Function|undefined} */ + #onpathvalidation = undefined; + /** @type {Function|undefined} */ + #onsessionticket = undefined; + /** @type {Function|undefined} */ + #onversionnegotiation = undefined; + /** @type {Function|undefined} */ + #onhandshake = undefined; + /** @type {Function|undefined} */ + #onnewtoken = undefined; + /** @type {Function|undefined} */ + #onearlyrejected = undefined; + /** @type {Function|undefined} */ + #onorigin = undefined; + /** @type {Function|undefined} */ + #ongoaway = undefined; + /** @type {Function|undefined} */ + #onkeylog = undefined; + /** @type {Function|undefined} */ + #onqlog = undefined; + #pendingQlog = undefined; + #handshakeInfo = undefined; + /** @type {{ local: SocketAddress, remote: SocketAddress }|undefined} */ + #path = undefined; + #certificate = undefined; + #peerCertificate = undefined; + #ephemeralKeyInfo = undefined; static { getQuicSessionState = function(session) { @@ -1062,11 +2649,17 @@ class QuicSession { this.#endpoint = endpoint; this.#handle = handle; this.#handle[kOwner] = this; + // Move any qlog entries that arrived before the wrapper existed. + if (handle._pendingQlog !== undefined) { + this.#pendingQlog = handle._pendingQlog; + handle._pendingQlog = undefined; + } this.#stats = new QuicSessionStats(kPrivateConstructor, handle.stats); this.#state = new QuicSessionState(kPrivateConstructor, handle.state); - this.#state.hasVersionNegotiationListener = true; - this.#state.hasPathValidationListener = true; - this.#state.hasSessionTicketListener = true; + + if (hasObserver('quic')) { + startPerf(this, kPerfEntry, { type: 'quic', name: 'QuicSession' }); + } debug('session created'); } @@ -1076,13 +2669,32 @@ class QuicSession { return this.#handle === undefined || this.#isPendingClose; } - /** - * Get the session ticket associated with this session, if any. - * @type {object|undefined} - */ - get sessionticket() { + /** @type {Function|undefined} */ + get onerror() { + QuicSession.#assertIsQuicSession(this); + return this.#onerror; + } + + set onerror(fn) { QuicSession.#assertIsQuicSession(this); - return this.#sessionticket; + if (fn === undefined) { + this.#onerror = undefined; + } else { + validateFunction(fn, 'onerror'); + this.#onerror = FunctionPrototypeBind(fn, this); + // When an onerror handler is provided, mark the pending promises + // as handled so that rejections from destroy(error) don't surface + // as unhandled rejections. The onerror callback is the + // application's error handler for this session. + markPromiseAsHandled(this.#pendingClose.promise); + markPromiseAsHandled(this.#pendingOpen.promise); + // Also mark existing streams' closed promises. Stream rejections + // during session destruction are expected collateral when the + // session has an error handler. + for (const stream of this.#streams) { + markPromiseAsHandled(stream.closed); + } + } } /** @type {OnStreamCallback} */ @@ -1097,7 +2709,7 @@ class QuicSession { this.#onstream = undefined; } else { validateFunction(fn, 'onstream'); - this.#onstream = fn.bind(this); + this.#onstream = FunctionPrototypeBind(fn, this); } } @@ -1114,11 +2726,234 @@ class QuicSession { this.#state.hasDatagramListener = false; } else { validateFunction(fn, 'ondatagram'); - this.#ondatagram = fn.bind(this); + this.#ondatagram = FunctionPrototypeBind(fn, this); this.#state.hasDatagramListener = true; } } + /** + * The ondatagramstatus callback is called when the status of a sent datagram + * is received. This is best-effort only. + * @type {OnDatagramStatusCallback} + */ + get ondatagramstatus() { + QuicSession.#assertIsQuicSession(this); + return this.#ondatagramstatus; + } + + set ondatagramstatus(fn) { + QuicSession.#assertIsQuicSession(this); + if (fn === undefined) { + this.#ondatagramstatus = undefined; + this.#state.hasDatagramStatusListener = false; + } else { + validateFunction(fn, 'ondatagramstatus'); + this.#ondatagramstatus = FunctionPrototypeBind(fn, this); + this.#state.hasDatagramStatusListener = true; + } + } + + /** @type {Function|undefined} */ + get onpathvalidation() { + QuicSession.#assertIsQuicSession(this); + return this.#onpathvalidation; + } + + set onpathvalidation(fn) { + QuicSession.#assertIsQuicSession(this); + if (fn === undefined) { + this.#onpathvalidation = undefined; + this.#state.hasPathValidationListener = false; + } else { + validateFunction(fn, 'onpathvalidation'); + this.#onpathvalidation = FunctionPrototypeBind(fn, this); + this.#state.hasPathValidationListener = true; + } + } + + get onkeylog() { + QuicSession.#assertIsQuicSession(this); + return this.#onkeylog; + } + + set onkeylog(fn) { + QuicSession.#assertIsQuicSession(this); + if (fn === undefined) { + this.#onkeylog = undefined; + } else { + validateFunction(fn, 'onkeylog'); + this.#onkeylog = FunctionPrototypeBind(fn, this); + } + } + + get onqlog() { + QuicSession.#assertIsQuicSession(this); + return this.#onqlog; + } + + set onqlog(fn) { + QuicSession.#assertIsQuicSession(this); + if (fn === undefined) { + this.#onqlog = undefined; + } else { + validateFunction(fn, 'onqlog'); + this.#onqlog = FunctionPrototypeBind(fn, this); + // Flush any qlog entries that were cached before the callback was set. + if (this.#pendingQlog !== undefined) { + const pending = this.#pendingQlog; + this.#pendingQlog = undefined; + for (let i = 0; i < pending.length; i += 2) { + this[kQlog](pending[i], pending[i + 1]); + } + } + } + } + + /** @type {Function|undefined} */ + get onsessionticket() { + QuicSession.#assertIsQuicSession(this); + return this.#onsessionticket; + } + + set onsessionticket(fn) { + QuicSession.#assertIsQuicSession(this); + if (fn === undefined) { + this.#onsessionticket = undefined; + this.#state.hasSessionTicketListener = false; + } else { + validateFunction(fn, 'onsessionticket'); + this.#onsessionticket = FunctionPrototypeBind(fn, this); + this.#state.hasSessionTicketListener = true; + } + } + + /** @type {Function|undefined} */ + get onversionnegotiation() { + QuicSession.#assertIsQuicSession(this); + return this.#onversionnegotiation; + } + + set onversionnegotiation(fn) { + QuicSession.#assertIsQuicSession(this); + if (fn === undefined) { + this.#onversionnegotiation = undefined; + } else { + validateFunction(fn, 'onversionnegotiation'); + this.#onversionnegotiation = FunctionPrototypeBind(fn, this); + } + } + + /** @type {Function|undefined} */ + get onhandshake() { + QuicSession.#assertIsQuicSession(this); + return this.#onhandshake; + } + + set onhandshake(fn) { + QuicSession.#assertIsQuicSession(this); + if (fn === undefined) { + this.#onhandshake = undefined; + } else { + validateFunction(fn, 'onhandshake'); + this.#onhandshake = FunctionPrototypeBind(fn, this); + } + } + + /** @type {Function|undefined} */ + get onnewtoken() { + QuicSession.#assertIsQuicSession(this); + return this.#onnewtoken; + } + + set onnewtoken(fn) { + QuicSession.#assertIsQuicSession(this); + if (fn === undefined) { + this.#onnewtoken = undefined; + this.#state.hasNewTokenListener = false; + } else { + validateFunction(fn, 'onnewtoken'); + this.#onnewtoken = FunctionPrototypeBind(fn, this); + this.#state.hasNewTokenListener = true; + } + } + + /** @type {Function|undefined} */ + get onearlyrejected() { + QuicSession.#assertIsQuicSession(this); + return this.#onearlyrejected; + } + + set onearlyrejected(fn) { + QuicSession.#assertIsQuicSession(this); + if (fn === undefined) { + this.#onearlyrejected = undefined; + } else { + validateFunction(fn, 'onearlyrejected'); + this.#onearlyrejected = FunctionPrototypeBind(fn, this); + } + } + + /** @type {Function|undefined} */ + get onorigin() { + QuicSession.#assertIsQuicSession(this); + return this.#onorigin; + } + + set onorigin(fn) { + QuicSession.#assertIsQuicSession(this); + if (fn === undefined) { + this.#onorigin = undefined; + this.#state.hasOriginListener = false; + } else { + validateFunction(fn, 'onorigin'); + this.#onorigin = FunctionPrototypeBind(fn, this); + this.#state.hasOriginListener = true; + } + } + + /** @type {Function|undefined} */ + get ongoaway() { + QuicSession.#assertIsQuicSession(this); + return this.#ongoaway; + } + + set ongoaway(fn) { + QuicSession.#assertIsQuicSession(this); + if (fn === undefined) { + this.#ongoaway = undefined; + } else { + validateFunction(fn, 'ongoaway'); + this.#ongoaway = FunctionPrototypeBind(fn, this); + } + } + + /** + * The maximum datagram size the peer will accept, or 0 if datagrams + * are not supported or the handshake has not yet completed. + * @type {bigint} + */ + get maxDatagramSize() { + QuicSession.#assertIsQuicSession(this); + return this.#state.maxDatagramSize; + } + + /** + * Maximum number of datagrams that can be queued while inside a + * ngtcp2 callback scope. When the queue is full, the oldest + * datagram is dropped and reported as lost. Default is 128. + * @type {number} + */ + get maxPendingDatagrams() { + QuicSession.#assertIsQuicSession(this); + return this.#state.maxPendingDatagrams; + } + + set maxPendingDatagrams(val) { + QuicSession.#assertIsQuicSession(this); + validateInteger(val, 'maxPendingDatagrams', 0, 0xFFFF); + this.#state.maxPendingDatagrams = val; + } + /** * The statistics collected for this session. * @type {QuicSessionStats} @@ -1139,6 +2974,53 @@ class QuicSession { return this.#endpoint; } + /** + * The local and remote socket addresses associated with the session. + * @type {{ local: SocketAddress, remote: SocketAddress } | undefined} + */ + get path() { + QuicSession.#assertIsQuicSession(this); + if (this.destroyed) return undefined; + return this.#path ??= { + __proto__: null, + local: new InternalSocketAddress(this.#handle.getLocalAddress()), + remote: new InternalSocketAddress(this.#handle.getRemoteAddress()), + }; + } + + /** + * The local certificate as an object, or undefined if not available. + * @type {object|undefined} + */ + get certificate() { + QuicSession.#assertIsQuicSession(this); + if (this.destroyed) return undefined; + return this.#certificate ??= this.#handle.getCertificate(); + } + + /** + * The peer's certificate as an object, or undefined if the peer did + * not present a certificate or the session is destroyed. + * @type {object|undefined} + */ + get peerCertificate() { + QuicSession.#assertIsQuicSession(this); + if (this.destroyed) return undefined; + return this.#peerCertificate ??= this.#handle.getPeerCertificate(); + } + + /** + * The ephemeral key info for the session. Only available on client + * sessions. Returns undefined for server sessions or if the session + * is destroyed. + * @type {object|undefined} + */ + get ephemeralKeyInfo() { + QuicSession.#assertIsQuicSession(this); + if (this.destroyed) return undefined; + return this.#ephemeralKeyInfo ??= this.#handle.getEphemeralKey(); + } + /** * @param {number} direction * @param {OpenStreamOptions} options @@ -1158,15 +3040,18 @@ class QuicSession { validateObject(options, 'options'); const { body, - sendOrder = 50, - [kHeaders]: headers, + priority = 'default', + incremental = false, + highWaterMark = kDefaultHighWaterMark, + headers, + onheaders, + ontrailers, + oninfo, + onwanttrailers, } = options; - if (headers !== undefined) { - validateObject(headers, 'options.headers'); - } - validateNumber(sendOrder, 'options.sendOrder'); - // TODO(@jasnell): Make use of sendOrder to set the priority + validateOneOf(priority, 'options.priority', ['default', 'low', 'high']); + validateBoolean(incremental, 'options.incremental'); const validatedBody = validateBody(body); @@ -1175,18 +3060,39 @@ class QuicSession { throw new ERR_QUIC_OPEN_STREAM_FAILED(); } - if (headers !== undefined) { - // If headers are specified and there's no body, then we assume - // that the headers are terminal. - handle.sendHeaders(1, buildNgHeaderString(headers), - validatedBody === undefined ? 1 : 0); + if (this.#state.isPrioritySupported) { + const urgency = priority === 'high' ? 0 : priority === 'low' ? 7 : 3; + handle.setPriority((urgency << 1) | (incremental ? 1 : 0)); } const stream = new QuicStream(kPrivateConstructor, handle, this, direction); this.#streams.add(stream); + if (typeof this.#onerror === 'function') { + markPromiseAsHandled(stream.closed); + } + + // If the body was a FileHandle, store it on the stream so it is + // closed automatically when the stream finishes. + if (body instanceof FileHandle) { + stream[kAttachFileHandle](body); + } + + // Set the high water mark for backpressure. + stream.highWaterMark = highWaterMark; + + // Set stream callbacks before sending headers to avoid missing events. + if (onheaders) stream.onheaders = onheaders; + if (ontrailers) stream.ontrailers = ontrailers; + if (oninfo) stream.oninfo = oninfo; + if (onwanttrailers) stream.onwanttrailers = onwanttrailers; + + if (headers !== undefined) { + stream.sendHeaders(headers, { terminal: validatedBody === undefined }); + } if (onSessionOpenStreamChannel.hasSubscribers) { onSessionOpenStreamChannel.publish({ + __proto__: null, stream, session: this, direction: dir, @@ -1207,6 +3113,8 @@ class QuicSession { } /** + * Creates a new unidirectional stream on this session. If the session + * does not allow new streams to be opened, an error will be thrown. * @param {OpenStreamOptions} [options] * @returns {Promise} */ @@ -1220,42 +3128,74 @@ class QuicSession { * of the sent datagram will be reported via the datagram-status event if * possible. * - * If a string is given it will be encoded as UTF-8. + * If a string is given it will be encoded using the specified encoding. * - * If an ArrayBufferView is given, the view will be copied. - * @param {ArrayBufferView|string} datagram The datagram payload - * @returns {Promise} + * If an ArrayBufferView is given, the bytes are copied into an internal + * buffer; the caller's source buffer is unchanged and may be reused + * immediately. Callers that want to ensure their source cannot be + * mutated after the call (for example, when handing the buffer off to + * another async consumer) can call ArrayBuffer.prototype.transfer() + * themselves before passing it. + * + * If a Promise is given, it will be awaited before sending. If the + * session closes while awaiting, 0n is returned silently. + * @param {ArrayBufferView|string|Promise} datagram The datagram payload + * @param {string} [encoding] The encoding to use if datagram is a string + * @returns {Promise} The datagram ID */ - async sendDatagram(datagram) { + async sendDatagram(datagram, encoding = 'utf8') { QuicSession.#assertIsQuicSession(this); if (this.#isClosedOrClosing) { throw new ERR_INVALID_STATE('Session is closed'); } + + const maxDatagramSize = this.#state.maxDatagramSize; + + // The peer max datagram size is either unknown or they have explicitly + // indicated that they do not support datagrams by setting it to 0. In + // either case, we do not send the datagram. + if (maxDatagramSize === 0) return kNilDatagramId; + + if (isPromise(datagram)) { + datagram = await datagram; + // Session may have closed while awaiting. Since datagrams are + // inherently unreliable, silently return rather than throwing. + if (this.#isClosedOrClosing) return kNilDatagramId; + } + if (typeof datagram === 'string') { - datagram = Buffer.from(datagram, 'utf8'); - } else { - if (!isArrayBufferView(datagram)) { - throw new ERR_INVALID_ARG_TYPE('datagram', - ['ArrayBufferView', 'string'], - datagram); - } - const length = datagram.byteLength; - const offset = datagram.byteOffset; - datagram = new Uint8Array(ArrayBufferPrototypeTransfer(datagram.buffer), - length, offset); + datagram = new Uint8Array(Buffer.from(datagram, encoding)); + } else if (!isArrayBufferView(datagram)) { + throw new ERR_INVALID_ARG_TYPE('datagram', + ['ArrayBufferView', 'string'], + datagram); } - debug(`sending datagram with ${datagram.byteLength} bytes`); + const length = isDataView(datagram) ? + DataViewPrototypeGetByteLength(datagram) : + TypedArrayPrototypeGetByteLength(datagram); + + // If the view has zero length (e.g. detached buffer), there's + // nothing to send. + if (length === 0) return kNilDatagramId; + + // The peer max datagram size is less than the datagram we want to send, + // so... don't send it. + if (length > maxDatagramSize) return kNilDatagramId; const id = this.#handle.sendDatagram(datagram); - if (onSessionSendDatagramChannel.hasSubscribers) { + if (id !== kNilDatagramId && onSessionSendDatagramChannel.hasSubscribers) { onSessionSendDatagramChannel.publish({ + __proto__: null, id, - length: datagram.byteLength, + length, session: this, }); } + + debug(`datagram ${id} sent with ${length} bytes`); + return id; } /** @@ -1272,6 +3212,7 @@ class QuicSession { this.#handle.updateKey(); if (onSessionUpdateKeyChannel.hasSubscribers) { onSessionUpdateKeyChannel.publish({ + __proto__: null, session: this, }); } @@ -1285,18 +3226,30 @@ class QuicSession { * New streams will not be allowed to be created. The returned promise will * be resolved when the session closes, or will be rejected if the session * closes abruptly due to an error. + * @param {object} [options] + * @param {bigint|number} [options.code] The error code to send in the + * CONNECTION_CLOSE frame. Defaults to NO_ERROR (0). + * @param {string} [options.type] Either `'transport'` (default) or + * `'application'`. Determines the error code namespace. + * @param {string} [options.reason] An optional human-readable reason + * string included in the CONNECTION_CLOSE frame (diagnostic only). * @returns {Promise} */ - close() { + close(options = kEmptyObject) { QuicSession.#assertIsQuicSession(this); + options = validateCloseOptions(options); if (!this.#isClosedOrClosing) { this.#isPendingClose = true; + if (options?.code !== undefined) { + this.#selfInitiatedClose = true; + } debug('gracefully closing the session'); - this.#handle?.gracefulClose(); + this.#handle.gracefulClose(options); if (onSessionClosingChannel.hasSubscribers) { onSessionClosingChannel.publish({ + __proto__: null, session: this, }); } @@ -1304,6 +3257,11 @@ class QuicSession { return this.closed; } + /** @type {boolean} */ + get closing() { + return this.#isPendingClose; + } + /** @type {Promise} */ get opened() { QuicSession.#assertIsQuicSession(this); @@ -1333,13 +3291,46 @@ class QuicSession { * the closed promise will be rejected with that error. If no error is given, * the closed promise will be resolved. * @param {any} error + * @param {object} [options] + * @param {bigint|number} [options.code] The error code to send in the + * CONNECTION_CLOSE frame. Defaults to NO_ERROR (0). + * @param {string} [options.type] Either `'transport'` (default) or + * `'application'`. Determines the error code namespace. + * @param {string} [options.reason] An optional human-readable reason + * string included in the CONNECTION_CLOSE frame (diagnostic only). */ - destroy(error) { + destroy(error, options) { QuicSession.#assertIsQuicSession(this); - if (this.destroyed) return; + // Two distinct guards (see also `QuicStream.destroy`): + // * `#destroying` flips synchronously here so any re-entrant call + // (e.g. from a user `onerror` callback or from a cascading + // `stream.destroy(error)` whose own `onerror` re-enters + // `session.destroy()`) hits this guard and returns immediately + // without running the teardown twice. + // * `destroyed` (i.e. `#handle === undefined`) signals + // "fully torn down". Defense-in-depth for paths that may have + // finished teardown without setting `#destroying` and for + // repeat invocations after this method has fully run. + if (this.#destroying || this.destroyed) return; + + if (options !== undefined) options = validateCloseOptions(options); + this.#destroying = true; debug('destroying the session'); + if (error !== undefined) { + if (onSessionErrorChannel.hasSubscribers) { + onSessionErrorChannel.publish({ + __proto__: null, + session: this, + error, + }); + } + if (typeof this.#onerror === 'function') { + invokeOnerror(this.#onerror, error); + } + } + // First, forcefully and immediately destroy all open streams, if any. for (const stream of this.#streams) { stream.destroy(error); @@ -1361,11 +3352,30 @@ class QuicSession { this.#endpoint = undefined; this.#isPendingClose = false; + // If the handshake never completed, reject the opened promise. The + // session is being destroyed, so the handshake will never complete + // and `await session.opened` would otherwise hang forever. The + // documented contract is that opened rejects when the session is + // destroyed before opening; see the `session.opened` docs in + // doc/api/quic.md. `[kHandshake]` clears `#pendingOpen.reject` once + // the handshake completes successfully, so this branch only runs if + // we are racing against a still-pending handshake. + // + // Mark the rejection as handled before rejecting so that callers who + // never explicitly `await session.opened` do not get an unhandled + // rejection warning - common for server-side sessions delivered via + // `onsession`, which often do not await opened. The rejection is + // still observable via `await session.opened`. + if (this.#pendingOpen.reject) { + markPromiseAsHandled(this.#pendingOpen.promise); + this.#pendingOpen.reject(error ?? new ERR_INVALID_STATE( + 'Session was destroyed before it opened')); + } + if (error) { // If the session is still waiting to be closed, and error // is specified, reject the closed promise. this.#pendingClose.reject?.(error); - this.#pendingOpen.reject?.(error); } else { this.#pendingClose.resolve?.(); } @@ -1378,20 +3388,73 @@ class QuicSession { this.#state[kFinishClose](); this.#stats[kFinishClose](); + if (this[kPerfEntry] && hasObserver('quic')) { + stopPerf(this, kPerfEntry, { + detail: { + stats: this.stats, + handshake: this.#handshakeInfo, + path: this.#path, + }, + }); + } + + this.#onerror = undefined; this.#onstream = undefined; this.#ondatagram = undefined; - this.#sessionticket = undefined; - - // Destroy the underlying C++ handle - this.#handle.destroy(); + this.#ondatagramstatus = undefined; + this.#onpathvalidation = undefined; + this.#onsessionticket = undefined; + this.#onkeylog = undefined; + this.#onversionnegotiation = undefined; + this.#onhandshake = undefined; + this.#onnewtoken = undefined; + this.#onorigin = undefined; + this.#ongoaway = undefined; + this.#path = undefined; + this.#certificate = undefined; + this.#peerCertificate = undefined; + this.#ephemeralKeyInfo = undefined; + + // Destroy the underlying C++ handle. Pass close error options if + // provided so the CONNECTION_CLOSE frame carries the correct code. + // Note: #onqlog is intentionally NOT cleared here because ngtcp2 + // emits the final qlog statement during ngtcp2_conn destruction, + // and the deferred callback must still be reachable. The reference + // is released when the QuicSession object is garbage collected. + this.#handle.destroy(options); this.#handle = undefined; if (onSessionClosedChannel.hasSubscribers) { onSessionClosedChannel.publish({ + __proto__: null, session: this, error, + stats: this.stats, + }); + } + } + + /** + * Called when the peer sends a GOAWAY frame (HTTP/3 only). The + * lastStreamId indicates the highest stream ID the peer may have + * processed - streams above it were not processed and may be retried. + * @param {bigint} lastStreamId + */ + [kGoaway](lastStreamId) { + this.#isPendingClose = true; + if (onSessionClosingChannel.hasSubscribers) { + onSessionClosingChannel.publish({ __proto__: null, session: this }); + } + if (onSessionGoawayChannel.hasSubscribers) { + onSessionGoawayChannel.publish({ + __proto__: null, + session: this, + lastStreamId, }); } + if (this.#ongoaway) { + safeCallbackInvoke(this.#ongoaway, this, lastStreamId); + } } /** @@ -1409,53 +3472,78 @@ class QuicSession { } debug('finishing closing the session with an error', errorType, code, reason); + + // If the local side initiated this close with an error code (via + // close({ code })), this is an intentional shutdown; not an error. + // The closed promise should resolve, not reject. + if (this.#selfInitiatedClose) { + this.destroy(); + return; + } + // Otherwise, errorType indicates the type of error that occurred, code indicates // the specific error, and reason is an optional string describing the error. + // code !== 0n here (the early return above handles code === 0n). + // The errorType values map to ngtcp2_ccerr_type: + // 0 = NGTCP2_CCERR_TYPE_TRANSPORT + // 1 = NGTCP2_CCERR_TYPE_APPLICATION + // 2 = NGTCP2_CCERR_TYPE_VERSION_NEGOTIATION + // 3 = NGTCP2_CCERR_TYPE_IDLE_CLOSE + // 4 = NGTCP2_CCERR_TYPE_DROP_CONN + // 5 = NGTCP2_CCERR_TYPE_RETRY + // The DROP_CONN/RETRY cases are typically intercepted before reaching + // here (DROP_CONN tears the connection down without notifying us, RETRY + // is server-only). The default branch is a safety net so any + // unexpected value still completes the close path - without it the + // session would leak with `closed` hanging forever. switch (errorType) { case 0: /* Transport Error */ - if (code === 0n) { - this.destroy(); - } else { - this.destroy(new ERR_QUIC_TRANSPORT_ERROR(code, reason)); - } + this.destroy(new ERR_QUIC_TRANSPORT_ERROR(code, reason)); break; case 1: /* Application Error */ - if (code === 0n) { - this.destroy(); - } else { - this.destroy(new ERR_QUIC_APPLICATION_ERROR(code, reason)); - } + this.destroy(new ERR_QUIC_APPLICATION_ERROR(code, reason)); break; case 2: /* Version Negotiation Error */ this.destroy(new ERR_QUIC_VERSION_NEGOTIATION_ERROR()); break; - case 3: /* Idle close */ { - // An idle close is not really an error. We can just destroy. + case 3: /* Idle close */ this.destroy(); break; - } + default: + this.destroy(new ERR_QUIC_TRANSPORT_ERROR(code, reason)); + break; } } + [kKeylog](line) { + if (this.destroyed || this.onkeylog === undefined) return; + safeCallbackInvoke(this.#onkeylog, this, line); + } + + [kQlog](data, fin) { + if (this.onqlog === undefined) return; + safeCallbackInvoke(this.#onqlog, this, data, fin); + } + /** - * @param {Uint8Array} u8 - * @param {boolean} early + * @param {Uint8Array} u8 The datagram payload + * @param {boolean} early A boolean indicating whether this datagram was received before the handshake completed */ [kDatagram](u8, early) { - // The datagram event should only be called if the session was created with + // The datagram event should only be called if the session has // an ondatagram callback. The callback should always exist here. - assert(this.#ondatagram, 'Unexpected datagram event'); + assert(typeof this.#ondatagram === 'function', 'Unexpected datagram event'); if (this.destroyed) return; - const length = u8.byteLength; - this.#ondatagram(u8, early); - + const length = TypedArrayPrototypeGetByteLength(u8); if (onSessionReceiveDatagramChannel.hasSubscribers) { onSessionReceiveDatagramChannel.publish({ + __proto__: null, length, early, session: this, }); } + safeCallbackInvoke(this.#ondatagram, this, u8, early); } /** @@ -1463,14 +3551,19 @@ class QuicSession { * @param {'lost'|'acknowledged'} status */ [kDatagramStatus](id, status) { + // The datagram status event should only be called if the session has + // an ondatagramstatus callback. The callback should always exist here. + assert(typeof this.#ondatagramstatus === 'function', 'Unexpected datagram status event'); if (this.destroyed) return; if (onSessionReceiveDatagramStatusChannel.hasSubscribers) { onSessionReceiveDatagramStatusChannel.publish({ + __proto__: null, id, status, session: this, }); } + safeCallbackInvoke(this.#ondatagramstatus, this, id, status); } /** @@ -1483,32 +3576,79 @@ class QuicSession { */ [kPathValidation](result, newLocalAddress, newRemoteAddress, oldLocalAddress, oldRemoteAddress, preferredAddress) { + assert(typeof this.#onpathvalidation === 'function', + 'Unexpected path validation event'); if (this.destroyed) return; + const newLocal = new InternalSocketAddress(newLocalAddress); + const newRemote = new InternalSocketAddress(newRemoteAddress); + const oldLocal = oldLocalAddress !== undefined ? + new InternalSocketAddress(oldLocalAddress) : null; + const oldRemote = oldRemoteAddress !== undefined ? + new InternalSocketAddress(oldRemoteAddress) : null; if (onSessionPathValidationChannel.hasSubscribers) { onSessionPathValidationChannel.publish({ + __proto__: null, result, - newLocalAddress, - newRemoteAddress, - oldLocalAddress, - oldRemoteAddress, + newLocalAddress: newLocal, + newRemoteAddress: newRemote, + oldLocalAddress: oldLocal, + oldRemoteAddress: oldRemote, preferredAddress, session: this, }); } + safeCallbackInvoke(this.#onpathvalidation, this, result, newLocal, newRemote, + oldLocal, oldRemote, preferredAddress); } /** * @param {object} ticket */ [kSessionTicket](ticket) { + assert(typeof this.#onsessionticket === 'function', + 'Unexpected session ticket event'); if (this.destroyed) return; - this.#sessionticket = ticket; if (onSessionTicketChannel.hasSubscribers) { onSessionTicketChannel.publish({ + __proto__: null, ticket, session: this, }); } + safeCallbackInvoke(this.#onsessionticket, this, ticket); + } + + /** + * @param {Buffer} token + * @param {SocketAddress} address + */ + [kNewToken](token, address) { + assert(typeof this.#onnewtoken === 'function', + 'Unexpected new token event'); + if (this.destroyed) return; + const addr = new InternalSocketAddress(address); + if (onSessionNewTokenChannel.hasSubscribers) { + onSessionNewTokenChannel.publish({ + __proto__: null, + token, + address: addr, + session: this, + }); + } + safeCallbackInvoke(this.#onnewtoken, this, token, addr); + } + + [kEarlyDataRejected]() { + if (this.destroyed) return; + if (onSessionEarlyRejectedChannel.hasSubscribers) { + onSessionEarlyRejectedChannel.publish({ + __proto__: null, + session: this, + }); + } + if (typeof this.#onearlyrejected === 'function') { + safeCallbackInvoke(this.#onearlyrejected, this); + } } /** @@ -1518,15 +3658,40 @@ class QuicSession { */ [kVersionNegotiation](version, requestedVersions, supportedVersions) { if (this.destroyed) return; - this.destroy(new ERR_QUIC_VERSION_NEGOTIATION_ERROR()); if (onSessionVersionNegotiationChannel.hasSubscribers) { onSessionVersionNegotiationChannel.publish({ + __proto__: null, version, requestedVersions, supportedVersions, session: this, }); } + if (this.#onversionnegotiation) { + safeCallbackInvoke(this.#onversionnegotiation, this, + version, requestedVersions, supportedVersions); + } + // Version negotiation is always a fatal event - the session must be + // destroyed regardless of whether the callback is set. + this.destroy(new ERR_QUIC_VERSION_NEGOTIATION_ERROR()); + } + + /** + * Called when the session receives an ORIGIN frame (RFC 9412). + * @param {string[]} origins + */ + [kOrigin](origins) { + assert(typeof this.#onorigin === 'function', + 'Unexpected origin event'); + if (this.destroyed) return; + if (onSessionOriginChannel.hasSubscribers) { + onSessionOriginChannel.publish({ + __proto__: null, + origins, + session: this, + }); + } + safeCallbackInvoke(this.#onorigin, this, origins); } /** @@ -1538,12 +3703,13 @@ class QuicSession { * @param {number} validationErrorCode */ [kHandshake](servername, protocol, cipher, cipherVersion, validationErrorReason, - validationErrorCode) { + validationErrorCode, earlyDataAttempted, earlyDataAccepted) { if (this.destroyed || !this.#pendingOpen.resolve) return; const addr = this.#handle.getRemoteAddress(); const info = { + __proto__: null, local: this.#endpoint.address, remote: addr !== undefined ? new InternalSocketAddress(addr) : @@ -1554,18 +3720,40 @@ class QuicSession { cipherVersion, validationErrorReason, validationErrorCode, + earlyDataAttempted, + earlyDataAccepted, }; - this.#pendingOpen.resolve?.(info); - this.#pendingOpen.resolve = undefined; - this.#pendingOpen.reject = undefined; + // Stash timing-relevant handshake info for the perf entry detail. + this.#handshakeInfo = { + __proto__: null, + servername, + protocol, + earlyDataAttempted, + earlyDataAccepted, + }; if (onSessionHandshakeChannel.hasSubscribers) { onSessionHandshakeChannel.publish({ + __proto__: null, session: this, ...info, }); } + + if (this.#onhandshake) { + safeCallbackInvoke(this.#onhandshake, this, info); + } + + this.#pendingOpen.resolve?.(info); + this.#pendingOpen.resolve = undefined; + this.#pendingOpen.reject = undefined; + this.#handshakeCompleted = true; + } + + /** @type {boolean} */ + get [kHandshakeCompleted]() { + return this.#handshakeCompleted; } /** @@ -1575,6 +3763,9 @@ class QuicSession { [kNewStream](handle, direction) { const stream = new QuicStream(kPrivateConstructor, handle, this, direction); + // Set the default high water mark for received streams. + stream.highWaterMark = kDefaultHighWaterMark; + // A new stream was received. If we don't have an onstream callback, then // there's nothing we can do about it. Destroy the stream in this case. if (typeof this.#onstream !== 'function') { @@ -1583,15 +3774,32 @@ class QuicSession { return; } this.#streams.add(stream); + // If the session has an onerror handler, mark the stream's closed + // promise as handled. See the onerror setter for explanation. + if (typeof this.#onerror === 'function') { + markPromiseAsHandled(stream.closed); + } - this.#onstream(stream); + // Apply default stream callbacks set at listen time before + // notifying onstream, so the user sees them already set. + const scbs = this[kStreamCallbacks]; + if (scbs) { + if (scbs.onheaders) stream.onheaders = scbs.onheaders; + if (scbs.ontrailers) stream.ontrailers = scbs.ontrailers; + if (scbs.oninfo) stream.oninfo = scbs.oninfo; + if (scbs.onwanttrailers) stream.onwanttrailers = scbs.onwanttrailers; + } if (onSessionReceivedStreamChannel.hasSubscribers) { onSessionReceivedStreamChannel.publish({ + __proto__: null, stream, session: this, + direction: direction === kStreamDirectionBidirectional ? 'bidi' : 'uni', }); } + + safeCallbackInvoke(this.#onstream, this, stream); } [kRemoveStream](stream) { @@ -1603,6 +3811,7 @@ class QuicSession { return this; const opts = { + __proto__: null, ...options, depth: options.depth == null ? null : options.depth - 1, }; @@ -1622,6 +3831,8 @@ class QuicSession { async [SymbolAsyncDispose]() { await this.close(); } } +let isQuicEndpoint; + // The QuicEndpoint represents a local UDP port binding. It can act as both a // server for receiving peer sessions, or a client for initiating them. The // local UDP port will be lazily bound only when connect() or listen() are @@ -1660,7 +3871,7 @@ class QuicEndpoint { * the endpoint closes abruptly due to an error). * @type {PromiseWithResolvers} */ - #pendingClose = Promise.withResolvers(); // eslint-disable-line node-core/prefer-primordials + #pendingClose = PromiseWithResolvers(); /** * If destroy() is called with an error, the error is stored here and used to reject * the pendingClose promise when [kFinishClose] is called. @@ -1689,18 +3900,35 @@ class QuicEndpoint { * @type {OnSessionCallback} */ #onsession = undefined; + #sessionCallbacks = undefined; static { getQuicEndpointState = function(endpoint) { - QuicEndpoint.#assertIsQuicEndpoint(endpoint); + assertIsQuicEndpoint(endpoint); return endpoint.#state; }; - } - static #assertIsQuicEndpoint(val) { - if (val == null || !(#handle in val)) { - throw new ERR_INVALID_THIS('QuicEndpoint'); - } + isQuicEndpoint = function(val) { + return val != null && #handle in val; + }; + + assertIsQuicEndpoint = function(val) { + if (!isQuicEndpoint(val)) { + throw new ERR_INVALID_THIS('QuicEndpoint'); + } + }; + + assertEndpointNotClosedOrClosing = function(endpoint) { + if (endpoint.#isClosedOrClosing) { + throw new ERR_INVALID_STATE('Endpoint is closed'); + } + }; + + assertEndpointIsNotBusy = function(endpoint) { + if (endpoint.#state.isBusy) { + throw new ERR_INVALID_STATE('Endpoint is busy'); + } + }; } /** @@ -1713,9 +3941,10 @@ class QuicEndpoint { const { retryTokenExpiration, tokenExpiration, - maxConnectionsPerHost, - maxConnectionsTotal, + maxConnectionsPerHost = 0, + maxConnectionsTotal = 0, maxStatelessResetsPerHost, + disableStatelessReset, addressLRUSize, maxRetries, rxDiagnosticLoss, @@ -1723,6 +3952,7 @@ class QuicEndpoint { udpReceiveBufferSize, udpSendBufferSize, udpTTL, + idleTimeout, validateAddress, ipv6Only, cc, @@ -1746,9 +3976,11 @@ class QuicEndpoint { address: address?.[kSocketAddressHandle], retryTokenExpiration, tokenExpiration, + // Connection limits are set on the state buffer, not passed to C++. maxConnectionsPerHost, maxConnectionsTotal, maxStatelessResetsPerHost, + disableStatelessReset, addressLRUSize, maxRetries, rxDiagnosticLoss, @@ -1756,6 +3988,7 @@ class QuicEndpoint { udpReceiveBufferSize, udpSendBufferSize, udpTTL, + idleTimeout, validateAddress, ipv6Only, cc, @@ -1767,6 +4000,8 @@ class QuicEndpoint { #newSession(handle) { const session = new QuicSession(kPrivateConstructor, handle, this); this.#sessions.add(session); + // Set default pending datagram queue size. + session.maxPendingDatagrams = kDefaultMaxPendingDatagrams; return session; } @@ -1774,13 +4009,31 @@ class QuicEndpoint { * @param {EndpointOptions} config */ constructor(config = kEmptyObject) { - this.#handle = new Endpoint_(this.#processEndpointOptions(config)); + const options = this.#processEndpointOptions(config); + this.#handle = new Endpoint_(options); this.#handle[kOwner] = this; this.#stats = new QuicEndpointStats(kPrivateConstructor, this.#handle.stats); this.#state = new QuicEndpointState(kPrivateConstructor, this.#handle.state); + // Connection limits are stored in the shared state buffer so they + // can be read by C++ and mutated from JS after construction. + // Use the public setters which validate the range. + if (options.maxConnectionsPerHost !== undefined) { + this.maxConnectionsPerHost = options.maxConnectionsPerHost; + } + if (options.maxConnectionsTotal !== undefined) { + this.maxConnectionsTotal = options.maxConnectionsTotal; + } + + endpointRegistry.add(this); + + if (hasObserver('quic')) { + startPerf(this, kPerfEntry, { type: 'quic', name: 'QuicEndpoint' }); + } + if (onEndpointCreatedChannel.hasSubscribers) { onEndpointCreatedChannel.publish({ + __proto__: null, endpoint: this, config, }); @@ -1794,7 +4047,7 @@ class QuicEndpoint { * @type {QuicEndpointStats} */ get stats() { - QuicEndpoint.#assertIsQuicEndpoint(this); + assertIsQuicEndpoint(this); return this.#stats; } @@ -1808,7 +4061,7 @@ class QuicEndpoint { * @type {boolean} */ get busy() { - QuicEndpoint.#assertIsQuicEndpoint(this); + assertIsQuicEndpoint(this); return this.#busy; } @@ -1816,10 +4069,8 @@ class QuicEndpoint { * @type {boolean} */ set busy(val) { - QuicEndpoint.#assertIsQuicEndpoint(this); - if (this.#isClosedOrClosing) { - throw new ERR_INVALID_STATE('Endpoint is closed'); - } + assertIsQuicEndpoint(this); + assertEndpointNotClosedOrClosing(this); // The val is allowed to be any truthy value // Non-op if there is no change if (!!val !== this.#busy) { @@ -1828,6 +4079,7 @@ class QuicEndpoint { this.#handle.markBusy(this.#busy); if (onEndpointBusyChangeChannel.hasSubscribers) { onEndpointBusyChangeChannel.publish({ + __proto__: null, endpoint: this, busy: this.#busy, }); @@ -1835,12 +4087,44 @@ class QuicEndpoint { } } + /** + * Maximum concurrent connections per remote IP address. + * 0 means unlimited (default). + * @type {number} + */ + get maxConnectionsPerHost() { + assertIsQuicEndpoint(this); + return this.#state.maxConnectionsPerHost; + } + + set maxConnectionsPerHost(val) { + assertIsQuicEndpoint(this); + validateInteger(val, 'maxConnectionsPerHost', 0, 0xFFFF); + this.#state.maxConnectionsPerHost = val; + } + + /** + * Maximum total concurrent connections. + * 0 means unlimited (default). + * @type {number} + */ + get maxConnectionsTotal() { + assertIsQuicEndpoint(this); + return this.#state.maxConnectionsTotal; + } + + set maxConnectionsTotal(val) { + assertIsQuicEndpoint(this); + validateInteger(val, 'maxConnectionsTotal', 0, 0xFFFF); + this.#state.maxConnectionsTotal = val; + } + /** * The local address the endpoint is bound to (if any) * @type {SocketAddress|undefined} */ get address() { - QuicEndpoint.#assertIsQuicEndpoint(this); + assertIsQuicEndpoint(this); if (this.#isClosedOrClosing) return undefined; if (this.#address === undefined) { const addr = this.#handle.address(); @@ -1855,20 +4139,62 @@ class QuicEndpoint { * @param {SessionOptions} [options] */ [kListen](onsession, options) { - if (this.#isClosedOrClosing) { - throw new ERR_INVALID_STATE('Endpoint is closed'); - } + assertEndpointNotClosedOrClosing(this); + assertEndpointIsNotBusy(this); if (this.#listening) { throw new ERR_INVALID_STATE('Endpoint is already listening'); } - if (this.#state.isBusy) { - throw new ERR_INVALID_STATE('Endpoint is busy'); - } validateObject(options, 'options'); - this.#onsession = onsession.bind(this); + this.#onsession = FunctionPrototypeBind(onsession, this); + + const { + onerror, + onstream, + ondatagram, + ondatagramstatus, + onpathvalidation, + onsessionticket, + onversionnegotiation, + onhandshake, + onnewtoken, + onearlyrejected, + onorigin, + ongoaway, + onkeylog, + onqlog, + // Stream-level callbacks applied to each incoming stream. + onheaders, + ontrailers, + oninfo, + onwanttrailers, + ...rest + } = options; + + // Store session and stream callbacks to apply to each new incoming session. + this.#sessionCallbacks = { + __proto__: null, + onerror, + onstream, + ondatagram, + ondatagramstatus, + onpathvalidation, + onsessionticket, + onversionnegotiation, + onhandshake, + onnewtoken, + onearlyrejected, + onorigin, + ongoaway, + onkeylog, + onqlog, + onheaders, + ontrailers, + oninfo, + onwanttrailers, + }; debug('endpoint listening as a server'); - this.#handle.listen(options); + this.#handle.listen(rest); this.#listening = true; } @@ -1879,14 +4205,13 @@ class QuicEndpoint { * @returns {QuicSession} */ [kConnect](address, options) { - if (this.#isClosedOrClosing) { - throw new ERR_INVALID_STATE('Endpoint is closed'); - } - if (this.#state.isBusy) { - throw new ERR_INVALID_STATE('Endpoint is busy'); - } + assertEndpointNotClosedOrClosing(this); + assertEndpointIsNotBusy(this); validateObject(options, 'options'); - const { sessionTicket, ...rest } = options; + const { + sessionTicket, + ...rest + } = options; debug('endpoint connecting as a client'); const handle = this.#handle.connect(address, rest, sessionTicket); @@ -1894,7 +4219,9 @@ class QuicEndpoint { throw new ERR_QUIC_CONNECTION_FAILED(); } const session = this.#newSession(handle); - + // Set callbacks before any async work to avoid missing events + // that fire during or immediately after the handshake. + applyCallbacks(session, options); return session; } @@ -1907,19 +4234,18 @@ class QuicEndpoint { * @returns {Promise} Returns this.closed */ close() { - QuicEndpoint.#assertIsQuicEndpoint(this); + assertIsQuicEndpoint(this); if (!this.#isClosedOrClosing) { + debug('gracefully closing the endpoint'); if (onEndpointClosingChannel.hasSubscribers) { onEndpointClosingChannel.publish({ + __proto__: null, endpoint: this, hasPendingError: this.#pendingError !== undefined, }); } this.#isPendingClose = true; - - debug('gracefully closing the endpoint'); - - this.#handle?.closeGracefully(); + this.#handle.closeGracefully(); } return this.closed; } @@ -1931,7 +4257,7 @@ class QuicEndpoint { * @type {Promise} */ get closed() { - QuicEndpoint.#assertIsQuicEndpoint(this); + assertIsQuicEndpoint(this); return this.#pendingClose.promise; } @@ -1940,19 +4266,19 @@ class QuicEndpoint { * @type {boolean} */ get closing() { - QuicEndpoint.#assertIsQuicEndpoint(this); + assertIsQuicEndpoint(this); return this.#isPendingClose; } /** @type {boolean} */ get listening() { - QuicEndpoint.#assertIsQuicEndpoint(this); + assertIsQuicEndpoint(this); return this.#listening; } /** @type {boolean} */ get destroyed() { - QuicEndpoint.#assertIsQuicEndpoint(this); + assertIsQuicEndpoint(this); return this.#handle === undefined; } @@ -1965,21 +4291,52 @@ class QuicEndpoint { * @returns {Promise} Returns this.closed */ destroy(error) { - QuicEndpoint.#assertIsQuicEndpoint(this); + assertIsQuicEndpoint(this); debug('destroying the endpoint'); + // Record the error before deciding whether to initiate a close. If + // `close()` was already called (e.g. the user kicked off a graceful + // shutdown and then a fatal error was reported afterwards via + // `destroy(err)`) we still want that error to surface on + // `endpoint.closed` rather than being silently swallowed when the + // last in-flight session finishes draining. Only the *first* error + // is recorded, matching how other Node subsystems handle a + // double-error race. + if (error !== undefined) this.#pendingError ??= error; + // Force all sessions to be abruptly closed *before* signalling the + // endpoint to close gracefully. The order matters: each session's + // `destroy(error, options)` asks the C++ side to emit a + // `CONNECTION_CLOSE` frame via `endpoint.Send(...)`. Once the + // endpoint has entered its closing state (after `close()`) it + // can drop those outgoing packets, in which case the peer would + // never learn of the teardown until its own idle timer fires + // (pimterry's B8). + // + // Important: only pass close options to sessions whose handshake + // has actually completed. Pre-handshake sessions cannot create a + // valid CONNECTION_CLOSE packet on the C++ side; the fallback + // synchronously fires `EmitClose` -> JS `[kFinishClose]` -> + // `destroy()`, which trips the `#destroying` guard and leaves the + // C++ side asserting an inconsistent destroyed state. + const closeOptions = errorToCloseOptions(error); + for (const session of this.#sessions) { + // Mark each cascaded session's `closed` as handled before + // destroying it. This prevents unhandled-rejection warnings when + // the session is collateral damage from an endpoint-level destroy + // (e.g. a synchronous throw out of a user `onsession` callback + // routed through safeCallbackInvoke). The rejection is still + // observable to any caller that explicitly awaits `session.closed`. + markPromiseAsHandled(session.closed); + session.destroy( + error, + session[kHandshakeCompleted] ? closeOptions : undefined); + } if (!this.#isClosedOrClosing) { - this.#pendingError = error; // Trigger a graceful close of the endpoint that'll ensure that the - // endpoint is closed down after all sessions are closed... Because - // we force all sessions to be abruptly destroyed as the next step, - // the endpoint will be closed immediately after all the sessions - // are destroyed. + // endpoint is closed down after all sessions are closed... All + // sessions were just forcefully destroyed above, so this should + // resolve promptly with nothing left to drain. this.close(); } - // Now, force all sessions to be abruptly closed... - for (const session of this.#sessions) { - session.destroy(error); - } return this.closed; } @@ -1992,7 +4349,7 @@ class QuicEndpoint { * @param {{replace?: boolean}} [options] */ setSNIContexts(entries, options = kEmptyObject) { - QuicEndpoint.#assertIsQuicEndpoint(this); + assertIsQuicEndpoint(this); if (this.#handle === undefined) { throw new ERR_INVALID_STATE('Endpoint is destroyed'); } @@ -2019,36 +4376,18 @@ class QuicEndpoint { this.#handle.setSNIContexts(processed, replace); } - #maybeGetCloseError(context, status) { - switch (context) { - case kCloseContextClose: { - return this.#pendingError; - } - case kCloseContextBindFailure: { - return new ERR_QUIC_ENDPOINT_CLOSED('Bind failure', status); - } - case kCloseContextListenFailure: { - return new ERR_QUIC_ENDPOINT_CLOSED('Listen failure', status); - } - case kCloseContextReceiveFailure: { - return new ERR_QUIC_ENDPOINT_CLOSED('Receive failure', status); - } - case kCloseContextSendFailure: { - return new ERR_QUIC_ENDPOINT_CLOSED('Send failure', status); - } - case kCloseContextStartFailure: { - return new ERR_QUIC_ENDPOINT_CLOSED('Start failure', status); - } - } - // Otherwise return undefined. - } - [kFinishClose](context, status) { if (this.#handle === undefined) return; debug('endpoint is finishing close', context, status); + endpointRegistry.delete(this); this.#handle = undefined; this.#stats[kFinishClose](); this.#state[kFinishClose](); + if (this[kPerfEntry] && hasObserver('quic')) { + stopPerf(this, kPerfEntry, { + detail: { stats: this.stats }, + }); + } this.#address = undefined; this.#busy = false; this.#listening = false; @@ -2073,10 +4412,11 @@ class QuicEndpoint { // set. Or, if context indicates an error condition that caused the endpoint // to be closed, the status will indicate the error code. In either case, // we will reject the pending close promise at this point. - const maybeCloseError = this.#maybeGetCloseError(context, status); + const maybeCloseError = maybeGetCloseError(context, status, this.#pendingError); if (maybeCloseError !== undefined) { if (onEndpointErrorChannel.hasSubscribers) { onEndpointErrorChannel.publish({ + __proto__: null, endpoint: this, error: maybeCloseError, }); @@ -2088,7 +4428,9 @@ class QuicEndpoint { } if (onEndpointClosedChannel.hasSubscribers) { onEndpointClosedChannel.publish({ + __proto__: null, endpoint: this, + stats: this.stats, }); } @@ -2101,15 +4443,28 @@ class QuicEndpoint { [kNewSession](handle) { const session = this.#newSession(handle); + // Apply session callbacks stored at listen time before notifying + // the onsession callback, to avoid missing events that fire + // during or immediately after the handshake. + if (this.#sessionCallbacks) { + applyCallbacks(session, this.#sessionCallbacks); + } if (onEndpointServerSessionChannel.hasSubscribers) { onEndpointServerSessionChannel.publish({ + __proto__: null, endpoint: this, session, + address: session.path?.remote, }); } assert(typeof this.#onsession === 'function', 'onsession callback not specified'); - this.#onsession(session); + // Route through safeCallbackInvoke so that a synchronous throw or a + // rejected promise from the user's onsession callback destroys this + // endpoint with the error rather than surfacing as an unhandled + // exception or unhandled rejection coming out of the C++ -> JS + // boundary. + safeCallbackInvoke(this.#onsession, this, session); } // Called by the QuicSession when it closes to remove itself from @@ -2123,6 +4478,7 @@ class QuicEndpoint { return this; const opts = { + __proto__: null, ...options, depth: options.depth == null ? null : options.depth - 1, }; @@ -2144,23 +4500,63 @@ class QuicEndpoint { }; /** - * @param {EndpointOptions} endpoint - * @returns {{ endpoint: Endpoint_, created: boolean }} + * Find an existing endpoint from the registry that is suitable for reuse. + * @param {SocketAddress} [targetAddress] The address the client will connect + * to. If provided, endpoints that are listening on that same address are + * excluded to prevent CID namespace collisions (the client's initial DCID + * association would conflict with the server's session routing on the + * same endpoint). + * @returns {QuicEndpoint|undefined} + */ +function findSuitableEndpoint(targetAddress) { + for (const endpoint of endpointRegistry) { + if (!endpoint.destroyed && + !endpoint.closing && + !endpoint.busy) { + // Don't reuse an endpoint for a connection to itself. + if (targetAddress && endpoint.listening && endpoint.address && + targetAddress.address === endpoint.address.address && + targetAddress.port === endpoint.address.port) { + continue; + } + return endpoint; + } + } + return undefined; +} + +/** + * @param {EndpointOptions|QuicEndpoint|undefined} endpoint + * @param {boolean} reuseEndpoint + * @param {boolean} forServer + * @param {SocketAddress} [targetAddress] + * @returns {QuicEndpoint} */ -function processEndpointOption(endpoint) { - if (endpoint === undefined) { - // No endpoint or endpoint options were given. Create a default. - return new QuicEndpoint(); - } else if (endpoint instanceof QuicEndpoint) { +function processEndpointOption(endpoint, + reuseEndpoint = true, + forServer = false, + targetAddress) { + if (isQuicEndpoint(endpoint)) { // We were given an existing endpoint. Use it as-is. return endpoint; } - return new QuicEndpoint(endpoint); + if (endpoint !== undefined) { + // We were given endpoint options. If reuse is enabled, we could + // look for a matching endpoint, but endpoint options imply the + // caller wants specific configuration. Create a new one. + return new QuicEndpoint(endpoint); + } + // No endpoint specified. Try to reuse an existing one if allowed. + if (reuseEndpoint && !forServer) { + const existing = findSuitableEndpoint(targetAddress); + if (existing !== undefined) return existing; + } + return new QuicEndpoint(); } /** - * Validate and extract identity options (keys, certs, ca, crl) from - * an SNI entry. + * Validate and extract identity options (keys, certs) from an SNI entry. + * CA and CRL are shared TLS options, not per-identity. * @param {object} identity * @param {string} label * @returns {object} @@ -2169,8 +4565,6 @@ function processIdentityOptions(identity, label) { const { keys, certs, - ca, - crl, verifyPrivateKey = false, } = identity; @@ -2184,26 +4578,6 @@ function processIdentityOptions(identity, label) { } } - if (ca !== undefined) { - const caInputs = ArrayIsArray(ca) ? ca : [ca]; - for (const caCert of caInputs) { - if (!isArrayBufferView(caCert) && !isArrayBuffer(caCert)) { - throw new ERR_INVALID_ARG_TYPE(`${label}.ca`, - ['ArrayBufferView', 'ArrayBuffer'], caCert); - } - } - } - - if (crl !== undefined) { - const crlInputs = ArrayIsArray(crl) ? crl : [crl]; - for (const crlCert of crlInputs) { - if (!isArrayBufferView(crlCert) && !isArrayBuffer(crlCert)) { - throw new ERR_INVALID_ARG_TYPE(`${label}.crl`, - ['ArrayBufferView', 'ArrayBuffer'], crlCert); - } - } - } - const keyHandles = []; if (keys !== undefined) { const keyInputs = ArrayIsArray(keys) ? keys : [keys]; @@ -2226,8 +4600,6 @@ function processIdentityOptions(identity, label) { __proto__: null, keys: keyHandles, certs, - ca, - crl, verifyPrivateKey, }; } @@ -2245,6 +4617,8 @@ function processTlsOptions(tls, forServer) { groups = DEFAULT_GROUPS, keylog = false, verifyClient = false, + rejectUnauthorized = true, + enableEarlyData = true, tlsTrace = false, sni, // Client-only: identity options are specified directly (no sni map) @@ -2266,6 +4640,8 @@ function processTlsOptions(tls, forServer) { } validateBoolean(keylog, 'options.keylog'); validateBoolean(verifyClient, 'options.verifyClient'); + validateBoolean(rejectUnauthorized, 'options.rejectUnauthorized'); + validateBoolean(enableEarlyData, 'options.enableEarlyData'); validateBoolean(tlsTrace, 'options.tlsTrace'); // Encode the ALPN option to wire format (length-prefixed protocol names). @@ -2299,6 +4675,28 @@ function processTlsOptions(tls, forServer) { encodedAlpn = buf.toString('latin1'); } + if (ca !== undefined) { + const caInputs = ArrayIsArray(ca) ? ca : [ca]; + for (const caCert of caInputs) { + if (!isArrayBufferView(caCert) && !isArrayBuffer(caCert)) { + throw new ERR_INVALID_ARG_TYPE('options.ca', + ['ArrayBufferView', 'ArrayBuffer'], + caCert); + } + } + } + + if (crl !== undefined) { + const crlInputs = ArrayIsArray(crl) ? crl : [crl]; + for (const crlCert of crlInputs) { + if (!isArrayBufferView(crlCert) && !isArrayBuffer(crlCert)) { + throw new ERR_INVALID_ARG_TYPE('options.crl', + ['ArrayBufferView', 'ArrayBuffer'], + crlCert); + } + } + } + // Shared TLS options (same for all identities on the endpoint). const shared = { __proto__: null, @@ -2308,32 +4706,45 @@ function processTlsOptions(tls, forServer) { groups, keylog, verifyClient, + rejectUnauthorized, + enableEarlyData, tlsTrace, + ca, + crl, }; // For servers, identity options come from the sni map. - // The '*' entry is the default/fallback identity. + // The '*' entry is the optional default/fallback identity. If omitted, + // only connections with a servername matching a specific entry will + // succeed; all others will be rejected at the TLS level. if (forServer) { if (sni === undefined || typeof sni !== 'object') { throw new ERR_MISSING_ARGS('options.sni'); } - if (sni['*'] === undefined) { - throw new ERR_MISSING_ARGS("options.sni['*']"); - } - // Process the default ('*') identity into the main tls options. - const defaultIdentity = processIdentityOptions(sni['*'], "options.sni['*']"); - if (defaultIdentity.keys.length === 0) { - throw new ERR_MISSING_ARGS("options.sni['*'].keys"); + // Must have at least one identity entry (wildcard or hostname-specific). + // A server with no identity at all cannot serve any connections. + const sniKeys = ObjectKeys(sni); + if (sniKeys.length === 0) { + throw new ERR_MISSING_ARGS('options.sni'); } - if (defaultIdentity.certs === undefined) { - throw new ERR_MISSING_ARGS("options.sni['*'].certs"); + + // Process the default ('*') identity if present. + let defaultIdentity = {}; + if (sni['*'] !== undefined) { + defaultIdentity = processIdentityOptions(sni['*'], "options.sni['*']"); + if (defaultIdentity.keys.length === 0) { + throw new ERR_MISSING_ARGS("options.sni['*'].keys"); + } + if (defaultIdentity.certs === undefined) { + throw new ERR_MISSING_ARGS("options.sni['*'].certs"); + } } // Build the SNI entries (excluding '*') as full TLS options objects. // Each inherits the shared options and overrides the identity fields. const sniEntries = { __proto__: null }; - for (const hostname of ObjectKeys(sni)) { + for (const hostname of sniKeys) { if (hostname === '*') continue; validateString(hostname, 'options.sni key'); const identity = processIdentityOptions(sni[hostname], @@ -2344,11 +4755,18 @@ function processTlsOptions(tls, forServer) { if (identity.certs === undefined) { throw new ERR_MISSING_ARGS(`options.sni['${hostname}'].certs`); } - // Build a full TLS options object: shared + identity. + // Extract ORIGIN frame options from the SNI entry. + const { + port, + authoritative, + } = sni[hostname]; + // Build a full TLS options object: shared + identity + origin options. sniEntries[hostname] = { __proto__: null, ...shared, ...identity, + ...(port !== undefined ? { port } : {}), + ...(authoritative !== undefined ? { authoritative } : {}), }; } @@ -2361,8 +4779,9 @@ function processTlsOptions(tls, forServer) { } // For clients, identity options are specified directly (no sni map). + // CA and CRL are in the shared options, not per-identity. const clientIdentity = processIdentityOptions({ - keys, certs, ca, crl, verifyPrivateKey, + keys, certs, verifyPrivateKey, }, 'options'); return { @@ -2376,6 +4795,34 @@ function processTlsOptions(tls, forServer) { * @param {'use'|'ignore'|'default'} policy * @returns {number} */ +/** + * Validate and normalize close error options for session.close() and + * session.destroy(). Returns the options object to pass to C++. + * @param {object} options + * @returns {object} + */ +function validateCloseOptions(options) { + validateObject(options, 'options'); + const { + code, + type = 'transport', + reason, + } = options; + + if (code !== undefined) { + if (typeof code !== 'bigint' && typeof code !== 'number') { + throw new ERR_INVALID_ARG_TYPE('options.code', + ['bigint', 'number'], code); + } + } + validateOneOf(type, 'options.type', ['transport', 'application']); + if (reason !== undefined) { + validateString(reason, 'options.reason'); + } + + return { __proto__: null, code, type, reason }; +} + function getPreferredAddressPolicy(policy = 'default') { switch (policy) { case 'use': return kPreferredAddressUse; @@ -2390,33 +4837,111 @@ function getPreferredAddressPolicy(policy = 'default') { * @param {{forServer: boolean, addressFamily: string}} [config] * @returns {SessionOptions} */ -function processSessionOptions(options, config = {}) { +function processSessionOptions(options, config = { __proto__: null }) { validateObject(options, 'options'); const { endpoint, + reuseEndpoint = true, version, minVersion, preferredAddressPolicy = 'default', transportParams = kEmptyObject, qlog = false, sessionTicket, + token, maxPayloadSize, unacknowledgedPacketThreshold = 0, handshakeTimeout, + keepAlive, maxStreamWindow, maxWindow, cc, + datagramDropPolicy = 'drop-oldest', + drainingPeriodMultiplier = 3, + maxDatagramSendAttempts = 5, + // HTTP/3 application-specific options. Nested under `application` + // to separate protocol-specific settings from transport-level ones. + application = kEmptyObject, + // Session callbacks that can be set at construction time to avoid + // race conditions with events that fire during or immediately + // after the handshake. + onerror, + onstream, + ondatagram, + ondatagramstatus, + onpathvalidation, + onsessionticket, + onversionnegotiation, + onhandshake, + onnewtoken, + onearlyrejected, + onorigin, + ongoaway, + onkeylog, + onqlog, + // Stream-level callbacks. + onheaders, + ontrailers, + oninfo, + onwanttrailers, } = options; const { forServer = false, + targetAddress, } = config; + if (token !== undefined) { + if (!isArrayBufferView(token)) { + throw new ERR_INVALID_ARG_TYPE('options.token', + ['ArrayBufferView'], token); + } + } + if (cc !== undefined) { validateOneOf(cc, 'options.cc', [CC_ALGO_RENO, CC_ALGO_BBR, CC_ALGO_CUBIC]); } - const actualEndpoint = processEndpointOption(endpoint); + validateOneOf(datagramDropPolicy, 'options.datagramDropPolicy', + ['drop-oldest', 'drop-newest']); + + validateInteger(drainingPeriodMultiplier, 'options.drainingPeriodMultiplier', + 3, 255); + + validateInteger(maxDatagramSendAttempts, 'options.maxDatagramSendAttempts', + 1, 255); + + // Validate preferred address in transport params if provided. + const { preferredAddressIpv4, preferredAddressIpv6 } = transportParams; + if (preferredAddressIpv4 !== undefined) { + if (!SocketAddress.isSocketAddress(preferredAddressIpv4)) { + throw new ERR_INVALID_ARG_TYPE( + 'options.transportParams.preferredAddressIpv4', + 'SocketAddress', preferredAddressIpv4); + } + if (preferredAddressIpv4.family !== 'ipv4') { + throw new ERR_INVALID_ARG_VALUE( + 'options.transportParams.preferredAddressIpv4', + preferredAddressIpv4, 'must be an IPv4 address'); + } + } + if (preferredAddressIpv6 !== undefined) { + if (!SocketAddress.isSocketAddress(preferredAddressIpv6)) { + throw new ERR_INVALID_ARG_TYPE( + 'options.transportParams.preferredAddressIpv6', + 'SocketAddress', preferredAddressIpv6); + } + if (preferredAddressIpv6.family !== 'ipv6') { + throw new ERR_INVALID_ARG_VALUE( + 'options.transportParams.preferredAddressIpv6', + preferredAddressIpv6, 'must be an IPv6 address'); + } + } + + const actualEndpoint = processEndpointOption(endpoint, + reuseEndpoint, + forServer, + targetAddress); return { __proto__: null, @@ -2424,16 +4949,44 @@ function processSessionOptions(options, config = {}) { version, minVersion, preferredAddressPolicy: getPreferredAddressPolicy(preferredAddressPolicy), - transportParams, + transportParams: { + ...transportParams, + preferredAddressIpv4: preferredAddressIpv4?.[kSocketAddressHandle], + preferredAddressIpv6: preferredAddressIpv6?.[kSocketAddressHandle], + }, tls: processTlsOptions(options, forServer), qlog, maxPayloadSize, unacknowledgedPacketThreshold, handshakeTimeout, + keepAlive, maxStreamWindow, maxWindow, sessionTicket, + token, cc, + datagramDropPolicy, + drainingPeriodMultiplier, + maxDatagramSendAttempts, + application, + onerror, + onstream, + ondatagram, + ondatagramstatus, + onpathvalidation, + onsessionticket, + onversionnegotiation, + onhandshake, + onnewtoken, + onearlyrejected, + onorigin, + ongoaway, + onkeylog, + onqlog, + onheaders, + ontrailers, + oninfo, + onwanttrailers, }; } @@ -2454,6 +5007,7 @@ async function listen(callback, options = kEmptyObject) { if (onEndpointListeningChannel.hasSubscribers) { onEndpointListeningChannel.publish({ + __proto__: null, endpoint, options, }); @@ -2482,12 +5036,22 @@ async function connect(address, options = kEmptyObject) { const { endpoint, ...rest - } = processSessionOptions(options); + } = processSessionOptions(options, { targetAddress: address }); + + if (onEndpointConnectChannel.hasSubscribers) { + onEndpointConnectChannel.publish({ + __proto__: null, + endpoint, + address, + options, + }); + } const session = endpoint[kConnect](address[kSocketAddressHandle], rest); if (onEndpointClientSessionChannel.hasSubscribers) { onEndpointClientSessionChannel.publish({ + __proto__: null, endpoint, session, address, @@ -2501,8 +5065,8 @@ async function connect(address, options = kEmptyObject) { ObjectDefineProperties(QuicEndpoint, { Stats: { __proto__: null, - writable: true, - configurable: true, + writable: false, + configurable: false, enumerable: true, value: QuicEndpointStats, }, @@ -2510,8 +5074,8 @@ ObjectDefineProperties(QuicEndpoint, { ObjectDefineProperties(QuicSession, { Stats: { __proto__: null, - writable: true, - configurable: true, + writable: false, + configurable: false, enumerable: true, value: QuicSessionStats, }, @@ -2519,8 +5083,8 @@ ObjectDefineProperties(QuicSession, { ObjectDefineProperties(QuicStream, { Stats: { __proto__: null, - writable: true, - configurable: true, + writable: false, + configurable: false, enumerable: true, value: QuicStreamStats, }, @@ -2532,6 +5096,7 @@ module.exports = { listen, connect, QuicEndpoint, + QuicError, QuicSession, QuicStream, CC_ALGO_RENO, diff --git a/lib/internal/quic/state.js b/lib/internal/quic/state.js index f8075457825630..1bca0b6619bc3e 100644 --- a/lib/internal/quic/state.js +++ b/lib/internal/quic/state.js @@ -5,11 +5,29 @@ const { DataView, DataViewPrototypeGetBigInt64, DataViewPrototypeGetBigUint64, + DataViewPrototypeGetByteLength, + DataViewPrototypeGetUint16, + DataViewPrototypeGetUint32, DataViewPrototypeGetUint8, + DataViewPrototypeSetUint16, + DataViewPrototypeSetUint32, DataViewPrototypeSetUint8, + Float32Array, JSONStringify, + Uint8Array, } = primordials; +// Determine native byte order. The shared state buffer is written by +// C++ in native byte order, so DataView reads must match. +const kIsLittleEndian = (() => { + // -1 as float32 is 0xBF800000. On little-endian, the bytes are + // [0x00, 0x00, 0x80, 0xBF], so byte[3] is 0xBF (non-zero). + // On big-endian, the bytes are [0xBF, 0x80, 0x00, 0x00], so byte[3] is 0. + const buf = new Float32Array(1); + buf[0] = -1; + return new Uint8Array(buf.buffer)[3] !== 0; +})(); + const { getOptionValue, } = require('internal/options'); @@ -49,10 +67,7 @@ const { // prevent further updates to the buffer. const { - IDX_STATE_SESSION_PATH_VALIDATION, - IDX_STATE_SESSION_VERSION_NEGOTIATION, - IDX_STATE_SESSION_DATAGRAM, - IDX_STATE_SESSION_SESSION_TICKET, + IDX_STATE_SESSION_LISTENER_FLAGS, IDX_STATE_SESSION_CLOSING, IDX_STATE_SESSION_GRACEFUL_CLOSE, IDX_STATE_SESSION_SILENT_CLOSE, @@ -61,15 +76,22 @@ const { IDX_STATE_SESSION_HANDSHAKE_CONFIRMED, IDX_STATE_SESSION_STREAM_OPEN_ALLOWED, IDX_STATE_SESSION_PRIORITY_SUPPORTED, + IDX_STATE_SESSION_HEADERS_SUPPORTED, IDX_STATE_SESSION_WRAPPED, IDX_STATE_SESSION_APPLICATION_TYPE, + IDX_STATE_SESSION_NO_ERROR_CODE, + IDX_STATE_SESSION_INTERNAL_ERROR_CODE, + IDX_STATE_SESSION_MAX_DATAGRAM_SIZE, IDX_STATE_SESSION_LAST_DATAGRAM_ID, + IDX_STATE_SESSION_MAX_PENDING_DATAGRAMS, IDX_STATE_ENDPOINT_BOUND, IDX_STATE_ENDPOINT_RECEIVING, IDX_STATE_ENDPOINT_LISTENING, IDX_STATE_ENDPOINT_CLOSING, IDX_STATE_ENDPOINT_BUSY, + IDX_STATE_ENDPOINT_MAX_CONNECTIONS_PER_HOST, + IDX_STATE_ENDPOINT_MAX_CONNECTIONS_TOTAL, IDX_STATE_ENDPOINT_PENDING_CALLBACKS, IDX_STATE_STREAM_ID, @@ -85,12 +107,13 @@ const { IDX_STATE_STREAM_WANTS_HEADERS, IDX_STATE_STREAM_WANTS_RESET, IDX_STATE_STREAM_WANTS_TRAILERS, + IDX_STATE_STREAM_RECEIVED_EARLY_DATA, + IDX_STATE_STREAM_WRITE_DESIRED_SIZE, + IDX_STATE_STREAM_HIGH_WATER_MARK, + IDX_STATE_STREAM_RESET_CODE, } = internalBinding('quic'); -assert(IDX_STATE_SESSION_PATH_VALIDATION !== undefined); -assert(IDX_STATE_SESSION_VERSION_NEGOTIATION !== undefined); -assert(IDX_STATE_SESSION_DATAGRAM !== undefined); -assert(IDX_STATE_SESSION_SESSION_TICKET !== undefined); +assert(IDX_STATE_SESSION_LISTENER_FLAGS !== undefined); assert(IDX_STATE_SESSION_CLOSING !== undefined); assert(IDX_STATE_SESSION_GRACEFUL_CLOSE !== undefined); assert(IDX_STATE_SESSION_SILENT_CLOSE !== undefined); @@ -99,8 +122,12 @@ assert(IDX_STATE_SESSION_HANDSHAKE_COMPLETED !== undefined); assert(IDX_STATE_SESSION_HANDSHAKE_CONFIRMED !== undefined); assert(IDX_STATE_SESSION_STREAM_OPEN_ALLOWED !== undefined); assert(IDX_STATE_SESSION_PRIORITY_SUPPORTED !== undefined); +assert(IDX_STATE_SESSION_HEADERS_SUPPORTED !== undefined); assert(IDX_STATE_SESSION_WRAPPED !== undefined); assert(IDX_STATE_SESSION_APPLICATION_TYPE !== undefined); +assert(IDX_STATE_SESSION_NO_ERROR_CODE !== undefined); +assert(IDX_STATE_SESSION_INTERNAL_ERROR_CODE !== undefined); +assert(IDX_STATE_SESSION_MAX_DATAGRAM_SIZE !== undefined); assert(IDX_STATE_SESSION_LAST_DATAGRAM_ID !== undefined); assert(IDX_STATE_ENDPOINT_BOUND !== undefined); assert(IDX_STATE_ENDPOINT_RECEIVING !== undefined); @@ -121,6 +148,8 @@ assert(IDX_STATE_STREAM_WANTS_BLOCK !== undefined); assert(IDX_STATE_STREAM_WANTS_HEADERS !== undefined); assert(IDX_STATE_STREAM_WANTS_RESET !== undefined); assert(IDX_STATE_STREAM_WANTS_TRAILERS !== undefined); +assert(IDX_STATE_STREAM_WRITE_DESIRED_SIZE !== undefined); +assert(IDX_STATE_STREAM_RESET_CODE !== undefined); class QuicEndpointState { /** @type {DataView} */ @@ -142,43 +171,69 @@ class QuicEndpointState { /** @type {boolean} */ get isBound() { - if (this.#handle.byteLength === 0) return undefined; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_ENDPOINT_BOUND); } /** @type {boolean} */ get isReceiving() { - if (this.#handle.byteLength === 0) return undefined; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_ENDPOINT_RECEIVING); } /** @type {boolean} */ get isListening() { - if (this.#handle.byteLength === 0) return undefined; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_ENDPOINT_LISTENING); } /** @type {boolean} */ get isClosing() { - if (this.#handle.byteLength === 0) return undefined; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_ENDPOINT_CLOSING); } /** @type {boolean} */ get isBusy() { - if (this.#handle.byteLength === 0) return undefined; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_ENDPOINT_BUSY); } + /** @type {number} */ + get maxConnectionsPerHost() { + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; + return DataViewPrototypeGetUint16( + this.#handle, IDX_STATE_ENDPOINT_MAX_CONNECTIONS_PER_HOST, kIsLittleEndian); + } + + set maxConnectionsPerHost(val) { + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return; + DataViewPrototypeSetUint16( + this.#handle, IDX_STATE_ENDPOINT_MAX_CONNECTIONS_PER_HOST, val, kIsLittleEndian); + } + + /** @type {number} */ + get maxConnectionsTotal() { + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; + return DataViewPrototypeGetUint16( + this.#handle, IDX_STATE_ENDPOINT_MAX_CONNECTIONS_TOTAL, kIsLittleEndian); + } + + set maxConnectionsTotal(val) { + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return; + DataViewPrototypeSetUint16( + this.#handle, IDX_STATE_ENDPOINT_MAX_CONNECTIONS_TOTAL, val, kIsLittleEndian); + } + /** - * The number of underlying callbacks that are pending. If the session - * is closing, these are the number of callbacks that the session is + * The number of underlying callbacks that are pending. If the endpoint + * is closing, these are the number of callbacks that the endpoint is * waiting on before it can be closed. * @type {bigint} */ get pendingCallbacks() { - if (this.#handle.byteLength === 0) return undefined; - return DataViewPrototypeGetBigUint64(this.#handle, IDX_STATE_ENDPOINT_PENDING_CALLBACKS); + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; + return DataViewPrototypeGetBigUint64(this.#handle, IDX_STATE_ENDPOINT_PENDING_CALLBACKS, kIsLittleEndian); } toString() { @@ -186,7 +241,7 @@ class QuicEndpointState { } toJSON() { - if (this.#handle.byteLength === 0) return {}; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return {}; return { __proto__: null, isBound: this.isBound, @@ -194,6 +249,8 @@ class QuicEndpointState { isListening: this.isListening, isClosing: this.isClosing, isBusy: this.isBusy, + maxConnectionsPerHost: this.maxConnectionsPerHost, + maxConnectionsTotal: this.maxConnectionsTotal, pendingCallbacks: `${this.pendingCallbacks}`, }; } @@ -202,11 +259,12 @@ class QuicEndpointState { if (depth < 0) return this; - if (this.#handle.byteLength === 0) { + if (DataViewPrototypeGetByteLength(this.#handle) === 0) { return 'QuicEndpointState { }'; } const opts = { + __proto__: null, ...options, depth: options.depth == null ? null : options.depth - 1, }; @@ -224,7 +282,7 @@ class QuicEndpointState { [kFinishClose]() { // Snapshot the state into a new DataView since the underlying // buffer will be destroyed. - if (this.#handle.byteLength === 0) return; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return; this.#handle = new DataView(new ArrayBuffer(0)); } } @@ -247,118 +305,199 @@ class QuicSessionState { this.#handle = new DataView(buffer); } - /** @type {boolean} */ - get hasPathValidationListener() { - if (this.#handle.byteLength === 0) return undefined; - return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_SESSION_PATH_VALIDATION); - } + // Listener flags are packed into a single uint32_t bitfield. The bit + // positions must match the SessionListenerFlags enum in session.cc. + static #LISTENER_PATH_VALIDATION = 1 << 0; + static #LISTENER_DATAGRAM = 1 << 1; + static #LISTENER_DATAGRAM_STATUS = 1 << 2; + static #LISTENER_SESSION_TICKET = 1 << 3; + static #LISTENER_NEW_TOKEN = 1 << 4; + static #LISTENER_ORIGIN = 1 << 5; - /** @type {boolean} */ - set hasPathValidationListener(val) { - if (this.#handle.byteLength === 0) return; - DataViewPrototypeSetUint8(this.#handle, IDX_STATE_SESSION_PATH_VALIDATION, val ? 1 : 0); + #getListenerFlag(flag) { + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; + return !!(DataViewPrototypeGetUint32( + this.#handle, IDX_STATE_SESSION_LISTENER_FLAGS, kIsLittleEndian) & flag); } - /** @type {boolean} */ - get hasVersionNegotiationListener() { - if (this.#handle.byteLength === 0) return undefined; - return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_SESSION_VERSION_NEGOTIATION); + #setListenerFlag(flag, val) { + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return; + const current = DataViewPrototypeGetUint32( + this.#handle, IDX_STATE_SESSION_LISTENER_FLAGS, kIsLittleEndian); + DataViewPrototypeSetUint32( + this.#handle, IDX_STATE_SESSION_LISTENER_FLAGS, + val ? (current | flag) : (current & ~flag), kIsLittleEndian); } /** @type {boolean} */ - set hasVersionNegotiationListener(val) { - if (this.#handle.byteLength === 0) return; - DataViewPrototypeSetUint8(this.#handle, IDX_STATE_SESSION_VERSION_NEGOTIATION, val ? 1 : 0); + get hasPathValidationListener() { + return this.#getListenerFlag(QuicSessionState.#LISTENER_PATH_VALIDATION); + } + set hasPathValidationListener(val) { + this.#setListenerFlag(QuicSessionState.#LISTENER_PATH_VALIDATION, val); } /** @type {boolean} */ get hasDatagramListener() { - if (this.#handle.byteLength === 0) return undefined; - return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_SESSION_DATAGRAM); + return this.#getListenerFlag(QuicSessionState.#LISTENER_DATAGRAM); + } + set hasDatagramListener(val) { + this.#setListenerFlag(QuicSessionState.#LISTENER_DATAGRAM, val); } /** @type {boolean} */ - set hasDatagramListener(val) { - if (this.#handle.byteLength === 0) return; - DataViewPrototypeSetUint8(this.#handle, IDX_STATE_SESSION_DATAGRAM, val ? 1 : 0); + get hasDatagramStatusListener() { + return this.#getListenerFlag(QuicSessionState.#LISTENER_DATAGRAM_STATUS); + } + set hasDatagramStatusListener(val) { + this.#setListenerFlag(QuicSessionState.#LISTENER_DATAGRAM_STATUS, val); } /** @type {boolean} */ get hasSessionTicketListener() { - if (this.#handle.byteLength === 0) return undefined; - return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_SESSION_SESSION_TICKET); + return this.#getListenerFlag(QuicSessionState.#LISTENER_SESSION_TICKET); + } + set hasSessionTicketListener(val) { + this.#setListenerFlag(QuicSessionState.#LISTENER_SESSION_TICKET, val); } /** @type {boolean} */ - set hasSessionTicketListener(val) { - if (this.#handle.byteLength === 0) return; - DataViewPrototypeSetUint8(this.#handle, IDX_STATE_SESSION_SESSION_TICKET, val ? 1 : 0); + get hasNewTokenListener() { + return this.#getListenerFlag(QuicSessionState.#LISTENER_NEW_TOKEN); + } + set hasNewTokenListener(val) { + this.#setListenerFlag(QuicSessionState.#LISTENER_NEW_TOKEN, val); + } + + /** @type {boolean} */ + get hasOriginListener() { + return this.#getListenerFlag(QuicSessionState.#LISTENER_ORIGIN); + } + set hasOriginListener(val) { + this.#setListenerFlag(QuicSessionState.#LISTENER_ORIGIN, val); } /** @type {boolean} */ get isClosing() { - if (this.#handle.byteLength === 0) return undefined; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_SESSION_CLOSING); } /** @type {boolean} */ get isGracefulClose() { - if (this.#handle.byteLength === 0) return undefined; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_SESSION_GRACEFUL_CLOSE); } /** @type {boolean} */ get isSilentClose() { - if (this.#handle.byteLength === 0) return undefined; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_SESSION_SILENT_CLOSE); } /** @type {boolean} */ get isStatelessReset() { - if (this.#handle.byteLength === 0) return undefined; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_SESSION_STATELESS_RESET); } /** @type {boolean} */ get isHandshakeCompleted() { - if (this.#handle.byteLength === 0) return undefined; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_SESSION_HANDSHAKE_COMPLETED); } /** @type {boolean} */ get isHandshakeConfirmed() { - if (this.#handle.byteLength === 0) return undefined; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_SESSION_HANDSHAKE_CONFIRMED); } /** @type {boolean} */ get isStreamOpenAllowed() { - if (this.#handle.byteLength === 0) return undefined; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_SESSION_STREAM_OPEN_ALLOWED); } /** @type {boolean} */ get isPrioritySupported() { - if (this.#handle.byteLength === 0) return undefined; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_SESSION_PRIORITY_SUPPORTED); } + /** + * Whether the negotiated application protocol supports headers. + * Returns 0 (unknown), 1 (supported), or 2 (not supported). + * @type {number} + */ + get headersSupported() { + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; + return DataViewPrototypeGetUint8(this.#handle, IDX_STATE_SESSION_HEADERS_SUPPORTED); + } + /** @type {boolean} */ get isWrapped() { - if (this.#handle.byteLength === 0) return undefined; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_SESSION_WRAPPED); } /** @type {number} */ get applicationType() { - if (this.#handle.byteLength === 0) return undefined; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; return DataViewPrototypeGetUint8(this.#handle, IDX_STATE_SESSION_APPLICATION_TYPE); } + /** + * The negotiated application protocol's "no error" code, populated + * by the C++ layer when the application is selected during ALPN + * negotiation. For raw QUIC this is `0n`; for HTTP/3 this is + * `0x100n` (`H3_NO_ERROR`). + * @type {bigint} + */ + get noErrorCode() { + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; + return DataViewPrototypeGetBigUint64( + this.#handle, IDX_STATE_SESSION_NO_ERROR_CODE, kIsLittleEndian); + } + + /** + * The negotiated application protocol's "internal error" code, + * populated by the C++ layer when the application is selected + * during ALPN negotiation. Used as the wire code for `RESET_STREAM` + * frames when a stream is aborted without a more specific code. + * For raw QUIC this is `0x1n` (NGTCP2_INTERNAL_ERROR); for HTTP/3 + * this is `0x102n` (`H3_INTERNAL_ERROR`). + * @type {bigint} + */ + get internalErrorCode() { + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; + return DataViewPrototypeGetBigUint64( + this.#handle, IDX_STATE_SESSION_INTERNAL_ERROR_CODE, kIsLittleEndian); + } + + /** @type {number} */ + get maxDatagramSize() { + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; + return DataViewPrototypeGetUint16(this.#handle, IDX_STATE_SESSION_MAX_DATAGRAM_SIZE, kIsLittleEndian); + } + /** @type {bigint} */ get lastDatagramId() { - if (this.#handle.byteLength === 0) return undefined; - return DataViewPrototypeGetBigUint64(this.#handle, IDX_STATE_SESSION_LAST_DATAGRAM_ID); + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; + return DataViewPrototypeGetBigUint64(this.#handle, IDX_STATE_SESSION_LAST_DATAGRAM_ID, kIsLittleEndian); + } + + /** @type {number} */ + get maxPendingDatagrams() { + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; + return DataViewPrototypeGetUint16( + this.#handle, IDX_STATE_SESSION_MAX_PENDING_DATAGRAMS, kIsLittleEndian); + } + + set maxPendingDatagrams(val) { + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return; + DataViewPrototypeSetUint16( + this.#handle, IDX_STATE_SESSION_MAX_PENDING_DATAGRAMS, val, kIsLittleEndian); } toString() { @@ -366,24 +505,31 @@ class QuicSessionState { } toJSON() { - if (this.#handle.byteLength === 0) return {}; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return {}; return { __proto__: null, hasPathValidationListener: this.hasPathValidationListener, - hasVersionNegotiationListener: this.hasVersionNegotiationListener, hasDatagramListener: this.hasDatagramListener, + hasDatagramStatusListener: this.hasDatagramStatusListener, hasSessionTicketListener: this.hasSessionTicketListener, + hasNewTokenListener: this.hasNewTokenListener, + hasOriginListener: this.hasOriginListener, isClosing: this.isClosing, isGracefulClose: this.isGracefulClose, isSilentClose: this.isSilentClose, isStatelessReset: this.isStatelessReset, - isDestroyed: this.isDestroyed, isHandshakeCompleted: this.isHandshakeCompleted, isHandshakeConfirmed: this.isHandshakeConfirmed, isStreamOpenAllowed: this.isStreamOpenAllowed, isPrioritySupported: this.isPrioritySupported, + headersSupported: this.headersSupported, isWrapped: this.isWrapped, + applicationType: this.applicationType, + noErrorCode: `${this.noErrorCode}`, + internalErrorCode: `${this.internalErrorCode}`, + maxDatagramSize: `${this.maxDatagramSize}`, lastDatagramId: `${this.lastDatagramId}`, + maxPendingDatagrams: this.maxPendingDatagrams, }; } @@ -391,31 +537,37 @@ class QuicSessionState { if (depth < 0) return this; - if (this.#handle.byteLength === 0) { + if (DataViewPrototypeGetByteLength(this.#handle) === 0) { return 'QuicSessionState { }'; } const opts = { + __proto__: null, ...options, depth: options.depth == null ? null : options.depth - 1, }; return `QuicSessionState ${inspect({ hasPathValidationListener: this.hasPathValidationListener, - hasVersionNegotiationListener: this.hasVersionNegotiationListener, hasDatagramListener: this.hasDatagramListener, + hasDatagramStatusListener: this.hasDatagramStatusListener, hasSessionTicketListener: this.hasSessionTicketListener, + hasNewTokenListener: this.hasNewTokenListener, + hasOriginListener: this.hasOriginListener, isClosing: this.isClosing, isGracefulClose: this.isGracefulClose, isSilentClose: this.isSilentClose, isStatelessReset: this.isStatelessReset, - isDestroyed: this.isDestroyed, isHandshakeCompleted: this.isHandshakeCompleted, isHandshakeConfirmed: this.isHandshakeConfirmed, isStreamOpenAllowed: this.isStreamOpenAllowed, isPrioritySupported: this.isPrioritySupported, + headersSupported: this.headersSupported, isWrapped: this.isWrapped, applicationType: this.applicationType, + noErrorCode: this.noErrorCode, + internalErrorCode: this.internalErrorCode, + maxDatagramSize: this.maxDatagramSize, lastDatagramId: this.lastDatagramId, }, opts)}`; } @@ -423,7 +575,7 @@ class QuicSessionState { [kFinishClose]() { // Snapshot the state into a new DataView since the underlying // buffer will be destroyed. - if (this.#handle.byteLength === 0) return; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return; this.#handle = new DataView(new ArrayBuffer(0)); } } @@ -448,113 +600,152 @@ class QuicStreamState { /** @type {bigint} */ get id() { - if (this.#handle.byteLength === 0) return undefined; - return DataViewPrototypeGetBigInt64(this.#handle, IDX_STATE_STREAM_ID); + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; + return DataViewPrototypeGetBigInt64(this.#handle, IDX_STATE_STREAM_ID, kIsLittleEndian); } /** @type {boolean} */ get pending() { - if (this.#handle.byteLength === 0) return undefined; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_STREAM_PENDING); } /** @type {boolean} */ get finSent() { - if (this.#handle.byteLength === 0) return undefined; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_STREAM_FIN_SENT); } /** @type {boolean} */ get finReceived() { - if (this.#handle.byteLength === 0) return undefined; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_STREAM_FIN_RECEIVED); } /** @type {boolean} */ get readEnded() { - if (this.#handle.byteLength === 0) return undefined; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_STREAM_READ_ENDED); } /** @type {boolean} */ get writeEnded() { - if (this.#handle.byteLength === 0) return undefined; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_STREAM_WRITE_ENDED); } /** @type {boolean} */ get reset() { - if (this.#handle.byteLength === 0) return undefined; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_STREAM_RESET); } /** @type {boolean} */ get hasOutbound() { - if (this.#handle.byteLength === 0) return undefined; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_STREAM_HAS_OUTBOUND); } /** @type {boolean} */ get hasReader() { - if (this.#handle.byteLength === 0) return undefined; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_STREAM_HAS_READER); } /** @type {boolean} */ get wantsBlock() { - if (this.#handle.byteLength === 0) return undefined; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_STREAM_WANTS_BLOCK); } /** @type {boolean} */ set wantsBlock(val) { - if (this.#handle.byteLength === 0) return; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return; DataViewPrototypeSetUint8(this.#handle, IDX_STATE_STREAM_WANTS_BLOCK, val ? 1 : 0); } /** @type {boolean} */ get [kWantsHeaders]() { - if (this.#handle.byteLength === 0) return undefined; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_STREAM_WANTS_HEADERS); } /** @type {boolean} */ set [kWantsHeaders](val) { - if (this.#handle.byteLength === 0) return; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return; DataViewPrototypeSetUint8(this.#handle, IDX_STATE_STREAM_WANTS_HEADERS, val ? 1 : 0); } /** @type {boolean} */ get wantsReset() { - if (this.#handle.byteLength === 0) return undefined; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_STREAM_WANTS_RESET); } /** @type {boolean} */ set wantsReset(val) { - if (this.#handle.byteLength === 0) return; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return; DataViewPrototypeSetUint8(this.#handle, IDX_STATE_STREAM_WANTS_RESET, val ? 1 : 0); } /** @type {boolean} */ get [kWantsTrailers]() { - if (this.#handle.byteLength === 0) return undefined; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_STREAM_WANTS_TRAILERS); } /** @type {boolean} */ set [kWantsTrailers](val) { - if (this.#handle.byteLength === 0) return; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return; DataViewPrototypeSetUint8(this.#handle, IDX_STATE_STREAM_WANTS_TRAILERS, val ? 1 : 0); } + /** @type {boolean} */ + get early() { + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; + return !!DataViewPrototypeGetUint8(this.#handle, IDX_STATE_STREAM_RECEIVED_EARLY_DATA); + } + + /** @type {bigint} */ + get resetCode() { + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; + return DataViewPrototypeGetBigUint64( + this.#handle, IDX_STATE_STREAM_RESET_CODE, kIsLittleEndian); + } + + /** @type {bigint} */ + get writeDesiredSize() { + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; + return DataViewPrototypeGetUint32( + this.#handle, IDX_STATE_STREAM_WRITE_DESIRED_SIZE, kIsLittleEndian); + } + + set writeDesiredSize(val) { + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return; + DataViewPrototypeSetUint32( + this.#handle, IDX_STATE_STREAM_WRITE_DESIRED_SIZE, val, kIsLittleEndian); + } + + /** @type {number} */ + get highWaterMark() { + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return undefined; + return DataViewPrototypeGetUint32( + this.#handle, IDX_STATE_STREAM_HIGH_WATER_MARK, kIsLittleEndian); + } + + set highWaterMark(val) { + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return; + DataViewPrototypeSetUint32( + this.#handle, IDX_STATE_STREAM_HIGH_WATER_MARK, val, kIsLittleEndian); + } + toString() { return JSONStringify(this.toJSON()); } toJSON() { - if (this.#handle.byteLength === 0) return {}; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return {}; return { __proto__: null, id: `${this.id}`, @@ -568,6 +759,7 @@ class QuicStreamState { hasReader: this.hasReader, wantsBlock: this.wantsBlock, wantsReset: this.wantsReset, + early: this.early, }; } @@ -575,11 +767,12 @@ class QuicStreamState { if (depth < 0) return this; - if (this.#handle.byteLength === 0) { + if (DataViewPrototypeGetByteLength(this.#handle) === 0) { return 'QuicStreamState { }'; } const opts = { + __proto__: null, ...options, depth: options.depth == null ? null : options.depth - 1, }; @@ -596,13 +789,14 @@ class QuicStreamState { hasReader: this.hasReader, wantsBlock: this.wantsBlock, wantsReset: this.wantsReset, + early: this.early, }, opts)}`; } [kFinishClose]() { // Snapshot the state into a new DataView since the underlying // buffer will be destroyed. - if (this.#handle.byteLength === 0) return; + if (DataViewPrototypeGetByteLength(this.#handle) === 0) return; this.#handle = new DataView(new ArrayBuffer(0)); } } diff --git a/lib/internal/quic/stats.js b/lib/internal/quic/stats.js index a612356250a06c..1c64b7c8227f68 100644 --- a/lib/internal/quic/stats.js +++ b/lib/internal/quic/stats.js @@ -58,11 +58,11 @@ const { IDX_STATS_ENDPOINT_IMMEDIATE_CLOSE_COUNT, IDX_STATS_SESSION_CREATED_AT, + IDX_STATS_SESSION_DESTROYED_AT, IDX_STATS_SESSION_CLOSING_AT, IDX_STATS_SESSION_HANDSHAKE_COMPLETED_AT, IDX_STATS_SESSION_HANDSHAKE_CONFIRMED_AT, IDX_STATS_SESSION_BYTES_RECEIVED, - IDX_STATS_SESSION_BYTES_SENT, IDX_STATS_SESSION_BIDI_IN_STREAM_COUNT, IDX_STATS_SESSION_BIDI_OUT_STREAM_COUNT, IDX_STATS_SESSION_UNI_IN_STREAM_COUNT, @@ -76,6 +76,15 @@ const { IDX_STATS_SESSION_RTTVAR, IDX_STATS_SESSION_SMOOTHED_RTT, IDX_STATS_SESSION_SSTHRESH, + IDX_STATS_SESSION_PKT_SENT, + IDX_STATS_SESSION_BYTES_SENT, + IDX_STATS_SESSION_PKT_RECV, + IDX_STATS_SESSION_BYTES_RECV, + IDX_STATS_SESSION_PKT_LOST, + IDX_STATS_SESSION_BYTES_LOST, + IDX_STATS_SESSION_PING_RECV, + IDX_STATS_SESSION_PKT_DISCARDED, + IDX_STATS_SESSION_DATAGRAMS_RECEIVED, IDX_STATS_SESSION_DATAGRAMS_SENT, IDX_STATS_SESSION_DATAGRAMS_ACKNOWLEDGED, @@ -108,11 +117,11 @@ assert(IDX_STATS_ENDPOINT_VERSION_NEGOTIATION_COUNT !== undefined); assert(IDX_STATS_ENDPOINT_STATELESS_RESET_COUNT !== undefined); assert(IDX_STATS_ENDPOINT_IMMEDIATE_CLOSE_COUNT !== undefined); assert(IDX_STATS_SESSION_CREATED_AT !== undefined); +assert(IDX_STATS_SESSION_DESTROYED_AT !== undefined); assert(IDX_STATS_SESSION_CLOSING_AT !== undefined); assert(IDX_STATS_SESSION_HANDSHAKE_COMPLETED_AT !== undefined); assert(IDX_STATS_SESSION_HANDSHAKE_CONFIRMED_AT !== undefined); assert(IDX_STATS_SESSION_BYTES_RECEIVED !== undefined); -assert(IDX_STATS_SESSION_BYTES_SENT !== undefined); assert(IDX_STATS_SESSION_BIDI_IN_STREAM_COUNT !== undefined); assert(IDX_STATS_SESSION_BIDI_OUT_STREAM_COUNT !== undefined); assert(IDX_STATS_SESSION_UNI_IN_STREAM_COUNT !== undefined); @@ -126,6 +135,14 @@ assert(IDX_STATS_SESSION_MIN_RTT !== undefined); assert(IDX_STATS_SESSION_RTTVAR !== undefined); assert(IDX_STATS_SESSION_SMOOTHED_RTT !== undefined); assert(IDX_STATS_SESSION_SSTHRESH !== undefined); +assert(IDX_STATS_SESSION_PKT_SENT !== undefined); +assert(IDX_STATS_SESSION_BYTES_SENT !== undefined); +assert(IDX_STATS_SESSION_PKT_RECV !== undefined); +assert(IDX_STATS_SESSION_BYTES_RECV !== undefined); +assert(IDX_STATS_SESSION_PKT_LOST !== undefined); +assert(IDX_STATS_SESSION_BYTES_LOST !== undefined); +assert(IDX_STATS_SESSION_PING_RECV !== undefined); +assert(IDX_STATS_SESSION_PKT_DISCARDED !== undefined); assert(IDX_STATS_SESSION_DATAGRAMS_RECEIVED !== undefined); assert(IDX_STATS_SESSION_DATAGRAMS_SENT !== undefined); assert(IDX_STATS_SESSION_DATAGRAMS_ACKNOWLEDGED !== undefined); @@ -260,6 +277,7 @@ class QuicEndpointStats { return this; const opts = { + __proto__: null, ...options, depth: options.depth == null ? null : options.depth - 1, }; @@ -286,7 +304,7 @@ class QuicEndpointStats { * True if this QuicEndpointStats object is still connected to the underlying * Endpoint stats source. If this returns false, then the stats object is * no longer being updated and should be considered stale. - * @returns {boolean} + * @type {boolean} */ get isConnected() { return !this.#disconnected; @@ -308,7 +326,7 @@ class QuicSessionStats { /** * @param {symbol} privateSymbol - * @param {BigUint64Array} buffer + * @param {ArrayBuffer} buffer */ constructor(privateSymbol, buffer) { // We use the kPrivateConstructor symbol to restrict the ability to @@ -327,6 +345,11 @@ class QuicSessionStats { return this.#handle[IDX_STATS_SESSION_CREATED_AT]; } + /** @type {bigint} */ + get destroyedAt() { + return this.#handle[IDX_STATS_SESSION_DESTROYED_AT]; + } + /** @type {bigint} */ get closingAt() { return this.#handle[IDX_STATS_SESSION_CLOSING_AT]; @@ -347,11 +370,6 @@ class QuicSessionStats { return this.#handle[IDX_STATS_SESSION_BYTES_RECEIVED]; } - /** @type {bigint} */ - get bytesSent() { - return this.#handle[IDX_STATS_SESSION_BYTES_SENT]; - } - /** @type {bigint} */ get bidiInStreamCount() { return this.#handle[IDX_STATS_SESSION_BIDI_IN_STREAM_COUNT]; @@ -373,7 +391,7 @@ class QuicSessionStats { } /** @type {bigint} */ - get maxBytesInFlights() { + get maxBytesInFlight() { return this.#handle[IDX_STATS_SESSION_MAX_BYTES_IN_FLIGHT]; } @@ -417,6 +435,38 @@ class QuicSessionStats { return this.#handle[IDX_STATS_SESSION_SSTHRESH]; } + get pktSent() { + return this.#handle[IDX_STATS_SESSION_PKT_SENT]; + } + + get bytesSent() { + return this.#handle[IDX_STATS_SESSION_BYTES_SENT]; + } + + get pktRecv() { + return this.#handle[IDX_STATS_SESSION_PKT_RECV]; + } + + get bytesRecv() { + return this.#handle[IDX_STATS_SESSION_BYTES_RECV]; + } + + get pktLost() { + return this.#handle[IDX_STATS_SESSION_PKT_LOST]; + } + + get bytesLost() { + return this.#handle[IDX_STATS_SESSION_BYTES_LOST]; + } + + get pingRecv() { + return this.#handle[IDX_STATS_SESSION_PING_RECV]; + } + + get pktDiscarded() { + return this.#handle[IDX_STATS_SESSION_PKT_DISCARDED]; + } + /** @type {bigint} */ get datagramsReceived() { return this.#handle[IDX_STATS_SESSION_DATAGRAMS_RECEIVED]; @@ -449,17 +499,14 @@ class QuicSessionStats { // support BigInts. createdAt: `${this.createdAt}`, closingAt: `${this.closingAt}`, - destroyedAt: `${this.destroyedAt}`, handshakeCompletedAt: `${this.handshakeCompletedAt}`, handshakeConfirmedAt: `${this.handshakeConfirmedAt}`, - gracefulClosingAt: `${this.gracefulClosingAt}`, bytesReceived: `${this.bytesReceived}`, - bytesSent: `${this.bytesSent}`, bidiInStreamCount: `${this.bidiInStreamCount}`, bidiOutStreamCount: `${this.bidiOutStreamCount}`, uniInStreamCount: `${this.uniInStreamCount}`, uniOutStreamCount: `${this.uniOutStreamCount}`, - maxBytesInFlights: `${this.maxBytesInFlights}`, + maxBytesInFlight: `${this.maxBytesInFlight}`, bytesInFlight: `${this.bytesInFlight}`, blockCount: `${this.blockCount}`, cwnd: `${this.cwnd}`, @@ -468,6 +515,14 @@ class QuicSessionStats { rttVar: `${this.rttVar}`, smoothedRtt: `${this.smoothedRtt}`, ssthresh: `${this.ssthresh}`, + pktSent: `${this.pktSent}`, + bytesSent: `${this.bytesSent}`, + pktRecv: `${this.pktRecv}`, + bytesRecv: `${this.bytesRecv}`, + pktLost: `${this.pktLost}`, + bytesLost: `${this.bytesLost}`, + pingRecv: `${this.pingRecv}`, + pktDiscarded: `${this.pktDiscarded}`, datagramsReceived: `${this.datagramsReceived}`, datagramsSent: `${this.datagramsSent}`, datagramsAcknowledged: `${this.datagramsAcknowledged}`, @@ -480,6 +535,7 @@ class QuicSessionStats { return this; const opts = { + __proto__: null, ...options, depth: options.depth == null ? null : options.depth - 1, }; @@ -488,17 +544,14 @@ class QuicSessionStats { connected: this.isConnected, createdAt: this.createdAt, closingAt: this.closingAt, - destroyedAt: this.destroyedAt, handshakeCompletedAt: this.handshakeCompletedAt, handshakeConfirmedAt: this.handshakeConfirmedAt, - gracefulClosingAt: this.gracefulClosingAt, bytesReceived: this.bytesReceived, - bytesSent: this.bytesSent, bidiInStreamCount: this.bidiInStreamCount, bidiOutStreamCount: this.bidiOutStreamCount, uniInStreamCount: this.uniInStreamCount, uniOutStreamCount: this.uniOutStreamCount, - maxBytesInFlights: this.maxBytesInFlights, + maxBytesInFlight: this.maxBytesInFlight, bytesInFlight: this.bytesInFlight, blockCount: this.blockCount, cwnd: this.cwnd, @@ -507,6 +560,14 @@ class QuicSessionStats { rttVar: this.rttVar, smoothedRtt: this.smoothedRtt, ssthresh: this.ssthresh, + pktSent: this.pktSent, + bytesSent: this.bytesSent, + pktRecv: this.pktRecv, + bytesRecv: this.bytesRecv, + pktLost: this.pktLost, + bytesLost: this.bytesLost, + pingRecv: this.pingRecv, + pktDiscarded: this.pktDiscarded, datagramsReceived: this.datagramsReceived, datagramsSent: this.datagramsSent, datagramsAcknowledged: this.datagramsAcknowledged, @@ -518,7 +579,7 @@ class QuicSessionStats { * True if this QuicSessionStats object is still connected to the underlying * Session stats source. If this returns false, then the stats object is * no longer being updated and should be considered stale. - * @returns {boolean} + * @type {boolean} */ get isConnected() { return !this.#disconnected; @@ -638,11 +699,12 @@ class QuicStreamStats { return this; const opts = { + __proto__: null, ...options, depth: options.depth == null ? null : options.depth - 1, }; - return `StreamStats ${inspect({ + return `QuicStreamStats ${inspect({ connected: this.isConnected, createdAt: this.createdAt, openedAt: this.openedAt, @@ -662,7 +724,7 @@ class QuicStreamStats { * True if this QuicStreamStats object is still connected to the underlying * Stream stats source. If this returns false, then the stats object is * no longer being updated and should be considered stale. - * @returns {boolean} + * @type {boolean} */ get isConnected() { return !this.#disconnected; diff --git a/lib/internal/quic/symbols.js b/lib/internal/quic/symbols.js index 1a6c56b1a0ae9d..973db27bc7cae9 100644 --- a/lib/internal/quic/symbols.js +++ b/lib/internal/quic/symbols.js @@ -23,18 +23,26 @@ const { // Symbols used to hide various private properties and methods from the // public API. +const kAttachFileHandle = Symbol('kAttachFileHandle'); const kBlocked = Symbol('kBlocked'); const kConnect = Symbol('kConnect'); +const kDrain = Symbol('kDrain'); const kDatagram = Symbol('kDatagram'); const kDatagramStatus = Symbol('kDatagramStatus'); +const kEarlyDataRejected = Symbol('kEarlyDataRejected'); const kFinishClose = Symbol('kFinishClose'); +const kGoaway = Symbol('kGoaway'); const kHandshake = Symbol('kHandshake'); +const kHandshakeCompleted = Symbol('kHandshakeCompleted'); const kHeaders = Symbol('kHeaders'); +const kKeylog = Symbol('kKeylog'); const kListen = Symbol('kListen'); +const kQlog = Symbol('kQlog'); const kNewSession = Symbol('kNewSession'); const kNewStream = Symbol('kNewStream'); -const kOnHeaders = Symbol('kOnHeaders'); -const kOnTrailers = Symbol('kOwnTrailers'); +const kNewToken = Symbol('kNewToken'); +const kStreamCallbacks = Symbol('kStreamCallbacks'); +const kOrigin = Symbol('kOrigin'); const kOwner = Symbol('kOwner'); const kPathValidation = Symbol('kPathValidation'); const kPrivateConstructor = Symbol('kPrivateConstructor'); @@ -49,21 +57,29 @@ const kWantsHeaders = Symbol('kWantsHeaders'); const kWantsTrailers = Symbol('kWantsTrailers'); module.exports = { + kAttachFileHandle, kBlocked, kConnect, kDatagram, kDatagramStatus, + kDrain, + kEarlyDataRejected, kFinishClose, + kGoaway, kHandshake, + kHandshakeCompleted, kHeaders, kInspect, + kKeylog, kKeyObjectHandle, kListen, kNewSession, kNewStream, - kOnHeaders, - kOnTrailers, + kNewToken, + kStreamCallbacks, + kOrigin, kOwner, + kQlog, kPathValidation, kPrivateConstructor, kRemoveSession, diff --git a/lib/quic.js b/lib/quic.js index d14a3a7406daf5..00e241015a361b 100644 --- a/lib/quic.js +++ b/lib/quic.js @@ -14,6 +14,7 @@ const { connect, listen, QuicEndpoint, + QuicError, QuicSession, QuicStream, CC_ALGO_RENO, @@ -52,6 +53,7 @@ module.exports = ObjectSeal(ObjectCreate(null, { connect: getEnumerableConstant(connect), listen: getEnumerableConstant(listen), QuicEndpoint: getEnumerableConstant(QuicEndpoint), + QuicError: getEnumerableConstant(QuicError), QuicSession: getEnumerableConstant(QuicSession), QuicStream: getEnumerableConstant(QuicStream), constants: getEnumerableConstant(constants), diff --git a/node.gyp b/node.gyp index b129c3db8d88c1..c06e95a98e5ce9 100644 --- a/node.gyp +++ b/node.gyp @@ -348,7 +348,6 @@ 'src/quic/bindingdata.cc', 'src/quic/cid.cc', 'src/quic/data.cc', - 'src/quic/logstream.cc', 'src/quic/packet.cc', 'src/quic/preferredaddress.cc', 'src/quic/sessionticket.cc', @@ -357,6 +356,7 @@ 'src/quic/endpoint.cc', 'src/quic/http3.cc', 'src/quic/session.cc', + 'src/quic/session_manager.cc', 'src/quic/streams.cc', 'src/quic/tlscontext.cc', 'src/quic/transportparams.cc', @@ -366,7 +366,6 @@ 'src/quic/cid.h', 'src/quic/data.h', 'src/quic/defs.h', - 'src/quic/logstream.h', 'src/quic/packet.h', 'src/quic/preferredaddress.h', 'src/quic/sessionticket.h', @@ -376,6 +375,7 @@ 'src/quic/endpoint.h', 'src/quic/http3.h', 'src/quic/session.h', + 'src/quic/session_manager.h', 'src/quic/streams.h', 'src/quic/tlscontext.h', 'src/quic/guard.h', diff --git a/src/dataqueue/queue.cc b/src/dataqueue/queue.cc index 537844806d3087..283d441e9e6336 100644 --- a/src/dataqueue/queue.cc +++ b/src/dataqueue/queue.cc @@ -391,10 +391,11 @@ class NonIdempotentDataQueueReader final // If the collection of entries is empty, there's nothing currently left to // read. How we respond depends on whether the data queue has been capped // or not. + if (data_queue_->entries_.empty()) { // If the data_queue_ is empty, and not capped, then we can reasonably // expect more data to be provided later, but we don't know exactly when - // that'll happe, so the proper response here is to return a blocked + // that'll happen, so the proper response here is to return a blocked // status. if (!data_queue_->is_capped()) { std::move(next)(bob::Status::STATUS_BLOCK, nullptr, 0, [](uint64_t) {}); @@ -437,8 +438,11 @@ class NonIdempotentDataQueueReader final CHECK(!pull_pending_); pull_pending_ = true; int status = current_reader->Pull( - [this, next = std::move(next)]( - int status, const DataQueue::Vec* vecs, uint64_t count, Done done) { + [this, next = std::move(next), options, data, count, max_count_hint]( + int status, + const DataQueue::Vec* vecs, + uint64_t vcount, + Done done) mutable { pull_pending_ = false; // In each of these cases, we do not expect that the source will @@ -446,13 +450,27 @@ class NonIdempotentDataQueueReader final CHECK_IMPLIES(status == bob::Status::STATUS_BLOCK || status == bob::Status::STATUS_WAIT || status == bob::Status::STATUS_EOS, - vecs == nullptr && count == 0); + vecs == nullptr && vcount == 0); if (status == bob::Status::STATUS_EOS) { data_queue_->entries_.erase(data_queue_->entries_.begin()); - ended_ = data_queue_->entries_.empty(); current_reader_ = nullptr; - if (!ended_) status = bob::Status::STATUS_CONTINUE; - std::move(next)(status, nullptr, 0, [](uint64_t) {}); + if (!data_queue_->entries_.empty()) { + // More entries remain. Pull from the next entry immediately + // rather than returning empty CONTINUE, which would leave + // callers with no data and no way to know they should retry. + Pull(std::move(next), options, data, count, max_count_hint); + } else if (!data_queue_->is_capped()) { + // The queue is empty but not capped — more data may arrive + // later. Return BLOCK so the consumer waits rather than + // falsely treating this as end-of-stream. + std::move(next)( + bob::Status::STATUS_BLOCK, nullptr, 0, [](uint64_t) {}); + } else { + // Empty and capped — truly done. + ended_ = true; + std::move(next)( + bob::Status::STATUS_EOS, nullptr, 0, [](uint64_t) {}); + } return; } @@ -461,7 +479,7 @@ class NonIdempotentDataQueueReader final if (data_queue_->HasBackpressureListeners()) { // How much did we actually read? size_t read = 0; - for (uint64_t n = 0; n < count; n++) { + for (uint64_t n = 0; n < vcount; n++) { read += vecs[n].len; } data_queue_->NotifyBackpressure(read); @@ -469,7 +487,7 @@ class NonIdempotentDataQueueReader final // Now that we have updated this readers state, we can forward // everything on to the outer next. - std::move(next)(status, vecs, count, std::move(done)); + std::move(next)(status, vecs, vcount, std::move(done)); }, options, data, diff --git a/src/debug_utils.h b/src/debug_utils.h index ffb8fe270018ee..52895a474b4ea4 100644 --- a/src/debug_utils.h +++ b/src/debug_utils.h @@ -54,7 +54,8 @@ void NODE_EXTERN_PRIVATE FWrite(FILE* file, const std::string& str); V(INSPECTOR_CLIENT) \ V(INSPECTOR_PROFILER) \ V(CODE_CACHE) \ - V(NGTCP2_DEBUG) \ + V(NGTCP2) \ + V(NGHTTP3) \ V(SEA) \ V(WASI) \ V(MODULE) \ diff --git a/src/node_blob.cc b/src/node_blob.cc index 00deb82f46c322..57d35358fbfd71 100644 --- a/src/node_blob.cc +++ b/src/node_blob.cc @@ -156,8 +156,7 @@ Local Blob::GetConstructorTemplate(Environment* env) { Isolate* isolate = env->isolate(); tmpl = NewFunctionTemplate(isolate, nullptr); tmpl->InstanceTemplate()->SetInternalFieldCount(Blob::kInternalFieldCount); - tmpl->SetClassName( - FIXED_ONE_BYTE_STRING(env->isolate(), "Blob")); + tmpl->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "Blob")); SetProtoMethod(isolate, tmpl, "getReader", GetReader); SetProtoMethod(isolate, tmpl, "slice", ToSlice); env->set_blob_constructor_template(tmpl); @@ -255,8 +254,7 @@ void Blob::New(const FunctionCallbackInfo& args) { } auto blob = Create(env, DataQueue::CreateIdempotent(std::move(entries))); - if (blob) - args.GetReturnValue().Set(blob->object()); + if (blob) args.GetReturnValue().Set(blob->object()); } void Blob::GetReader(const FunctionCallbackInfo& args) { @@ -278,8 +276,7 @@ void Blob::ToSlice(const FunctionCallbackInfo& args) { size_t start = args[0].As()->Value(); size_t end = args[1].As()->Value(); BaseObjectPtr slice = blob->Slice(env, start, end); - if (slice) - args.GetReturnValue().Set(slice->object()); + if (slice) args.GetReturnValue().Set(slice->object()); } void Blob::MemoryInfo(MemoryTracker* tracker) const { @@ -343,6 +340,7 @@ void Blob::Reader::Pull(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args); Blob::Reader* reader; ASSIGN_OR_RETURN_UNWRAP(&reader, args.This()); + reader->pull_pending_ = false; CHECK(args[0]->IsFunction()); Local fn = args[0].As(); @@ -414,19 +412,31 @@ void Blob::Reader::Pull(const FunctionCallbackInfo& args) { void Blob::Reader::SetWakeup(const FunctionCallbackInfo& args) { Blob::Reader* reader; ASSIGN_OR_RETURN_UNWRAP(&reader, args.This()); + if (args[0]->IsUndefined()) { + reader->wakeup_.Reset(); + return; + } CHECK(args[0]->IsFunction()); reader->wakeup_.Reset(args.GetIsolate(), args[0].As()); } -void Blob::Reader::NotifyPull() { +void Blob::Reader::NotifyPull(bool fin) { if (wakeup_.IsEmpty() || !env()->can_call_into_js()) return; + // FIN notifications always fire — they must not be suppressed by + // pull_pending_ because there will be no further notifications to + // wake the iterator. Regular data notifications respect pull_pending_ + // to coalesce multiple deliveries within a single packet. + if (!fin && pull_pending_) return; + pull_pending_ = true; HandleScope handle_scope(env()->isolate()); Local fn = wakeup_.Get(env()->isolate()); - MakeCallback(fn, 0, nullptr); + // Pass fin as the first argument so the JS iterator knows EOS is + // imminent and should pull again without waiting for another wakeup. + Local argv[] = {v8::Boolean::New(env()->isolate(), fin)}; + MakeCallback(fn, 1, argv); } -BaseObjectPtr -Blob::BlobTransferData::Deserialize( +BaseObjectPtr Blob::BlobTransferData::Deserialize( Environment* env, Local context, std::unique_ptr self) { @@ -448,10 +458,10 @@ std::unique_ptr Blob::CloneForMessaging() const { void Blob::StoreDataObject(const FunctionCallbackInfo& args) { Realm* realm = Realm::GetCurrent(args); - CHECK(args[0]->IsString()); // ID key + CHECK(args[0]->IsString()); // ID key CHECK(Blob::HasInstance(realm->env(), args[1])); // Blob - CHECK(args[2]->IsUint32()); // Length - CHECK(args[3]->IsString()); // Type + CHECK(args[2]->IsUint32()); // Length + CHECK(args[3]->IsString()); // Type BlobBindingData* binding_data = realm->GetBindingData(); Isolate* isolate = realm->isolate(); @@ -531,12 +541,8 @@ void BlobBindingData::StoredDataObject::MemoryInfo( } BlobBindingData::StoredDataObject::StoredDataObject( - const BaseObjectPtr& blob_, - size_t length_, - const std::string& type_) - : blob(blob_), - length(length_), - type(type_) {} + const BaseObjectPtr& blob_, size_t length_, const std::string& type_) + : blob(blob_), length(length_), type(type_) {} BlobBindingData::BlobBindingData(Realm* realm, Local wrap) : SnapshotableObject(realm, wrap, type_int) { @@ -550,8 +556,7 @@ void BlobBindingData::MemoryInfo(MemoryTracker* tracker) const { } void BlobBindingData::store_data_object( - const std::string& uuid, - const BlobBindingData::StoredDataObject& object) { + const std::string& uuid, const BlobBindingData::StoredDataObject& object) { data_objects_[uuid] = object; } @@ -566,8 +571,7 @@ void BlobBindingData::revoke_data_object(const std::string& uuid) { BlobBindingData::StoredDataObject BlobBindingData::get_data_object( const std::string& uuid) { auto entry = data_objects_.find(uuid); - if (entry == data_objects_.end()) - return BlobBindingData::StoredDataObject {}; + if (entry == data_objects_.end()) return BlobBindingData::StoredDataObject{}; return entry->second; } diff --git a/src/node_blob.h b/src/node_blob.h index 88a56c7ec9a453..e782b96594b564 100644 --- a/src/node_blob.h +++ b/src/node_blob.h @@ -23,8 +23,7 @@ namespace node { class Blob : public BaseObject { public: - static void RegisterExternalReferences( - ExternalReferenceRegistry* registry); + static void RegisterExternalReferences(ExternalReferenceRegistry* registry); static void CreatePerIsolateProperties(IsolateData* isolate_data, v8::Local target); @@ -83,7 +82,7 @@ class Blob : public BaseObject { BaseObjectPtr blob); static void Pull(const v8::FunctionCallbackInfo& args); static void SetWakeup(const v8::FunctionCallbackInfo& args); - void NotifyPull(); + void NotifyPull(bool fin = false); explicit Reader(Environment* env, v8::Local obj, @@ -97,6 +96,7 @@ class Blob : public BaseObject { std::shared_ptr inner_; BaseObjectPtr strong_ptr_; bool eos_ = false; + bool pull_pending_ = false; v8::Global wakeup_; }; @@ -134,19 +134,17 @@ class BlobBindingData : public SnapshotableObject { StoredDataObject() = default; - StoredDataObject( - const BaseObjectPtr& blob_, - size_t length_, - const std::string& type_); + StoredDataObject(const BaseObjectPtr& blob_, + size_t length_, + const std::string& type_); void MemoryInfo(MemoryTracker* tracker) const override; SET_SELF_SIZE(StoredDataObject) SET_MEMORY_INFO_NAME(StoredDataObject) }; - void store_data_object( - const std::string& uuid, - const StoredDataObject& object); + void store_data_object(const std::string& uuid, + const StoredDataObject& object); void revoke_data_object(const std::string& uuid); diff --git a/src/node_file.h b/src/node_file.h index 8f81c23d3d0308..17f3b4203c8edd 100644 --- a/src/node_file.h +++ b/src/node_file.h @@ -338,6 +338,7 @@ class FileHandle final : public AsyncWrap, public StreamBase { static void New(const v8::FunctionCallbackInfo& args); int GetFD() override { return fd_; } + const std::string& original_name() const { return original_name_; } int Release(); diff --git a/src/node_perf_common.h b/src/node_perf_common.h index ad09658e13ec79..01e7f35241ac12 100644 --- a/src/node_perf_common.h +++ b/src/node_perf_common.h @@ -34,12 +34,13 @@ extern uint64_t performance_v8_start; V(LOOP_EXIT, "loopExit") \ V(BOOTSTRAP_COMPLETE, "bootstrapComplete") -#define NODE_PERFORMANCE_ENTRY_TYPES(V) \ - V(GC, "gc") \ - V(HTTP, "http") \ - V(HTTP2, "http2") \ - V(NET, "net") \ - V(DNS, "dns") +#define NODE_PERFORMANCE_ENTRY_TYPES(V) \ + V(GC, "gc") \ + V(HTTP, "http") \ + V(HTTP2, "http2") \ + V(NET, "net") \ + V(DNS, "dns") \ + V(QUIC, "quic") enum PerformanceMilestone { #define V(name, _) NODE_PERFORMANCE_MILESTONE_##name, diff --git a/src/node_sockaddr.cc b/src/node_sockaddr.cc index c869d423b254cc..a9f1a7376bc1fa 100644 --- a/src/node_sockaddr.cc +++ b/src/node_sockaddr.cc @@ -40,41 +40,31 @@ SocketAddress FromUVHandle(F fn, const T& handle) { } } // namespace -bool SocketAddress::ToSockAddr( - int32_t family, - const char* host, - uint32_t port, - sockaddr_storage* addr) { +bool SocketAddress::ToSockAddr(int32_t family, + const char* host, + uint32_t port, + sockaddr_storage* addr) { switch (family) { case AF_INET: - return uv_ip4_addr( - host, - port, - reinterpret_cast(addr)) == 0; + return uv_ip4_addr(host, port, reinterpret_cast(addr)) == 0; case AF_INET6: - return uv_ip6_addr( - host, - port, - reinterpret_cast(addr)) == 0; + return uv_ip6_addr(host, port, reinterpret_cast(addr)) == + 0; default: UNREACHABLE(); } } -bool SocketAddress::New( - const char* host, - uint32_t port, - SocketAddress* addr) { +bool SocketAddress::New(const char* host, uint32_t port, SocketAddress* addr) { return New(AF_INET, host, port, addr) || New(AF_INET6, host, port, addr); } -bool SocketAddress::New( - int32_t family, - const char* host, - uint32_t port, - SocketAddress* addr) { - return ToSockAddr(family, host, port, - reinterpret_cast(addr->storage())); +bool SocketAddress::New(int32_t family, + const char* host, + uint32_t port, + SocketAddress* addr) { + return ToSockAddr( + family, host, port, reinterpret_cast(addr->storage())); } size_t SocketAddress::Hash::operator()(const SocketAddress& addr) const { @@ -102,6 +92,43 @@ size_t SocketAddress::Hash::operator()(const SocketAddress& addr) const { } } +size_t SocketAddress::IpHash::operator()(const SocketAddress& addr) const { + // Hash only the IP address bytes, ignoring the port. + switch (addr.family()) { + case AF_INET: { + const sockaddr_in* ipv4 = + reinterpret_cast(addr.raw()); + return HashBytes(reinterpret_cast(&ipv4->sin_addr), 4); + } + case AF_INET6: { + const sockaddr_in6* ipv6 = + reinterpret_cast(addr.raw()); + return HashBytes(reinterpret_cast(&ipv6->sin6_addr), 16); + } + default: + UNREACHABLE(); + } +} + +bool SocketAddress::IpEqual::operator()(const SocketAddress& a, + const SocketAddress& b) const { + if (a.family() != b.family()) return false; + switch (a.family()) { + case AF_INET: { + const sockaddr_in* a4 = reinterpret_cast(a.raw()); + const sockaddr_in* b4 = reinterpret_cast(b.raw()); + return memcmp(&a4->sin_addr, &b4->sin_addr, 4) == 0; + } + case AF_INET6: { + const sockaddr_in6* a6 = reinterpret_cast(a.raw()); + const sockaddr_in6* b6 = reinterpret_cast(b.raw()); + return memcmp(&a6->sin6_addr, &b6->sin6_addr, 16) == 0; + } + default: + UNREACHABLE(); + } +} + SocketAddress SocketAddress::FromSockName(const uv_tcp_t& handle) { return FromUVHandle(uv_tcp_getsockname, handle); } @@ -119,21 +146,15 @@ SocketAddress SocketAddress::FromPeerName(const uv_udp_t& handle) { } namespace { -constexpr uint8_t mask[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff }; - -bool is_match_ipv4( - const SocketAddress& one, - const SocketAddress& two) { - const sockaddr_in* one_in = - reinterpret_cast(one.data()); - const sockaddr_in* two_in = - reinterpret_cast(two.data()); +constexpr uint8_t mask[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff}; + +bool is_match_ipv4(const SocketAddress& one, const SocketAddress& two) { + const sockaddr_in* one_in = reinterpret_cast(one.data()); + const sockaddr_in* two_in = reinterpret_cast(two.data()); return memcmp(&one_in->sin_addr, &two_in->sin_addr, sizeof(uint32_t)) == 0; } -bool is_match_ipv6( - const SocketAddress& one, - const SocketAddress& two) { +bool is_match_ipv6(const SocketAddress& one, const SocketAddress& two) { const sockaddr_in6* one_in = reinterpret_cast(one.data()); const sockaddr_in6* two_in = @@ -141,29 +162,23 @@ bool is_match_ipv6( return memcmp(&one_in->sin6_addr, &two_in->sin6_addr, 16) == 0; } -bool is_match_ipv4_ipv6( - const SocketAddress& ipv4, - const SocketAddress& ipv6) { +bool is_match_ipv4_ipv6(const SocketAddress& ipv4, const SocketAddress& ipv6) { const sockaddr_in* check_ipv4 = reinterpret_cast(ipv4.data()); const sockaddr_in6* check_ipv6 = reinterpret_cast(ipv6.data()); - const uint8_t* ptr = - reinterpret_cast(&check_ipv6->sin6_addr); + const uint8_t* ptr = reinterpret_cast(&check_ipv6->sin6_addr); return memcmp(ptr, mask, sizeof(mask)) == 0 && - memcmp(ptr + sizeof(mask), - &check_ipv4->sin_addr, - sizeof(uint32_t)) == 0; + memcmp(ptr + sizeof(mask), &check_ipv4->sin_addr, sizeof(uint32_t)) == + 0; } std::partial_ordering compare_ipv4(const SocketAddress& one, const SocketAddress& two) { - const sockaddr_in* one_in = - reinterpret_cast(one.data()); - const sockaddr_in* two_in = - reinterpret_cast(two.data()); + const sockaddr_in* one_in = reinterpret_cast(one.data()); + const sockaddr_in* two_in = reinterpret_cast(two.data()); const uint32_t s_addr_one = ntohl(one_in->sin_addr.s_addr); const uint32_t s_addr_two = ntohl(two_in->sin_addr.s_addr); @@ -193,19 +208,15 @@ std::partial_ordering compare_ipv4_ipv6(const SocketAddress& ipv4, const SocketAddress& ipv6) { const sockaddr_in* ipv4_in = reinterpret_cast(ipv4.data()); - const sockaddr_in6 * ipv6_in = + const sockaddr_in6* ipv6_in = reinterpret_cast(ipv6.data()); - const uint8_t* ptr = - reinterpret_cast(&ipv6_in->sin6_addr); + const uint8_t* ptr = reinterpret_cast(&ipv6_in->sin6_addr); if (memcmp(ptr, mask, sizeof(mask)) != 0) return std::partial_ordering::unordered; - int ret = memcmp( - &ipv4_in->sin_addr, - ptr + sizeof(mask), - sizeof(uint32_t)); + int ret = memcmp(&ipv4_in->sin_addr, ptr + sizeof(mask), sizeof(uint32_t)); if (ret < 0) return std::partial_ordering::less; @@ -214,25 +225,21 @@ std::partial_ordering compare_ipv4_ipv6(const SocketAddress& ipv4, return std::partial_ordering::equivalent; } -bool in_network_ipv4( - const SocketAddress& ip, - const SocketAddress& net, - int prefix) { +bool in_network_ipv4(const SocketAddress& ip, + const SocketAddress& net, + int prefix) { uint32_t mask = ((1ull << prefix) - 1) << (32 - prefix); - const sockaddr_in* ip_in = - reinterpret_cast(ip.data()); - const sockaddr_in* net_in = - reinterpret_cast(net.data()); + const sockaddr_in* ip_in = reinterpret_cast(ip.data()); + const sockaddr_in* net_in = reinterpret_cast(net.data()); return (htonl(ip_in->sin_addr.s_addr) & mask) == (htonl(net_in->sin_addr.s_addr) & mask); } -bool in_network_ipv6( - const SocketAddress& ip, - const SocketAddress& net, - int prefix) { +bool in_network_ipv6(const SocketAddress& ip, + const SocketAddress& net, + int prefix) { // Special case, if prefix == 128, then just do a // straight comparison. if (prefix == 128) @@ -242,27 +249,23 @@ bool in_network_ipv6( int len = (prefix - r) / 8; uint8_t mask = ((1 << r) - 1) << (8 - r); - const sockaddr_in6* ip_in = - reinterpret_cast(ip.data()); + const sockaddr_in6* ip_in = reinterpret_cast(ip.data()); const sockaddr_in6* net_in = reinterpret_cast(net.data()); - if (memcmp(&ip_in->sin6_addr, &net_in->sin6_addr, len) != 0) - return false; + if (memcmp(&ip_in->sin6_addr, &net_in->sin6_addr, len) != 0) return false; - const uint8_t* p1 = reinterpret_cast( - ip_in->sin6_addr.s6_addr); - const uint8_t* p2 = reinterpret_cast( - net_in->sin6_addr.s6_addr); + const uint8_t* p1 = + reinterpret_cast(ip_in->sin6_addr.s6_addr); + const uint8_t* p2 = + reinterpret_cast(net_in->sin6_addr.s6_addr); return (p1[len] & mask) == (p2[len] & mask); } -bool in_network_ipv4_ipv6( - const SocketAddress& ip, - const SocketAddress& net, - int prefix) { - +bool in_network_ipv4_ipv6(const SocketAddress& ip, + const SocketAddress& net, + int prefix) { if (prefix == 128) return compare_ipv4_ipv6(ip, net) == std::partial_ordering::equivalent; @@ -270,8 +273,7 @@ bool in_network_ipv4_ipv6( int len = (prefix - r) / 8; uint8_t mask = ((1 << r) - 1) << (8 - r); - const sockaddr_in* ip_in = - reinterpret_cast(ip.data()); + const sockaddr_in* ip_in = reinterpret_cast(ip.data()); const sockaddr_in6* net_in = reinterpret_cast(net.data()); @@ -279,35 +281,29 @@ bool in_network_ipv4_ipv6( uint8_t* ptr = ip_mask; memcpy(ptr + 12, &ip_in->sin_addr, 4); - if (memcmp(ptr, &net_in->sin6_addr, len) != 0) - return false; + if (memcmp(ptr, &net_in->sin6_addr, len) != 0) return false; ptr += len; - const uint8_t* p2 = reinterpret_cast( - net_in->sin6_addr.s6_addr); + const uint8_t* p2 = + reinterpret_cast(net_in->sin6_addr.s6_addr); return (ptr[0] & mask) == (p2[len] & mask); } -bool in_network_ipv6_ipv4( - const SocketAddress& ip, - const SocketAddress& net, - int prefix) { +bool in_network_ipv6_ipv4(const SocketAddress& ip, + const SocketAddress& net, + int prefix) { if (prefix == 32) return compare_ipv4_ipv6(net, ip) == std::partial_ordering::equivalent; uint32_t m = ((1ull << prefix) - 1) << (32 - prefix); - const sockaddr_in6* ip_in = - reinterpret_cast(ip.data()); - const sockaddr_in* net_in = - reinterpret_cast(net.data()); + const sockaddr_in6* ip_in = reinterpret_cast(ip.data()); + const sockaddr_in* net_in = reinterpret_cast(net.data()); - const uint8_t* ptr = - reinterpret_cast(&ip_in->sin6_addr); + const uint8_t* ptr = reinterpret_cast(&ip_in->sin6_addr); - if (memcmp(ptr, mask, sizeof(mask)) != 0) - return false; + if (memcmp(ptr, mask, sizeof(mask)) != 0) return false; ptr += sizeof(mask); uint32_t check = nbytes::ReadUint32BE(ptr); @@ -324,14 +320,18 @@ bool SocketAddress::is_match(const SocketAddress& other) const { switch (family()) { case AF_INET: switch (other.family()) { - case AF_INET: return is_match_ipv4(*this, other); - case AF_INET6: return is_match_ipv4_ipv6(*this, other); + case AF_INET: + return is_match_ipv4(*this, other); + case AF_INET6: + return is_match_ipv4_ipv6(*this, other); } break; case AF_INET6: switch (other.family()) { - case AF_INET: return is_match_ipv4_ipv6(other, *this); - case AF_INET6: return is_match_ipv6(*this, other); + case AF_INET: + return is_match_ipv4_ipv6(other, *this); + case AF_INET6: + return is_match_ipv6(*this, other); } break; } @@ -342,8 +342,10 @@ std::partial_ordering SocketAddress::compare(const SocketAddress& other) const { switch (family()) { case AF_INET: switch (other.family()) { - case AF_INET: return compare_ipv4(*this, other); - case AF_INET6: return compare_ipv4_ipv6(*this, other); + case AF_INET: + return compare_ipv4(*this, other); + case AF_INET6: + return compare_ipv4_ipv6(*this, other); } break; case AF_INET6: @@ -361,28 +363,31 @@ std::partial_ordering SocketAddress::compare(const SocketAddress& other) const { } break; } - case AF_INET6: return compare_ipv6(*this, other); + case AF_INET6: + return compare_ipv6(*this, other); } break; } return std::partial_ordering::unordered; } -bool SocketAddress::is_in_network( - const SocketAddress& other, - int prefix) const { - +bool SocketAddress::is_in_network(const SocketAddress& other, + int prefix) const { switch (family()) { case AF_INET: switch (other.family()) { - case AF_INET: return in_network_ipv4(*this, other, prefix); - case AF_INET6: return in_network_ipv4_ipv6(*this, other, prefix); + case AF_INET: + return in_network_ipv4(*this, other, prefix); + case AF_INET6: + return in_network_ipv4_ipv6(*this, other, prefix); } break; case AF_INET6: switch (other.family()) { - case AF_INET: return in_network_ipv6_ipv4(*this, other, prefix); - case AF_INET6: return in_network_ipv6(*this, other, prefix); + case AF_INET: + return in_network_ipv6_ipv4(*this, other, prefix); + case AF_INET6: + return in_network_ipv6(*this, other, prefix); } break; } @@ -397,8 +402,7 @@ SocketAddressBlockList::SocketAddressBlockList( void SocketAddressBlockList::AddSocketAddress( const std::shared_ptr& address) { Mutex::ScopedLock lock(mutex_); - std::unique_ptr rule = - std::make_unique(address); + std::unique_ptr rule = std::make_unique(address); rules_.emplace_front(std::move(rule)); address_rules_[*address.get()] = rules_.begin(); } @@ -423,8 +427,7 @@ void SocketAddressBlockList::AddSocketAddressRange( } void SocketAddressBlockList::AddSocketAddressMask( - const std::shared_ptr& network, - int prefix) { + const std::shared_ptr& network, int prefix) { Mutex::ScopedLock lock(mutex_); std::unique_ptr rule = std::make_unique(network, prefix); @@ -435,8 +438,7 @@ bool SocketAddressBlockList::Apply( const std::shared_ptr& address) { Mutex::ScopedLock lock(mutex_); for (const auto& rule : rules_) { - if (rule->Apply(address)) - return true; + if (rule->Apply(address)) return true; } return parent_ ? parent_->Apply(address) : false; } @@ -448,14 +450,11 @@ SocketAddressBlockList::SocketAddressRule::SocketAddressRule( SocketAddressBlockList::SocketAddressRangeRule::SocketAddressRangeRule( const std::shared_ptr& start_, const std::shared_ptr& end_) - : start(start_), - end(end_) {} + : start(start_), end(end_) {} SocketAddressBlockList::SocketAddressMaskRule::SocketAddressMaskRule( - const std::shared_ptr& network_, - int prefix_) - : network(network_), - prefix(prefix_) {} + const std::shared_ptr& network_, int prefix_) + : network(network_), prefix(prefix_) {} bool SocketAddressBlockList::SocketAddressRule::Apply( const std::shared_ptr& address) { @@ -472,8 +471,7 @@ std::string SocketAddressBlockList::SocketAddressRule::ToString() { bool SocketAddressBlockList::SocketAddressRangeRule::Apply( const std::shared_ptr& address) { - return *address.get() >= *start.get() && - *address.get() <= *end.get(); + return *address.get() >= *start.get() && *address.get() <= *end.get(); } std::string SocketAddressBlockList::SocketAddressRangeRule::ToString() { @@ -503,19 +501,16 @@ std::string SocketAddressBlockList::SocketAddressMaskRule::ToString() { MaybeLocal SocketAddressBlockList::ListRules(Environment* env) { Mutex::ScopedLock lock(mutex_); LocalVector rules(env->isolate()); - if (!ListRules(env, &rules)) - return MaybeLocal(); + if (!ListRules(env, &rules)) return MaybeLocal(); return Array::New(env->isolate(), rules.data(), rules.size()); } bool SocketAddressBlockList::ListRules(Environment* env, LocalVector* rules) { - if (parent_ && !parent_->ListRules(env, rules)) - return false; + if (parent_ && !parent_->ListRules(env, rules)) return false; for (const auto& rule : rules_) { Local str; - if (!rule->ToV8String(env).ToLocal(&str)) - return false; + if (!rule->ToV8String(env).ToLocal(&str)) return false; rules->push_back(str); } return true; @@ -545,8 +540,7 @@ SocketAddressBlockListWrap::SocketAddressBlockListWrap( Environment* env, Local wrap, std::shared_ptr blocklist) - : BaseObject(env, wrap), - blocklist_(std::move(blocklist)) { + : BaseObject(env, wrap), blocklist_(std::move(blocklist)) { MakeWeak(); } @@ -554,8 +548,9 @@ BaseObjectPtr SocketAddressBlockListWrap::New( Environment* env) { Local obj; if (!env->blocklist_constructor_template() - ->InstanceTemplate() - ->NewInstance(env->context()).ToLocal(&obj)) { + ->InstanceTemplate() + ->NewInstance(env->context()) + .ToLocal(&obj)) { return nullptr; } BaseObjectPtr wrap = @@ -565,25 +560,22 @@ BaseObjectPtr SocketAddressBlockListWrap::New( } BaseObjectPtr SocketAddressBlockListWrap::New( - Environment* env, - std::shared_ptr blocklist) { + Environment* env, std::shared_ptr blocklist) { Local obj; if (!env->blocklist_constructor_template() - ->InstanceTemplate() - ->NewInstance(env->context()).ToLocal(&obj)) { + ->InstanceTemplate() + ->NewInstance(env->context()) + .ToLocal(&obj)) { return nullptr; } BaseObjectPtr wrap = MakeBaseObject( - env, - obj, - std::move(blocklist)); + env, obj, std::move(blocklist)); CHECK(wrap); return wrap; } -void SocketAddressBlockListWrap::New( - const FunctionCallbackInfo& args) { +void SocketAddressBlockListWrap::New(const FunctionCallbackInfo& args) { CHECK(args.IsConstructCall()); Environment* env = Environment::GetCurrent(args); new SocketAddressBlockListWrap(env, args.This()); @@ -622,9 +614,8 @@ void SocketAddressBlockListWrap::AddRange( if (*start_addr->address().get() > *end_addr->address().get()) return args.GetReturnValue().Set(false); - wrap->blocklist_->AddSocketAddressRange( - start_addr->address(), - end_addr->address()); + wrap->blocklist_->AddSocketAddressRange(start_addr->address(), + end_addr->address()); args.GetReturnValue().Set(true); } @@ -687,9 +678,8 @@ SocketAddressBlockListWrap::CloneForMessaging() const { return std::make_unique(this); } -bool SocketAddressBlockListWrap::HasInstance( - Environment* env, - Local value) { +bool SocketAddressBlockListWrap::HasInstance(Environment* env, + Local value) { return GetConstructorTemplate(env)->HasInstance(value); } @@ -711,11 +701,10 @@ Local SocketAddressBlockListWrap::GetConstructorTemplate( return tmpl; } -void SocketAddressBlockListWrap::Initialize( - Local target, - Local unused, - Local context, - void* priv) { +void SocketAddressBlockListWrap::Initialize(Local target, + Local unused, + Local context, + void* priv) { Environment* env = Environment::GetCurrent(context); SetConstructorFunction(context, @@ -772,12 +761,12 @@ void SocketAddressBase::Initialize(Environment* env, Local target) { } BaseObjectPtr SocketAddressBase::Create( - Environment* env, - std::shared_ptr address) { + Environment* env, std::shared_ptr address) { Local obj; if (!GetConstructorTemplate(env) - ->InstanceTemplate() - ->NewInstance(env->context()).ToLocal(&obj)) { + ->InstanceTemplate() + ->NewInstance(env->context()) + .ToLocal(&obj)) { return nullptr; } @@ -788,8 +777,8 @@ void SocketAddressBase::New(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args); CHECK(args.IsConstructCall()); CHECK(args[0]->IsString()); // address - CHECK(args[1]->IsInt32()); // port - CHECK(args[2]->IsInt32()); // family + CHECK(args[1]->IsInt32()); // port + CHECK(args[2]->IsInt32()); // family CHECK(args[3]->IsUint32()); // flow label Utf8Value address(env->isolate(), args[0]); @@ -820,19 +809,21 @@ void SocketAddressBase::Detail(const FunctionCallbackInfo& args) { return; if (detail->Set(env->context(), env->address_string(), address).IsJust() && - detail->Set( - env->context(), - env->port_string(), - Int32::New(env->isolate(), base->address_->port())).IsJust() && - detail->Set( - env->context(), - env->family_string(), - Int32::New(env->isolate(), base->address_->family())).IsJust() && - detail->Set( - env->context(), - env->flowlabel_string(), - Uint32::New(env->isolate(), base->address_->flow_label())) - .IsJust()) { + detail + ->Set(env->context(), + env->port_string(), + Int32::New(env->isolate(), base->address_->port())) + .IsJust() && + detail + ->Set(env->context(), + env->family_string(), + Int32::New(env->isolate(), base->address_->family())) + .IsJust() && + detail + ->Set(env->context(), + env->flowlabel_string(), + Uint32::New(env->isolate(), base->address_->flow_label())) + .IsJust()) { args.GetReturnValue().Set(detail); } } @@ -852,12 +843,10 @@ void SocketAddressBase::LegacyDetail(const FunctionCallbackInfo& args) { args.GetReturnValue().Set(address); } -SocketAddressBase::SocketAddressBase( - Environment* env, - Local wrap, - std::shared_ptr address) - : BaseObject(env, wrap), - address_(std::move(address)) { +SocketAddressBase::SocketAddressBase(Environment* env, + Local wrap, + std::shared_ptr address) + : BaseObject(env, wrap), address_(std::move(address)) { MakeWeak(); } @@ -865,8 +854,8 @@ void SocketAddressBase::MemoryInfo(MemoryTracker* tracker) const { tracker->TrackField("address", address_); } -std::unique_ptr -SocketAddressBase::CloneForMessaging() const { +std::unique_ptr SocketAddressBase::CloneForMessaging() + const { return std::make_unique(this); } diff --git a/src/node_sockaddr.h b/src/node_sockaddr.h index a522505949a263..d67a26e8615cdc 100644 --- a/src/node_sockaddr.h +++ b/src/node_sockaddr.h @@ -3,9 +3,9 @@ #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS +#include "base_object.h" #include "env.h" #include "memory_tracker.h" -#include "base_object.h" #include "node.h" #include "node_worker.h" #include "uv.h" @@ -27,6 +27,16 @@ class SocketAddress : public MemoryRetainer { size_t operator()(const SocketAddress& addr) const; }; + // Hashes and compares only the IP address, ignoring the port. + // Useful for per-host connection counting where clients from + // the same IP but different ports should be treated as one host. + struct IpHash { + size_t operator()(const SocketAddress& addr) const; + }; + struct IpEqual { + bool operator()(const SocketAddress& a, const SocketAddress& b) const; + }; + inline bool operator==(const SocketAddress& other) const; inline bool operator!=(const SocketAddress& other) const; @@ -36,23 +46,18 @@ class SocketAddress : public MemoryRetainer { inline static bool is_numeric_host(const char* hostname, int family); // Returns true if converting {family, host, port} to *addr succeeded. - static bool ToSockAddr( - int32_t family, - const char* host, - uint32_t port, - sockaddr_storage* addr); + static bool ToSockAddr(int32_t family, + const char* host, + uint32_t port, + sockaddr_storage* addr); // Returns true if converting {family, host, port} to *addr succeeded. - static bool New( - int32_t family, - const char* host, - uint32_t port, - SocketAddress* addr); + static bool New(int32_t family, + const char* host, + uint32_t port, + SocketAddress* addr); - static bool New( - const char* host, - uint32_t port, - SocketAddress* addr); + static bool New(const char* host, uint32_t port, SocketAddress* addr); // Returns the port for an IPv4 or IPv6 address. inline static int GetPort(const sockaddr* addr); @@ -135,6 +140,9 @@ class SocketAddress : public MemoryRetainer { template using Map = std::unordered_map; + template + using IpMap = std::unordered_map; + private: sockaddr_storage address_; }; @@ -146,18 +154,16 @@ class SocketAddressBase : public BaseObject { Environment* env); static void Initialize(Environment* env, v8::Local target); static BaseObjectPtr Create( - Environment* env, - std::shared_ptr address); + Environment* env, std::shared_ptr address); static void New(const v8::FunctionCallbackInfo& args); static void Detail(const v8::FunctionCallbackInfo& args); static void LegacyDetail(const v8::FunctionCallbackInfo& args); static void GetFlowLabel(const v8::FunctionCallbackInfo& args); - SocketAddressBase( - Environment* env, - v8::Local wrap, - std::shared_ptr address); + SocketAddressBase(Environment* env, + v8::Local wrap, + std::shared_ptr address); inline const std::shared_ptr& address() const { return address_; @@ -245,13 +251,11 @@ class SocketAddressBlockList : public MemoryRetainer { void RemoveSocketAddress(const std::shared_ptr& address); - void AddSocketAddressRange( - const std::shared_ptr& start, - const std::shared_ptr& end); + void AddSocketAddressRange(const std::shared_ptr& start, + const std::shared_ptr& end); - void AddSocketAddressMask( - const std::shared_ptr& address, - int prefix); + void AddSocketAddressMask(const std::shared_ptr& address, + int prefix); bool Apply(const std::shared_ptr& address); @@ -282,9 +286,8 @@ class SocketAddressBlockList : public MemoryRetainer { std::shared_ptr start; std::shared_ptr end; - SocketAddressRangeRule( - const std::shared_ptr& start, - const std::shared_ptr& end); + SocketAddressRangeRule(const std::shared_ptr& start, + const std::shared_ptr& end); bool Apply(const std::shared_ptr& address) override; std::string ToString() override; @@ -298,9 +301,8 @@ class SocketAddressBlockList : public MemoryRetainer { std::shared_ptr network; int prefix; - SocketAddressMaskRule( - const std::shared_ptr& address, - int prefix); + SocketAddressMaskRule(const std::shared_ptr& address, + int prefix); bool Apply(const std::shared_ptr& address) override; std::string ToString() override; @@ -336,8 +338,7 @@ class SocketAddressBlockListWrap : public BaseObject { static BaseObjectPtr New(Environment* env); static BaseObjectPtr New( - Environment* env, - std::shared_ptr blocklist); + Environment* env, std::shared_ptr blocklist); static void New(const v8::FunctionCallbackInfo& args); static void AddAddress(const v8::FunctionCallbackInfo& args); @@ -346,11 +347,10 @@ class SocketAddressBlockListWrap : public BaseObject { static void Check(const v8::FunctionCallbackInfo& args); static void GetRules(const v8::FunctionCallbackInfo& args); - SocketAddressBlockListWrap( - Environment* env, - v8::Local wrap, - std::shared_ptr blocklist = - std::make_shared()); + SocketAddressBlockListWrap(Environment* env, + v8::Local wrap, + std::shared_ptr blocklist = + std::make_shared()); void MemoryInfo(node::MemoryTracker* tracker) const override; SET_MEMORY_INFO_NAME(SocketAddressBlockListWrap) diff --git a/src/node_util.cc b/src/node_util.cc index 8be8a8b5726a26..6d3373caae6c5c 100644 --- a/src/node_util.cc +++ b/src/node_util.cc @@ -460,6 +460,15 @@ void ConstructSharedArrayBuffer(const FunctionCallbackInfo& args) { args.GetReturnValue().Set(sab); } +// Marks a promise as handled and silent to prevent unhandled rejection +// tracking from triggering. +void MarkPromiseAsHandled(const FunctionCallbackInfo& args) { + CHECK(args[0]->IsPromise()); + Local promise = args[0].As(); + promise->MarkAsHandled(); + promise->MarkAsSilent(); +} + void RegisterExternalReferences(ExternalReferenceRegistry* registry) { registry->Register(GetPromiseDetails); registry->Register(GetProxyDetails); @@ -478,6 +487,7 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry) { registry->Register(DefineLazyProperties); registry->Register(DefineLazyPropertiesGetter); registry->Register(ConstructSharedArrayBuffer); + registry->Register(MarkPromiseAsHandled); } void Initialize(Local target, @@ -583,6 +593,7 @@ void Initialize(Local target, target, "constructSharedArrayBuffer", ConstructSharedArrayBuffer); + SetMethod(context, target, "markPromiseAsHandled", MarkPromiseAsHandled); Local should_abort_on_uncaught_toggle = FIXED_ONE_BYTE_STRING(env->isolate(), "shouldAbortOnUncaughtToggle"); diff --git a/src/quic/README.md b/src/quic/README.md new file mode 100644 index 00000000000000..9583acbcd76417 --- /dev/null +++ b/src/quic/README.md @@ -0,0 +1,418 @@ +# Node.js QUIC Implementation (`src/quic/`) + +This directory contains the C++ implementation of the Node.js experimental QUIC +support (`--experimental-quic`). The implementation builds on three external +libraries: **ngtcp2** (QUIC transport), **nghttp3** (HTTP/3 framing), and +**OpenSSL** (TLS 1.3). + +## Architecture Overview + +The stack is layered as: + +```text +┌─────────────────────────────────────────────┐ +│ JavaScript API (lib/internal/quic/) │ +├─────────────────────────────────────────────┤ +│ Endpoint — UDP socket, packet I/O │ +│ Session — QUIC connection (ngtcp2) │ +│ Application — ALPN protocol logic │ +│ Stream — Bidirectional data flow │ +├─────────────────────────────────────────────┤ +│ ngtcp2 / nghttp3 / OpenSSL │ +├─────────────────────────────────────────────┤ +│ libuv — UDP, timers, thread pool │ +└─────────────────────────────────────────────┘ +``` + +An **Endpoint** binds a UDP socket and dispatches incoming packets to +**Sessions**. Each Session wraps an `ngtcp2_conn` and delegates +protocol-specific behavior to an **Application** (selected by ALPN +negotiation). Sessions contain **Streams** — bidirectional or unidirectional +data channels that carry application data. + +## File Map + +### Foundation + +| File | Purpose | +| ------------- | ------------------------------------------------------------------ | +| `guard.h` | OpenSSL QUIC guard macro | +| `defs.h` | Core enums, typedefs, constants, macros | +| `arena.h` | Block-based arena allocator (header-only template) | +| `data.h/cc` | `Path`, `PathStorage`, `Store`, `QuicError` | +| `cid.h/cc` | `CID` — Connection ID with hash, factory, map alias | +| `tokens.h/cc` | `TokenSecret`, `StatelessResetToken`, `RetryToken`, `RegularToken` | + +### Security + +| File | Purpose | +| -------------------- | ----------------------------------------------------------- | +| `tlscontext.h/cc` | `TLSContext`, `TLSSession` — OpenSSL integration, SNI, ALPN | +| `sessionticket.h/cc` | `SessionTicket` — TLS 1.3 session resumption and 0-RTT | + +### Core + +| File | Purpose | +| ------------------ | ------------------------------------------------------------ | +| `endpoint.h/cc` | `Endpoint` — UDP binding, packet dispatch, retry/validation | +| `session.h/cc` | `Session` — QUIC connection state machine (\~3,500 lines) | +| `streams.h/cc` | `Stream`, `Outbound`, `PendingStream` — data flow | +| `application.h/cc` | `Session::Application` base + `DefaultApplication` | +| `http3.h/cc` | `Http3ApplicationImpl` — nghttp3 integration (\~1,400 lines) | + +### Infrastructure + +| File | Purpose | +| ----------------------- | ------------------------------------------------------------- | +| `bindingdata.h/cc` | `BindingData` — JS binding state, callback scopes, allocators | +| `session_manager.h/cc` | `SessionManager` — per-Realm CID→Session routing | +| `transportparams.h/cc` | `TransportParams` — QUIC transport parameter encoding | +| `packet.h/cc` | `Packet` — arena-allocated outbound packets | +| `preferredaddress.h/cc` | `PreferredAddress` — server preferred address helper | +| `quic.cc` | Module entry point (binding registration) | + +## Key Design Patterns + +### SendPendingDataScope (RAII Send Coalescing) + +Every entry point that may generate outbound data creates a +`SendPendingDataScope`. Scopes nest — an internal depth counter ensures +`Application::SendPendingData()` is called exactly once, when the outermost +scope exits: + +```cpp +{ + SendPendingDataScope outer(session); // depth 1 + { + SendPendingDataScope inner(session); // depth 2 + // ... generate data ... + } // depth 1 — no send yet +} // depth 0 — SendPendingData() fires +``` + +This is used in `Session::Receive`, `Endpoint::Connect`, `Session::Close`, +`Session::ResumeStream`, and all stream write operations. + +### NgTcp2CallbackScope / NgHttp3CallbackScope + +Per-session RAII guards that prevent re-entrant calls into ngtcp2/nghttp3. +While active, `can_send_packets()` returns false, blocking the send loop. +If `Destroy()` is called during a callback (e.g., via JS `MakeCallback`), +destruction is deferred until the scope exits, preventing use-after-free. + +### Bob Protocol (Pull-Based Streaming) + +Data flows through the stack using the **bob** (Bytes-Over-Buffers) pull +protocol defined in `src/node_bob.h`. The consumer calls `Pull()` on a +source, which responds with one of four status codes: + +| Status | Meaning | +| --------------------- | ---------------------------------------------------------------- | +| `STATUS_EOS` (0) | End of stream — no more data | +| `STATUS_CONTINUE` (1) | Data delivered; pull again | +| `STATUS_BLOCK` (2) | No data now; try later | +| `STATUS_WAIT` (3) | Async — source will invoke the `next` callback when data arrives | + +The `Done` callback passed with each pull signals that the consumer is +finished with the buffer memory, enabling zero-copy transfer. + +### Three-Phase Buffer Lifecycle + +Data in `Stream::Outbound` moves through three states: + +```text +Pulled (uncommitted) → Committed (in-flight) → Acknowledged (freed) +``` + +* **Uncommitted**: Read from the DataQueue but not yet accepted by ngtcp2 +* **Committed**: Accepted into a QUIC packet by `ngtcp2_conn_writev_stream` +* **Acknowledged**: Peer ACKed the data; buffer memory is released + +Separate cursors on each buffer entry track progression. This allows ngtcp2 +to retry uncommitted data (e.g., after pacing/congestion clears) without +re-reading from the source. + +### Application Abstraction + +`Session::Application` is a virtual interface that the Session delegates +ALPN-specific behavior to. Two implementations exist: + +* **`DefaultApplication`** (`application.cc`): Used for non-HTTP/3 ALPN + protocols. Maintains its own stream scheduling queue. Streams are scheduled + via an intrusive linked list. + +* **`Http3ApplicationImpl`** (`http3.cc`): Used when ALPN negotiates `h3`. + Wraps `nghttp3_conn` for HTTP/3 framing, header compression (QPACK), + server push, and stream prioritization. Manages unidirectional control + streams internally. + +The Application is selected during ALPN negotiation — immediately for +clients (ALPN known upfront), during the `OnSelectAlpn` TLS callback for +servers. + +### Thread-Local Allocator + +Both ngtcp2 and nghttp3 require custom allocators (`ngtcp2_mem`, +`nghttp3_mem`). These allocator structs must outlive every object they +create. Some nghttp3 objects (notably `rcbuf`s backing V8 external strings) +can survive past `BindingData` destruction during isolate teardown. + +The solution uses `thread_local` storage: + +```cpp +struct QuicAllocState { + BindingData* binding = nullptr; // Nulled in ~BindingData + ngtcp2_mem ngtcp2; + nghttp3_mem nghttp3; +}; +thread_local QuicAllocState quic_alloc_state; +``` + +Each allocation prepends its size before the returned pointer. This allows +`free` and `realloc` to report correct sizes for memory tracking. When +`binding` is null (after `BindingData` destruction), allocations still +succeed but memory tracking is silently skipped. + +## Session Lifecycle + +### Creation + +**Client**: `Endpoint::Connect()` builds a `Session::Config` with +`Side::CLIENT`, creates a `TLSContext`, and calls `Session::Create()` → +`ngtcp2_conn_client_new()`. The Application is selected immediately. + +**Server**: `Endpoint::Receive()` processes an Initial packet through +address validation (retry tokens, LRU cache), then calls `Session::Create()` +→ `ngtcp2_conn_server_new()`. The Application is selected later, during ALPN +negotiation in the TLS handshake. + +### The Receive Path + +```text +uv_udp_recv_cb + → Endpoint::Receive() + → FindSession(dcid) // CID lookup across endpoints + ├── Found → Session::Receive() + └── Not found: + ├── Stateless reset? → process + ├── Short header? → SendStatelessReset() + └── Long header? → acceptInitialPacket() + ├── ngtcp2_accept() + ├── Address validation (retry tokens, LRU) + └── Session::Create() + +Session::Receive() + → SendPendingDataScope // will send after processing + → NgTcp2CallbackScope // re-entrancy guard + → ngtcp2_conn_read_pkt() // decrypt, process frames + triggers callbacks: + ├── recv_stream_data → Application::ReceiveStreamData() + ├── stream_open → Application::ReceiveStreamOpen() + ├── acked_stream_data → Application::AcknowledgeStreamData() + ├── handshake_completed → Session::HandshakeCompleted() + └── ... others + → Application::PostReceive() // deferred operations (e.g., GOAWAY) +``` + +### The Send Loop + +```text +SendPendingDataScope::~SendPendingDataScope() + → Application::SendPendingData() + Loop (up to max_packet_count): + ├── GetStreamData() // pull data from next stream + │ └── stream->Pull() // bob pull from Outbound→DataQueue + ├── WriteVStream() // ngtcp2_conn_writev_stream() + │ encrypts, frames, paces + ├── if ndatalen > 0: StreamCommit() + │ stream->Commit(datalen, fin) + ├── if nwrite > 0: Send() // uv_udp_send() + ├── if WRITE_MORE: continue // room for more in this packet + ├── if STREAM_DATA_BLOCKED: // flow control + │ StreamDataBlocked(), continue + └── if nwrite == 0: // pacing/congestion + ResumeStream() if data pending, return + On exit: UpdateTimer(), UpdateDataStats() +``` + +When `nwrite == 0` and the stream had unsent data (payload or FIN), the +stream is re-scheduled via `Application::ResumeStream()` so the next +timer-triggered `SendPendingData` retries it. + +### Close Methods + +| Method | Behavior | +| ------------ | ----------------------------------------------------------- | +| **DEFAULT** | Destroys all streams, sends CONNECTION\_CLOSE, emits to JS | +| **SILENT** | Same but skips CONNECTION\_CLOSE (errors, stateless resets) | +| **GRACEFUL** | Sends GOAWAY (H3), waits for streams to close naturally | + +### Timer + +`Session::UpdateTimer()` queries `ngtcp2_conn_get_expiry()` and sets a libuv +timer. When it fires, `OnTimeout()` calls `ngtcp2_conn_handle_expiry()` then +`SendPendingData()` to retransmit lost packets, send PINGs, or retry +pacing-blocked sends. + +## Stream Lifecycle + +### Creation + +**Local streams**: `Session::OpenStream()` calls +`ngtcp2_conn_open_bidi_stream()` or `ngtcp2_conn_open_uni_stream()`. If the +handshake is incomplete or the concurrency limit is reached, the stream is +created in **pending** state and queued. When the peer grants capacity +(`ExtendMaxStreams`), pending streams are fulfilled with real stream IDs. + +**Remote streams**: ngtcp2 notifies via callbacks. The Application creates a +`Stream` object and emits it to JavaScript. + +### Outbound Data Flow + +The `Stream::Outbound` class bridges a `DataQueue` (the data source) to +ngtcp2's packet-writing loop. A `DataQueue::Reader` provides the bob +pull interface. + +Supported body source types (via `GetDataQueueFromSource`): + +| Source | Strategy | +| ------------------- | -------------------------------------------- | +| `ArrayBuffer` | Zero-copy detach, or copy if non-detachable | +| `SharedArrayBuffer` | Always copy | +| `ArrayBufferView` | Zero-copy detach of underlying buffer | +| `Blob` | Slice of Blob's existing DataQueue | +| `String` | UTF-8 encode into BackingStore | +| `FileHandle` | `FdEntry` — async file reads via thread pool | + +For `FileHandle` bodies, the `FdEntry::ReaderImpl` dispatches `uv_fs_read` +to the libuv thread pool and returns `STATUS_WAIT`. When the read completes, +the callback appends data to the Outbound buffer and calls +`session().ResumeStream(id)` to re-enter the send loop. + +### Inbound Data Flow + +Received stream data is delivered by ngtcp2 via +`Application::ReceiveStreamData()`, which calls `stream->ReceiveData()`. +Data is appended to the stream's inbound `DataQueue`. The JavaScript side +consumes this via an async iterator (the `stream/iter` `bytes()` helper). +The stream implements `DataQueue::BackpressureListener` to extend the +QUIC flow control window as data is consumed. + +### Streaming Mode (Writer API) + +When no body is provided at stream creation, the JavaScript `stream.writer` +API uses streaming mode. The Outbound creates a non-idempotent DataQueue. +Each `writeSync()` / `write()` call appends an in-memory entry. The +`endSync()` / `end()` call caps the queue, signaling EOS to the send loop. + +## SessionManager + +The `SessionManager` is a per-Realm singleton that owns the authoritative +CID→Session mapping. It enables: + +* **Cross-endpoint routing**: A session's CIDs are registered globally so + packets arriving on any endpoint find the right session. +* **Connection migration**: When a session migrates to a new path, the + SessionManager updates the routing without requiring endpoint-specific + knowledge. +* **Stateless reset token mapping**: Maps reset tokens to sessions for + detecting stateless resets on any endpoint. + +CID lookup uses a three-tier strategy: + +1. Direct SCID match in `SessionManager::sessions_` +2. Cross-endpoint DCID→SCID in `SessionManager::dcid_to_scid_` +3. Per-endpoint DCID→SCID in `Endpoint::dcid_to_scid_` (peer-chosen CIDs) + +## Address Validation + +The endpoint uses an LRU cache to track validated remote addresses. For +unvalidated addresses: + +1. If no token is present, a **Retry** packet is sent with a cryptographic + token (HKDF-derived, time-limited). +2. The client retransmits the Initial with the retry token. +3. The token is validated; the session is created with the original DCID + preserved for transport parameter verification. + +Regular tokens (from `NEW_TOKEN` frames) follow the same validation path +but without the retry handshake. The LRU cache allows subsequent +connections from the same address to skip validation entirely. + +## HTTP/3 Application (`http3.cc`) + +The `Http3ApplicationImpl` wraps `nghttp3_conn` and handles: + +* **Header compression**: QPACK encoding/decoding via nghttp3's internal + encoder/decoder streams (unidirectional). +* **Stream management**: Only bidirectional streams are exposed to + JavaScript. Unidirectional control, encoder, and decoder streams are + managed internally. +* **FIN management**: `stream_fin_managed_by_application()` returns true. + nghttp3 controls when FIN is sent based on HTTP/3 framing (DATA frames, + trailing HEADERS). The `EndWriting()` notification from JavaScript is + forwarded to `nghttp3_conn_shutdown_stream_write()`. +* **Data read callback**: `on_read_data_callback` pulls data from the + stream's Outbound during `nghttp3_conn_writev_stream`. Bytes must be + committed inside the callback (before `StreamCommit`) because QPACK can + cause re-entrant `read_data` calls. +* **GOAWAY**: `BeginShutdown()` sends a GOAWAY frame. The goaway ID is + deferred to `PostReceive()` (outside callback scopes) so it can safely + invoke JavaScript. +* **Settings**: HTTP/3 SETTINGS (max field section size, QPACK capacities, + CONNECT protocol, datagrams) are negotiated and enforced. Datagram + support follows RFC 9297 — when the peer's SETTINGS disable datagrams, + `sendDatagram()` is blocked. +* **0-RTT**: Early data settings are validated during ticket extraction + (`ValidateTicketData` in `ExtractSessionTicketAppData`). If the server's + settings changed incompatibly, the ticket is rejected before TLS accepts + it. + +## Error Handling + +`QuicError` (`data.h`) encapsulates QUIC error codes with a type namespace +(transport, application, version negotiation, idle close). Factory methods +wrap ngtcp2 error codes, TLS alerts, and application errors. + +On the JavaScript side, `convertQuicError()` transforms the C++ error +representation into `ERR_QUIC_TRANSPORT_ERROR` or +`ERR_QUIC_APPLICATION_ERROR` objects. Clean closes (transport NO\_ERROR, +H3 NO\_ERROR, or idle close) resolve `stream.closed`; all other errors +reject it. + +## Packet Allocation + +Outbound packets are allocated from an `ArenaPool` owned by the +Endpoint. The arena provides O(1) allocation from contiguous memory blocks +(128 slots per block), avoiding per-packet heap allocation and V8 object +overhead. Packets are returned to the pool when the UDP send completes +(via the `Packet::Listener::PacketDone` callback). + +## Debug Logging + +Use the `NODE_DEBUG_NATIVE` environment variable to enable detailed debug +logging: + +* `QUIC` - general QUIC events (sessions, streams, packets) +* `NGTCP2` - ngtcp2 callback events and error codes +* `NGHTTP3` - nghttp3 callback events and error codes + +```bash +NODE_DEBUG_NATIVE=QUIC,NGTCP2,NGHTTP3 node --experimental-quic ... +``` + +The debug output will be printed to stderr and can be extremely verbose. + +Used in combination with `qlog` and `keylog` options when creating a +`QuicSession`, this can help significantly with debugging and understanding +QUIC behavior and identifying bugs / performance issues in the implementation. + +## External Dependencies + +| Library | Role | Location | +| ------- | --------------------------------------- | ------------------------- | +| ngtcp2 | QUIC transport protocol | `deps/ngtcp2/ngtcp2/` | +| nghttp3 | HTTP/3 framing, QPACK | `deps/ngtcp2/nghttp3/` | +| OpenSSL | TLS 1.3 handshake, encryption | system or `deps/openssl/` | +| libuv | UDP sockets, timers, thread pool | `deps/uv/` | +| V8 | JavaScript engine, GC, external strings | `deps/v8/` | diff --git a/src/quic/application.cc b/src/quic/application.cc index 81c1c0ebe5f49c..b5d8c8609fa3dc 100644 --- a/src/quic/application.cc +++ b/src/quic/application.cc @@ -1,3 +1,4 @@ +#include "util.h" #if HAVE_OPENSSL && HAVE_QUIC #include "guard.h" #ifndef OPENSSL_NO_QUIC @@ -34,6 +35,8 @@ const Session::Application_Options Session::Application_Options::kDefault = {}; Session::Application_Options::operator const nghttp3_settings() const { // In theory, Application::Options might contain options for more than just // HTTP/3. Here we extract only the properties that are relevant to HTTP/3. + // Later if we add more application types we can add more properties or + // divide this up into multiple option structs. return nghttp3_settings{ .max_field_section_size = max_field_section_size, .qpack_max_dtable_capacity = @@ -43,11 +46,13 @@ Session::Application_Options::operator const nghttp3_settings() const { .qpack_blocked_streams = static_cast(qpack_blocked_streams), .enable_connect_protocol = enable_connect_protocol, .h3_datagram = enable_datagrams, - // TODO(@jasnell): Support origin frames? + // origin_list is nullptr here because it is set directly on the + // nghttp3_settings in Http3ApplicationImpl::InitializeConnection() + // from the SNI configuration. .origin_list = nullptr, .glitch_ratelim_burst = 1000, .glitch_ratelim_rate = 33, - .qpack_indexing_strat = NGHTTP3_QPACK_INDEXING_STRAT_NONE, + .qpack_indexing_strat = NGHTTP3_QPACK_INDEXING_STRAT_EAGER, }; } @@ -139,53 +144,21 @@ bool Session::Application::Start() { return true; } -bool Session::Application::AcknowledgeStreamData(int64_t stream_id, - size_t datalen) { - if (auto stream = session().FindStream(stream_id)) [[likely]] { +bool Session::Application::AcknowledgeStreamData(stream_id id, size_t datalen) { + if (auto stream = session().FindStream(id)) [[likely]] { stream->Acknowledge(datalen); - return true; } - return false; -} - -void Session::Application::BlockStream(int64_t id) { - // By default do nothing. -} - -bool Session::Application::CanAddHeader(size_t current_count, - size_t current_headers_length, - size_t this_header_length) { - // By default headers are not supported. - return false; -} - -bool Session::Application::SendHeaders(const Stream& stream, - HeadersKind kind, - const Local& headers, - HeadersFlags flags) { - // By default do nothing. - return false; -} - -void Session::Application::ResumeStream(int64_t id) { - // By default do nothing. -} - -void Session::Application::ExtendMaxStreams(EndpointLabel label, - Direction direction, - uint64_t max_streams) { - // By default do nothing. -} - -void Session::Application::ExtendMaxStreamData(Stream* stream, - uint64_t max_data) { - Debug(session_, "Application extending max stream data"); - // By default do nothing. + // Returning true even when the stream is not found is intentional. + // After a stream is destroyed, the peer can still ACK data that was + // previously sent. This is benign and should not be treated as an error. + return true; } void Session::Application::CollectSessionTicketAppData( SessionTicket::AppData* app_data) const { - // By default do nothing. + // By default, write just the application type byte. + uint8_t buf[1] = {static_cast(type())}; + app_data->Set(uv_buf_init(reinterpret_cast(buf), 1)); } SessionTicket::AppData::Status @@ -197,14 +170,39 @@ Session::Application::ExtractSessionTicketAppData( : SessionTicket::AppData::Status::TICKET_USE; } -void Session::Application::SetStreamPriority(const Stream& stream, - StreamPriority priority, - StreamPriorityFlags flags) { - // By default do nothing. +std::optional Session::Application::ParseTicketData( + const uv_buf_t& data) { + if (data.len == 0 || data.base == nullptr) return std::nullopt; + auto app_type = + static_cast(reinterpret_cast(data.base)[0]); + switch (app_type) { + case Type::DEFAULT: + return DefaultTicketData{}; + case Type::HTTP3: + return ParseHttp3TicketData(data); + default: + return std::nullopt; + } } -StreamPriority Session::Application::GetStreamPriority(const Stream& stream) { - return StreamPriority::DEFAULT; +bool Session::Application::ValidateTicketData( + const PendingTicketAppData& data, const Application_Options& options) { + if (std::holds_alternative(data)) { + // TODO(@jasnell): This validation probably belongs in http3.cc but keeping + // it here for now. + const auto& ticket = std::get(data); + return options.max_field_section_size >= ticket.max_field_section_size && + options.qpack_max_dtable_capacity >= + ticket.qpack_max_dtable_capacity && + options.qpack_encoder_max_dtable_capacity >= + ticket.qpack_encoder_max_dtable_capacity && + options.qpack_blocked_streams >= ticket.qpack_blocked_streams && + (!ticket.enable_connect_protocol || + options.enable_connect_protocol) && + (!ticket.enable_datagrams || options.enable_datagrams); + } + // DefaultTicketData always validates. + return true; } Packet::Ptr Session::Application::CreateStreamDataPacket() { @@ -212,23 +210,120 @@ Packet::Ptr Session::Application::CreateStreamDataPacket() { session_->remote_address(), session_->max_packet_size(), "stream data"); } -void Session::Application::StreamClose(Stream* stream, QuicError&& error) { +void Session::Application::ReceiveStreamClose(Stream* stream, + QuicError&& error) { DCHECK_NOT_NULL(stream); stream->Destroy(std::move(error)); } -void Session::Application::StreamStopSending(Stream* stream, - QuicError&& error) { +void Session::Application::ReceiveStreamStopSending(Stream* stream, + QuicError&& error) { DCHECK_NOT_NULL(stream); stream->ReceiveStopSending(std::move(error)); } -void Session::Application::StreamReset(Stream* stream, - uint64_t final_size, - QuicError&& error) { +void Session::Application::ReceiveStreamReset(Stream* stream, + uint64_t final_size, + QuicError&& error) { stream->ReceiveStreamReset(final_size, std::move(error)); } +// Attempts to pack a pending datagram into the current packet. +// Returns the nwrite value from ngtcp2_conn_writev_datagram. +// On fatal error, closes the session and returns the error code. +// The caller should check: +// > 0: packet is complete, send it (pos was NOT advanced — caller +// must add nwrite to pos and send) +// NGTCP2_ERR_WRITE_MORE: datagram packed, room for more +// 0: congestion controlled or doesn't fit, datagram stays in queue +// < 0 (other): fatal error, session already closed +ssize_t Session::Application::TryWritePendingDatagram(PathStorage* path, + uint8_t* dest, + size_t destlen) { + CHECK(session_->HasPendingDatagrams()); + auto max_attempts = session_->config().options.max_datagram_send_attempts; + + // Skip datagrams that have already exceeded the send attempt limit + // from a previous SendPendingData cycle. + while (session_->HasPendingDatagrams()) { + auto& front = session_->PeekPendingDatagram(); + if (front.send_attempts < max_attempts) break; + Debug(session_, + "Datagram %" PRIu64 " abandoned after %u attempts", + front.id, + front.send_attempts); + session_->DatagramStatus(front.id, DatagramStatus::ABANDONED); + session_->PopPendingDatagram(); + } + + if (!session_->HasPendingDatagrams()) return 0; + auto& dg = session_->PeekPendingDatagram(); + ngtcp2_vec dgvec = dg.data; + int accepted = 0; + int dg_flags = NGTCP2_WRITE_DATAGRAM_FLAG_MORE; + + ssize_t dg_nwrite = ngtcp2_conn_writev_datagram(*session_, + &path->path, + nullptr, + dest, + destlen, + &accepted, + dg_flags, + dg.id, + &dgvec, + 1, + uv_hrtime()); + + if (accepted) { + // Nice, the datagram was accepted! + Debug(session_, "Datagram %" PRIu64 " accepted into packet", dg.id); + session_->DatagramSent(dg.id); + session_->PopPendingDatagram(); + } else { + Debug(session_, "Datagram %" PRIu64 " not accepted into packet", dg.id); + } + + switch (dg_nwrite) { + case 0: { + // If dg_nwrite is 0, we are either congestion controlled or + // there wasn't enough room in the packet for the datagram or + // we aren't in a state where we can send. + // We'll skip this attempt and return 0. + CHECK(!accepted); + dg.send_attempts++; + return 0; + } + case NGTCP2_ERR_WRITE_MORE: { + // There's still room left in the packet! + return NGTCP2_ERR_WRITE_MORE; + } + case NGTCP2_ERR_INVALID_STATE: + case NGTCP2_ERR_INVALID_ARGUMENT: { + // Non-fatal error cases. Peer either does not support datagrams + // or the datagram is too large for the peer's max. + // Abandon the datagram and signal skip by returning std::nullopt. + session_->DatagramStatus(dg.id, DatagramStatus::ABANDONED); + session_->PopPendingDatagram(); + return 0; + } + default: { + // Fatal errors: PKT_NUM_EXHAUSTED, CALLBACK_FAILURE, NOMEM, etc. + Debug(session_, "Fatal datagram error: %zd", dg_nwrite); + session_->SetLastError(QuicError::ForNgtcp2Error(dg_nwrite)); + session_->Close(CloseMethod::SILENT); + return dg_nwrite; + } + } + UNREACHABLE(); +} + +// the SendPendingData method is the primary driver for sending data from the +// application layer. It loops through available stream data and pending +// datagrams and generates packets to send until there is either no more +// data to send or we hit the maximum number of packets to send in one go. +// This method is extremely delicate. A bug in this method can break the +// entire QUIC implementation; so be very careful when making changes here +// and make sure to test thoroughly. When in doubt... don't change it. void Session::Application::SendPendingData() { DCHECK(!session().is_destroyed()); if (!session().can_send_packets()) [[unlikely]] { @@ -262,19 +357,14 @@ void Session::Application::SendPendingData() { size_t packet_send_count = 0; Packet::Ptr packet; - uint8_t* pos = nullptr; - uint8_t* begin = nullptr; auto ensure_packet = [&] { if (!packet) { packet = CreateStreamDataPacket(); if (!packet) [[unlikely]] return false; - pos = begin = packet->data(); } DCHECK(packet); - DCHECK_NOT_NULL(pos); - DCHECK_NOT_NULL(begin); return true; }; @@ -302,21 +392,38 @@ void Session::Application::SendPendingData() { } // If we got here, we were at least successful in checking for stream data. - // There might not be any stream data to send. + // There might not be any stream data to send. If there is no stream data, + // that's perfectly fine, we still need to serialize any frames we do have + // (pings, acks, datagrams, etc) so we'll just keep going. if (stream_data.id >= 0) { Debug(session_, "Application using stream data: %s", stream_data); + } else { + Debug(session_, "No stream data to send"); + } + if (session_->HasPendingDatagrams()) { + Debug(session_, "There are pending datagrams to send"); } // Awesome, let's write our packet! - ssize_t nwrite = - WriteVStream(&path, pos, &ndatalen, max_packet_size, stream_data); + ssize_t nwrite = WriteVStream( + &path, packet->data(), &ndatalen, packet->length(), stream_data); + // When ndatalen is > 0, that's our indication that stream data was accepted + // in to the packet. Yay! if (ndatalen > 0) { Debug(session_, "Application accepted %zu bytes from stream %" PRIi64 " into packet", ndatalen, stream_data.id); + if (!StreamCommit(&stream_data, ndatalen)) { + // Data was accepted into the packet, but for some reason adjusting + // the stream's committed data failed. Treat as fatal. + Debug(session_, "Failed to commit accepted bytes in stream"); + session_->SetLastError(QuicError::ForNgtcp2Error(NGTCP2_ERR_INTERNAL)); + closed = true; + return session_->Close(CloseMethod::SILENT); + } } else if (stream_data.id >= 0) { Debug(session_, "Application did not accept any bytes from stream %" PRIi64 @@ -324,6 +431,23 @@ void Session::Application::SendPendingData() { stream_data.id); } + // When nwrite is zero, it means we are congestion limited or it is + // just not our turn to send something. Re-schedule the stream if it + // had unsent data (payload or FIN) so the next timer-triggered + // SendPendingData retries it. Without this, a FIN-only send that + // hits nwrite=0 is lost forever — the stream already returned EOS + // from Pull and won't be re-scheduled by anyone else. + // We call Application::ResumeStream directly (not Session::ResumeStream) + // to avoid creating a SendPendingDataScope — we're already inside + // SendPendingData and re-entering would just hit nwrite=0 again. + if (nwrite == 0) { + Debug(session_, "Congestion or not our turn to send"); + if (stream_data.id >= 0 && (stream_data.count > 0 || stream_data.fin)) { + ResumeStream(stream_data.id); + } + return; + } + // A negative nwrite value indicates either an error or that there is more // data to write into the packet. if (nwrite < 0) { @@ -344,7 +468,7 @@ void Session::Application::SendPendingData() { case NGTCP2_ERR_STREAM_SHUT_WR: { // Indicates that the writable side of the stream should be closed // locally or the stream is being reset. In either case, we can't send - // any stream data! + // data for this stream! Debug(session_, "Closing stream %" PRIi64 " for writing", stream_data.id); @@ -357,16 +481,36 @@ void Session::Application::SendPendingData() { if (stream_data.stream) [[likely]] { stream_data.stream->EndWritable(); } + // Notify the application that the stream's write side is shut + // so it stops queuing data. Without this, GetStreamData would + // keep returning the same stream and we'd loop forever. + StreamWriteShut(stream_data.id); continue; } case NGTCP2_ERR_WRITE_MORE: { - if (ndatalen >= 0 && !StreamCommit(&stream_data, ndatalen)) { - Debug(session_, - "Failed to commit stream data while writing packets"); - session_->SetLastError( - QuicError::ForNgtcp2Error(NGTCP2_ERR_INTERNAL)); - closed = true; - return session_->Close(CloseMethod::SILENT); + Debug(session_, "Packet buffer not full, coalesce more data into it"); + // Room for more in this packet. Try to pack a pending datagram + // if there is one. Otherwise just loop around and keep going. + if (session_->HasPendingDatagrams()) { + auto result = TryWritePendingDatagram( + &path, packet->data(), packet->length()); + // When result is 0, either the datagram was congestion controlled, + // didn't fit in the packet, or was abandoned. Skip and continue. + + // When result is > 0, the packet is done and the result is the + // completed size of the packet we're sending. + if (result > 0) { + size_t len = result; + Debug(session_, "Sending packet with %zu bytes", len); + packet->Truncate(len); + session_->Send(std::move(packet), path); + if (++packet_send_count == max_packet_count) return; + } else if (result < 0) { + // Any negative result other than NGTCP2_ERR_WRITE_MORE + // at this point is fatal. The session will have been + // closed. + if (result != NGTCP2_ERR_WRITE_MORE) return; + } } continue; } @@ -390,46 +534,42 @@ void Session::Application::SendPendingData() { session_->SetLastError(QuicError::ForNgtcp2Error(nwrite)); closed = true; return session_->Close(CloseMethod::SILENT); - } else if (ndatalen >= 0 && !StreamCommit(&stream_data, ndatalen)) { - session_->SetLastError(QuicError::ForNgtcp2Error(NGTCP2_ERR_INTERNAL)); - closed = true; - return session_->Close(CloseMethod::SILENT); } - // When nwrite is zero, it means we are congestion limited or it is - // just not our turn now to send something. Stop sending packets. - if (nwrite == 0) { - // If there was stream data selected, we should reschedule it to try - // sending again. - if (stream_data.id >= 0) ResumeStream(stream_data.id); - - // There might be a partial packet already prepared. If so, send it. - size_t datalen = pos - begin; - if (datalen) { - Debug(session_, "Sending packet with %zu bytes", datalen); - packet->Truncate(datalen); + // At this point we have a packet prepared to send. The nwrite + // is the size of the packet we are sending. + size_t len = nwrite; + Debug(session_, "Sending packet with %zu bytes", len); + packet->Truncate(len); + session_->Send(std::move(packet), path); + if (++packet_send_count == max_packet_count) return; + + // If there are pending datagrams, try sending them in a fresh packet. + // This is necessary because ngtcp2_conn_writev_stream only returns + // NGTCP2_ERR_WRITE_MORE when there is actual stream data — when no + // streams are active, the coalescing path above is never reached and + // datagrams would never be sent. + if (session_->HasPendingDatagrams()) { + if (!ensure_packet()) [[unlikely]] { + Debug(session_, "Failed to create packet for datagram"); + session_->SetLastError(QuicError::ForNgtcp2Error(NGTCP2_ERR_INTERNAL)); + closed = true; + return session_->Close(CloseMethod::SILENT); + } + auto result = + TryWritePendingDatagram(&path, packet->data(), packet->length()); + if (result > 0) { + Debug(session_, "Sending datagram packet with %zd bytes", result); + packet->Truncate(static_cast(result)); session_->Send(std::move(packet), path); + if (++packet_send_count == max_packet_count) return; + } else if (result < 0 && result != NGTCP2_ERR_WRITE_MORE) { + // Fatal error — session already closed by TryWritePendingDatagram. + return; } - // If no data, Ptr destructor releases the packet. - - return; + // If result == 0 (congestion) or NGTCP2_ERR_WRITE_MORE (datagram + // packed but room for more), the loop continues normally. } - - // At this point we have a packet prepared to send. - pos += nwrite; - size_t datalen = pos - begin; - Debug(session_, "Sending packet with %zu bytes", datalen); - packet->Truncate(datalen); - session_->Send(std::move(packet), path); - - // If we have sent the maximum number of packets, we're done. - if (++packet_send_count == max_packet_count) { - return; - } - - // Prepare to loop back around to prepare a new packet. - // packet is already empty from the std::move above. - pos = begin = nullptr; } } @@ -455,6 +595,7 @@ ssize_t Session::Application::WriteVStream(PathStorage* path, uv_hrtime()); } +// ============================================================================ // The DefaultApplication is the default implementation of Session::Application // that is used for all unrecognized ALPN identifiers. class DefaultApplication final : public Session::Application { @@ -470,7 +611,35 @@ class DefaultApplication final : public Session::Application { error_code GetNoErrorCode() const override { return 0; } - bool ReceiveStreamData(int64_t stream_id, + // Raw QUIC has no application-defined "general failure" code, so + // fall back to the QUIC transport-level INTERNAL_ERROR (0x1) used + // by ngtcp2 for unspecified failures. + error_code GetInternalErrorCode() const override { + return NGTCP2_INTERNAL_ERROR; + } + + void EarlyDataRejected() override { + // Destroy all open streams — ngtcp2 has already discarded their + // internal state when it rejected the early data. + session().DestroyAllStreams(QuicError::ForApplication(0)); + if (!session().is_destroyed()) { + session().EmitEarlyDataRejected(); + } + } + + bool ApplySessionTicketData(const PendingTicketAppData& data) override { + return std::holds_alternative(data); + } + + bool ReceiveStreamOpen(stream_id id) override { + auto stream = session().CreateStream(id); + if (!stream || session().is_destroyed()) [[unlikely]] { + return !session().is_destroyed(); + } + return true; + } + + bool ReceiveStreamData(stream_id id, const uint8_t* data, size_t datalen, const Stream::ReceiveDataFlags& flags, @@ -478,10 +647,10 @@ class DefaultApplication final : public Session::Application { BaseObjectPtr stream; if (stream_user_data == nullptr) { // This is the first time we're seeing this stream. Implicitly create it. - stream = session().CreateStream(stream_id); - if (!stream) [[unlikely]] { - // We couldn't actually create the stream for whatever reason. - Debug(&session(), "Default application failed to create new stream"); + stream = session().CreateStream(id); + if (!stream || session().is_destroyed()) [[unlikely]] { + // We couldn't create the stream, or the session was destroyed + // during the onstream callback (via MakeCallback re-entrancy). return false; } } else { @@ -546,7 +715,6 @@ class DefaultApplication final : public Session::Application { if (count > 0) { stream->Schedule(&stream_queue_); - } else { } // Not calling done here because we defer committing @@ -569,14 +737,26 @@ class DefaultApplication final : public Session::Application { return 0; } - void ResumeStream(int64_t id) override { ScheduleStream(id); } + void ResumeStream(stream_id id) override { ScheduleStream(id); } - void BlockStream(int64_t id) override { + void BlockStream(stream_id id) override { if (auto stream = session().FindStream(id)) [[likely]] { + // Remove the stream from the send queue. It will be re-scheduled + // via ExtendMaxStreamData when the peer grants more flow control. + // Without this, SendPendingData would repeatedly pop and retry + // the same blocked stream in an infinite loop. + stream->Unschedule(); stream->EmitBlocked(); } } + void ExtendMaxStreamData(Stream* stream, uint64_t max_data) override { + // The peer granted more flow control for this stream. Re-schedule + // it so SendPendingData will resume writing. + DCHECK_NOT_NULL(stream); + stream->Schedule(&stream_queue_); + } + bool StreamCommit(StreamData* stream_data, size_t datalen) override { DCHECK_NOT_NULL(stream_data); CHECK(stream_data->stream); @@ -589,7 +769,7 @@ class DefaultApplication final : public Session::Application { SET_NO_MEMORY_INFO() private: - void ScheduleStream(int64_t id) { + void ScheduleStream(stream_id id) { if (auto stream = session().FindStream(id)) [[likely]] { stream->Schedule(&stream_queue_); } diff --git a/src/quic/application.h b/src/quic/application.h index 11ee977c44967c..673a4000e4ba2d 100644 --- a/src/quic/application.h +++ b/src/quic/application.h @@ -2,6 +2,9 @@ #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS +#include +#include + #include "base_object.h" #include "bindingdata.h" #include "defs.h" @@ -11,34 +14,82 @@ namespace node::quic { +// Parsed session ticket application data, produced by +// Application::ParseTicketData() before ALPN negotiation and consumed +// by Application::ApplySessionTicketData() after. +struct DefaultTicketData {}; +struct Http3TicketData { + uint64_t max_field_section_size; + uint64_t qpack_max_dtable_capacity; + uint64_t qpack_encoder_max_dtable_capacity; + uint64_t qpack_blocked_streams; + bool enable_connect_protocol; + bool enable_datagrams; +}; +using PendingTicketAppData = + std::variant; + // An Application implements the ALPN-protocol specific semantics on behalf // of a QUIC Session. class Session::Application : public MemoryRetainer { public: using Options = Session::Application_Options; + Application(Session* session, const Options& options); + DISALLOW_COPY_AND_MOVE(Application) + // The type of Application, exposed via the session state so JS // can observe which Application was selected after ALPN negotiation. + // This is used primarily for testing/debugging. enum class Type : uint8_t { NONE = 0, // Not yet selected (server pre-negotiation) DEFAULT = 1, // DefaultApplication (non-h3 ALPN) HTTP3 = 2, // Http3ApplicationImpl (h3 / h3-XX ALPN) }; - - Application(Session* session, const Options& options); - DISALLOW_COPY_AND_MOVE(Application) - virtual Type type() const = 0; virtual bool Start(); + // Returns true if Start() has been called successfully. + virtual bool is_started() const { return false; } + + // Called when the server rejects 0-RTT early data. The application + // must destroy all streams that were opened during the 0-RTT phase + // since ngtcp2 has already discarded their internal state. + virtual void EarlyDataRejected() = 0; + + // The "no error code" is the application-level error code that signals + // "no error". Per the QUIC spec, this can vary by application protocol + // and is not necessarily 0. virtual error_code GetNoErrorCode() const = 0; + // The "internal error code" is the application-level error code used + // to signal a non-specific failure when no more specific code has + // been provided by the caller. For example, `writer.fail(reason)` on + // the JS side uses this code when `reason` is not a `QuicError` + // carrying an explicit code. For HTTP/3 this is + // `NGHTTP3_H3_INTERNAL_ERROR` (0x102); for raw QUIC applications + // there is no defined application code so we fall back to + // NGTCP2_INTERNAL_ERROR (0x1). + virtual error_code GetInternalErrorCode() const = 0; + + // Called after Session::Receive processes a packet, outside all callback + // scopes. Applications can use this to handle deferred operations that + // require calling into JS (e.g., HTTP/3 GOAWAY processing). + virtual void PostReceive() {} + + // Called when ngtcp2 notifies us that a new remote stream has been + // opened. The Application decides whether to create a Stream object + // (and fire the JS onstream callback) based on the stream type. For + // example, HTTP/3 only creates Stream objects for bidi streams since + // uni streams are managed internally by nghttp3. + virtual bool ReceiveStreamOpen(stream_id id) = 0; + // Session will forward all received stream data immediately on to the // Application. The only additional processing the Session does is to // automatically adjust the session-level flow control window. It is up to // the Application to do the same for the Stream-level flow control. - virtual bool ReceiveStreamData(int64_t stream_id, + virtual bool ReceiveStreamData(stream_id id, const uint8_t* data, size_t datalen, const Stream::ReceiveDataFlags& flags, @@ -46,22 +97,30 @@ class Session::Application : public MemoryRetainer { // Session will forward all data acknowledgements for a stream to the // Application. - virtual bool AcknowledgeStreamData(int64_t stream_id, size_t datalen); + virtual bool AcknowledgeStreamData(stream_id id, size_t datalen); // Called to determine if a Header can be added to this application. // Applications that do not support headers will always return false. virtual bool CanAddHeader(size_t current_count, size_t current_headers_length, - size_t this_header_length); + size_t this_header_length) { + return false; + } + + // Called when ngtcp2 reports NGTCP2_ERR_STREAM_SHUT_WR for a stream. + // Applications that manage their own framing (e.g., HTTP/3) must inform + // their protocol layer that the stream's write side is shut so it stops + // queuing data for that stream. The default is a no-op. + virtual void StreamWriteShut(stream_id id) {} // Called to mark the identified stream as being blocked. Not all // Application types will support blocked streams, and those that do will do // so differently. - virtual void BlockStream(int64_t id); + virtual void BlockStream(stream_id id) {} // Called when the session determines that there is outbound data available // to send for the given stream. - virtual void ResumeStream(int64_t id); + virtual void ResumeStream(stream_id id) {} // Called when the Session determines that the maximum number of // remotely-initiated unidirectional streams has been extended. Not all @@ -69,16 +128,27 @@ class Session::Application : public MemoryRetainer { // nothing. virtual void ExtendMaxStreams(EndpointLabel label, Direction direction, - uint64_t max_streams); + uint64_t max_streams) {} + + // Returns true if the application manages stream FIN internally (e.g., + // HTTP/3 uses nghttp3 which sends FIN via the fin flag in writev_stream). + // When true, the stream infrastructure must NOT call + // ngtcp2_conn_shutdown_stream_write when the JS write side ends — + // the application protocol layer handles it. + virtual bool stream_fin_managed_by_application() const { return false; } // Called when the Session determines that the flow control window for the // given stream has been expanded. Not all Application types will require // this notification so the default is to do nothing. - virtual void ExtendMaxStreamData(Stream* stream, uint64_t max_data); + virtual void ExtendMaxStreamData(Stream* stream, uint64_t max_data) { + Debug(session_, "Application extending max stream data"); + // By default do nothing. + } // Different Applications may wish to set some application data in the // session ticket (e.g. http/3 would set server settings in the application - // data). By default, there's nothing to set. + // data). The first byte written MUST be the Application::Type enum value. + // By default, writes just the type byte. virtual void CollectSessionTicketAppData( SessionTicket::AppData* app_data) const; @@ -89,17 +159,37 @@ class Session::Application : public MemoryRetainer { const SessionTicket::AppData& app_data, SessionTicket::AppData::Source::Flag flag); + // Validates parsed ticket data against current application options. + // Returns false if the stored settings are more permissive than the + // current config (e.g., a feature was enabled when the ticket was + // issued but is now disabled). + static bool ValidateTicketData(const PendingTicketAppData& data, + const Application_Options& options); + + // Parse session ticket app data before ALPN negotiation. Reads the + // type byte and dispatches to the appropriate application-specific + // parser. Returns std::nullopt if parsing fails. + static std::optional ParseTicketData( + const uv_buf_t& data); + + // Called after ALPN negotiation to validate and apply previously + // parsed session ticket app data. Returns false if the data is + // incompatible (e.g., type mismatch or settings downgrade), which + // causes the handshake to fail. + virtual bool ApplySessionTicketData(const PendingTicketAppData& data) = 0; + // Notifies the Application that the identified stream has been closed. - virtual void StreamClose(Stream* stream, QuicError&& error = QuicError()); + virtual void ReceiveStreamClose(Stream* stream, + QuicError&& error = QuicError()); // Notifies the Application that the identified stream has been reset. - virtual void StreamReset(Stream* stream, - uint64_t final_size, - QuicError&& error = QuicError()); + virtual void ReceiveStreamReset(Stream* stream, + uint64_t final_size, + QuicError&& error = QuicError()); // Notifies the Application that the identified stream should stop sending. - virtual void StreamStopSending(Stream* stream, - QuicError&& error = QuicError()); + virtual void ReceiveStreamStopSending(Stream* stream, + QuicError&& error = QuicError()); // Submits an outbound block of headers for the given stream. Not all // Application types will support headers, in which case this function @@ -107,31 +197,57 @@ class Session::Application : public MemoryRetainer { virtual bool SendHeaders(const Stream& stream, HeadersKind kind, const v8::Local& headers, - HeadersFlags flags = HeadersFlags::NONE); + HeadersFlags flags = HeadersFlags::NONE) { + return false; + } // Signals to the Application that it should serialize and transmit any // pending session and stream packets it has accumulated. void SendPendingData(); + // Returns true if the application protocol supports sending and + // receiving headers on streams (e.g. HTTP/3). Applications that + // do not support headers should return false (the default). + virtual bool SupportsHeaders() const { return false; } + + // Initiates application-level graceful shutdown signaling (e.g., + // HTTP/3 GOAWAY). Called when Session::Close(GRACEFUL) is invoked. + virtual void BeginShutdown() {} + + // Completes the application-level graceful shutdown. Called from + // FinishClose() before CONNECTION_CLOSE is sent. For HTTP/3, this + // sends the final GOAWAY with the actual last accepted stream ID. + virtual void CompleteShutdown() {} + // Set the priority level of the stream if supported by the application. Not // all applications support priorities, in which case this function is a // non-op. virtual void SetStreamPriority( const Stream& stream, StreamPriority priority = StreamPriority::DEFAULT, - StreamPriorityFlags flags = StreamPriorityFlags::NONE); + StreamPriorityFlags flags = StreamPriorityFlags::NON_INCREMENTAL) {} + + struct StreamPriorityResult { + StreamPriority priority; + StreamPriorityFlags flags; + }; // Get the priority level of the stream if supported by the application. Not // all applications support priorities, in which case this function returns // the default stream priority. - virtual StreamPriority GetStreamPriority(const Stream& stream); + virtual StreamPriorityResult GetStreamPriority(const Stream& stream) { + return {StreamPriority::DEFAULT, StreamPriorityFlags::NON_INCREMENTAL}; + } + // The StreamData struct is used by the application to pass pending stream + // data to the session for transmission. struct StreamData; virtual int GetStreamData(StreamData* data) = 0; virtual bool StreamCommit(StreamData* data, size_t datalen) = 0; inline Environment* env() const { return session().env(); } + inline Session& session() { CHECK_NOT_NULL(session_); return *session_; @@ -144,6 +260,15 @@ class Session::Application : public MemoryRetainer { private: Packet::Ptr CreateStreamDataPacket(); + // Tries to pack a pending datagram into the current packet buffer. + // If < 0 is returned, either NGTCP2_ERR_WRITE_MORE or a fatal error is + // returned; the caller must check. If > 0 is returned, the packet is done + // and the value is the size of the finalized packet. If 0 is returned, + // the datagram is either congestion limited or was abandoned + ssize_t TryWritePendingDatagram(PathStorage* path, + uint8_t* dest, + size_t destlen); + // Write the given stream_data into the buffer. ssize_t WriteVStream(PathStorage* path, uint8_t* buf, @@ -159,7 +284,7 @@ struct Session::Application::StreamData final { size_t count = 0; // The stream identifier. If this is a negative value then no stream is // identified. - int64_t id = -1; + stream_id id = -1; int fin = 0; ngtcp2_vec data[kMaxVectorCount]{}; BaseObjectPtr stream; diff --git a/src/quic/bindingdata.cc b/src/quic/bindingdata.cc index a8b72900d5a60c..647808d5a1e6bf 100644 --- a/src/quic/bindingdata.cc +++ b/src/quic/bindingdata.cc @@ -11,11 +11,15 @@ #include #include #include +#include #include #include "bindingdata.h" +#include "session.h" +#include "session_manager.h" namespace node { +using mem::kReserveSizeAndAlign; using v8::Function; using v8::FunctionTemplate; using v8::Local; @@ -25,24 +29,155 @@ using v8::Value; namespace quic { +// ============================================================================ +// Thread-local QUIC allocator. +// +// Both ngtcp2 and nghttp3 take an allocator struct (ngtcp2_mem / +// nghttp3_mem) whose pointer is stored inside every object they +// allocate. Some of those objects — notably nghttp3 rcbufs backing +// V8 external strings — can outlive the BindingData that created them +// (freed during V8 isolate teardown, after Environment cleanup). +// +// To handle this safely, both allocators live in a thread-local static +// struct that is never destroyed. Memory tracking goes through the +// BindingData pointer when it is alive and is silently skipped during +// teardown (after ~BindingData nulls the pointer). +// +// The allocation functions use the same prepended-size-header scheme as +// NgLibMemoryManager (node_mem-inl.h) so that frees always know the +// allocation size regardless of whether BindingData is still around. + +namespace { +struct QuicAllocState { + BindingData* binding = nullptr; + ngtcp2_mem ngtcp2 = {}; + nghttp3_mem nghttp3 = {}; +}; +thread_local QuicAllocState quic_alloc_state; + +// Core allocation functions shared by both ngtcp2 and nghttp3. +// user_data always points to the thread-local QuicAllocState. + +void* QuicRealloc(void* ptr, size_t size, void* user_data) { + auto* state = static_cast(user_data); + + size_t previous_size = 0; + char* original_ptr = nullptr; + + if (size > 0) size += kReserveSizeAndAlign; + + if (ptr != nullptr) { + original_ptr = static_cast(ptr) - kReserveSizeAndAlign; + previous_size = *reinterpret_cast(original_ptr); + if (previous_size == 0) { + char* ret = UncheckedRealloc(original_ptr, size); + if (ret != nullptr) ret += kReserveSizeAndAlign; + return ret; + } + } + + if (state->binding) { + state->binding->CheckAllocatedSize(previous_size); + } + + char* mem = UncheckedRealloc(original_ptr, size); + + if (mem != nullptr) { + const int64_t new_size = size - previous_size; + if (state->binding) { + state->binding->IncreaseAllocatedSize(new_size); + state->binding->env()->external_memory_accounter()->Update( + state->binding->env()->isolate(), new_size); + } + *reinterpret_cast(mem) = size; + mem += kReserveSizeAndAlign; + } else if (size == 0) { + if (state->binding) { + state->binding->DecreaseAllocatedSize(previous_size); + state->binding->env()->external_memory_accounter()->Decrease( + state->binding->env()->isolate(), previous_size); + } + } + return mem; +} + +void* QuicMalloc(size_t size, void* user_data) { + return QuicRealloc(nullptr, size, user_data); +} + +void QuicFree(void* ptr, void* user_data) { + if (ptr == nullptr) return; + CHECK_NULL(QuicRealloc(ptr, 0, user_data)); +} + +void* QuicCalloc(size_t nmemb, size_t size, void* user_data) { + size_t real_size = MultiplyWithOverflowCheck(nmemb, size); + void* mem = QuicMalloc(real_size, user_data); + if (mem != nullptr) memset(mem, 0, real_size); + return mem; +} + +// Thin wrappers with the correct function-pointer types for each +// library. The signatures happen to be identical today, but keeping +// them separate avoids ABI coupling between ngtcp2 and nghttp3. + +void* Ngtcp2Malloc(size_t size, void* ud) { + return QuicMalloc(size, ud); +} +void Ngtcp2Free(void* ptr, void* ud) { + QuicFree(ptr, ud); +} +void* Ngtcp2Calloc(size_t n, size_t s, void* ud) { + return QuicCalloc(n, s, ud); +} +void* Ngtcp2Realloc(void* ptr, size_t size, void* ud) { + return QuicRealloc(ptr, size, ud); +} + +void* Nghttp3Malloc(size_t size, void* ud) { + return QuicMalloc(size, ud); +} +void Nghttp3Free(void* ptr, void* ud) { + QuicFree(ptr, ud); +} +void* Nghttp3Calloc(size_t n, size_t s, void* ud) { + return QuicCalloc(n, s, ud); +} +void* Nghttp3Realloc(void* ptr, size_t size, void* ud) { + return QuicRealloc(ptr, size, ud); +} +} // namespace + BindingData& BindingData::Get(Environment* env) { return *(env->principal_realm()->GetBindingData()); } -BindingData::operator ngtcp2_mem() { - return MakeAllocator(); +BindingData::~BindingData() { + quic_alloc_state.binding = nullptr; } -BindingData::operator nghttp3_mem() { - ngtcp2_mem allocator = *this; - nghttp3_mem http3_allocator = { - allocator.user_data, - allocator.malloc, - allocator.free, - allocator.calloc, - allocator.realloc, +ngtcp2_mem* BindingData::ngtcp2_allocator() { + quic_alloc_state.binding = this; + quic_alloc_state.ngtcp2 = { + &quic_alloc_state, + Ngtcp2Malloc, + Ngtcp2Free, + Ngtcp2Calloc, + Ngtcp2Realloc, }; - return http3_allocator; + return &quic_alloc_state.ngtcp2; +} + +nghttp3_mem* BindingData::nghttp3_allocator() { + quic_alloc_state.binding = this; + quic_alloc_state.nghttp3 = { + &quic_alloc_state, + Nghttp3Malloc, + Nghttp3Free, + Nghttp3Calloc, + Nghttp3Realloc, + }; + return &quic_alloc_state.nghttp3; } void BindingData::CheckAllocatedSize(size_t previous_size) const { @@ -59,7 +194,20 @@ void BindingData::DecreaseAllocatedSize(size_t size) { current_ngtcp2_memory_ -= size; } +// Forwards detailed(verbose) debugging information from nghttp3. Enabled using +// the NODE_DEBUG_NATIVE=NGHTTP3 category. +void nghttp3_debug_log(const char* fmt, va_list args) { + auto isolate = v8::Isolate::GetCurrent(); + if (isolate == nullptr) return; + auto env = Environment::GetCurrent(isolate); + if (env->enabled_debug_list()->enabled(DebugCategory::NGHTTP3)) { + fprintf(stderr, "nghttp3 "); + vfprintf(stderr, fmt, args); + } +} + void BindingData::InitPerContext(Realm* realm, Local target) { + nghttp3_set_debug_vprintf_callback(nghttp3_debug_log); SetMethod(realm->context(), target, "setCallbacks", SetCallbacks); Realm::GetCurrent(realm->context())->AddBindingData(target); } @@ -75,6 +223,13 @@ BindingData::BindingData(Realm* realm, Local object) MakeWeak(); } +SessionManager& BindingData::session_manager() { + if (!session_manager_) { + session_manager_ = std::make_unique(env()); + } + return *session_manager_; +} + void BindingData::MemoryInfo(MemoryTracker* tracker) const { #define V(name, _) tracker->TrackField(#name, name##_callback()); @@ -162,36 +317,31 @@ JS_METHOD_IMPL(BindingData::SetCallbacks) { #undef V } -NgTcp2CallbackScope::NgTcp2CallbackScope(Environment* env) : env(env) { - auto& binding = BindingData::Get(env); - CHECK(!binding.in_ngtcp2_callback_scope); - binding.in_ngtcp2_callback_scope = true; +NgTcp2CallbackScope::NgTcp2CallbackScope(Session* session) : session(session) { + CHECK(!session->in_ngtcp2_callback_scope_); + session->in_ngtcp2_callback_scope_ = true; } NgTcp2CallbackScope::~NgTcp2CallbackScope() { - auto& binding = BindingData::Get(env); - binding.in_ngtcp2_callback_scope = false; -} - -bool NgTcp2CallbackScope::in_ngtcp2_callback(Environment* env) { - auto& binding = BindingData::Get(env); - return binding.in_ngtcp2_callback_scope; + session->in_ngtcp2_callback_scope_ = false; + if (session->destroy_deferred_) { + session->destroy_deferred_ = false; + session->Destroy(); + } } -NgHttp3CallbackScope::NgHttp3CallbackScope(Environment* env) : env(env) { - auto& binding = BindingData::Get(env); - CHECK(!binding.in_nghttp3_callback_scope); - binding.in_nghttp3_callback_scope = true; +NgHttp3CallbackScope::NgHttp3CallbackScope(Session* session) + : session(session) { + CHECK(!session->in_nghttp3_callback_scope_); + session->in_nghttp3_callback_scope_ = true; } NgHttp3CallbackScope::~NgHttp3CallbackScope() { - auto& binding = BindingData::Get(env); - binding.in_nghttp3_callback_scope = false; -} - -bool NgHttp3CallbackScope::in_nghttp3_callback(Environment* env) { - auto& binding = BindingData::Get(env); - return binding.in_nghttp3_callback_scope; + session->in_nghttp3_callback_scope_ = false; + if (session->destroy_deferred_) { + session->destroy_deferred_ = false; + session->Destroy(); + } } CallbackScopeBase::CallbackScopeBase(Environment* env) diff --git a/src/quic/bindingdata.h b/src/quic/bindingdata.h index 05751d0fbcd01a..cc3c3a49f5647a 100644 --- a/src/quic/bindingdata.h +++ b/src/quic/bindingdata.h @@ -11,6 +11,7 @@ #include #include #include +#include #include #include "defs.h" @@ -18,13 +19,14 @@ namespace node::quic { class Endpoint; class Packet; +class Session; +class SessionManager; // ============================================================================ // The FunctionTemplates the BindingData will store for us. #define QUIC_CONSTRUCTORS(V) \ V(endpoint) \ - V(logstream) \ V(session) \ V(stream) \ V(udp) @@ -36,37 +38,48 @@ class Packet; #define QUIC_JS_CALLBACKS(V) \ V(endpoint_close, EndpointClose) \ V(session_close, SessionClose) \ + V(session_early_data_rejected, SessionEarlyDataRejected) \ + V(session_goaway, SessionGoaway) \ V(session_datagram, SessionDatagram) \ V(session_datagram_status, SessionDatagramStatus) \ V(session_handshake, SessionHandshake) \ + V(session_keylog, SessionKeyLog) \ + V(session_qlog, SessionQlog) \ V(session_new, SessionNew) \ V(session_new_token, SessionNewToken) \ + V(session_origin, SessionOrigin) \ V(session_path_validation, SessionPathValidation) \ V(session_ticket, SessionTicket) \ V(session_version_negotiation, SessionVersionNegotiation) \ V(stream_blocked, StreamBlocked) \ V(stream_close, StreamClose) \ V(stream_created, StreamCreated) \ + V(stream_drain, StreamDrain) \ V(stream_headers, StreamHeaders) \ V(stream_reset, StreamReset) \ V(stream_trailers, StreamTrailers) // The various JS strings the implementation uses. #define QUIC_STRINGS(V) \ + V(abandoned, "abandoned") \ V(aborted, "aborted") \ V(acknowledged, "acknowledged") \ V(ack_delay_exponent, "ackDelayExponent") \ V(active_connection_id_limit, "activeConnectionIDLimit") \ V(address_lru_size, "addressLRUSize") \ V(application, "application") \ + V(authoritative, "authoritative") \ V(bbr, "bbr") \ V(ca, "ca") \ V(cc_algorithm, "cc") \ V(certs, "certs") \ + V(code, "code") \ V(ciphers, "ciphers") \ V(crl, "crl") \ V(cubic, "cubic") \ + V(datagram_drop_policy, "datagramDropPolicy") \ V(disable_stateless_reset, "disableStatelessReset") \ + V(draining_period_multiplier, "drainingPeriodMultiplier") \ V(enable_connect_protocol, "enableConnectProtocol") \ V(enable_early_data, "enableEarlyData") \ V(enable_datagrams, "enableDatagrams") \ @@ -77,6 +90,7 @@ class Packet; V(groups, "groups") \ V(handshake_timeout, "handshakeTimeout") \ V(http3_alpn, &NGHTTP3_ALPN_H3[1]) \ + V(keep_alive_timeout, "keepAlive") \ V(initial_max_data, "initialMaxData") \ V(initial_max_stream_data_bidi_local, "initialMaxStreamDataBidiLocal") \ V(initial_max_stream_data_bidi_remote, "initialMaxStreamDataBidiRemote") \ @@ -86,15 +100,16 @@ class Packet; V(ipv6_only, "ipv6Only") \ V(keylog, "keylog") \ V(keys, "keys") \ - V(logstream, "LogStream") \ V(lost, "lost") \ V(max_ack_delay, "maxAckDelay") \ V(max_connections_per_host, "maxConnectionsPerHost") \ V(max_connections_total, "maxConnectionsTotal") \ V(max_datagram_frame_size, "maxDatagramFrameSize") \ + V(max_datagram_send_attempts, "maxDatagramSendAttempts") \ V(max_field_section_size, "maxFieldSectionSize") \ V(max_header_length, "maxHeaderLength") \ V(max_header_pairs, "maxHeaderPairs") \ + V(idle_timeout, "idleTimeout") \ V(max_idle_timeout, "maxIdleTimeout") \ V(max_payload_size, "maxPayloadSize") \ V(max_retries, "maxRetries") \ @@ -102,12 +117,16 @@ class Packet; V(max_stream_window, "maxStreamWindow") \ V(max_window, "maxWindow") \ V(min_version, "minVersion") \ + V(port, "port") \ + V(preferred_address_ipv4, "preferredAddressIpv4") \ + V(preferred_address_ipv6, "preferredAddressIpv6") \ V(preferred_address_strategy, "preferredAddressPolicy") \ V(alpn, "alpn") \ V(qlog, "qlog") \ V(qpack_blocked_streams, "qpackBlockedStreams") \ V(qpack_encoder_max_dtable_capacity, "qpackEncoderMaxDTableCapacity") \ V(qpack_max_dtable_capacity, "qpackMaxDTableCapacity") \ + V(reason, "reason") \ V(reject_unauthorized, "rejectUnauthorized") \ V(reno, "reno") \ V(reset_token_secret, "resetTokenSecret") \ @@ -122,7 +141,9 @@ class Packet; V(token, "token") \ V(token_expiration, "tokenExpiration") \ V(token_secret, "tokenSecret") \ + V(transport, "transport") \ V(transport_params, "transportParams") \ + V(type, "type") \ V(tx_loss, "txDiagnosticLoss") \ V(udp_receive_buffer_size, "udpReceiveBufferSize") \ V(udp_send_buffer_size, "udpSendBufferSize") \ @@ -151,27 +172,37 @@ class BindingData final static inline BindingData& Get(Realm* realm) { return Get(realm->env()); } BindingData(Realm* realm, v8::Local object); + ~BindingData() override; DISALLOW_COPY_AND_MOVE(BindingData) void MemoryInfo(MemoryTracker* tracker) const override; SET_MEMORY_INFO_NAME(BindingData) SET_SELF_SIZE(BindingData) - // NgLibMemoryManager - operator ngtcp2_mem(); - operator nghttp3_mem(); + // NgLibMemoryManager — the base class provides CheckAllocatedSize, + // IncreaseAllocatedSize, DecreaseAllocatedSize, and StopTrackingMemory. + // Actual allocations go through the thread-local allocators below. void CheckAllocatedSize(size_t previous_size) const; void IncreaseAllocatedSize(size_t size); void DecreaseAllocatedSize(size_t size); + // Thread-local allocators that outlive BindingData destruction. + // Both ngtcp2 and nghttp3 store the allocator pointer inside every + // object they allocate; some of those objects (e.g., nghttp3 rcbufs + // backing V8 external strings) can be freed after BindingData is gone. + ngtcp2_mem* ngtcp2_allocator(); + nghttp3_mem* nghttp3_allocator(); + // Installs the set of JavaScript callback functions that are used to // bridge out to the JS API. JS_METHOD(SetCallbacks); + // Lazily-created per-Realm SessionManager. Centralizes CID -> Session + // routing so that any endpoint can route packets to any session. + SessionManager& session_manager(); + std::unordered_map> listening_endpoints; - bool in_ngtcp2_callback_scope = false; - bool in_nghttp3_callback_scope = false; size_t current_ngtcp2_memory_ = 0; // The following set up various storage and accessors for common strings, @@ -214,6 +245,8 @@ class BindingData final #define V(name, _) mutable v8::Eternal on_##name##_string_; QUIC_JS_CALLBACKS(V) #undef V + + std::unique_ptr session_manager_; }; JS_METHOD_IMPL(IllegalConstructor); @@ -221,20 +254,22 @@ JS_METHOD_IMPL(IllegalConstructor); // The ngtcp2 and nghttp3 callbacks have certain restrictions // that forbid re-entry. We provide the following scopes for // use in those to help protect against it. +// These callback scopes are per-session, not per-environment. This ensures +// that one session's ngtcp2/nghttp3 callback does not block an unrelated +// session from sending packets. A BaseObjectPtr prevents the Session from +// being prematurely freed while the scope is alive on the stack. struct NgTcp2CallbackScope final { - Environment* env; - explicit NgTcp2CallbackScope(Environment* env); + BaseObjectPtr session; + explicit NgTcp2CallbackScope(Session* session); DISALLOW_COPY_AND_MOVE(NgTcp2CallbackScope) ~NgTcp2CallbackScope(); - static bool in_ngtcp2_callback(Environment* env); }; struct NgHttp3CallbackScope final { - Environment* env; - explicit NgHttp3CallbackScope(Environment* env); + BaseObjectPtr session; + explicit NgHttp3CallbackScope(Session* session); DISALLOW_COPY_AND_MOVE(NgHttp3CallbackScope) ~NgHttp3CallbackScope(); - static bool in_nghttp3_callback(Environment* env); }; struct CallbackScopeBase { diff --git a/src/quic/data.cc b/src/quic/data.cc index f43ae4ce6edbc4..be2bf458d28352 100644 --- a/src/quic/data.cc +++ b/src/quic/data.cc @@ -88,31 +88,45 @@ Store::Store(std::unique_ptr store, size_t length, size_t offset) CHECK_LE(length_, store_->ByteLength() - offset_); } -Maybe Store::From(Local buffer, Local detach_key) { - if (!buffer->IsDetachable()) { - return Nothing(); - } - bool res; - auto backing = buffer->GetBackingStore(); +Maybe Store::From(Local buffer) { + v8::Isolate* isolate = v8::Isolate::GetCurrent(); + Environment* env = Environment::GetCurrent(isolate->GetCurrentContext()); auto length = buffer->ByteLength(); - if (!buffer->Detach(detach_key).To(&res) || !res) { + auto dest = ArrayBuffer::NewBackingStore( + isolate, + length, + v8::BackingStoreInitializationMode::kUninitialized, + v8::BackingStoreOnFailureMode::kReturnNull); + if (!dest) { + THROW_ERR_MEMORY_ALLOCATION_FAILED(env); return Nothing(); } - return Just(Store(std::move(backing), length, 0)); + if (length > 0) { + memcpy(dest->Data(), buffer->Data(), length); + } + return Just(Store(std::move(dest), length, 0)); } -Maybe Store::From(Local view, Local detach_key) { - if (!view->Buffer()->IsDetachable()) { - return Nothing(); - } - bool res; - auto backing = view->Buffer()->GetBackingStore(); +Maybe Store::From(Local view) { + v8::Isolate* isolate = v8::Isolate::GetCurrent(); + Environment* env = Environment::GetCurrent(isolate->GetCurrentContext()); auto length = view->ByteLength(); auto offset = view->ByteOffset(); - if (!view->Buffer()->Detach(detach_key).To(&res) || !res) { + auto dest = ArrayBuffer::NewBackingStore( + isolate, + length, + v8::BackingStoreInitializationMode::kUninitialized, + v8::BackingStoreOnFailureMode::kReturnNull); + if (!dest) { + THROW_ERR_MEMORY_ALLOCATION_FAILED(env); return Nothing(); } - return Just(Store(std::move(backing), length, offset)); + if (length > 0) { + memcpy(dest->Data(), + static_cast(view->Buffer()->Data()) + offset, + length); + } + return Just(Store(std::move(dest), length, 0)); } Store Store::CopyFrom(Local buffer) { @@ -161,8 +175,7 @@ T Store::convert() const { // We can only safely convert to T if we have a valid store. CHECK(store_); T buf; - buf.base = - store_ != nullptr ? static_cast(store_->Data()) + offset_ : nullptr; + buf.base = static_cast(store_->Data()) + offset_; buf.len = length_; return buf; } @@ -223,6 +236,45 @@ QuicError::QuicError(const ngtcp2_ccerr& error) error_(error), ptr_(&error_) {} +QuicError::QuicError(QuicError&& other) noexcept + : reason_(std::move(other.reason_)), + error_(other.error_), + ptr_(other.ptr_ == &other.error_ ? &error_ : other.ptr_) { + // Fix up the internal reason pointer after moving. + error_.reason = reason_c_str(); + error_.reasonlen = reason_.length(); +} + +QuicError& QuicError::operator=(QuicError&& other) noexcept { + if (this != &other) { + reason_ = std::move(other.reason_); + error_ = other.error_; + ptr_ = (other.ptr_ == &other.error_) ? &error_ : other.ptr_; + error_.reason = reason_c_str(); + error_.reasonlen = reason_.length(); + } + return *this; +} + +QuicError::QuicError(const QuicError& other) + : reason_(other.reason_), + error_(other.error_), + ptr_(other.ptr_ == &other.error_ ? &error_ : other.ptr_) { + error_.reason = reason_c_str(); + error_.reasonlen = reason_.length(); +} + +QuicError& QuicError::operator=(const QuicError& other) { + if (this != &other) { + reason_ = other.reason_; + error_ = other.error_; + ptr_ = (other.ptr_ == &other.error_) ? &error_ : other.ptr_; + error_.reason = reason_c_str(); + error_.reasonlen = reason_.length(); + } + return *this; +} + const uint8_t* QuicError::reason_c_str() const { return reinterpret_cast(reason_.c_str()); } @@ -296,11 +348,13 @@ std::optional QuicError::get_crypto_error() const { MaybeLocal QuicError::ToV8Value(Environment* env) const { if ((type() == Type::TRANSPORT && code() == NGTCP2_NO_ERROR) || - (type() == Type::APPLICATION && code() == NGHTTP3_H3_NO_ERROR)) { + (type() == Type::APPLICATION && code() == NGHTTP3_H3_NO_ERROR) || + type() == Type::IDLE_CLOSE) { // Note that we only return undefined for *known* no-error application // codes. It is possible that other application types use other specific // no-error codes, but since we don't know which application is being used, // we'll just return the error code value for those below. + // Idle close is always clean — the session timed out normally. return Undefined(env->isolate()); } diff --git a/src/quic/data.h b/src/quic/data.h index bd974ac0c8ba0a..2b6d777caf7b81 100644 --- a/src/quic/data.h +++ b/src/quic/data.h @@ -54,28 +54,28 @@ class Store final : public MemoryRetainer { size_t length, size_t offset = 0); - // Creates a Store from the contents of an ArrayBuffer, always detaching - // it in the process. An empty Maybe will be returned if the ArrayBuffer - // is not detachable or detaching failed (likely due to a detach key - // mismatch). - static v8::Maybe From( - v8::Local buffer, - v8::Local detach_key = v8::Local()); - - // Creates a Store from the contents of an ArrayBufferView, always detaching - // it in the process. An empty Maybe will be returned if the ArrayBuffer - // is not detachable or detaching failed (likely due to a detach key - // mismatch). - static v8::Maybe From( - v8::Local view, - v8::Local detach_key = v8::Local()); + // Creates a Store by copying the contents of an ArrayBuffer into a fresh + // BackingStore. The caller's buffer is not modified, so callers can safely + // reuse or mutate it after the call returns. Returns an empty Maybe on + // allocation failure, in which case an `ERR_MEMORY_ALLOCATION_FAILED` + // exception will have been scheduled on the isolate. + static v8::Maybe From(v8::Local buffer); + + // Creates a Store by copying the contents of an ArrayBufferView into a + // fresh BackingStore. The caller's view (and its underlying ArrayBuffer) + // is not modified. Returns an empty Maybe on allocation failure, in which + // case an `ERR_MEMORY_ALLOCATION_FAILED` exception will have been + // scheduled on the isolate. + static v8::Maybe From(v8::Local view); // Creates a Store from the contents of an ArrayBuffer, always copying the - // content. + // content. Equivalent to `From()` but returns a Store directly without + // surfacing allocation failure. static Store CopyFrom(v8::Local buffer); - // Creates a Store from the contents of an ArrayBufferView, always copying the - // content. + // Creates a Store from the contents of an ArrayBufferView, always copying + // the content. Equivalent to `From()` but returns a Store directly without + // surfacing allocation failure. static Store CopyFrom(v8::Local view); v8::Local ToUint8Array(Environment* env) const; @@ -208,6 +208,16 @@ class QuicError final : public MemoryRetainer { explicit QuicError(const ngtcp2_ccerr* ptr); explicit QuicError(const ngtcp2_ccerr& error); + // Move constructor and assignment must fix up ptr_ when it points + // to the internal error_ member (as set by the default constructor + // and the ForTransport/ForApplication factory methods). + QuicError(QuicError&& other) noexcept; + QuicError& operator=(QuicError&& other) noexcept; + + // Copy constructor and assignment must also fix up ptr_. + QuicError(const QuicError& other); + QuicError& operator=(const QuicError& other); + Type type() const; error_code code() const; const std::string_view reason() const; diff --git a/src/quic/defs.h b/src/quic/defs.h index b26ca5f9a4f12e..6b18c19f4c3c6d 100644 --- a/src/quic/defs.h +++ b/src/quic/defs.h @@ -12,8 +12,8 @@ namespace node::quic { #define NGTCP2_SUCCESS 0 -#define NGTCP2_ERR(V) (V != NGTCP2_SUCCESS) -#define NGTCP2_OK(V) (V == NGTCP2_SUCCESS) +#define NGTCP2_ERR(V) ((V) != NGTCP2_SUCCESS) +#define NGTCP2_OK(V) ((V) == NGTCP2_SUCCESS) #define IF_QUIC_DEBUG(env) \ if (env->enabled_debug_list()->enabled(DebugCategory::QUIC)) [[unlikely]] @@ -83,6 +83,39 @@ bool SetOption(Environment* env, return true; } +template +bool SetOption(Environment* env, + Opt* options, + const v8::Local& object, + const v8::Local& name) { + v8::Local value; + if (!object->Get(env->context(), name).ToLocal(&value)) return false; + if (!value->IsUndefined()) { + if (!value->IsUint32()) { + Utf8Value nameStr(env->isolate(), name); + THROW_ERR_INVALID_ARG_VALUE( + env, "The %s option must be an uint16", nameStr); + return false; + } + v8::Local num; + if (!value->ToUint32(env->context()).ToLocal(&num)) { + Utf8Value nameStr(env->isolate(), name); + THROW_ERR_INVALID_ARG_VALUE( + env, "The %s option must be an uint16", nameStr); + return false; + } + uint32_t val = num->Value(); + if (val > 0xFFFF) { + Utf8Value nameStr(env->isolate(), name); + THROW_ERR_INVALID_ARG_VALUE( + env, "The %s option must fit in a uint16", nameStr); + return false; + } + options->*member = static_cast(val); + } + return true; +} + template bool SetOption(Environment* env, Opt* options, @@ -205,7 +238,7 @@ uint64_t GetStat(Stats* stats) { if (!GetConstructorTemplate(env) \ ->InstanceTemplate() \ ->NewInstance(env->context()) \ - .ToLocal(&obj)) { \ + .ToLocal(&name)) { \ return ret; \ } @@ -214,7 +247,7 @@ uint64_t GetStat(Stats* stats) { if (!GetConstructorTemplate(env) \ ->InstanceTemplate() \ ->NewInstance(env->context()) \ - .ToLocal(&obj)) { \ + .ToLocal(&name)) { \ return; \ } @@ -285,8 +318,14 @@ enum class StreamPriority : uint8_t { }; enum class StreamPriorityFlags : uint8_t { - NONE, NON_INCREMENTAL, + INCREMENTAL, +}; + +enum class HeadersSupportState : uint8_t { + UNKNOWN, + SUPPORTED, + UNSUPPORTED, }; enum class PathValidationResult : uint8_t { @@ -298,6 +337,7 @@ enum class PathValidationResult : uint8_t { enum class DatagramStatus : uint8_t { ACKNOWLEDGED, LOST, + ABANDONED, }; #define CC_ALGOS(V) \ diff --git a/src/quic/endpoint.cc b/src/quic/endpoint.cc index 8d801de5f94b79..a3b3b57dbadf6b 100644 --- a/src/quic/endpoint.cc +++ b/src/quic/endpoint.cc @@ -11,6 +11,7 @@ #include #include #include +#include #include #include #include @@ -21,6 +22,7 @@ #include "endpoint.h" #include "http3.h" #include "ncrypto.h" +#include "session_manager.h" namespace node { @@ -53,6 +55,10 @@ namespace quic { V(CLOSING, closing, uint8_t) \ /* Temporarily paused serving new initial requests */ \ V(BUSY, busy, uint8_t) \ + /* Max concurrent connections per IP (0 = unlimited) */ \ + V(MAX_CONNECTIONS_PER_HOST, max_connections_per_host, uint16_t) \ + /* Max total concurrent connections (0 = unlimited) */ \ + V(MAX_CONNECTIONS_TOTAL, max_connections_total, uint16_t) \ /* The number of pending send callbacks */ \ V(PENDING_CALLBACKS, pending_callbacks, uint64_t) @@ -189,7 +195,6 @@ Maybe Endpoint::Options::From(Environment* env, env, &options, params, state.name##_string()) if (!SET(retry_token_expiration) || !SET(token_expiration) || - !SET(max_connections_per_host) || !SET(max_connections_total) || !SET(max_stateless_resets) || !SET(address_lru_size) || !SET(max_retries) || !SET(validate_address) || !SET(disable_stateless_reset) || !SET(ipv6_only) || @@ -197,7 +202,8 @@ Maybe Endpoint::Options::From(Environment* env, !SET(rx_loss) || !SET(tx_loss) || #endif !SET(udp_receive_buffer_size) || !SET(udp_send_buffer_size) || - !SET(udp_ttl) || !SET(reset_token_secret) || !SET(token_secret)) { + !SET(udp_ttl) || !SET(idle_timeout) || !SET(reset_token_secret) || + !SET(token_secret)) { return Nothing(); } @@ -245,10 +251,6 @@ std::string Endpoint::Options::ToString() const { " seconds"; res += prefix + "token expiration: " + std::to_string(token_expiration) + " seconds"; - res += prefix + "max connections per host: " + - std::to_string(max_connections_per_host); - res += prefix + - "max connections total: " + std::to_string(max_connections_total); res += prefix + "max stateless resets: " + std::to_string(max_stateless_resets); res += prefix + "address lru size: " + std::to_string(address_lru_size); @@ -268,6 +270,7 @@ std::string Endpoint::Options::ToString() const { res += prefix + "udp send buffer size: " + std::to_string(udp_send_buffer_size); res += prefix + "udp ttl: " + std::to_string(udp_ttl); + res += prefix + "idle timeout: " + std::to_string(idle_timeout) + " seconds"; res += indent.Close(); return res; @@ -471,7 +474,6 @@ int Endpoint::UDP::Send(Packet::Ptr packet) { // Detach from the Ptr — libuv takes ownership until the callback fires. Packet* raw = packet.release(); uv_buf_t buf = *raw; - int err = uv_udp_send(raw->req(), &impl_->handle_, &buf, @@ -532,8 +534,6 @@ void Endpoint::InitPerContext(Realm* realm, Local target) { ENDPOINT_STATE(V) #undef V - NODE_DEFINE_CONSTANT(target, DEFAULT_MAX_CONNECTIONS); - NODE_DEFINE_CONSTANT(target, DEFAULT_MAX_CONNECTIONS_PER_HOST); NODE_DEFINE_CONSTANT(target, DEFAULT_MAX_SOCKETADDRESS_LRU_SIZE); NODE_DEFINE_CONSTANT(target, DEFAULT_MAX_STATELESS_RESETS); NODE_DEFINE_CONSTANT(target, DEFAULT_MAX_RETRY_LIMIT); @@ -593,9 +593,15 @@ Endpoint::Endpoint(Environment* env, packet_pool_(kDefaultMaxPacketLength, ArenaPool::kDefaultSlotsPerBlock), udp_(this), - addrLRU_(options_.address_lru_size) { + idle_timer_(env, + [this] { + HandleScope scope(this->env()->isolate()); + Destroy(); + }), + addr_validation_lru_(options_.address_lru_size) { MakeWeak(); udp_.Unref(); + idle_timer_.Unref(); STAT_RECORD_TIMESTAMP(Stats, created_at); IF_QUIC_DEBUG(env) { Debug(this, "Endpoint created. Options %s", options.ToString()); @@ -640,11 +646,12 @@ RegularToken Endpoint::GenerateNewToken(uint32_t version, return RegularToken(version, remote_address, options_.token_secret); } +SessionManager& Endpoint::session_manager() const { + return BindingData::Get(env()).session_manager(); +} + StatelessResetToken Endpoint::GenerateNewStatelessResetToken( uint8_t* token, const CID& cid) const { - Debug(const_cast(this), - "Generating new stateless reset token for CID %s", - cid); DCHECK(!is_closed() && !is_closing()); return StatelessResetToken(token, options_.reset_token_secret, cid); } @@ -652,9 +659,38 @@ StatelessResetToken Endpoint::GenerateNewStatelessResetToken( void Endpoint::AddSession(const CID& cid, BaseObjectPtr session) { DCHECK(!is_closed() && !is_closing()); Debug(this, "Adding session for CID %s", cid); - IncrementSocketAddressCounter(session->remote_address()); + if (state_->max_connections_per_host > 0) { + conn_counts_per_host_[session->remote_address()]++; + } + auto& mgr = session_manager(); + // Associate peer-chosen CIDs in the local dcid_to_scid_ map. AssociateCID(session->config().dcid, session->config().scid); - sessions_[cid] = session; + mgr.AddSession(cid, session); + mgr.SetPrimaryEndpoint(session.get(), this); + // For server sessions, associate the client's original DCID (ocid) so + // that 0-RTT packets arriving in a separate UDP datagram can be routed + // to this session. This must happen after the session is added (so + // FindSession can resolve the mapping) but before EmitNewSession (which + // runs JS and may yield to libuv, allowing the 0-RTT packet to arrive). + if (session->is_server() && session->config().ocid) { + AssociateCID(session->config().ocid, session->config().scid); + } + // After Retry, the client continues to use the Retry SCID as its DCID + // until the handshake completes. Register it so retransmitted Initials + // and subsequent handshake packets can be routed to this session. + if (session->is_server() && session->config().retry_scid) { + AssociateCID(session->config().retry_scid, session->config().scid); + } + // Increment the primary session count and ref the handle BEFORE + // EmitNewSession. EmitNewSession calls into JS, which may close/destroy + // the session synchronously. The session's ~Impl calls RemoveSession + // which decrements the count. If we increment after EmitNewSession, + // RemoveSession would see count=0 and the count would be permanently + // off by one. + if (primary_session_count_++ == 0) { + idle_timer_.Stop(); + udp_.Ref(); + } if (session->is_server()) { STAT_INCREMENT(Stats, server_sessions); // We only emit the new session event for server sessions. @@ -664,46 +700,58 @@ void Endpoint::AddSession(const CID& cid, BaseObjectPtr session) { } else { STAT_INCREMENT(Stats, client_sessions); } - udp_.Ref(); } void Endpoint::RemoveSession(const CID& cid, const SocketAddress& remote_address) { if (is_closed()) return; Debug(this, "Removing session for CID %s", cid); - if (sessions_.erase(cid)) { - DecrementSocketAddressCounter(remote_address); + auto it = conn_counts_per_host_.find(remote_address); + if (it != conn_counts_per_host_.end()) { + if (--it->second == 0) { + conn_counts_per_host_.erase(it); + } } - if (sessions_.empty()) { + if (primary_session_count_ > 0 && --primary_session_count_ == 0) { udp_.Unref(); + session_manager().RemoveSession(cid); + // The endpoint may be idle (no sessions, not listening). MaybeDestroy + // handles both closing (immediate destroy) and idle timeout (start + // timer or destroy based on idle_timeout setting). + MaybeDestroy(); + return; } + session_manager().RemoveSession(cid); if (state_->closing == 1) MaybeDestroy(); } BaseObjectPtr Endpoint::FindSession(const CID& cid) { - auto session_it = sessions_.find(cid); - if (session_it == std::end(sessions_)) { - // If our given cid is not a match that doesn't mean we - // give up. A session might be identified by multiple - // CIDs. Let's see if our secondary map has a match! - auto scid_it = dcid_to_scid_.find(cid); - if (scid_it != std::end(dcid_to_scid_)) { - session_it = sessions_.find(scid_it->second); - CHECK_NE(session_it, std::end(sessions_)); - return session_it->second; - } - // No match found. - return {}; + // First, try the SessionManager's primary sessions_ map directly. + // This handles the common case where the CID is a locally-generated SCID. + auto session = session_manager().FindSession(cid); + if (session) return session; + + // If not found, check this endpoint's local dcid_to_scid_ map for a + // secondary CID mapping. This map contains peer-chosen CID values that + // are only meaningful in the context of this endpoint's sessions. + auto scid_it = dcid_to_scid_.find(cid); + if (scid_it != dcid_to_scid_.end()) { + session = session_manager().FindSession(scid_it->second); + if (session) return session; + // Stale mapping — clean up. + dcid_to_scid_.erase(scid_it); } - // Match found! - return session_it->second; + + return {}; } void Endpoint::AssociateCID(const CID& cid, const CID& scid) { - if (!is_closed() && !is_closing() && cid && scid && cid != scid && - dcid_to_scid_[cid] != scid) { - Debug(this, "Associating CID %s with SCID %s", cid, scid); - dcid_to_scid_.emplace(cid, scid); + if (!is_closed() && !is_closing() && cid && scid && cid != scid) { + auto it = dcid_to_scid_.find(cid); + if (it == dcid_to_scid_.end() || it->second != scid) { + Debug(this, "Associating CID %s with SCID %s", cid, scid); + dcid_to_scid_[cid] = scid; + } } } @@ -718,14 +766,14 @@ void Endpoint::AssociateStatelessResetToken(const StatelessResetToken& token, Session* session) { if (is_closed() || is_closing()) return; Debug(this, "Associating stateless reset token %s with session", token); - token_map_[token] = session; + session_manager().AssociateStatelessResetToken(token, session); } void Endpoint::DisassociateStatelessResetToken( const StatelessResetToken& token) { if (!is_closed()) { Debug(this, "Disassociating stateless reset token %s", token); - token_map_.erase(token); + session_manager().DisassociateStatelessResetToken(token); } } @@ -774,7 +822,7 @@ void Endpoint::SendRetry(const PathDescriptor& options) { // its own. What this count does not give is the rate of retry, so it is still // somewhat limited. Debug(this, "Sending retry on path %s", options); - auto info = addrLRU_.Upsert(options.remote_address); + auto info = addr_validation_lru_.Upsert(options.remote_address); if (++(info->retry_count) <= options_.max_retries) { auto packet = Packet::CreateRetryPacket(*this, options, options_.token_secret); @@ -821,24 +869,29 @@ bool Endpoint::SendStatelessReset(const PathDescriptor& options, const auto exceeds_limits = [&] { SocketAddressInfoTraits::Type* counts = - addrLRU_.Peek(options.remote_address); + addr_validation_lru_.Peek(options.remote_address); auto count = counts != nullptr ? counts->reset_count : 0; return count >= options_.max_stateless_resets; }; // Per the QUIC spec, we need to protect against sending too many stateless // reset tokens to an endpoint to prevent endless looping. - if (exceeds_limits()) return false; + if (exceeds_limits()) { + Debug(this, "Stateless reset rate limit exceeded"); + return false; + } auto packet = Packet::CreateStatelessResetPacket( *this, options, options_.reset_token_secret, source_len); if (packet) { - addrLRU_.Upsert(options.remote_address)->reset_count++; + Debug(this, "Sending stateless reset packet (%zu bytes)", packet->length()); + addr_validation_lru_.Upsert(options.remote_address)->reset_count++; STAT_INCREMENT(Stats, stateless_reset_count); Send(std::move(packet)); return true; } + Debug(this, "Failed to create stateless reset packet"); return false; } @@ -886,8 +939,9 @@ bool Endpoint::Start() { return false; } - BindingData::Get(env()).listening_endpoints[this] = - BaseObjectPtr(this); + auto& binding = BindingData::Get(env()); + binding.listening_endpoints[this] = BaseObjectPtr(this); + binding.session_manager().RegisterEndpoint(this, udp_.local_address()); state_->receiving = 1; return true; } @@ -929,6 +983,7 @@ void Endpoint::Listen(const Session::Options& options) { }; if (Start()) { Debug(this, "Listening with options %s", server_state_->options); + idle_timer_.Stop(); state_->listening = 1; } } @@ -978,13 +1033,25 @@ BaseObjectPtr Endpoint::Connect( } void Endpoint::MaybeDestroy() { - if (!is_closed() && sessions_.empty() && state_->pending_callbacks == 0 && - state_->listening == 0) { - // Destroy potentially creates v8 handles so let's make sure - // we have a HandleScope on the stack. - HandleScope scope(env()->isolate()); - Destroy(); + if (is_closed() || primary_session_count_ > 0 || + state_->pending_callbacks > 0 || state_->listening == 1) { + return; } + if (options_.idle_timeout > 0) { + // Start the idle timer. If it fires before a new session or listen + // call reactivates this endpoint, the endpoint will be destroyed. + idle_timer_.Update(options_.idle_timeout * 1000); + return; + } + // With idle_timeout == 0, only destroy if the endpoint is actively + // closing (via close() or CloseGracefully). An idle endpoint that + // is not closing stays alive with an unref'd handle so the process + // can still exit. + if (state_->closing != 1) return; + // Destroy potentially creates v8 handles so let's make sure + // we have a HandleScope on the stack. + HandleScope scope(env()->isolate()); + Destroy(); } void Endpoint::Destroy(CloseContext context, int status) { @@ -1020,14 +1087,9 @@ void Endpoint::Destroy(CloseContext context, int status) { // If there are open sessions still, shut them down. As those clean themselves // up, they will remove themselves. The cleanup here will be synchronous and // no attempt will be made to communicate further with the peer. - // Intentionally copy the sessions map so that we can safely iterate over it - // while those clean themselves up. - auto sessions = sessions_; - for (auto& session : sessions) - session.second->Close(Session::CloseMethod::SILENT); - sessions.clear(); - DCHECK(sessions_.empty()); - token_map_.clear(); + idle_timer_.Close(); + session_manager().CloseAllSessionsFor(this); + DCHECK_EQ(primary_session_count_, 0); dcid_to_scid_.clear(); server_state_.reset(); @@ -1035,7 +1097,9 @@ void Endpoint::Destroy(CloseContext context, int status) { state_->closing = 0; state_->bound = 0; state_->receiving = 0; - BindingData::Get(env()).listening_endpoints.erase(this); + auto& binding = BindingData::Get(env()); + binding.listening_endpoints.erase(this); + binding.session_manager().UnregisterEndpoint(this); STAT_RECORD_TIMESTAMP(Stats, destroyed_at); EmitClose(close_context_, close_status_); @@ -1045,7 +1109,6 @@ void Endpoint::CloseGracefully() { if (is_closed() || is_closing()) return; Debug(this, "Closing gracefully"); - state_->listening = 0; state_->closing = 1; @@ -1062,7 +1125,7 @@ void Endpoint::Receive(const uv_buf_t& buf, const CID& dcid, const CID& scid) { DCHECK_NOT_NULL(session); - DCHECK(!session->is_destroyed()); + if (session->is_destroyed()) return; size_t len = store.length(); if (session->Receive(std::move(store), local_address, remote_address)) { STAT_INCREMENT_N(Stats, bytes_received, len); @@ -1129,32 +1192,28 @@ void Endpoint::Receive(const uv_buf_t& buf, return; } - // If ngtcp2_is_supported_version returns a non-zero value, the version is - // recognized and supported. If it returns 0, we'll go ahead and send a - // version negotiation packet in response. - if (ngtcp2_is_supported_version(hd.version) == 0) { - Debug(this, - "Packet not acceptable because the version (%d) is not supported. " - "Will attempt to send version negotiation", - hd.version); - SendVersionNegotiation( - PathDescriptor{version, dcid, scid, local_address, remote_address}); - // The packet was successfully processed, even if we did refuse the - // connection. - STAT_INCREMENT(Stats, packets_received); - return; - } + // Unsupported versions are handled earlier in Receive() via the + // NGTCP2_ERR_VERSION_NEGOTIATION return from ngtcp2_pkt_decode_version_cid. + // If we reach here, the version must be supported. + CHECK_NE(ngtcp2_is_supported_version(hd.version), 0); // This is the next important condition check... If the server has been // marked busy or the remote peer has exceeded their maximum number of // concurrent connections, any new connections will be shut down // immediately. const auto limits_exceeded = ([&] { - if (sessions_.size() >= options_.max_connections_total) return true; - - SocketAddressInfoTraits::Type* counts = addrLRU_.Peek(remote_address); - auto count = counts != nullptr ? counts->active_connections : 0; - return count >= options_.max_connections_per_host; + if (state_->max_connections_total > 0 && + primary_session_count_ >= state_->max_connections_total) { + return true; + } + if (state_->max_connections_per_host > 0) { + auto it = conn_counts_per_host_.find(remote_address); + if (it != conn_counts_per_host_.end() && + it->second >= state_->max_connections_per_host) { + return true; + } + } + return false; })(); if (state_->busy || limits_exceeded) { @@ -1168,7 +1227,7 @@ void Endpoint::Receive(const uv_buf_t& buf, // the same. if (state_->busy) STAT_INCREMENT(Stats, server_busy_count); SendImmediateConnectionClose( - PathDescriptor{version, scid, dcid, local_address, remote_address}, + PathDescriptor{version, dcid, scid, local_address, remote_address}, QuicError::ForTransport(NGTCP2_CONNECTION_REFUSED)); // The packet was successfully processed, even if we did refuse the // connection. @@ -1179,6 +1238,12 @@ void Endpoint::Receive(const uv_buf_t& buf, Debug( this, "Accepting initial packet for %s from %s", dcid, remote_address); + // Generate a fresh server SCID rather than reusing the client's original + // DCID. The client's original DCID is typically short (8 bytes) and we + // need a 20-byte SCID to properly match short_dcidlen passed to + // ngtcp2_pkt_decode_version_cid. + auto server_scid = server_state_->options.cid_factory->Generate(); + // At this point, we start to set up the configuration for our local // session. We pass the received scid here as the dcid argument value // because that is the value *this* session will use as the outbound dcid. @@ -1189,55 +1254,86 @@ void Endpoint::Receive(const uv_buf_t& buf, local_address, remote_address, scid, - dcid, + server_scid, dcid); Debug(this, "Using session config %s", config); // The this point, the config.scid and config.dcid represent *our* views of // the CIDs. Specifically, config.dcid identifies the peer and config.scid - // identifies us. config.dcid should equal scid, and config.scid should - // equal dcid. + // identifies us. config.dcid should equal scid (peer's SCID is our DCID), + // and config.ocid should equal dcid (peer's original DCID). DCHECK(config.dcid == scid); - DCHECK(config.scid == dcid); + DCHECK(config.ocid == dcid); const auto is_remote_address_validated = ([&] { - auto info = addrLRU_.Peek(remote_address); + auto info = addr_validation_lru_.Peek(remote_address); return info != nullptr ? info->validated : false; })(); - // QUIC has address validation built in to the handshake but allows for - // an additional explicit validation request using RETRY frames. If we - // are using explicit validation, we check for the existence of a valid - // token in the packet. If one does not exist, we send a retry with - // a new token. If it does exist, and if it is valid, we grab the original - // cid and continue. - if (!is_remote_address_validated) { + // Retry token processing and address validation are two separate + // concerns. A retry token MUST always be parsed when present because + // it carries the original_destination_connection_id (ODCID) that the + // server must echo in its transport parameters. Without it, the peer + // will reject the connection with PROTOCOL_VIOLATION. + // + // The address validation LRU cache determines whether we need to + // *send* a Retry, but must NOT skip *processing* an incoming retry + // token — a concurrent connection may have already validated the + // address (populating the LRU) while this connection's Retry was + // still in flight. + + // Step 1: Always process a retry token if present, to extract the + // ODCID regardless of address validation state. + if (hd.type == NGTCP2_PKT_INITIAL && hd.tokenlen > 0 && + hd.token[0] == RetryToken::kTokenMagic) { + RetryToken token(hd.token, hd.tokenlen); + Debug(this, + "Initial packet from %s has retry token %s", + remote_address, + token); + auto ocid = + token.Validate(version, + remote_address, + dcid, + options_.token_secret, + options_.retry_token_expiration * NGTCP2_SECONDS); + if (!ocid.has_value()) { + Debug(this, "Retry token from %s is invalid.", remote_address); + SendImmediateConnectionClose( + PathDescriptor{version, scid, dcid, local_address, remote_address}, + QuicError::ForTransport(NGTCP2_CONNECTION_REFUSED)); + STAT_INCREMENT(Stats, packets_received); + return; + } + + Debug(this, + "Retry token from %s is valid. Original dcid %s", + remote_address, + ocid.value()); + config.ocid = ocid.value(); + config.retry_scid = dcid; + config.set_token(token); + + // Mark the address as validated since the retry round-trip proves + // reachability. + Debug(this, "Remote address %s is validated", remote_address); + addr_validation_lru_.Upsert(remote_address)->validated = true; + } + + // Step 2: Address validation — decide whether to send a Retry or + // accept the packet. This only applies when the address has not + // been validated yet (no LRU hit and no retry token above). + if (!is_remote_address_validated && !config.retry_scid) { Debug(this, "Remote address %s is not validated", remote_address); switch (hd.type) { case NGTCP2_PKT_INITIAL: - // First, let's see if we need to do anything here. - if (options_.validate_address) { - // If there is no token, generate and send one. if (hd.tokenlen == 0) { Debug(this, "Initial packet has no token. Sending retry to %s to start " "validation", remote_address); - // In this case we sent a retry to the remote peer and return - // without creating a session. What we expect to happen next is - // that the remote peer will try again with a new initial packet - // that includes the retry token we are sending them. It's - // possible, however, that they just give up and go away or send - // us another initial packet that does not have the token. In that - // case we'll end up right back here asking them to validate - // again. - // - // It is possible that the SendRetry(...) won't actually send a - // retry if the remote address has exceeded the maximum number of - // retry attempts it is allowed as tracked by the addressLRU - // cache. In that case, we'll just drop the packet on the floor. SendRetry(PathDescriptor{ version, dcid, @@ -1245,53 +1341,12 @@ void Endpoint::Receive(const uv_buf_t& buf, local_address, remote_address, }); - // We still consider this a successfully handled packet even - // if we send a retry. STAT_INCREMENT(Stats, packets_received); return; } - // We have two kinds of tokens, each prefixed with a different - // magic byte. + // Non-retry tokens (regular tokens). switch (hd.token[0]) { - case RetryToken::kTokenMagic: { - RetryToken token(hd.token, hd.tokenlen); - Debug(this, - "Initial packet from %s has retry token %s", - remote_address, - token); - auto ocid = token.Validate( - version, - remote_address, - dcid, - options_.token_secret, - options_.retry_token_expiration * NGTCP2_SECONDS); - if (!ocid.has_value()) { - Debug( - this, "Retry token from %s is invalid.", remote_address); - // Invalid retry token was detected. Close the connection. - SendImmediateConnectionClose( - PathDescriptor{ - version, scid, dcid, local_address, remote_address}, - QuicError::ForTransport(NGTCP2_CONNECTION_REFUSED)); - // We still consider this a successfully handled packet even - // if we send a connection close. - STAT_INCREMENT(Stats, packets_received); - return; - } - - // The ocid is the original dcid that was encoded into the - // original retry packet sent to the client. We use it for - // validation. - Debug(this, - "Retry token from %s is valid. Original dcid %s", - remote_address, - ocid.value()); - config.ocid = ocid.value(); - config.retry_scid = dcid; - config.set_token(token); - break; - } case RegularToken::kTokenMagic: { RegularToken token(hd.token, hd.tokenlen); Debug(this, @@ -1306,10 +1361,6 @@ void Endpoint::Receive(const uv_buf_t& buf, Debug(this, "Regular token from %s is invalid.", remote_address); - // If the regular token is invalid, let's send a retry to be - // lenient. There's a small risk that a malicious peer is - // trying to make us do some work but the risk is fairly low - // here. SendRetry(PathDescriptor{ version, dcid, @@ -1317,8 +1368,6 @@ void Endpoint::Receive(const uv_buf_t& buf, local_address, remote_address, }); - // We still consider this to be a successfully handled packet - // if a retry is sent. STAT_INCREMENT(Stats, packets_received); return; } @@ -1330,13 +1379,6 @@ void Endpoint::Receive(const uv_buf_t& buf, Debug(this, "Initial packet from %s has unknown token type", remote_address); - // If our prefix bit does not match anything we know about, - // let's send a retry to be lenient. There's a small risk that a - // malicious peer is trying to make us do some work but the risk - // is fairly low here. The SendRetry will avoid sending a retry - // if the remote address has exceeded the maximum number of - // retry attempts it is allowed as tracked by the addressLRU - // cache. SendRetry(PathDescriptor{ version, dcid, @@ -1349,33 +1391,16 @@ void Endpoint::Receive(const uv_buf_t& buf, } } - // Ok! If we've got this far, our token is valid! Which means our - // path to the remote address is valid (for now). Let's record that - // so we don't have to do this dance again for this endpoint - // instance. Debug(this, "Remote address %s is validated", remote_address); - addrLRU_.Upsert(remote_address)->validated = true; + addr_validation_lru_.Upsert(remote_address)->validated = true; } else if (hd.tokenlen > 0) { Debug(this, "Ignoring initial packet from %s with unexpected token", remote_address); - // If validation is turned off and there is a token, that's weird. - // The peer should only have a token if we sent it to them and we - // wouldn't have sent it unless validation was turned on. Let's - // assume the peer is buggy or malicious and drop the packet on the - // floor. return; } break; case NGTCP2_PKT_0RTT: - // 0-RTT packets are inherently replayable and could be sent - // from a spoofed source address to trigger amplification. - // When address validation is enabled, we send a Retry to - // force the client to prove it can receive at its claimed - // address. This adds a round trip but prevents amplification - // attacks. When address validation is disabled (e.g., on - // trusted networks), we skip the Retry and allow 0-RTT to - // proceed without additional validation. if (options_.validate_address) { Debug( this, "Sending retry to %s due to 0RTT packet", remote_address); @@ -1434,12 +1459,13 @@ void Endpoint::Receive(const uv_buf_t& buf, // If a Session has been associated with the token, then it is a valid // stateless reset token. We need to dispatch it to the session to be // processed. - auto it = token_map_.find(StatelessResetToken(vec.base)); - if (it != token_map_.end()) { + auto* session = session_manager().FindSessionByStatelessResetToken( + StatelessResetToken(vec.base)); + if (session != nullptr) { // If the session happens to have been destroyed already, we'll // just ignore the packet. - if (!it->second->is_destroyed()) [[likely]] { - receive(it->second, + if (!session->is_destroyed()) [[likely]] { + receive(session, std::move(store), local_address, remote_address, @@ -1491,10 +1517,29 @@ void Endpoint::Receive(const uv_buf_t& buf, // cannot be processed; all we can do is ignore it. If it succeeds, we have a // valid QUIC header but there is still no guarantee that the packet can be // successfully processed. - if (ngtcp2_pkt_decode_version_cid( - &pversion_cid, vec.base, vec.len, NGTCP2_MAX_CIDLEN) < 0) { - Debug(this, "Failed to decode packet header, ignoring"); - return; // Ignore the packet! + switch (ngtcp2_pkt_decode_version_cid( + &pversion_cid, vec.base, vec.len, NGTCP2_MAX_CIDLEN)) { + case 0: + break; // Supported version, continue processing. + case NGTCP2_ERR_VERSION_NEGOTIATION: { + // The packet has an unsupported version but the CIDs were + // successfully decoded. Send a Version Negotiation response + // per RFC 9000 Section 6. The VN packet's DCID is the client's + // SCID and vice versa (mirrored back to the client). + Debug(this, + "Packet version %d is not supported, sending version negotiation", + pversion_cid.version); + CID dcid(pversion_cid.dcid, pversion_cid.dcidlen); + CID scid(pversion_cid.scid, pversion_cid.scidlen); + SendVersionNegotiation(PathDescriptor{ + pversion_cid.version, dcid, scid, local_address(), remote_address}); + STAT_INCREMENT(Stats, packets_received); + return; + } + default: + // Truly invalid packet — cannot be decoded at all. + Debug(this, "Failed to decode packet header, ignoring"); + return; } // QUIC currently requires CID lengths of max NGTCP2_MAX_CIDLEN. Ignore any @@ -1550,11 +1595,26 @@ void Endpoint::Receive(const uv_buf_t& buf, // stateless reset, the packet will be handled with no additional action // necessary here. We want to return immediately without committing any // further resources. - if (!scid && maybeStatelessReset(dcid, scid, store, addr, remote_address)) { + if (pversion_cid.version == 0 && + maybeStatelessReset(dcid, scid, store, addr, remote_address)) { Debug(this, "Packet was a stateless reset"); return; // Stateless reset! Don't do any further processing. } + // If this is a short header packet for an unknown DCID, send a + // stateless reset so the peer knows the session is gone. Short header + // packets are identified by version == 0 (set by ngtcp2_pkt_decode_ + // version_cid). We must NOT use !scid here because long header Initial + // packets can have a 0-length SCID (valid per RFC 9000 Section 7.2). + if (pversion_cid.version == 0) { + Debug(this, "Sending stateless reset for unknown short header packet"); + SendStatelessReset( + PathDescriptor{ + pversion_cid.version, dcid, scid, addr, remote_address}, + store.length()); + return; + } + // Process the packet as an initial packet... return acceptInitialPacket(pversion_cid.version, dcid, @@ -1587,18 +1647,9 @@ void Endpoint::PacketDone(int status) { DCHECK_GE(state_->pending_callbacks, 1); state_->pending_callbacks--; env()->DecreaseWaitingRequestCounter(); - // Can we go ahead and close now? - if (state_->closing == 1) MaybeDestroy(); -} - -void Endpoint::IncrementSocketAddressCounter(const SocketAddress& addr) { - addrLRU_.Upsert(addr)->active_connections++; -} - -void Endpoint::DecrementSocketAddressCounter(const SocketAddress& addr) { - auto* counts = addrLRU_.Peek(addr); - if (counts != nullptr && counts->active_connections > 0) - counts->active_connections--; + // Check if we can close or start the idle timer now that this + // pending callback has completed. + if (state_->closing == 1 || primary_session_count_ == 0) MaybeDestroy(); } bool Endpoint::is_closed() const { @@ -1619,10 +1670,7 @@ void Endpoint::MemoryInfo(MemoryTracker* tracker) const { tracker->TrackField("server_options", server_state_->options); tracker->TrackField("server_tls_context", server_state_->tls_context); } - tracker->TrackField("token_map", token_map_); - tracker->TrackField("sessions", sessions_); - tracker->TrackField("cid_map", dcid_to_scid_); - tracker->TrackField("address LRU", addrLRU_); + tracker->TrackField("address LRU", addr_validation_lru_); } // ====================================================================================== diff --git a/src/quic/endpoint.h b/src/quic/endpoint.h index fa003d3aed2481..b9f20f8659dfa6 100644 --- a/src/quic/endpoint.h +++ b/src/quic/endpoint.h @@ -6,6 +6,7 @@ #include #include #include +#include #include #include #include @@ -14,6 +15,7 @@ #include "bindingdata.h" #include "packet.h" #include "session.h" +#include "session_manager.h" #include "sessionticket.h" #include "tokens.h" @@ -24,12 +26,25 @@ namespace node::quic { // client and server simultaneously. class Endpoint final : public AsyncWrap, public Packet::Listener { public: - static constexpr uint64_t DEFAULT_MAX_CONNECTIONS = - std::min(kMaxSizeT, kMaxSafeJsInteger); - static constexpr uint64_t DEFAULT_MAX_CONNECTIONS_PER_HOST = 100; - static constexpr uint64_t DEFAULT_MAX_SOCKETADDRESS_LRU_SIZE = - (DEFAULT_MAX_CONNECTIONS_PER_HOST * 10); + // The socket address LRU is used for tracking validated remote addresses. + static constexpr uint64_t DEFAULT_MAX_SOCKETADDRESS_LRU_SIZE = 1024; + + // The max stateless resets is the maximum number of stateless reset packets + // that the Endpoint will generate for a given remote host within a window of + // time (while tracking that host in the socket address LRU). This is not + // mandated by QUIC, and the limit is arbitrary. We can set it to whatever + // we'd like. The purpose is to prevent a malicious peer from intentionally + // triggering generation of a large number of stateless resets. Once the + // limit is reached, packets that would have otherwise triggered generation + // of a stateless reset will simply be dropped instead. static constexpr uint64_t DEFAULT_MAX_STATELESS_RESETS = 10; + + // Similar to stateless resets, the max retry limit is the maximum number of + // retry packets that the Endpoint will generate for a given remote host + // within a window of time (while tracking that host in the socket address + // LRU). This is not mandated by QUIC, and the limit is arbitrary. We can set + // it to whatever we'd like. The purpose is to prevent a malicious peer from + // intentionally triggering generation of a large number of retries. static constexpr uint64_t DEFAULT_MAX_RETRY_LIMIT = 10; // Endpoint configuration options @@ -50,17 +65,10 @@ class Endpoint final : public AsyncWrap, public Packet::Listener { RetryToken::QUIC_DEFAULT_RETRYTOKEN_EXPIRATION / NGTCP2_SECONDS; // Tokens issued using NEW_TOKEN are time-limited. By default, tokens expire - // after DEFAULT_TOKEN_EXPIRATION *seconds*. + // after QUIC_DEFAULT_REGULARTOKEN_EXPIRATION *seconds*. uint64_t token_expiration = RegularToken::QUIC_DEFAULT_REGULARTOKEN_EXPIRATION / NGTCP2_SECONDS; - // Each Endpoint places limits on the number of concurrent connections from - // a single host, and the total number of concurrent connections allowed as - // a whole. These are set to fairly modest, and arbitrary defaults. We can - // set these to whatever we'd like. - uint64_t max_connections_per_host = DEFAULT_MAX_CONNECTIONS_PER_HOST; - uint64_t max_connections_total = DEFAULT_MAX_CONNECTIONS; - // A stateless reset in QUIC is a discrete mechanism that one endpoint can // use to communicate to a peer that it has lost whatever state it // previously held about a session. Because generating a stateless reset @@ -134,6 +142,14 @@ class Endpoint final : public AsyncWrap, public Packet::Listener { // Setting to 0 uses the default. uint8_t udp_ttl = 0; + // When an endpoint becomes idle (not listening and no primary sessions), + // it will be destroyed after this many seconds. A value of 0 means + // destroy immediately when idle (default, preserves pre-SessionManager + // behavior). A positive value keeps the endpoint alive for potential + // reuse by future connect() or listen() calls. + static constexpr uint64_t DEFAULT_IDLE_TIMEOUT = 0; + uint64_t idle_timeout = DEFAULT_IDLE_TIMEOUT; + void MemoryInfo(MemoryTracker* tracker) const override; SET_MEMORY_INFO_NAME(Endpoint::Config) SET_SELF_SIZE(Options) @@ -324,9 +340,6 @@ class Endpoint final : public AsyncWrap, public Packet::Listener { void EmitNewSession(const BaseObjectPtr& session); void EmitClose(CloseContext context, int status); - void IncrementSocketAddressCounter(const SocketAddress& address); - void DecrementSocketAddressCounter(const SocketAddress& address); - // JavaScript API // Create a new Endpoint. @@ -376,6 +389,11 @@ class Endpoint final : public AsyncWrap, public Packet::Listener { ArenaPool packet_pool_; UDP udp_; + // Idle timer: started when the endpoint becomes idle (not listening, + // no primary sessions). When it fires, the endpoint is destroyed. + // Stopped when a new session is added or listening begins. + TimerWrapHandle idle_timer_; + struct ServerState { Session::Options options; std::shared_ptr tls_context; @@ -383,18 +401,29 @@ class Endpoint final : public AsyncWrap, public Packet::Listener { // Set if/when the endpoint is configured to listen. std::optional server_state_ = std::nullopt; - // A Session is generally identified by one or more CIDs. We use two - // maps for this rather than one to avoid creating a whole bunch of - // BaseObjectPtr references. The primary map (sessions_) just maps - // the original CID to the Session, the second map (dcid_to_scid_) - // maps the additional CIDs to the primary. - CID::Map> sessions_; + // Count of sessions for which this endpoint is the primary endpoint. + // Drives ref/unref and idle timer logic. The actual session-to-endpoint + // mapping is maintained by the SessionManager. + size_t primary_session_count_ = 0; + + // Per-endpoint CID -> SCID mapping for peer-chosen CIDs from connection + // establishment (config.dcid, config.ocid). These are kept per-endpoint + // because peer-chosen values can collide across endpoints (e.g., a + // client's random outgoing DCID matching an incoming DCID on the server + // endpoint). Locally-generated CIDs that need cross-endpoint routing + // (preferred address, multipath) go in SessionManager::dcid_to_scid_. + // + // Endpoint::FindSession does a three-tier lookup: + // 1. SessionManager::sessions_[cid] (direct SCID match) + // 2. SessionManager::dcid_to_scid_[cid] (cross-endpoint CID) + // 3. Endpoint::dcid_to_scid_[cid] (peer-chosen CID) + // Each tier resolves to an SCID and looks up SessionManager::sessions_. CID::Map dcid_to_scid_; - StatelessResetToken::Map token_map_; + + SessionManager& session_manager() const; struct SocketAddressInfoTraits final { struct Type final { - size_t active_connections; size_t reset_count; size_t retry_count; uint64_t timestamp; @@ -405,7 +434,14 @@ class Endpoint final : public AsyncWrap, public Packet::Listener { static void Touch(const SocketAddress& address, Type* type); }; - SocketAddressLRU addrLRU_; + SocketAddressLRU addr_validation_lru_; + + // Per-IP connection counts for maxConnectionsPerHost enforcement. + // Only populated when max_connections_per_host > 0. Entries are + // added in AddSession and removed when the count reaches 0 in + // RemoveSession. The map size is bounded by the number of active + // sessions (each entry has count >= 1). + SocketAddress::IpMap conn_counts_per_host_; CloseContext close_context_ = CloseContext::CLOSE; int close_status_ = 0; diff --git a/src/quic/http3.cc b/src/quic/http3.cc index 2a21c0cf321970..ea07c0a5a596fb 100644 --- a/src/quic/http3.cc +++ b/src/quic/http3.cc @@ -1,3 +1,4 @@ +#include "nghttp3/lib/nghttp3_conn.h" #if HAVE_OPENSSL && HAVE_QUIC #include "guard.h" #ifndef OPENSSL_NO_QUIC @@ -11,6 +12,7 @@ #include #include #include +#include #include "application.h" #include "bindingdata.h" #include "defs.h" @@ -25,6 +27,63 @@ using v8::Local; namespace quic { +namespace { +constexpr uint8_t kSessionTicketAppDataVersion = 1; +// Layout: [type(1)][version(1)][crc(4)][payload(34)] = 40 bytes +constexpr size_t kSessionTicketAppDataSize = 40; +constexpr size_t kSessionTicketAppDataHeaderSize = 6; // type + version + crc +constexpr size_t kSessionTicketAppDataPayloadSize = + kSessionTicketAppDataSize - kSessionTicketAppDataHeaderSize; + +inline void WriteBE32(uint8_t* buf, uint32_t val) { + buf[0] = static_cast((val >> 24) & 0xff); + buf[1] = static_cast((val >> 16) & 0xff); + buf[2] = static_cast((val >> 8) & 0xff); + buf[3] = static_cast(val & 0xff); +} + +inline uint32_t ReadBE32(const uint8_t* buf) { + return (static_cast(buf[0]) << 24) | + (static_cast(buf[1]) << 16) | + (static_cast(buf[2]) << 8) | static_cast(buf[3]); +} + +inline void WriteBE64(uint8_t* buf, uint64_t val) { + buf[0] = static_cast((val >> 56) & 0xff); + buf[1] = static_cast((val >> 48) & 0xff); + buf[2] = static_cast((val >> 40) & 0xff); + buf[3] = static_cast((val >> 32) & 0xff); + buf[4] = static_cast((val >> 24) & 0xff); + buf[5] = static_cast((val >> 16) & 0xff); + buf[6] = static_cast((val >> 8) & 0xff); + buf[7] = static_cast(val & 0xff); +} + +inline uint64_t ReadBE64(const uint8_t* buf) { + return (static_cast(buf[0]) << 56) | + (static_cast(buf[1]) << 48) | + (static_cast(buf[2]) << 40) | + (static_cast(buf[3]) << 32) | + (static_cast(buf[4]) << 24) | + (static_cast(buf[5]) << 16) | + (static_cast(buf[6]) << 8) | static_cast(buf[7]); +} + +// Serialize an nghttp3_pri into an RFC 9218 priority field value +// (e.g., "u=3" or "u=0, i"). Returns the number of bytes written. +// This is used only for setting the priority field of HTTP/3 streams on +// the client side. +inline size_t FormatPriority(char* buf, size_t buflen, const nghttp3_pri& pri) { + int len; + if (pri.inc) { + len = snprintf(buf, buflen, "u=%d, i", pri.urgency); + } else { + len = snprintf(buf, buflen, "u=%d", pri.urgency); + } + return static_cast(len); +} +} // namespace + struct Http3HeadersTraits { using nv_t = nghttp3_nv; }; @@ -85,9 +144,16 @@ class Http3ApplicationImpl final : public Session::Application { public: Http3ApplicationImpl(Session* session, const Options& options) : Application(session, options), - allocator_(BindingData::Get(env())), + allocator_(BindingData::Get(env()).nghttp3_allocator()), options_(options), - conn_(InitializeConnection()) { + conn_(nullptr) { + // Build the ORIGIN frame payload from the SNI configuration before + // creating the nghttp3 connection, since InitializeConnection needs + // the origin_vec_ to be ready for settings.origin_list. + if (session->is_server()) { + BuildOriginPayload(); + } + conn_ = InitializeConnection(); session->set_priority_supported(); } @@ -97,8 +163,45 @@ class Http3ApplicationImpl final : public Session::Application { error_code GetNoErrorCode() const override { return NGHTTP3_H3_NO_ERROR; } + // HTTP/3 defines H3_INTERNAL_ERROR (0x102) for non-specific failures + // initiated by the implementation; this is the right code to send + // on RESET_STREAM when a stream is being aborted without an + // application-supplied code. + error_code GetInternalErrorCode() const override { + return NGHTTP3_H3_INTERNAL_ERROR; + } + + void EarlyDataRejected() override { + // When 0-RTT is rejected, destroy the nghttp3 connection and all + // open streams — ngtcp2 has discarded their internal state. + // Reset started_ so Start() is called again via on_receive_rx_key + // at 1RTT to recreate the nghttp3 connection. + conn_.reset(); + started_ = false; + session().DestroyAllStreams(QuicError::ForApplication(0)); + if (!session().is_destroyed()) { + session().EmitEarlyDataRejected(); + } + } + + bool ReceiveStreamOpen(stream_id id) override { + // In HTTP/3, only create Stream objects for bidirectional streams. + // Unidirectional streams (control, QPACK encoder/decoder) are + // managed internally by nghttp3 and should not be exposed to JS. + if (!ngtcp2_is_bidi_stream(id)) return true; + auto stream = session().CreateStream(id); + if (!stream || session().is_destroyed()) [[unlikely]] { + return !session().is_destroyed(); + } + return true; + } + + bool SupportsHeaders() const override { return true; } + + bool is_started() const override { return started_; } + bool Start() override { - CHECK(!started_); + if (started_) return true; started_ = true; Debug(&session(), "Starting HTTP/3 application."); @@ -158,20 +261,29 @@ class Http3ApplicationImpl final : public Session::Application { return ret; } - bool ReceiveStreamData(int64_t stream_id, + void BeginShutdown() override { + if (conn_) nghttp3_conn_submit_shutdown_notice(*this); + } + + void CompleteShutdown() override { + if (conn_) nghttp3_conn_shutdown(*this); + } + + bool ReceiveStreamData(stream_id id, const uint8_t* data, size_t datalen, const Stream::ReceiveDataFlags& flags, void* unused) override { Debug(&session(), "HTTP/3 application received %zu bytes of data " - "on stream %" PRIi64 ". Is final? %d", + "on stream %" PRIi64 ". Is final? %d. Is early? %d", datalen, - stream_id, - flags.fin); + id, + flags.fin, + flags.early); - ssize_t nread = nghttp3_conn_read_stream( - *this, stream_id, data, datalen, flags.fin ? 1 : 0); + auto nread = nghttp3_conn_read_stream2( + *this, id, data, datalen, flags.fin ? 1 : 0, uv_hrtime()); if (nread < 0) { Debug(&session(), @@ -184,20 +296,29 @@ class Http3ApplicationImpl final : public Session::Application { Debug(&session(), "Extending stream and connection offset by %zd bytes", nread); - session().ExtendStreamOffset(stream_id, nread); + session().ExtendStreamOffset(id, nread); session().ExtendOffset(nread); } + // If this data arrived as 0-RTT, mark the stream. We set it after + // nghttp3_conn_read_stream2 because the stream may not exist until + // nghttp3 processes the headers (via on_begin_headers). + if (flags.early) { + if (auto stream = session().FindStream(id)) { + stream->set_early(); + } + } + return true; } - bool AcknowledgeStreamData(int64_t stream_id, size_t datalen) override { + bool AcknowledgeStreamData(stream_id id, size_t datalen) override { Debug(&session(), "HTTP/3 application received acknowledgement for %zu bytes of data " "on stream %" PRIi64, datalen, - stream_id); - return nghttp3_conn_add_ack_offset(*this, stream_id, datalen) == 0; + id); + return nghttp3_conn_add_ack_offset(*this, id, datalen) == 0; } bool CanAddHeader(size_t current_count, @@ -205,18 +326,26 @@ class Http3ApplicationImpl final : public Session::Application { size_t this_header_length) override { // We cannot add the header if we've either reached // * the max number of header pairs or - // * the max number of header bytes - return (current_count < options_.max_header_pairs) && + // * the max number of header bytes (name + value combined) + // current_count is the number of entries in the headers vector + // (each pair = name entry + value entry = 2 entries). + return (current_count / 2 < options_.max_header_pairs) && (current_headers_length + this_header_length) <= options_.max_header_length; } - void BlockStream(int64_t id) override { + bool stream_fin_managed_by_application() const override { return true; } + + void StreamWriteShut(stream_id id) override { + nghttp3_conn_shutdown_stream_write(*this, id); + } + + void BlockStream(stream_id id) override { nghttp3_conn_block_stream(*this, id); Application::BlockStream(id); } - void ResumeStream(int64_t id) override { + void ResumeStream(stream_id id) override { nghttp3_conn_resume_stream(*this, id); Application::ResumeStream(id); } @@ -259,31 +388,126 @@ class Http3ApplicationImpl final : public Session::Application { void CollectSessionTicketAppData( SessionTicket::AppData* app_data) const override { - // TODO(@jasnell): When HTTP/3 settings become dynamic or - // configurable per-connection, store them here so they can be - // validated on 0-RTT resumption. Candidates include: - // max_field_section_size, qpack_max_dtable_capacity, - // qpack_encoder_max_dtable_capacity, qpack_blocked_streams, - // enable_connect_protocol, and enable_datagrams. On extraction, - // compare stored values against current settings and return - // TICKET_IGNORE_RENEW if incompatible. + uint8_t buf[kSessionTicketAppDataSize]; + buf[0] = static_cast(Type::HTTP3); + buf[1] = kSessionTicketAppDataVersion; + + uint8_t* payload = buf + kSessionTicketAppDataHeaderSize; + WriteBE64(payload, options_.max_field_section_size); + WriteBE64(payload + 8, options_.qpack_max_dtable_capacity); + WriteBE64(payload + 16, options_.qpack_encoder_max_dtable_capacity); + WriteBE64(payload + 24, options_.qpack_blocked_streams); + payload[32] = options_.enable_connect_protocol ? 1 : 0; + payload[33] = options_.enable_datagrams ? 1 : 0; + + uLong crc = crc32(0L, Z_NULL, 0); + crc = crc32(crc, payload, kSessionTicketAppDataPayloadSize); + WriteBE32(buf + 2, static_cast(crc)); + + app_data->Set( + uv_buf_init(reinterpret_cast(buf), kSessionTicketAppDataSize)); } SessionTicket::AppData::Status ExtractSessionTicketAppData( const SessionTicket::AppData& app_data, SessionTicket::AppData::Source::Flag flag) override { - // See CollectSessionTicketAppData above. + auto data = app_data.Get(); + if (!data || data->len != kSessionTicketAppDataSize) { + return SessionTicket::AppData::Status::TICKET_IGNORE_RENEW; + } + + const uint8_t* buf = reinterpret_cast(data->base); + + // buf[0] is the application type byte, buf[1] is the version. + if (buf[0] != static_cast(Type::HTTP3) || + buf[1] != kSessionTicketAppDataVersion) { + Debug(&session(), + "Ticket app data rejected: type=%d version=%d " + "(expected type=%d version=%d)", + buf[0], + buf[1], + static_cast(Type::HTTP3), + kSessionTicketAppDataVersion); + return SessionTicket::AppData::Status::TICKET_IGNORE_RENEW; + } + + const uint8_t* payload = buf + kSessionTicketAppDataHeaderSize; + uint32_t stored_crc = ReadBE32(buf + 2); + uLong computed_crc = crc32(0L, Z_NULL, 0); + computed_crc = + crc32(computed_crc, payload, kSessionTicketAppDataPayloadSize); + if (stored_crc != static_cast(computed_crc)) { + Debug(&session(), + "Ticket app data rejected: CRC mismatch " + "(stored=%u computed=%u)", + stored_crc, + static_cast(computed_crc)); + return SessionTicket::AppData::Status::TICKET_IGNORE_RENEW; + } + + uint64_t stored_max_field_section_size = ReadBE64(payload); + uint64_t stored_qpack_max_dtable_capacity = ReadBE64(payload + 8); + uint64_t stored_qpack_encoder_max_dtable_capacity = ReadBE64(payload + 16); + uint64_t stored_qpack_blocked_streams = ReadBE64(payload + 24); + bool stored_enable_connect_protocol = payload[32] != 0; + bool stored_enable_datagrams = payload[33] != 0; + + Debug(&session(), + "Ticket app data: stored mfss=%" PRIu64 " qmdc=%" PRIu64 + " qemdc=%" PRIu64 " qbs=%" PRIu64 " ecp=%d ed=%d", + stored_max_field_section_size, + stored_qpack_max_dtable_capacity, + stored_qpack_encoder_max_dtable_capacity, + stored_qpack_blocked_streams, + stored_enable_connect_protocol, + stored_enable_datagrams); + Debug(&session(), + "Current opts: mfss=%" PRIu64 " qmdc=%" PRIu64 " qemdc=%" PRIu64 + " qbs=%" PRIu64 " ecp=%d ed=%d", + options_.max_field_section_size, + options_.qpack_max_dtable_capacity, + options_.qpack_encoder_max_dtable_capacity, + options_.qpack_blocked_streams, + options_.enable_connect_protocol, + options_.enable_datagrams); + if (options_.max_field_section_size < stored_max_field_section_size || + options_.qpack_max_dtable_capacity < stored_qpack_max_dtable_capacity || + options_.qpack_encoder_max_dtable_capacity < + stored_qpack_encoder_max_dtable_capacity || + options_.qpack_blocked_streams < stored_qpack_blocked_streams || + (stored_enable_connect_protocol && !options_.enable_connect_protocol) || + (stored_enable_datagrams && !options_.enable_datagrams)) { + Debug(&session(), "Ticket app data REJECTED"); + return SessionTicket::AppData::Status::TICKET_IGNORE_RENEW; + } + Debug(&session(), "Ticket app data ACCEPTED"); + return flag == SessionTicket::AppData::Source::Flag::STATUS_RENEW ? SessionTicket::AppData::Status::TICKET_USE_RENEW : SessionTicket::AppData::Status::TICKET_USE; } - void StreamClose(Stream* stream, QuicError&& error = QuicError()) override { + bool ApplySessionTicketData(const PendingTicketAppData& data) override { + if (!std::holds_alternative(data)) return false; + const auto& ticket = std::get(data); + // Validate that current settings are >= stored settings. + return options_.max_field_section_size >= ticket.max_field_section_size && + options_.qpack_max_dtable_capacity >= + ticket.qpack_max_dtable_capacity && + options_.qpack_encoder_max_dtable_capacity >= + ticket.qpack_encoder_max_dtable_capacity && + options_.qpack_blocked_streams >= ticket.qpack_blocked_streams && + (!ticket.enable_connect_protocol || + options_.enable_connect_protocol) && + (!ticket.enable_datagrams || options_.enable_datagrams); + } + + void ReceiveStreamClose(Stream* stream, + QuicError&& error = QuicError()) override { Debug( &session(), "HTTP/3 application closing stream %" PRIi64, stream->id()); - uint64_t code = NGHTTP3_H3_NO_ERROR; - if (error) { - CHECK_EQ(error.type(), QuicError::Type::APPLICATION); + error_code code = NGHTTP3_H3_NO_ERROR; + if (error.type() == QuicError::Type::APPLICATION) { code = error.code(); } @@ -303,9 +527,9 @@ class Http3ApplicationImpl final : public Session::Application { session().Close(); } - void StreamReset(Stream* stream, - uint64_t final_size, - QuicError&& error = QuicError()) override { + void ReceiveStreamReset(Stream* stream, + uint64_t final_size, + QuicError&& error = QuicError()) override { // We are shutting down the readable side of the local stream here. Debug(&session(), "HTTP/3 application resetting stream %" PRIi64, @@ -321,9 +545,9 @@ class Http3ApplicationImpl final : public Session::Application { session().Close(); } - void StreamStopSending(Stream* stream, - QuicError&& error = QuicError()) override { - Application::StreamStopSending(stream, std::move(error)); + void ReceiveStreamStopSending(Stream* stream, + QuicError&& error = QuicError()) override { + Application::ReceiveStreamStopSending(stream, std::move(error)); } bool SendHeaders(const Stream& stream, @@ -363,8 +587,11 @@ class Http3ApplicationImpl final : public Session::Application { "Submitting %" PRIu64 " response headers for stream %" PRIu64, nva.length(), stream.id()); - return nghttp3_conn_submit_response( - *this, stream.id(), nva.data(), nva.length(), reader_ptr); + return nghttp3_conn_submit_response(*this, + stream.id(), + nva.data(), + nva.length(), + reader_ptr) == 0; } else { // Otherwise we're submitting a request... Debug(&session(), @@ -398,7 +625,7 @@ class Http3ApplicationImpl final : public Session::Application { StreamPriority priority, StreamPriorityFlags flags) override { nghttp3_pri pri; - pri.inc = (flags == StreamPriorityFlags::NON_INCREMENTAL) ? 0 : 1; + pri.inc = (flags == StreamPriorityFlags::INCREMENTAL) ? 1 : 0; switch (priority) { case StreamPriority::HIGH: pri.urgency = NGHTTP3_URGENCY_HIGH; @@ -412,33 +639,44 @@ class Http3ApplicationImpl final : public Session::Application { } if (session().is_server()) { nghttp3_conn_set_server_stream_priority(*this, stream.id(), &pri); + } else { + // The client API takes a serialized RFC 9218 priority field value + // (e.g., "u=0, i") rather than an nghttp3_pri struct. + char buf[8]; + size_t len = FormatPriority(buf, sizeof(buf), pri); + nghttp3_conn_set_client_stream_priority( + *this, stream.id(), reinterpret_cast(buf), len); } - // Client-side priority is set at request submission time via - // nghttp3_conn_submit_request and is not typically changed - // after the fact. The client API takes a serialized RFC 9218 - // field value rather than an nghttp3_pri struct. } - StreamPriority GetStreamPriority(const Stream& stream) override { + StreamPriorityResult GetStreamPriority(const Stream& stream) override { + // nghttp3_conn_get_stream_priority is only available on the server + // side, where it reflects the peer's requested priority (e.g., from + // PRIORITY_UPDATE frames). Client-side priority is tracked by the + // Stream itself and returned directly from GetPriority in streams.cc. + if (!session().is_server()) { + auto& stored = stream.stored_priority(); + return {stored.priority, stored.flags}; + } nghttp3_pri pri; if (nghttp3_conn_get_stream_priority(*this, &pri, stream.id()) == 0) { - // TODO(@jasnell): The nghttp3_pri.inc (incremental) flag is - // not yet exposed. When priority-based stream scheduling is - // implemented, GetStreamPriority should return both urgency - // and the incremental flag (making get/set symmetrical). - // The inc flag determines whether the server should interleave - // data from this stream with others of the same urgency - // (inc=1) or complete it first (inc=0). + StreamPriority level; switch (pri.urgency) { case NGHTTP3_URGENCY_HIGH: - return StreamPriority::HIGH; + level = StreamPriority::HIGH; + break; case NGHTTP3_URGENCY_LOW: - return StreamPriority::LOW; + level = StreamPriority::LOW; + break; default: - return StreamPriority::DEFAULT; + level = StreamPriority::DEFAULT; + break; } + return {level, + pri.inc ? StreamPriorityFlags::INCREMENTAL + : StreamPriorityFlags::NON_INCREMENTAL}; } - return StreamPriority::DEFAULT; + return {StreamPriority::DEFAULT, StreamPriorityFlags::NON_INCREMENTAL}; } int GetStreamData(StreamData* data) override { @@ -454,7 +692,7 @@ class Http3ApplicationImpl final : public Session::Application { } data->count = static_cast(ret); - if (data->id > 0 && data->id != control_stream_id_ && + if (data->id >= 0 && data->id != control_stream_id_ && data->id != qpack_dec_stream_id_ && data->id != qpack_enc_stream_id_) { data->stream = session().FindStream(data->id); @@ -469,13 +707,32 @@ class Http3ApplicationImpl final : public Session::Application { "HTTP/3 application committing stream %" PRIi64 " data %zu", data->id, datalen); + // datalen is the total framed bytes consumed by ngtcp2, which includes + // H3 frame overhead (HEADERS frame bytes, DATA frame type/length). + // nghttp3 tracks its own offset via add_write_offset. int err = nghttp3_conn_add_write_offset(*this, data->id, datalen); if (err != 0) { session().SetLastError(QuicError::ForApplication( nghttp3_err_infer_quic_app_error_code(err))); return false; } - if (data->stream) data->stream->Commit(datalen, data->fin); + // Raw application bytes are committed to the stream's outbound + // immediately in on_read_data_callback (so that re-entrant + // fill_outq calls see the advanced position). We only need to + // propagate the fin flag here. + if (data->stream && data->fin) { + data->stream->Commit(0, true); + } + // After body data is committed, if on_read_data_callback signaled + // EOF+NO_END_STREAM (trailers pending), emit the want-trailers + // event to JS. This runs outside the NgHttp3CallbackScope so it's + // safe to call into JS. The JS handler calls sendTrailers() which + // calls nghttp3_conn_submit_trailers, queuing the TRAILERS frame + // for the next writev_stream in the send loop. + if (pending_trailers_stream_ == data->id) { + pending_trailers_stream_ = -1; + if (data->stream) data->stream->EmitWantTrailers(); + } return true; } @@ -489,27 +746,56 @@ class Http3ApplicationImpl final : public Session::Application { return conn_.get(); } - inline bool is_control_stream(int64_t id) const { + inline bool is_control_stream(stream_id id) const { return id == control_stream_id_ || id == qpack_dec_stream_id_ || id == qpack_enc_stream_id_; } + void BuildOriginPayload() { + // Build the serialized ORIGIN frame payload from the SNI configuration. + // Each origin entry is: 2-byte BE length + origin string. + // Wildcard ('*') entries and entries with authoritative=false are skipped. + auto& sni = session().config().options.sni; + for (auto& [hostname, opts] : sni) { + if (hostname == "*" || !opts.authoritative) continue; + std::string origin = "https://"; + origin += hostname; + if (opts.port != 443) { + origin += ":"; + origin += std::to_string(opts.port); + } + // 2-byte BE length prefix + uint16_t len = static_cast(origin.size()); + origin_payload_.push_back(static_cast((len >> 8) & 0xff)); + origin_payload_.push_back(static_cast(len & 0xff)); + // Origin string bytes + origin_payload_.insert( + origin_payload_.end(), origin.begin(), origin.end()); + } + if (!origin_payload_.empty()) { + origin_vec_ = {origin_payload_.data(), origin_payload_.size()}; + } + } + Http3ConnectionPointer InitializeConnection() { nghttp3_conn* conn = nullptr; nghttp3_settings settings = options_; + if (!origin_payload_.empty()) { + settings.origin_list = &origin_vec_; + } if (session().is_server()) { CHECK_EQ(nghttp3_conn_server_new( - &conn, &kCallbacks, &settings, &allocator_, this), + &conn, &kCallbacks, &settings, allocator_, this), 0); } else { CHECK_EQ(nghttp3_conn_client_new( - &conn, &kCallbacks, &settings, &allocator_, this), + &conn, &kCallbacks, &settings, allocator_, this), 0); } return Http3ConnectionPointer(conn); } - void OnStreamClose(Stream* stream, uint64_t app_error_code) { + void OnStreamClose(Stream* stream, error_code app_error_code) { if (app_error_code != NGHTTP3_H3_NO_ERROR) { Debug(&session(), "HTTP/3 application received stream close for stream %" PRIi64 @@ -522,20 +808,19 @@ class Http3ApplicationImpl final : public Session::Application { ExtendMaxStreams(EndpointLabel::REMOTE, direction, 1); } - void OnBeginHeaders(int64_t stream_id) { - auto stream = session().FindStream(stream_id); - // If the stream does not exist or is destroyed, ignore! + void OnBeginHeaders(stream_id id) { + auto stream = FindOrCreateStream(conn_.get(), &session(), id); if (!stream) [[unlikely]] return; Debug(&session(), "HTTP/3 application beginning initial block of headers for stream " "%" PRIi64, - stream_id); + id); stream->BeginHeaders(HeadersKind::INITIAL); } - void OnReceiveHeader(int64_t stream_id, Http3Header&& header) { - auto stream = session().FindStream(stream_id); + void OnReceiveHeader(stream_id id, Http3Header&& header) { + auto stream = session().FindStream(id); if (!stream) [[unlikely]] return; @@ -554,17 +839,17 @@ class Http3ApplicationImpl final : public Session::Application { stream->AddHeader(std::move(header)); } - void OnEndHeaders(int64_t stream_id, int fin) { - auto stream = session().FindStream(stream_id); + void OnEndHeaders(stream_id id, int fin) { + auto stream = session().FindStream(id); if (!stream) [[unlikely]] return; Debug(&session(), "HTTP/3 application received end of headers for stream %" PRIi64, - stream_id); + id); stream->EmitHeaders(); if (fin) { // The stream is done. There's no more data to receive! - Debug(&session(), "Headers are final for stream %" PRIi64, stream_id); + Debug(&session(), "Headers are final for stream %" PRIi64, id); Stream::ReceiveDataFlags flags{ .fin = true, .early = false, @@ -573,18 +858,18 @@ class Http3ApplicationImpl final : public Session::Application { } } - void OnBeginTrailers(int64_t stream_id) { - auto stream = session().FindStream(stream_id); + void OnBeginTrailers(stream_id id) { + auto stream = FindOrCreateStream(conn_.get(), &session(), id); if (!stream) [[unlikely]] return; Debug(&session(), "HTTP/3 application beginning block of trailers for stream %" PRIi64, - stream_id); + id); stream->BeginHeaders(HeadersKind::TRAILING); } - void OnReceiveTrailer(int64_t stream_id, Http3Header&& header) { - auto stream = session().FindStream(stream_id); + void OnReceiveTrailer(stream_id id, Http3Header&& header) { + auto stream = session().FindStream(id); if (!stream) [[unlikely]] return; IF_QUIC_DEBUG(env()) { @@ -593,19 +878,19 @@ class Http3ApplicationImpl final : public Session::Application { header.name(), header.value()); } - stream->AddHeader(header); + stream->AddHeader(std::move(header)); } - void OnEndTrailers(int64_t stream_id, int fin) { - auto stream = session().FindStream(stream_id); + void OnEndTrailers(stream_id id, int fin) { + auto stream = session().FindStream(id); if (!stream) [[unlikely]] return; Debug(&session(), "HTTP/3 application received end of trailers for stream %" PRIi64, - stream_id); + id); stream->EmitHeaders(); if (fin) { - Debug(&session(), "Trailers are final for stream %" PRIi64, stream_id); + Debug(&session(), "Trailers are final for stream %" PRIi64, id); Stream::ReceiveDataFlags flags{ .fin = true, .early = false, @@ -614,13 +899,13 @@ class Http3ApplicationImpl final : public Session::Application { } } - void OnEndStream(int64_t stream_id) { - auto stream = session().FindStream(stream_id); + void OnEndStream(stream_id id) { + auto stream = session().FindStream(id); if (!stream) [[unlikely]] return; Debug(&session(), "HTTP/3 application received end of stream for stream %" PRIi64, - stream_id); + id); Stream::ReceiveDataFlags flags{ .fin = true, .early = false, @@ -628,63 +913,126 @@ class Http3ApplicationImpl final : public Session::Application { stream->ReceiveData(nullptr, 0, flags); } - void OnStopSending(int64_t stream_id, uint64_t app_error_code) { - auto stream = session().FindStream(stream_id); + void OnStopSending(stream_id id, error_code app_error_code) { + auto stream = session().FindStream(id); if (!stream) [[unlikely]] return; Debug(&session(), "HTTP/3 application received stop sending for stream %" PRIi64, - stream_id); + id); stream->ReceiveStopSending(QuicError::ForApplication(app_error_code)); } - void OnResetStream(int64_t stream_id, uint64_t app_error_code) { - auto stream = session().FindStream(stream_id); + void OnResetStream(stream_id id, error_code app_error_code) { + auto stream = session().FindStream(id); if (!stream) [[unlikely]] return; Debug(&session(), "HTTP/3 application received reset stream for stream %" PRIi64, - stream_id); + id); stream->ReceiveStreamReset(0, QuicError::ForApplication(app_error_code)); } - void OnShutdown(int64_t id) { - // The peer has sent a GOAWAY frame initiating a graceful shutdown. - // For a client, id is the stream ID beyond which the server will - // not process requests. For a server, id is a push ID (server - // push is not implemented). Streams/pushes with IDs >= id will - // not be processed by the peer. - // - // When id equals NGHTTP3_SHUTDOWN_NOTICE_STREAM_ID (client) or - // NGHTTP3_SHUTDOWN_NOTICE_PUSH_ID (server), this is a notice of - // intent to shut down rather than an immediate refusal. + void OnShutdown(stream_id id) { + // The peer has sent a GOAWAY frame. This callback fires inside + // NgHttp3CallbackScope, so we cannot call into JS, destroy streams, + // or enter Close(GRACEFUL) here (which could trigger FinishClose and + // deferred destroy, preventing PostReceive from running). // - // This can be called multiple times with a decreasing id as the - // peer progressively reduces the set of streams it will process. + // Store the GOAWAY stream ID — PostReceive() handles everything + // outside all callback scopes. For the shutdown notice (first phase, + // sentinel ID), we still store it so PostReceive knows to enter + // graceful close mode. For the final GOAWAY (real stream ID), we + // overwrite with the lower value. Debug(&session(), "HTTP/3 received GOAWAY (id=%" PRIi64 ")", id); - session().Close(Session::CloseMethod::GRACEFUL); + pending_goaway_id_ = id; + } + + void PostReceive() override { + if (pending_goaway_id_ < 0) return; + stream_id goaway_id = pending_goaway_id_; + pending_goaway_id_ = -1; + + bool is_notice = + static_cast(goaway_id) >= NGHTTP3_SHUTDOWN_NOTICE_STREAM_ID; + + // For the shutdown notice, replace the sentinel stream ID with -1 + // so JS sees a clean marker instead of a huge implementation detail. + stream_id emit_id = is_notice ? -1 : goaway_id; + + if (!is_notice) { + // Final GOAWAY: destroy client-initiated bidi streams with + // IDs > goaway_id. These were not processed by the peer and + // can be retried. Copy the map because Destroy modifies it. + auto streams = session().streams(); + for (auto& [id, stream] : streams) { + if (session().is_destroyed()) return; + if (ngtcp2_is_bidi_stream(id) && id > goaway_id) { + stream->Destroy( + QuicError::ForApplication(NGHTTP3_H3_REQUEST_REJECTED)); + } + } + if (session().is_destroyed()) return; + } + + // Notify JS for both notice and final GOAWAY. The notice uses + // -1 to signal "server is shutting down, stop new requests" without + // implying any specific stream boundary. The final GOAWAY (if it + // arrives separately) provides the exact stream ID for retry decisions. + // + // We do NOT call Close(GRACEFUL) here. The JS ongoaway handler sets + // isPendingClose (preventing new streams). The session closes naturally + // when the peer sends CONNECTION_CLOSE after all streams finish. + // Calling Close(GRACEFUL) would send a GOAWAY back and trigger + // BeginShutdown, which can interfere with in-progress streams. + session().EmitGoaway(emit_id); } - void OnReceiveSettings(const nghttp3_settings* settings) { + void OnReceiveSettings(const nghttp3_proto_settings* settings) { options_.enable_connect_protocol = settings->enable_connect_protocol; options_.enable_datagrams = settings->h3_datagram; options_.max_field_section_size = settings->max_field_section_size; options_.qpack_blocked_streams = settings->qpack_blocked_streams; - options_.qpack_encoder_max_dtable_capacity = - settings->qpack_encoder_max_dtable_capacity; options_.qpack_max_dtable_capacity = settings->qpack_max_dtable_capacity; + + // Per RFC 9297 §3, an H3 endpoint MUST NOT send HTTP Datagrams + // unless the peer indicated support via SETTINGS_H3_DATAGRAM=1. + // If the peer disabled it, set the session's max datagram size to 0 + // which blocks sends at the existing JS/C++ check. + if (!settings->h3_datagram) { + session().set_max_datagram_size(0); + } + Debug(&session(), "HTTP/3 application received updated settings: %s", options_); } bool started_ = false; - nghttp3_mem allocator_; + nghttp3_mem* allocator_; Options options_; Http3ConnectionPointer conn_; - int64_t control_stream_id_ = -1; - int64_t qpack_dec_stream_id_ = -1; - int64_t qpack_enc_stream_id_ = -1; + stream_id control_stream_id_ = -1; + stream_id qpack_dec_stream_id_ = -1; + stream_id qpack_enc_stream_id_ = -1; + + // Set by on_read_data_callback when EOF+NO_END_STREAM (trailers pending). + // Consumed by StreamCommit to trigger EmitWantTrailers outside the + // nghttp3 callback scope. + stream_id pending_trailers_stream_ = -1; + + // Set by OnShutdown when the peer sends a final GOAWAY. Consumed by + // PostReceive() outside all callback scopes to destroy rejected + // streams and notify JS. + stream_id pending_goaway_id_ = -1; + + // ORIGIN frame support (RFC 9412). + // origin_payload_ holds the serialized ORIGIN frame payload for sending. + // origin_vec_ points into origin_payload_ for nghttp3_settings.origin_list. + // received_origins_ accumulates origins from received ORIGIN frames. + std::vector origin_payload_; + nghttp3_vec origin_vec_{nullptr, 0}; + std::vector received_origins_; // ========================================================================== // Static callbacks @@ -698,11 +1046,11 @@ class Http3ApplicationImpl final : public Session::Application { static BaseObjectWeakPtr FindOrCreateStream(nghttp3_conn* conn, Session* session, - int64_t stream_id) { - if (auto stream = session->FindStream(stream_id)) { + stream_id id) { + if (auto stream = session->FindStream(id)) { return stream; } - if (auto stream = session->CreateStream(stream_id)) { + if (auto stream = session->CreateStream(id)) { return stream; } return {}; @@ -712,10 +1060,10 @@ class Http3ApplicationImpl final : public Session::Application { auto ptr = From(conn, conn_user_data); \ CHECK_NOT_NULL(ptr); \ auto& name = *ptr; \ - NgHttp3CallbackScope scope(name.env()); + NgHttp3CallbackScope scope(&name.session()); static nghttp3_ssize on_read_data_callback(nghttp3_conn* conn, - int64_t stream_id, + stream_id id, nghttp3_vec* vec, size_t veccnt, uint32_t* pflags, @@ -724,13 +1072,17 @@ class Http3ApplicationImpl final : public Session::Application { auto ptr = From(conn, conn_user_data); CHECK_NOT_NULL(ptr); auto& app = *ptr; - NgHttp3CallbackScope scope(app.env()); + NgHttp3CallbackScope scope(&app.session()); - auto stream = app.session().FindStream(stream_id); + auto stream = app.session().FindStream(id); if (!stream) return NGHTTP3_ERR_CALLBACK_FAILURE; if (stream->is_eos()) { *pflags |= NGHTTP3_DATA_FLAG_EOF; + if (stream->wants_trailers()) { + *pflags |= NGHTTP3_DATA_FLAG_NO_END_STREAM; + app.pending_trailers_stream_ = id; + } return 0; } @@ -746,12 +1098,35 @@ class Http3ApplicationImpl final : public Session::Application { return; case bob::Status::STATUS_EOS: *pflags |= NGHTTP3_DATA_FLAG_EOF; + if (stream->wants_trailers()) { + *pflags |= NGHTTP3_DATA_FLAG_NO_END_STREAM; + app.pending_trailers_stream_ = id; + } break; } count = std::min(count, max_count); + // nghttp3 requires read_data to return either data (count > 0), + // EOF, or WOULDBLOCK. A STATUS_CONTINUE with 0 vecs means the + // outbound has no uncommitted data right now (e.g., all data was + // already committed on a previous call, or the DataQueue is empty + // but not yet capped). Map this to WOULDBLOCK so nghttp3 sets + // READ_DATA_BLOCKED and waits for ResumeStream. + if (count == 0 && !((*pflags) & NGHTTP3_DATA_FLAG_EOF)) { + result = NGHTTP3_ERR_WOULDBLOCK; + return; + } + size_t raw_bytes = 0; for (size_t n = 0; n < count; n++) { vec[n].base = data[n].base; vec[n].len = data[n].len; + raw_bytes += data[n].len; + } + // Commit the raw application bytes immediately so that the + // next Pull (if fill_outq re-enters read_data) sees the + // advanced position. Commit only moves the offset — the + // underlying buffers stay valid until Acknowledge. + if (raw_bytes > 0) { + stream->Commit(raw_bytes); } result = static_cast(count); }; @@ -767,30 +1142,40 @@ class Http3ApplicationImpl final : public Session::Application { } static int on_acked_stream_data(nghttp3_conn* conn, - int64_t stream_id, + stream_id id, uint64_t datalen, void* conn_user_data, void* stream_user_data) { - NGHTTP3_CALLBACK_SCOPE(app); - return app.AcknowledgeStreamData(stream_id, static_cast(datalen)) - ? NGTCP2_SUCCESS - : NGHTTP3_ERR_CALLBACK_FAILURE; + // This callback is invoked by nghttp3_conn_add_ack_offset() (called + // from Http3ApplicationImpl::AcknowledgeStreamData). We must NOT call + // AcknowledgeStreamData here — that would re-enter nghttp3 via + // nghttp3_conn_add_ack_offset, triggering the NgHttp3CallbackScope + // re-entrancy assertion. Instead, directly notify the stream that data + // was acknowledged, which is what the base Application implementation + // does. + auto ptr = From(conn, conn_user_data); + CHECK_NOT_NULL(ptr); + auto& app = *ptr; + if (auto stream = app.session().FindStream(id)) { + stream->Acknowledge(static_cast(datalen)); + } + return NGTCP2_SUCCESS; } static int on_stream_close(nghttp3_conn* conn, - int64_t stream_id, - uint64_t app_error_code, + stream_id id, + error_code app_error_code, void* conn_user_data, void* stream_user_data) { NGHTTP3_CALLBACK_SCOPE(app); - if (auto stream = app.session().FindStream(stream_id)) { + if (auto stream = app.session().FindStream(id)) { app.OnStreamClose(stream.get(), app_error_code); } return NGTCP2_SUCCESS; } static int on_receive_data(nghttp3_conn* conn, - int64_t stream_id, + stream_id id, const uint8_t* data, size_t datalen, void* conn_user_data, @@ -799,12 +1184,11 @@ class Http3ApplicationImpl final : public Session::Application { // The on_receive_data callback will never be called for control streams, // so we know that if we get here, the data received is for a stream that // we know is for an HTTP payload. - if (app.is_control_stream(stream_id)) [[unlikely]] { + if (app.is_control_stream(id)) [[unlikely]] { return NGHTTP3_ERR_CALLBACK_FAILURE; } auto& session = app.session(); - if (auto stream = FindOrCreateStream(conn, &session, stream_id)) - [[likely]] { + if (auto stream = FindOrCreateStream(conn, &session, id)) [[likely]] { stream->ReceiveData(data, datalen, Stream::ReceiveDataFlags{}); return NGTCP2_SUCCESS; } @@ -812,32 +1196,32 @@ class Http3ApplicationImpl final : public Session::Application { } static int on_deferred_consume(nghttp3_conn* conn, - int64_t stream_id, + stream_id id, size_t consumed, void* conn_user_data, void* stream_user_data) { NGHTTP3_CALLBACK_SCOPE(app); auto& session = app.session(); Debug(&session, "HTTP/3 application deferred consume %zu bytes", consumed); - session.ExtendStreamOffset(stream_id, consumed); + session.ExtendStreamOffset(id, consumed); session.ExtendOffset(consumed); return NGTCP2_SUCCESS; } static int on_begin_headers(nghttp3_conn* conn, - int64_t stream_id, + stream_id id, void* conn_user_data, void* stream_user_data) { NGHTTP3_CALLBACK_SCOPE(app); - if (app.is_control_stream(stream_id)) [[unlikely]] { + if (app.is_control_stream(id)) [[unlikely]] { return NGHTTP3_ERR_CALLBACK_FAILURE; } - app.OnBeginHeaders(stream_id); + app.OnBeginHeaders(id); return NGTCP2_SUCCESS; } static int on_receive_header(nghttp3_conn* conn, - int64_t stream_id, + stream_id id, int32_t token, nghttp3_rcbuf* name, nghttp3_rcbuf* value, @@ -845,42 +1229,41 @@ class Http3ApplicationImpl final : public Session::Application { void* conn_user_data, void* stream_user_data) { NGHTTP3_CALLBACK_SCOPE(app); - if (app.is_control_stream(stream_id)) [[unlikely]] { + if (app.is_control_stream(id)) [[unlikely]] { return NGHTTP3_ERR_CALLBACK_FAILURE; } if (Http3Header::IsZeroLength(token, name, value)) return NGTCP2_SUCCESS; - app.OnReceiveHeader(stream_id, - Http3Header(app.env(), token, name, value, flags)); + app.OnReceiveHeader(id, Http3Header(app.env(), token, name, value, flags)); return NGTCP2_SUCCESS; } static int on_end_headers(nghttp3_conn* conn, - int64_t stream_id, + stream_id id, int fin, void* conn_user_data, void* stream_user_data) { NGHTTP3_CALLBACK_SCOPE(app); - if (app.is_control_stream(stream_id)) [[unlikely]] { + if (app.is_control_stream(id)) [[unlikely]] { return NGHTTP3_ERR_CALLBACK_FAILURE; } - app.OnEndHeaders(stream_id, fin); + app.OnEndHeaders(id, fin); return NGTCP2_SUCCESS; } static int on_begin_trailers(nghttp3_conn* conn, - int64_t stream_id, + stream_id id, void* conn_user_data, void* stream_user_data) { NGHTTP3_CALLBACK_SCOPE(app); - if (app.is_control_stream(stream_id)) [[unlikely]] { + if (app.is_control_stream(id)) [[unlikely]] { return NGHTTP3_ERR_CALLBACK_FAILURE; } - app.OnBeginTrailers(stream_id); + app.OnBeginTrailers(id); return NGTCP2_SUCCESS; } static int on_receive_trailer(nghttp3_conn* conn, - int64_t stream_id, + stream_id id, int32_t token, nghttp3_rcbuf* name, nghttp3_rcbuf* value, @@ -888,74 +1271,75 @@ class Http3ApplicationImpl final : public Session::Application { void* conn_user_data, void* stream_user_data) { NGHTTP3_CALLBACK_SCOPE(app); - if (app.is_control_stream(stream_id)) [[unlikely]] { + if (app.is_control_stream(id)) [[unlikely]] { return NGHTTP3_ERR_CALLBACK_FAILURE; } if (Http3Header::IsZeroLength(token, name, value)) return NGTCP2_SUCCESS; - app.OnReceiveTrailer(stream_id, - Http3Header(app.env(), token, name, value, flags)); + app.OnReceiveTrailer(id, Http3Header(app.env(), token, name, value, flags)); return NGTCP2_SUCCESS; } static int on_end_trailers(nghttp3_conn* conn, - int64_t stream_id, + stream_id id, int fin, void* conn_user_data, void* stream_user_data) { NGHTTP3_CALLBACK_SCOPE(app); - if (app.is_control_stream(stream_id)) [[unlikely]] { + if (app.is_control_stream(id)) [[unlikely]] { return NGHTTP3_ERR_CALLBACK_FAILURE; } - app.OnEndTrailers(stream_id, fin); + app.OnEndTrailers(id, fin); return NGTCP2_SUCCESS; } static int on_end_stream(nghttp3_conn* conn, - int64_t stream_id, + stream_id id, void* conn_user_data, void* stream_user_data) { NGHTTP3_CALLBACK_SCOPE(app); - if (app.is_control_stream(stream_id)) [[unlikely]] { + if (app.is_control_stream(id)) [[unlikely]] { return NGHTTP3_ERR_CALLBACK_FAILURE; } - app.OnEndStream(stream_id); + app.OnEndStream(id); return NGTCP2_SUCCESS; } static int on_stop_sending(nghttp3_conn* conn, - int64_t stream_id, - uint64_t app_error_code, + stream_id id, + error_code app_error_code, void* conn_user_data, void* stream_user_data) { NGHTTP3_CALLBACK_SCOPE(app); - if (app.is_control_stream(stream_id)) [[unlikely]] { + if (app.is_control_stream(id)) [[unlikely]] { return NGHTTP3_ERR_CALLBACK_FAILURE; } - app.OnStopSending(stream_id, app_error_code); + app.OnStopSending(id, app_error_code); return NGTCP2_SUCCESS; } static int on_reset_stream(nghttp3_conn* conn, - int64_t stream_id, - uint64_t app_error_code, + stream_id id, + error_code app_error_code, void* conn_user_data, void* stream_user_data) { NGHTTP3_CALLBACK_SCOPE(app); - if (app.is_control_stream(stream_id)) [[unlikely]] { + if (app.is_control_stream(id)) [[unlikely]] { return NGHTTP3_ERR_CALLBACK_FAILURE; } - app.OnResetStream(stream_id, app_error_code); + app.OnResetStream(id, app_error_code); return NGTCP2_SUCCESS; } - static int on_shutdown(nghttp3_conn* conn, int64_t id, void* conn_user_data) { + static int on_shutdown(nghttp3_conn* conn, + stream_id id, + void* conn_user_data) { NGHTTP3_CALLBACK_SCOPE(app); app.OnShutdown(id); return NGTCP2_SUCCESS; } static int on_receive_settings(nghttp3_conn* conn, - const nghttp3_settings* settings, + const nghttp3_proto_settings* settings, void* conn_user_data) { NGHTTP3_CALLBACK_SCOPE(app); app.OnReceiveSettings(settings); @@ -966,14 +1350,18 @@ class Http3ApplicationImpl final : public Session::Application { const uint8_t* origin, size_t originlen, void* conn_user_data) { - // ORIGIN frames (RFC 8336) are used for connection coalescing - // across multiple origins. Not yet implemented u2014 requires - // connection pooling and multi-origin reuse support. + NGHTTP3_CALLBACK_SCOPE(app); + app.received_origins_.emplace_back(reinterpret_cast(origin), + originlen); return NGTCP2_SUCCESS; } static int on_end_origin(nghttp3_conn* conn, void* conn_user_data) { - // See on_receive_origin above. + NGHTTP3_CALLBACK_SCOPE(app); + if (!app.received_origins_.empty()) { + app.session().EmitOrigins(std::move(app.received_origins_)); + app.received_origins_.clear(); + } return NGTCP2_SUCCESS; } @@ -981,27 +1369,52 @@ class Http3ApplicationImpl final : public Session::Application { CHECK(ncrypto::CSPRNG(dest, destlen)); } - static constexpr nghttp3_callbacks kCallbacks = {on_acked_stream_data, - on_stream_close, - on_receive_data, - on_deferred_consume, - on_begin_headers, - on_receive_header, - on_end_headers, - on_begin_trailers, - on_receive_trailer, - on_end_trailers, - on_stop_sending, - on_end_stream, - on_reset_stream, - on_shutdown, - on_receive_settings, - on_receive_origin, - on_end_origin, - on_rand, - nullptr}; + static constexpr nghttp3_callbacks kCallbacks = { + on_acked_stream_data, + on_stream_close, + on_receive_data, + on_deferred_consume, + on_begin_headers, + on_receive_header, + on_end_headers, + on_begin_trailers, + on_receive_trailer, + on_end_trailers, + on_stop_sending, + on_end_stream, + on_reset_stream, + on_shutdown, + nullptr, // recv_settings (deprecated) + on_receive_origin, + on_end_origin, + on_rand, + on_receive_settings}; }; +std::optional ParseHttp3TicketData(const uv_buf_t& data) { + if (data.len != kSessionTicketAppDataSize) return std::nullopt; + + const uint8_t* buf = reinterpret_cast(data.base); + + // buf[0] is the type byte (already checked by caller), buf[1] is version. + if (buf[1] != kSessionTicketAppDataVersion) return std::nullopt; + + const uint8_t* payload = buf + kSessionTicketAppDataHeaderSize; + uint32_t stored_crc = ReadBE32(buf + 2); + uLong computed_crc = crc32(0L, Z_NULL, 0); + computed_crc = crc32(computed_crc, payload, kSessionTicketAppDataPayloadSize); + if (stored_crc != static_cast(computed_crc)) return std::nullopt; + + return Http3TicketData{ + ReadBE64(payload), + ReadBE64(payload + 8), + ReadBE64(payload + 16), + ReadBE64(payload + 24), + payload[32] != 0, + payload[33] != 0, + }; +} + std::unique_ptr CreateHttp3Application( Session* session, const Session::Application_Options& options) { Debug(session, "Selecting HTTP/3 application"); diff --git a/src/quic/http3.h b/src/quic/http3.h index b49f3daf8b1621..f1a1b674d96903 100644 --- a/src/quic/http3.h +++ b/src/quic/http3.h @@ -3,6 +3,8 @@ #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS #include +#include +#include "application.h" #include "session.h" namespace node::quic { @@ -13,6 +15,11 @@ namespace node::quic { std::unique_ptr CreateHttp3Application( Session* session, const Session::Application_Options& options); +// Parse HTTP/3 specific session ticket app data. Called from +// Application::ParseTicketData() when the type byte is HTTP3. +// The data includes the type byte prefix. +std::optional ParseHttp3TicketData(const uv_buf_t& data); + } // namespace node::quic #endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS diff --git a/src/quic/logstream.cc b/src/quic/logstream.cc deleted file mode 100644 index 511b2a1ef46ebe..00000000000000 --- a/src/quic/logstream.cc +++ /dev/null @@ -1,140 +0,0 @@ -#if HAVE_OPENSSL && HAVE_QUIC -#include "guard.h" -#ifndef OPENSSL_NO_QUIC -#include "logstream.h" -#include -#include -#include -#include -#include -#include -#include -#include -#include "bindingdata.h" - -namespace node { - -using v8::FunctionTemplate; -using v8::Local; -using v8::Object; - -namespace quic { - -JS_CONSTRUCTOR_IMPL(LogStream, logstream_constructor_template, { - tmpl = FunctionTemplate::New(env->isolate()); - JS_INHERIT(AsyncWrap); - JS_CLASS_FIELDS(logstream, StreamBase::kInternalFieldCount); - StreamBase::AddMethods(env, tmpl); -}) - -BaseObjectPtr LogStream::Create(Environment* env) { - JS_NEW_INSTANCE_OR_RETURN(env, obj, nullptr); - return MakeDetachedBaseObject(env, obj); -} - -LogStream::LogStream(Environment* env, Local obj) - : AsyncWrap(env, obj, PROVIDER_QUIC_LOGSTREAM), StreamBase(env) { - MakeWeak(); - AttachToObject(GetObject()); -} - -void LogStream::Emit(const uint8_t* data, size_t len, EmitOption option) { - if (fin_seen_) return; - fin_seen_ = option == EmitOption::FIN; - - size_t remaining = len; - // If the len is greater than the size of the buffer returned by - // EmitAlloc then EmitRead will be called multiple times. - while (remaining != 0) { - uv_buf_t buf = EmitAlloc(remaining); - size_t chunk_len = std::min(remaining, buf.len); - memcpy(buf.base, data, chunk_len); - remaining -= chunk_len; - data += chunk_len; - // If we are actively reading from the stream, we'll call emit - // read immediately. Otherwise we buffer the chunk and will push - // the chunks out the next time ReadStart() is called. - if (reading_) { - EmitRead(chunk_len, buf); - } else { - // The total measures the total memory used so we always - // increment but buf.len and not chunk len. - ensure_space(buf.len); - total_ += buf.len; - buffer_.push_back(Chunk{chunk_len, buf}); - } - } - - if (ended_ && reading_) { - EmitRead(UV_EOF); - } -} - -void LogStream::Emit(const std::string_view line, EmitOption option) { - Emit(reinterpret_cast(line.data()), line.length(), option); -} - -void LogStream::End() { - ended_ = true; -} - -int LogStream::ReadStart() { - if (reading_) return 0; - // Flush any chunks that have already been buffered. - for (const auto& chunk : buffer_) EmitRead(chunk.len, chunk.buf); - total_ = 0; - buffer_.clear(); - if (fin_seen_) { - // If we've already received the fin, there's nothing else to wait for. - EmitRead(UV_EOF); - return ReadStop(); - } - // Otherwise, we're going to wait for more chunks to be written. - reading_ = true; - return 0; -} - -int LogStream::ReadStop() { - reading_ = false; - return 0; -} - -// We do not use either of these. -int LogStream::DoShutdown(ShutdownWrap* req_wrap) { - UNREACHABLE(); -} -int LogStream::DoWrite(WriteWrap* w, - uv_buf_t* bufs, - size_t count, - uv_stream_t* send_handle) { - UNREACHABLE(); -} - -bool LogStream::IsAlive() { - return !ended_; -} - -bool LogStream::IsClosing() { - return ended_; -} - -AsyncWrap* LogStream::GetAsyncWrap() { - return this; -} - -void LogStream::MemoryInfo(MemoryTracker* tracker) const { - tracker->TrackFieldWithSize("buffer", total_); -} - -// The LogStream buffer enforces a maximum size of kMaxLogStreamBuffer. -void LogStream::ensure_space(size_t amt) { - while (total_ + amt > kMaxLogStreamBuffer) { - total_ -= buffer_.front().buf.len; - buffer_.pop_front(); - } -} -} // namespace quic -} // namespace node - -#endif // OPENSSL_NO_QUIC -#endif // HAVE_OPENSSL && HAVE_QUIC diff --git a/src/quic/logstream.h b/src/quic/logstream.h deleted file mode 100644 index b8bb1ebaecb8a0..00000000000000 --- a/src/quic/logstream.h +++ /dev/null @@ -1,84 +0,0 @@ -#pragma once - -#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS - -#include -#include -#include -#include -#include -#include "defs.h" - -namespace node::quic { - -// The LogStream is a utility that the QUIC impl uses to publish both QLog -// and Keylog diagnostic data (one instance for each). -class LogStream final : public AsyncWrap, public StreamBase { - public: - enum InternalFields { - kInternalFieldCount = std::max(AsyncWrap::kInternalFieldCount, - StreamBase::kInternalFieldCount), - }; - - JS_CONSTRUCTOR(LogStream); - - static BaseObjectPtr Create(Environment* env); - - LogStream(Environment* env, v8::Local obj); - - enum class EmitOption : uint8_t { - NONE, - FIN, - }; - - void Emit(const uint8_t* data, - size_t len, - EmitOption option = EmitOption::NONE); - - void Emit(const std::string_view line, EmitOption option = EmitOption::NONE); - - void End(); - - int ReadStart() override; - - int ReadStop() override; - - // We do not use either of these. - int DoShutdown(ShutdownWrap* req_wrap) override; - int DoWrite(WriteWrap* w, - uv_buf_t* bufs, - size_t count, - uv_stream_t* send_handle) override; - - bool IsAlive() override; - bool IsClosing() override; - AsyncWrap* GetAsyncWrap() override; - - void MemoryInfo(MemoryTracker* tracker) const override; - SET_MEMORY_INFO_NAME(LogStream) - SET_SELF_SIZE(LogStream) - - private: - struct Chunk { - // len will be <= buf.len - size_t len; - uv_buf_t buf; - }; - size_t total_ = 0; - std::list buffer_; - bool fin_seen_ = false; - bool ended_ = false; - bool reading_ = false; - - // The value here is fairly arbitrary. Once we get everything - // fully implemented and start working with this, we might - // tune this number further. - static constexpr size_t kMaxLogStreamBuffer = 1024 * 10; - - // The LogStream buffer enforces a maximum size of kMaxLogStreamBuffer. - void ensure_space(size_t amt); -}; - -} // namespace node::quic - -#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS diff --git a/src/quic/packet.cc b/src/quic/packet.cc index f7a3f3d35d47b7..71a817e49ed5c1 100644 --- a/src/quic/packet.cc +++ b/src/quic/packet.cc @@ -127,11 +127,15 @@ Packet::Ptr Packet::CreateImmediateConnectionClosePacket( "immediate connection close (endpoint)"); if (!packet) return packet; ngtcp2_vec vec = *packet; + // ngtcp2_crypto_write_connection_close expects dcid to be the + // client's SCID and scid to be the client's DCID (mirrored). + // PathDescriptor carries the incoming packet's CIDs as-is, so + // we swap here. ssize_t nwrite = ngtcp2_crypto_write_connection_close(vec.base, vec.len, path_descriptor.version, - path_descriptor.dcid, path_descriptor.scid, + path_descriptor.dcid, reason.code(), nullptr, 0); @@ -160,9 +164,11 @@ Packet::Ptr Packet::CreateStatelessResetPacket( if (!packet) return packet; ngtcp2_vec vec = *packet; - ssize_t nwrite = ngtcp2_pkt_write_stateless_reset( + auto nwrite = ngtcp2_pkt_write_stateless_reset2( vec.base, pktlen, token, random, kRandlen); - if (nwrite <= static_cast(kMinStatelessResetLen)) return Ptr(); + if (nwrite < static_cast(kMinStatelessResetLen)) { + return Ptr(); + } packet->Truncate(static_cast(nwrite)); return packet; @@ -203,14 +209,18 @@ Packet::Ptr Packet::CreateVersionNegotiationPacket( if (!packet) return packet; ngtcp2_vec vec = *packet; + // ngtcp2_pkt_write_version_negotiation expects dcid to be the + // client's SCID and scid to be the client's DCID (mirrored). + // PathDescriptor carries the incoming packet's CIDs as-is, so + // we swap here. ssize_t nwrite = ngtcp2_pkt_write_version_negotiation(vec.base, pktlen, 0, - path_descriptor.dcid, - path_descriptor.dcid.length(), path_descriptor.scid, path_descriptor.scid.length(), + path_descriptor.dcid, + path_descriptor.dcid.length(), sv, arraysize(sv)); if (nwrite <= 0) return Ptr(); diff --git a/src/quic/packet.h b/src/quic/packet.h index 78eb51a9d6b3fa..ffeb582471333f 100644 --- a/src/quic/packet.h +++ b/src/quic/packet.h @@ -69,6 +69,15 @@ class Packet final { size_t capacity() const { return capacity_; } const SocketAddress& destination() const { return destination_; } Listener* listener() const { return listener_; } + + // Redirect the packet to a different endpoint for cross-endpoint sends + // (e.g., PATH_RESPONSE on a preferred address path). Updates the + // listener (for pending_callbacks accounting) and the destination + // (for uv_udp_send targeting). The packet data is unchanged. + void Redirect(Listener* listener, const SocketAddress& destination) { + listener_ = listener; + destination_ = destination; + } uv_udp_send_t* req() { return &req_; } operator uv_buf_t() const { diff --git a/src/quic/session.cc b/src/quic/session.cc index 4877c1789d3fa1..b53bc291c20163 100644 --- a/src/quic/session.cc +++ b/src/quic/session.cc @@ -24,11 +24,11 @@ #include "defs.h" #include "endpoint.h" #include "http3.h" -#include "logstream.h" #include "ncrypto.h" #include "packet.h" #include "preferredaddress.h" #include "session.h" +#include "session_manager.h" #include "sessionticket.h" #include "streams.h" #include "tlscontext.h" @@ -40,6 +40,7 @@ using v8::Array; using v8::ArrayBufferView; using v8::BigInt; using v8::Boolean; +using v8::FunctionCallbackInfo; using v8::HandleScope; using v8::Int32; using v8::Integer; @@ -49,6 +50,7 @@ using v8::LocalVector; using v8::Maybe; using v8::MaybeLocal; using v8::Nothing; +using v8::Number; using v8::Object; using v8::ObjectTemplate; using v8::String; @@ -57,11 +59,70 @@ using v8::Value; namespace quic { +// Listener flags are packed into a single uint32_t bitfield to reduce +// the size of the shared state buffer. Each bit indicates whether a +// corresponding JS callback is registered. +enum class SessionListenerFlags : uint32_t { + PATH_VALIDATION = 1 << 0, + DATAGRAM = 1 << 1, + DATAGRAM_STATUS = 1 << 2, + SESSION_TICKET = 1 << 3, + NEW_TOKEN = 1 << 4, + ORIGIN = 1 << 5, +}; + +inline SessionListenerFlags operator|(SessionListenerFlags a, + SessionListenerFlags b) { + return static_cast(static_cast(a) | + static_cast(b)); +} + +inline SessionListenerFlags operator&(SessionListenerFlags a, + SessionListenerFlags b) { + return static_cast(static_cast(a) & + static_cast(b)); +} + +inline SessionListenerFlags operator&(uint32_t a, SessionListenerFlags b) { + return static_cast(a & static_cast(b)); +} + +inline bool operator!(SessionListenerFlags a) { + return static_cast(a) == 0; +} + +inline bool HasListenerFlag(uint32_t flags, SessionListenerFlags flag) { + return !!(flags & flag); +} + +// Compute the maximum datagram payload that fits within the peer's +// max_datagram_frame_size transport parameter. The DATAGRAM frame has +// overhead of 1 byte (frame type) + variable-length integer encoding +// of the payload length. This mirrors the check in ngtcp2's +// ngtcp2_pkt_datagram_framelen (1 + varint_len(payload) + payload). +uint64_t MaxDatagramPayload(uint64_t max_frame_size) { + // A DATAGRAM frame needs at least 1 (type) + 1 (varint) + 0 (data). + if (max_frame_size < 2) return 0; + // QUIC variable-length integer encoding sizes (RFC 9000 Section 16). + auto varint_len = [](uint64_t n) -> uint64_t { + if (n < 64) return 1; + if (n < 16384) return 2; + if (n < 1073741824) return 4; + return 8; + }; + // Start with the optimistic payload assuming minimum varint (1 byte). + uint64_t payload = max_frame_size - 2; + // If the payload requires a larger varint, the overhead increases. + // Recompute with the actual varint length of the candidate payload. + uint64_t overhead = 1 + varint_len(payload); + if (overhead + payload > max_frame_size) { + payload = max_frame_size - 1 - varint_len(max_frame_size - 3); + } + return payload; +} + #define SESSION_STATE(V) \ - V(PATH_VALIDATION, path_validation, uint8_t) \ - V(VERSION_NEGOTIATION, version_negotiation, uint8_t) \ - V(DATAGRAM, datagram, uint8_t) \ - V(SESSION_TICKET, session_ticket, uint8_t) \ + V(LISTENER_FLAGS, listener_flags, uint32_t) \ V(CLOSING, closing, uint8_t) \ V(GRACEFUL_CLOSE, graceful_close, uint8_t) \ V(SILENT_CLOSE, silent_close, uint8_t) \ @@ -70,17 +131,22 @@ namespace quic { V(HANDSHAKE_CONFIRMED, handshake_confirmed, uint8_t) \ V(STREAM_OPEN_ALLOWED, stream_open_allowed, uint8_t) \ V(PRIORITY_SUPPORTED, priority_supported, uint8_t) \ + V(HEADERS_SUPPORTED, headers_supported, uint8_t) \ V(WRAPPED, wrapped, uint8_t) \ V(APPLICATION_TYPE, application_type, uint8_t) \ - V(LAST_DATAGRAM_ID, last_datagram_id, datagram_id) + V(NO_ERROR_CODE, no_error_code, error_code) \ + V(INTERNAL_ERROR_CODE, internal_error_code, error_code) \ + V(MAX_DATAGRAM_SIZE, max_datagram_size, uint16_t) \ + V(LAST_DATAGRAM_ID, last_datagram_id, datagram_id) \ + V(MAX_PENDING_DATAGRAMS, max_pending_datagrams, uint16_t) #define SESSION_STATS(V) \ V(CREATED_AT, created_at) \ + V(DESTROYED_AT, destroyed_at) \ V(CLOSING_AT, closing_at) \ V(HANDSHAKE_COMPLETED_AT, handshake_completed_at) \ V(HANDSHAKE_CONFIRMED_AT, handshake_confirmed_at) \ V(BYTES_RECEIVED, bytes_received) \ - V(BYTES_SENT, bytes_sent) \ V(BIDI_IN_STREAM_COUNT, bidi_in_stream_count) \ V(BIDI_OUT_STREAM_COUNT, bidi_out_stream_count) \ V(UNI_IN_STREAM_COUNT, uni_in_stream_count) \ @@ -94,22 +160,34 @@ namespace quic { V(RTTVAR, rttvar) \ V(SMOOTHED_RTT, smoothed_rtt) \ V(SSTHRESH, ssthresh) \ + V(PKT_SENT, pkt_sent) \ + V(BYTES_SENT, bytes_sent) \ + V(PKT_RECV, pkt_recv) \ + V(BYTES_RECV, bytes_recv) \ + V(PKT_LOST, pkt_lost) \ + V(BYTES_LOST, bytes_lost) \ + V(PING_RECV, ping_recv) \ + V(PKT_DISCARDED, pkt_discarded) \ V(DATAGRAMS_RECEIVED, datagrams_received) \ V(DATAGRAMS_SENT, datagrams_sent) \ V(DATAGRAMS_ACKNOWLEDGED, datagrams_acknowledged) \ V(DATAGRAMS_LOST, datagrams_lost) +#define NO_SIDE_EFFECT true +#define SIDE_EFFECT false + #define SESSION_JS_METHODS(V) \ - V(Destroy, destroy, false) \ - V(GetRemoteAddress, getRemoteAddress, true) \ - V(GetCertificate, getCertificate, true) \ - V(GetEphemeralKeyInfo, getEphemeralKey, true) \ - V(GetPeerCertificate, getPeerCertificate, true) \ - V(GracefulClose, gracefulClose, false) \ - V(SilentClose, silentClose, false) \ - V(UpdateKey, updateKey, false) \ - V(OpenStream, openStream, false) \ - V(SendDatagram, sendDatagram, false) + V(Destroy, destroy, SIDE_EFFECT) \ + V(GetRemoteAddress, getRemoteAddress, NO_SIDE_EFFECT) \ + V(GetLocalAddress, getLocalAddress, NO_SIDE_EFFECT) \ + V(GetCertificate, getCertificate, NO_SIDE_EFFECT) \ + V(GetEphemeralKeyInfo, getEphemeralKey, NO_SIDE_EFFECT) \ + V(GetPeerCertificate, getPeerCertificate, NO_SIDE_EFFECT) \ + V(GracefulClose, gracefulClose, SIDE_EFFECT) \ + V(SilentClose, silentClose, SIDE_EFFECT) \ + V(UpdateKey, updateKey, SIDE_EFFECT) \ + V(OpenStream, openStream, SIDE_EFFECT) \ + V(SendDatagram, sendDatagram, SIDE_EFFECT) struct Session::State final { #define V(_, name, type) type name; @@ -191,11 +269,12 @@ void on_qlog_write(void* user_data, uint32_t flags, const void* data, size_t len) { - static_cast(user_data)->HandleQlog(flags, data, len); + static_cast(user_data)->EmitQlog( + flags, std::string_view(static_cast(data), len)); } // Forwards detailed(verbose) debugging information from ngtcp2. Enabled using -// the NODE_DEBUG_NATIVE=NGTCP2_DEBUG category. +// the NODE_DEBUG_NATIVE=NGTCP2 category. void ngtcp2_debug_log(void* user_data, const char* fmt, ...) { va_list ap; va_start(ap, fmt); @@ -203,7 +282,9 @@ void ngtcp2_debug_log(void* user_data, const char* fmt, ...) { format[strlen(fmt)] = '\n'; // Debug() does not work with the va_list here. So we use vfprintf // directly instead. Ngtcp2DebugLog is only enabled when the debug - // category is enabled. + // category is enabled. The thread ID prefix helps distinguish output + // from concurrent sessions across worker threads. + fprintf(stderr, "ngtcp2 "); vfprintf(stderr, format.c_str(), ap); va_end(ap); } @@ -296,6 +377,31 @@ bool SetOption(Environment* env, return true; } +template +bool SetOption(Environment* env, + Opt* options, + const v8::Local& object, + const v8::Local& name) { + v8::Local value; + if (!object->Get(env->context(), name).ToLocal(&value)) return false; + if (!value->IsUndefined()) { + if (!value->IsUint32()) { + Utf8Value nameStr(env->isolate(), name); + THROW_ERR_INVALID_ARG_VALUE( + env, "The %s option must be an uint8", *nameStr); + return false; + } + uint32_t val = value.As()->Value(); + if (val > 255) { + Utf8Value nameStr(env->isolate(), name); + THROW_ERR_INVALID_ARG_VALUE( + env, "The %s option must be <= 255", *nameStr); + return false; + } + options->*member = static_cast(val); + } + return true; +} } // namespace // ============================================================================ @@ -319,6 +425,20 @@ Session::Config::Config(Environment* env, ngtcp2_settings_default(&settings); settings.initial_ts = uv_hrtime(); + // Advertise all versions ngtcp2 supports for compatible version + // negotiation (RFC 9368). The preferred list orders the newest + // version first so that negotiation upgrades when possible. The + // initial packet version (options.version) defaults to V1 for + // maximum compatibility with peers that don't support version + // negotiation. + static const uint32_t kSupportedVersions[] = {NGTCP2_PROTO_VER_V2, + NGTCP2_PROTO_VER_V1}; + + settings.preferred_versions = kSupportedVersions; + settings.preferred_versionslen = std::size(kSupportedVersions); + settings.available_versions = kSupportedVersions; + settings.available_versionslen = std::size(kSupportedVersions); + // TODO(@jasnell): Path MTU Discovery is disabled because libuv does not // currently expose the IP_DONTFRAG / IP_MTU_DISCOVER socket options // needed for PMTUD probes to work correctly. Revisit when libuv adds @@ -340,7 +460,7 @@ Session::Config::Config(Environment* env, settings.qlog_write = on_qlog_write; } - if (env->enabled_debug_list()->enabled(DebugCategory::NGTCP2_DEBUG)) { + if (env->enabled_debug_list()->enabled(DebugCategory::NGTCP2)) { settings.log_printf = ngtcp2_debug_log; } @@ -436,14 +556,38 @@ Maybe Session::Options::From(Environment* env, if (!SET(version) || !SET(min_version) || !SET(preferred_address_strategy) || !SET(transport_params) || !SET(tls_options) || !SET(qlog) || - !SET(handshake_timeout) || !SET(max_stream_window) || !SET(max_window) || - !SET(max_payload_size) || !SET(unacknowledged_packet_threshold) || - !SET(cc_algorithm)) { + !SET(handshake_timeout) || !SET(keep_alive_timeout) || + !SET(max_stream_window) || !SET(max_window) || !SET(max_payload_size) || + !SET(unacknowledged_packet_threshold) || !SET(cc_algorithm) || + !SET(draining_period_multiplier) || !SET(max_datagram_send_attempts)) { return Nothing(); } #undef SET + // RFC 9000 Section 10.2 requires the draining period to be at least 3x PTO. + static const uint8_t kMinDrainingPeriodMultiplier = 3; + options.draining_period_multiplier = std::max( + options.draining_period_multiplier, kMinDrainingPeriodMultiplier); + + // At least 1 send attempt is required. + options.max_datagram_send_attempts = + std::max(options.max_datagram_send_attempts, static_cast(1)); + + // Parse the datagram drop policy from a string option. + { + Local policy_val; + if (params->Get(env->context(), state.datagram_drop_policy_string()) + .ToLocal(&policy_val) && + !policy_val->IsUndefined()) { + Utf8Value policy_str(env->isolate(), policy_val); + if (strcmp(*policy_str, "drop-newest") == 0) { + options.datagram_drop_policy = DatagramDropPolicy::DROP_NEWEST; + } + // Default is DROP_OLDEST, no need to check for "drop-oldest". + } + } + // Parse the application-specific options (HTTP/3 qpack settings, etc.). // These are used if the negotiated ALPN selects Http3ApplicationImpl. { @@ -552,10 +696,13 @@ std::string Session::Options::ToString() const { // ngtcp2 static callback functions // Utility used only within Session::Impl to reduce boilerplate +// Resolves the Session* from ngtcp2 callback arguments. The +// NgTcp2CallbackScope is NOT created here — it is placed at the +// ngtcp2 entry points (Receive, OnTimeout) so that the deferred +// destroy only fires after all callbacks for that call have completed. #define NGTCP2_CALLBACK_SCOPE(name) \ auto name = Impl::From(conn, user_data); \ - if (name == nullptr) return NGTCP2_ERR_CALLBACK_FAILURE; \ - NgTcp2CallbackScope scope(name->env()); + if (name == nullptr) return NGTCP2_ERR_CALLBACK_FAILURE; // Session::Impl maintains most of the internal state of an active Session. struct Session::Impl final : public MemoryRetainer { @@ -571,9 +718,24 @@ struct Session::Impl final : public MemoryRetainer { TimerWrapHandle timer_; size_t send_scope_depth_ = 0; QuicError last_error_; + + // Datagrams queued for sending. Serialized into packets by + // SendPendingData alongside stream data. + std::deque pending_datagrams_; PendingStream::PendingStreamQueue pending_bidi_stream_queue_; PendingStream::PendingStreamQueue pending_uni_stream_queue_; + // Session ticket app data parsed before ALPN negotiation. + // Validated and applied in SetApplication() after ALPN selects + // the application type. + std::optional pending_ticket_data_; + + // When true, the handshake is deferred until the first stream or + // datagram is sent. This is set for client sessions with a session + // ticket, enabling 0-RTT: the first send triggers the handshake + // and the stream/datagram data is included in the 0-RTT flight. + bool handshake_deferred_ = false; + Impl(Session* session, Endpoint* endpoint, const Config& config) : session_(session), stats_(env()->isolate()), @@ -589,42 +751,6 @@ struct Session::Impl final : public MemoryRetainer { inline bool is_closing() const { return state_->closing; } - /** - * @returns {boolean} Returns true if the Session can be destroyed - * immediately. - */ - bool Close() { - if (state_->closing) return true; - state_->closing = 1; - STAT_RECORD_TIMESTAMP(Stats, closing_at); - - // Iterate through all of the known streams and close them. The streams - // will remove themselves from the Session as soon as they are closed. - // Note: we create a copy because the streams will remove themselves - // while they are cleaning up which will invalidate the iterator. - StreamsMap streams = streams_; - for (auto& stream : streams) stream.second->Destroy(last_error_); - DCHECK(streams.empty()); - - // Clear the pending streams. - while (!pending_bidi_stream_queue_.IsEmpty()) { - pending_bidi_stream_queue_.PopFront()->reject(last_error_); - } - while (!pending_uni_stream_queue_.IsEmpty()) { - pending_uni_stream_queue_.PopFront()->reject(last_error_); - } - - // If we are able to send packets, we should try sending a connection - // close packet to the remote peer. - if (!state_->silent_close) { - session_->SendConnectionClose(); - } - - timer_.Close(); - - return !state_->wrapped; - } - ~Impl() { // Ensure that Close() was called before dropping DCHECK(is_closing()); @@ -640,9 +766,9 @@ struct Session::Impl final : public MemoryRetainer { ngtcp2_conn_get_scid(*session_, nullptr)); ngtcp2_conn_get_scid(*session_, cids.out()); - MaybeStackBuffer tokens( - ngtcp2_conn_get_active_dcid(*session_, nullptr)); - ngtcp2_conn_get_active_dcid(*session_, tokens.out()); + MaybeStackBuffer tokens( + ngtcp2_conn_get_active_dcid2(*session_, nullptr)); + ngtcp2_conn_get_active_dcid2(*session_, tokens.out()); endpoint->DisassociateCID(config_.dcid); endpoint->DisassociateCID(config_.preferred_address_cid); @@ -654,7 +780,7 @@ struct Session::Impl final : public MemoryRetainer { for (size_t n = 0; n < tokens.length(); n++) { if (tokens[n].token_present) { endpoint->DisassociateStatelessResetToken( - StatelessResetToken(tokens[n].token)); + StatelessResetToken(&tokens[n].token)); } } @@ -692,6 +818,86 @@ struct Session::Impl final : public MemoryRetainer { // TODO(@jasnell): Fast API alternatives for each of these + // Parse optional close error code options: { code, type, reason } + // Returns true on success (including when no options were provided). + // Returns false on validation error (exception thrown). + // Sets *did_set to true if an error code was actually applied. + static bool MaybeSetCloseError(const FunctionCallbackInfo& args, + int options_index, + Session* session, + bool* did_set = nullptr) { + if (did_set) *did_set = false; + auto env = Environment::GetCurrent(args); + if (args.Length() <= options_index || args[options_index]->IsUndefined()) { + return true; + } + if (!args[options_index]->IsObject()) { + THROW_ERR_INVALID_ARG_TYPE(env, "options must be an object"); + return false; + } + auto options = args[options_index].As(); + auto& state = BindingData::Get(env); + auto context = env->context(); + + // code: bigint (optional) + Local code_val; + if (!options->Get(context, state.code_string()).ToLocal(&code_val)) { + return false; + } + if (code_val->IsUndefined()) return true; + + uint64_t code; + if (code_val->IsBigInt()) { + bool lossless; + code = code_val.As()->Uint64Value(&lossless); + if (!lossless) { + THROW_ERR_INVALID_ARG_VALUE(env, "options.code is too large"); + return false; + } + } else if (code_val->IsNumber()) { + code = static_cast(code_val.As()->Value()); + } else { + THROW_ERR_INVALID_ARG_TYPE(env, + "options.code must be a bigint or number"); + return false; + } + + // type: string (optional, default 'transport') + Local type_val; + if (!options->Get(context, state.type_string()).ToLocal(&type_val)) { + return false; + } + bool is_application = false; + if (!type_val->IsUndefined()) { + if (type_val->StrictEquals(state.application_string())) { + is_application = true; + } else if (!type_val->StrictEquals(state.transport_string())) { + THROW_ERR_INVALID_ARG_VALUE( + env, "options.type must be 'transport' or 'application'"); + return false; + } + } + + // reason: string (optional) + std::string reason; + Local reason_val; + if (!options->Get(context, state.reason_string()).ToLocal(&reason_val)) { + return false; + } + if (!reason_val->IsUndefined()) { + Utf8Value reason_str(env->isolate(), reason_val); + reason = std::string(*reason_str, reason_str.length()); + } + + if (is_application) { + session->SetLastError(QuicError::ForApplication(code, std::move(reason))); + } else { + session->SetLastError(QuicError::ForTransport(code, std::move(reason))); + } + if (did_set) *did_set = true; + return true; + } + JS_METHOD(Destroy) { auto env = Environment::GetCurrent(args); Session* session; @@ -703,6 +909,15 @@ struct Session::Impl final : public MemoryRetainer { // as we strictly enforce it here. return THROW_ERR_INVALID_STATE(env, "Session is destroyed"); } + // args[0] is the optional close error options object. + bool has_close_options = false; + if (!MaybeSetCloseError(args, 0, session, &has_close_options)) return; + // If an error code was provided by the caller, send CONNECTION_CLOSE + // with that code before destroying. SendConnectionClose writes the + // packet and hands it to the endpoint — it doesn't wait for ack. + if (has_close_options) { + session->SendConnectionClose(); + } session->Destroy(); } @@ -721,6 +936,21 @@ struct Session::Impl final : public MemoryRetainer { ->object()); } + JS_METHOD(GetLocalAddress) { + auto env = Environment::GetCurrent(args); + Session* session; + ASSIGN_OR_RETURN_UNWRAP(&session, args.This()); + + if (session->is_destroyed()) { + return THROW_ERR_INVALID_STATE(env, "Session is destroyed"); + } + + auto address = session->local_address(); + args.GetReturnValue().Set( + SocketAddressBase::Create(env, std::make_shared(address)) + ->object()); + } + JS_METHOD(GetCertificate) { auto env = Environment::GetCurrent(args); Session* session; @@ -773,6 +1003,8 @@ struct Session::Impl final : public MemoryRetainer { return THROW_ERR_INVALID_STATE(env, "Session is destroyed"); } + // args[0] is the optional close error options object. + if (!MaybeSetCloseError(args, 0, session)) return; session->Close(CloseMethod::GRACEFUL); } @@ -819,11 +1051,12 @@ struct Session::Impl final : public MemoryRetainer { // GetDataQueueFromSource handles type validation. std::shared_ptr data_source; - if (!Stream::GetDataQueueFromSource(env, args[1]).To(&data_source) || - data_source == nullptr) [[unlikely]] { - THROW_ERR_INVALID_ARG_VALUE(env, "Invalid data source"); + if (!Stream::GetDataQueueFromSource(env, args[1]).To(&data_source)) + [[unlikely]] { + return THROW_ERR_INVALID_ARG_VALUE(env, "Invalid data source"); } + session->impl_->handshake_deferred_ = false; SendPendingDataScope send_scope(session); auto direction = FromV8Value(args[0]); Local stream; @@ -843,6 +1076,7 @@ struct Session::Impl final : public MemoryRetainer { } DCHECK(args[0]->IsArrayBufferView()); + session->impl_->handshake_deferred_ = false; SendPendingDataScope send_scope(session); Store store; @@ -888,7 +1122,7 @@ struct Session::Impl final : public MemoryRetainer { ngtcp2_connection_id_status_type type, uint64_t seq, const ngtcp2_cid* cid, - const uint8_t* token, + const ngtcp2_stateless_reset_token* token, void* user_data) { NGTCP2_CALLBACK_SCOPE(session) std::optional maybe_reset_token; @@ -896,7 +1130,6 @@ struct Session::Impl final : public MemoryRetainer { auto& endpoint = session->endpoint(); switch (type) { case NGTCP2_CONNECTION_ID_STATUS_TYPE_ACTIVATE: { - endpoint.AssociateCID(session->config().scid, CID(cid)); if (token != nullptr) { endpoint.AssociateStatelessResetToken(StatelessResetToken(token), session); @@ -904,7 +1137,6 @@ struct Session::Impl final : public MemoryRetainer { break; } case NGTCP2_CONNECTION_ID_STATUS_TYPE_DEACTIVATE: { - endpoint.DisassociateCID(CID(cid)); if (token != nullptr) { endpoint.DisassociateStatelessResetToken(StatelessResetToken(token)); } @@ -953,14 +1185,15 @@ struct Session::Impl final : public MemoryRetainer { void* user_data, void* stream_user_data) { NGTCP2_CALLBACK_SCOPE(session) - session->application().ExtendMaxStreamData(Stream::From(stream_user_data), - max_data); + if (auto* stream = Stream::From(stream_user_data)) { + session->application().ExtendMaxStreamData(stream, max_data); + } return NGTCP2_SUCCESS; } static int on_get_new_cid(ngtcp2_conn* conn, ngtcp2_cid* cid, - uint8_t* token, + ngtcp2_stateless_reset_token* token, size_t cidlen, void* user_data) { NGTCP2_CALLBACK_SCOPE(session) @@ -1047,6 +1280,10 @@ struct Session::Impl final : public MemoryRetainer { if (level != NGTCP2_ENCRYPTION_LEVEL_1RTT) return NGTCP2_SUCCESS; + // If the application was already started via on_receive_tx_key + // (0-RTT path), this is a no-op. + if (session->application().is_started()) return NGTCP2_SUCCESS; + Debug(session, "Receiving RX key for level %s for dcid %s", to_string(level), @@ -1057,9 +1294,16 @@ struct Session::Impl final : public MemoryRetainer { } static int on_receive_stateless_reset(ngtcp2_conn* conn, - const ngtcp2_pkt_stateless_reset* sr, + const ngtcp2_pkt_stateless_reset2* sr, void* user_data) { NGTCP2_CALLBACK_SCOPE(session) + Debug(session, "Received stateless reset from peer"); + // This callback is informational. ngtcp2 has already set the + // connection state to NGTCP2_CS_DRAINING before invoking this + // callback, and ngtcp2_conn_read_pkt will return + // NGTCP2_ERR_DRAINING. The actual close handling happens in + // Session::Receive when it processes that return value and + // checks this flag. session->impl_->state_->stateless_reset = 1; return NGTCP2_SUCCESS; } @@ -1107,9 +1351,22 @@ struct Session::Impl final : public MemoryRetainer { ngtcp2_encryption_level level, void* user_data) { NGTCP2_CALLBACK_SCOPE(session); - CHECK(session->is_server()); - if (level != NGTCP2_ENCRYPTION_LEVEL_1RTT) return NGTCP2_SUCCESS; + // For SERVER: fires at 1RTT — start the application after handshake. + // For CLIENT: fires at 0RTT — start the application early so that + // HTTP/3 control/QPACK streams are bound before 0-RTT requests. + // Without this, nghttp3_conn_submit_request asserts because the + // QPACK encoder stream isn't bound yet. + if (session->is_server()) { + if (level != NGTCP2_ENCRYPTION_LEVEL_1RTT) return NGTCP2_SUCCESS; + } else { + if (level != NGTCP2_ENCRYPTION_LEVEL_0RTT) return NGTCP2_SUCCESS; + } + + // application_ may be null if ALPN selection hasn't happened yet + // (e.g., ALPN mismatch causes the handshake to fail during key + // installation). Without an application, we can't start. + if (!session->impl_->application_) return NGTCP2_ERR_CALLBACK_FAILURE; Debug(session, "Receiving TX key for level %s for dcid %s", @@ -1154,12 +1411,21 @@ struct Session::Impl final : public MemoryRetainer { void* user_data, void* stream_user_data) { NGTCP2_CALLBACK_SCOPE(session) + auto* stream = Stream::From(stream_user_data); + if (stream == nullptr) return NGTCP2_SUCCESS; if (flags & NGTCP2_STREAM_CLOSE_FLAG_APP_ERROR_CODE_SET) { - session->application().StreamClose( - Stream::From(stream_user_data), - QuicError::ForApplication(app_error_code)); + session->application().ReceiveStreamClose( + stream, QuicError::ForApplication(app_error_code)); } else { - session->application().StreamClose(Stream::From(stream_user_data)); + session->application().ReceiveStreamClose(stream); + } + return NGTCP2_SUCCESS; + } + + static int on_stream_open(ngtcp2_conn* conn, stream_id id, void* user_data) { + NGTCP2_CALLBACK_SCOPE(session) + if (!session->application().ReceiveStreamOpen(id)) { + return NGTCP2_ERR_CALLBACK_FAILURE; } return NGTCP2_SUCCESS; } @@ -1171,10 +1437,10 @@ struct Session::Impl final : public MemoryRetainer { void* user_data, void* stream_user_data) { NGTCP2_CALLBACK_SCOPE(session) - session->application().StreamReset( - Stream::From(stream_user_data), - final_size, - QuicError::ForApplication(app_error_code)); + auto* stream = Stream::From(stream_user_data); + if (stream == nullptr) return NGTCP2_SUCCESS; + session->application().ReceiveStreamReset( + stream, final_size, QuicError::ForApplication(app_error_code)); return NGTCP2_SUCCESS; } @@ -1184,9 +1450,10 @@ struct Session::Impl final : public MemoryRetainer { void* user_data, void* stream_user_data) { NGTCP2_CALLBACK_SCOPE(session) - session->application().StreamStopSending( - Stream::From(stream_user_data), - QuicError::ForApplication(app_error_code)); + auto* stream = Stream::From(stream_user_data); + if (stream == nullptr) return NGTCP2_SUCCESS; + session->application().ReceiveStreamStopSending( + stream, QuicError::ForApplication(app_error_code)); return NGTCP2_SUCCESS; } @@ -1200,6 +1467,9 @@ struct Session::Impl final : public MemoryRetainer { auto session = Impl::From(conn, user_data); if (session == nullptr) return NGTCP2_ERR_CALLBACK_FAILURE; Debug(session, "Early data was rejected"); + if (session->impl_->application_) { + session->application().EarlyDataRejected(); + } return NGTCP2_SUCCESS; } @@ -1224,14 +1494,14 @@ struct Session::Impl final : public MemoryRetainer { ngtcp2_crypto_hp_mask_cb, on_receive_stream_data, on_acknowledge_stream_data_offset, - nullptr, + on_stream_open, on_stream_close, - on_receive_stateless_reset, + nullptr, // recv_stateless_reset (deprecated, use v2 below) ngtcp2_crypto_recv_retry_cb, on_extend_max_streams_bidi, on_extend_max_streams_uni, on_rand, - on_get_new_cid, + nullptr, // get_new_connection_id (deprecated, use v2 below) on_remove_connection_id, ngtcp2_crypto_update_key_cb, on_path_validation, @@ -1240,7 +1510,7 @@ struct Session::Impl final : public MemoryRetainer { on_extend_max_remote_streams_bidi, on_extend_max_remote_streams_uni, on_extend_max_stream_data, - on_cid_status, + nullptr, // dcid_status (deprecated, use v2 below) on_handshake_confirmed, on_receive_new_token, ngtcp2_crypto_delete_crypto_aead_ctx_cb, @@ -1248,13 +1518,17 @@ struct Session::Impl final : public MemoryRetainer { on_receive_datagram, on_acknowledge_datagram, on_lost_datagram, - ngtcp2_crypto_get_path_challenge_data_cb, + nullptr, // get_path_challenge_data (deprecated, use v2 below) on_stream_stop_sending, ngtcp2_crypto_version_negotiation_cb, on_receive_rx_key, - nullptr, + on_receive_tx_key, on_early_data_rejected, - on_begin_path_validation}; + on_begin_path_validation, + on_receive_stateless_reset, + on_get_new_cid, + on_cid_status, + ngtcp2_crypto_get_path_challenge_data2_cb}; static constexpr ngtcp2_callbacks SERVER = { nullptr, @@ -1267,14 +1541,14 @@ struct Session::Impl final : public MemoryRetainer { ngtcp2_crypto_hp_mask_cb, on_receive_stream_data, on_acknowledge_stream_data_offset, - nullptr, + on_stream_open, on_stream_close, - on_receive_stateless_reset, + nullptr, // recv_stateless_reset (deprecated, use v2 below) nullptr, on_extend_max_streams_bidi, on_extend_max_streams_uni, on_rand, - on_get_new_cid, + nullptr, // get_new_connection_id (deprecated, use v2 below) on_remove_connection_id, ngtcp2_crypto_update_key_cb, on_path_validation, @@ -1283,7 +1557,7 @@ struct Session::Impl final : public MemoryRetainer { on_extend_max_remote_streams_bidi, on_extend_max_remote_streams_uni, on_extend_max_stream_data, - on_cid_status, + nullptr, // dcid_status (deprecated, use v2 below) nullptr, nullptr, ngtcp2_crypto_delete_crypto_aead_ctx_cb, @@ -1291,13 +1565,17 @@ struct Session::Impl final : public MemoryRetainer { on_receive_datagram, on_acknowledge_datagram, on_lost_datagram, - ngtcp2_crypto_get_path_challenge_data_cb, + nullptr, // get_path_challenge_data (deprecated, use v2 below) on_stream_stop_sending, ngtcp2_crypto_version_negotiation_cb, nullptr, on_receive_tx_key, on_early_data_rejected, - on_begin_path_validation}; + on_begin_path_validation, + on_receive_stateless_reset, + on_get_new_cid, + on_cid_status, + ngtcp2_crypto_get_path_challenge_data2_cb}; }; #undef NGTCP2_CALLBACK_SCOPE @@ -1312,13 +1590,18 @@ Session::SendPendingDataScope::SendPendingDataScope(Session* session) Session::SendPendingDataScope::SendPendingDataScope( const BaseObjectPtr& session) - : SendPendingDataScope(session.get()) {} + : session(session.get()) { + CHECK_NOT_NULL(session); + CHECK(!session->is_destroyed()); + ++session->impl_->send_scope_depth_; +} Session::SendPendingDataScope::~SendPendingDataScope() { if (session->is_destroyed()) return; DCHECK_GE(session->impl_->send_scope_depth_, 1); + Debug(session, "Send Scope Depth %zu", session->impl_->send_scope_depth_); if (--session->impl_->send_scope_depth_ == 0 && - session->impl_->application_) { + session->impl_->application_ && !session->impl_->handshake_deferred_) { session->application().SendPendingData(); } } @@ -1341,11 +1624,15 @@ Session::Session(Endpoint* endpoint, const std::optional& session_ticket) : AsyncWrap(endpoint->env(), object, PROVIDER_QUIC_SESSION), side_(config.side), - allocator_(BindingData::Get(env())), + allocator_(BindingData::Get(env()).ngtcp2_allocator()), impl_(std::make_unique(this, endpoint, config)), connection_(InitConnection()), tls_session_(tls_context->NewSession(this, session_ticket)) { DCHECK(impl_); + { + auto& stats_ = impl_->stats_; + STAT_RECORD_TIMESTAMP(Stats, created_at); + } // For clients, select the Application immediately — the ALPN is // known upfront from the options. For servers, application_ stays @@ -1356,6 +1643,21 @@ Session::Session(Endpoint* endpoint, if (app) SetApplication(std::move(app)); } + // For client sessions with a session ticket and early data enabled, + // defer the handshake until the first stream or datagram is sent. + // This enables 0-RTT: the stream/datagram data is included in the + // first flight alongside the ClientHello. When early data is + // disabled, the handshake starts immediately (no 0-RTT attempt). + if (config.side == Side::CLIENT && session_ticket.has_value() && + config.options.tls_options.enable_early_data) { + impl_->handshake_deferred_ = true; + } + + if (config.options.keep_alive_timeout > 0) { + ngtcp2_conn_set_keep_alive_timeout( + *this, config.options.keep_alive_timeout * NGTCP2_MILLISECONDS); + } + MakeWeak(); Debug(this, "Session created."); auto& binding = BindingData::Get(env()); @@ -1365,18 +1667,6 @@ Session::Session(Endpoint* endpoint, JS_DEFINE_READONLY_PROPERTY( env(), object, env()->state_string(), impl_->state_.GetArrayBuffer()); - if (config.options.qlog) [[unlikely]] { - qlog_stream_ = LogStream::Create(env()); - JS_DEFINE_READONLY_PROPERTY( - env(), object, binding.qlog_string(), qlog_stream_->object()); - } - - if (config.options.tls_options.keylog) [[unlikely]] { - keylog_stream_ = LogStream::Create(env()); - JS_DEFINE_READONLY_PROPERTY( - env(), object, binding.keylog_string(), keylog_stream_->object()); - } - UpdateDataStats(); } @@ -1407,7 +1697,7 @@ Session::QuicConnectionPointer Session::InitConnection() { &Impl::SERVER, &config().settings, transport_params, - &allocator_, + allocator_, this), 0); break; @@ -1421,7 +1711,7 @@ Session::QuicConnectionPointer Session::InitConnection() { &Impl::CLIENT, &config().settings, transport_params, - &allocator_, + allocator_, this), 0); break; @@ -1439,7 +1729,7 @@ bool Session::is_server() const { } bool Session::is_destroyed() const { - return !impl_; + return !impl_ || destroy_deferred_; } bool Session::is_destroyed_or_closing() const { @@ -1450,6 +1740,14 @@ void Session::Close(CloseMethod method) { if (is_destroyed()) return; auto& stats_ = impl_->stats_; + // If the handshake was deferred (0-RTT client that never sent), + // no packets were ever transmitted. Close silently since there is + // nothing to communicate to the peer. + if (impl_->handshake_deferred_) { + impl_->handshake_deferred_ = false; + method = CloseMethod::SILENT; + } + if (impl_->last_error_) { Debug(this, "Closing with error: %s", impl_->last_error_); } @@ -1480,19 +1778,62 @@ void Session::Close(CloseMethod method) { return FinishClose(); } case CloseMethod::GRACEFUL: { - // If there are no open streams, then we can close just immediately and + // If we are already closing gracefully, do nothing. + if (impl_->state_->graceful_close) [[unlikely]] { + return; + } + impl_->state_->graceful_close = 1; + + // application_ may be null for server sessions if close() is called + // before the TLS handshake selects the ALPN. Without an application + // we cannot do a graceful shutdown (GOAWAY, CONNECTION_CLOSE etc.), + // so fall through to a silent close. + if (!impl_->application_) { + impl_->state_->silent_close = 1; + return FinishClose(); + } + + // The SendPendingDataScope ensures that the GOAWAY packet queued + // by BeginShutdown is actually sent. Without it, the GOAWAY sits + // in nghttp3's outq until the next Receive() triggers a send. + SendPendingDataScope send_scope(this); + + // Signal application-level graceful shutdown (e.g., HTTP/3 GOAWAY). + // BeginShutdown can trigger callbacks that re-enter JS and destroy + // this session, so check is_destroyed() after it returns. + application().BeginShutdown(); + if (is_destroyed()) return; + + // If there are no open streams, then we can close immediately and // not worry about waiting around. if (impl_->streams_.empty()) { impl_->state_->silent_close = 0; - impl_->state_->graceful_close = 0; return FinishClose(); } - // If we are already closing gracefully, do nothing. - if (impl_->state_->graceful_close) [[unlikely]] { - return; + // Shut down the writable side of streams whose readable side is + // already ended (e.g., peer called resetStream or sent FIN). Without + // this, such half-closed streams will never fire on_stream_close and + // the graceful close hangs. Streams still actively receiving data + // are left alone to complete naturally. + // + // When the application manages stream FIN (HTTP/3), skip this — a + // writable stream with a closed read side is the normal request/ + // response pattern (server received full request, still sending + // response). The application protocol handles stream completion. + if (!application().stream_fin_managed_by_application()) { + Session::SendPendingDataScope send_scope(this); + for (auto& [id, stream] : impl_->streams_) { + if (stream->is_writable() && !stream->is_readable()) { + stream->EndWritable(); + ngtcp2_conn_shutdown_stream_write(*this, 0, id, 0); + } + } } - impl_->state_->graceful_close = 1; + // The SendPendingDataScope destructor can trigger callbacks that + // re-enter JS and destroy this session. + if (is_destroyed()) return; + Debug(this, "Gracefully closing session (waiting on %zu streams)", impl_->streams_.size()); @@ -1504,37 +1845,81 @@ void Session::Close(CloseMethod method) { void Session::FinishClose() { // FinishClose() should be called only after, and as a result of, Close() - // being called first. - DCHECK(!is_destroyed()); + // being called first. However, re-entrancy through MakeCallback or timer + // callbacks can cause impl_ to be destroyed at any point during this + // method. We must check is_destroyed() after every operation that could + // trigger MakeCallback (stream destruction, pending queue rejection, + // SendConnectionClose, EmitClose). + if (is_destroyed()) return; DCHECK(impl_->state_->closing); - // If impl_->Close() returns true, then the session can be destroyed - // immediately without round-tripping through JavaScript. - if (impl_->Close()) { - return Destroy(); + // Clear the graceful_close flag to prevent RemoveStream() from + // re-entering FinishClose() when we destroy streams below. + impl_->state_->graceful_close = 0; + + // Destroy all open streams immediately. We copy the map because + // streams remove themselves during destruction. Each Destroy() call + // triggers MakeCallback which can destroy impl_ via JS re-entrancy. + StreamsMap streams = impl_->streams_; + for (auto& stream : streams) { + if (is_destroyed()) return; + stream.second->Destroy(impl_->last_error_); } + if (is_destroyed()) return; + + // Clear pending stream queues. + while (!impl_->pending_bidi_stream_queue_.IsEmpty()) { + impl_->pending_bidi_stream_queue_.PopFront()->reject(impl_->last_error_); + } + while (!impl_->pending_uni_stream_queue_.IsEmpty()) { + impl_->pending_uni_stream_queue_.PopFront()->reject(impl_->last_error_); + } + + // Send final application-level shutdown and CONNECTION_CLOSE + // unless this is a silent close. + if (!impl_->state_->silent_close) { + if (impl_->application_) { + application().CompleteShutdown(); + } + SendConnectionClose(); + } + if (is_destroyed()) return; + + impl_->timer_.Close(); - // Otherwise, we emit a close callback so that the JavaScript side can - // clean up anything it needs to clean up before destroying. - EmitClose(); + // If the session was passed to JavaScript, we need to round-trip + // through JS so it can clean up before we destroy. The JS side + // will synchronously call destroy(), which calls Session::Destroy(). + if (impl_->state_->wrapped) { + EmitClose(impl_->last_error_); + } else { + Destroy(); + } } void Session::Destroy() { - // Destroy() should be called only after, and as a result of, Close() - // being called first. DCHECK(impl_); - DCHECK(impl_->state_->closing); + // Ensure the closing flag is set for the ~Impl() DCHECK. Normally + // this is set by Session::Close(), but JS destroy() can be called + // directly without going through Close() first. + impl_->state_->closing = 1; + + // If we're inside a ngtcp2 or nghttp3 callback scope, we cannot + // destroy impl_ now because the callback is executing methods on + // objects owned by impl_ (e.g., the Application). Defer the + // destruction until the scope exits. + if (in_ngtcp2_callback_scope_ || in_nghttp3_callback_scope_) { + Debug(this, "Session destroy deferred (in callback scope)"); + destroy_deferred_ = true; + return; + } + Debug(this, "Session destroyed"); - impl_.reset(); - if (qlog_stream_ || keylog_stream_) { - env()->SetImmediate( - [qlog = qlog_stream_, keylog = keylog_stream_](Environment*) { - if (qlog) qlog->End(); - if (keylog) keylog->End(); - }); + { + auto& stats_ = impl_->stats_; + STAT_RECORD_TIMESTAMP(Stats, destroyed_at); } - qlog_stream_.reset(); - keylog_stream_.reset(); + impl_.reset(); } PendingStream::PendingStreamQueue& Session::pending_bidi_stream_queue() const { @@ -1596,7 +1981,29 @@ std::unique_ptr Session::SelectApplicationFromAlpn( void Session::SetApplication(std::unique_ptr app) { DCHECK(!impl_->application_); + // If we have pending ticket data from a session ticket that was + // parsed before ALPN negotiation, validate it against the selected + // application now. If the type doesn't match or the application + // rejects the data, the handshake will fail (application_ stays null + // and the caller returns an error). + if (impl_->pending_ticket_data_.has_value()) { + auto data = std::move(*impl_->pending_ticket_data_); + impl_->pending_ticket_data_.reset(); + if (!app->ApplySessionTicketData(data)) { + Debug(this, "Session ticket app data rejected by application"); + return; + } + } impl_->state_->application_type = static_cast(app->type()); + impl_->state_->headers_supported = static_cast( + app->SupportsHeaders() ? HeadersSupportState::SUPPORTED + : HeadersSupportState::UNSUPPORTED); + // Surface the application's "no error" and "internal error" codes via + // session state so that JS-side code (e.g. the stream writer's fail() + // path) can resolve the right wire code for the negotiated ALPN + // without duplicating the per-application table. + impl_->state_->no_error_code = app->GetNoErrorCode(); + impl_->state_->internal_error_code = app->GetInternalErrorCode(); impl_->application_ = std::move(app); } @@ -1633,20 +2040,50 @@ const Session::Options& Session::options() const { return impl_->config_.options; } -void Session::HandleQlog(uint32_t flags, const void* data, size_t len) { - DCHECK(qlog_stream_); +void Session::EmitQlog(uint32_t flags, std::string_view data) { + if (!env()->can_call_into_js()) return; + + bool fin = (flags & NGTCP2_QLOG_WRITE_FLAG_FIN) != 0; + // Fun fact... ngtcp2 does not emit the final qlog statement until the - // ngtcp2_conn object is destroyed. - std::vector buffer(len); - memcpy(buffer.data(), data, len); - Debug(this, "Emitting qlog data to the qlog stream"); - env()->SetImmediate([ptr = qlog_stream_, buffer = std::move(buffer), flags]( - Environment*) { - ptr->Emit(buffer.data(), - buffer.size(), - flags & NGTCP2_QLOG_WRITE_FLAG_FIN ? LogStream::EmitOption::FIN - : LogStream::EmitOption::NONE); - }); + // ngtcp2_conn object is destroyed. That means this method is called + // synchronously during impl_.reset() in Session::Destroy(), at which + // point is_destroyed() is true. We cannot use MakeCallback here because + // it can trigger microtask processing and re-entrancy while the + // ngtcp2_conn is mid-destruction. Defer the final chunk via SetImmediate. + if (is_destroyed()) { + auto isolate = env()->isolate(); + v8::Global recv(isolate, object()); + v8::Global cb( + isolate, BindingData::Get(env()).session_qlog_callback()); + std::string buf(data); + env()->SetImmediate([recv = std::move(recv), + cb = std::move(cb), + buf = std::move(buf), + fin](Environment* env) { + HandleScope handle_scope(env->isolate()); + auto context = env->context(); + Local argv[] = { + Undefined(env->isolate()), + Boolean::New(env->isolate(), fin), + }; + if (!ToV8Value(context, buf).ToLocal(&argv[0])) return; + USE(cb.Get(env->isolate()) + ->Call(context, recv.Get(env->isolate()), arraysize(argv), argv)); + }); + return; + } + + auto isolate = env()->isolate(); + Local argv[] = {Undefined(isolate), Boolean::New(isolate, fin)}; + if (!ToV8Value(env()->context(), data).ToLocal(&argv[0])) { + Debug(this, "Failed to convert qlog data to V8 string"); + return; + } + + Debug(this, "Emitting qlog data"); + MakeCallback( + BindingData::Get(env()).session_qlog_callback(), arraysize(argv), argv); } const TransportParams Session::local_transport_params() const { @@ -1685,18 +2122,26 @@ bool Session::Receive(Store&& store, // It is important to understand that reading the packet will cause // callback functions to be invoked, any one of which could lead to - // the Session being closed/destroyed synchronously. After calling - // ngtcp2_conn_read_pkt here, we will need to double check that the - // session is not destroyed before we try doing anything with it - // (like updating stats, sending pending data, etc). - int err = - ngtcp2_conn_read_pkt(*this, - &path, - // TODO(@jasnell): ECN pkt_info blocked on libuv - nullptr, - vec.base, - vec.len, - uv_hrtime()); + // the Session being closed/destroyed synchronously. The callback scope + // ensures that any deferred destroy waits until all callbacks for this + // packet have completed. After calling ngtcp2_conn_read_pkt here, we + // will need to double check that the session is not destroyed before + // we try doing anything with it (like updating stats, sending pending + // data, etc). + int err; + { + NgTcp2CallbackScope callback_scope(this); + err = ngtcp2_conn_read_pkt(*this, + &path, + // TODO(@jasnell): ECN pkt_info blocked on libuv + nullptr, + vec.base, + vec.len, + uv_hrtime()); + } + if (is_destroyed()) return false; + + Debug(this, "Session receiving %zu-byte packet with result %d", vec.len, err); switch (err) { case 0: { @@ -1704,6 +2149,9 @@ bool Session::Receive(Store&& store, if (!is_destroyed()) [[likely]] { auto& stats_ = impl_->stats_; STAT_INCREMENT_N(Stats, bytes_received, vec.len); + // Process deferred operations that couldn't run inside callback + // scopes (e.g., HTTP/3 GOAWAY handling that calls into JS). + application().PostReceive(); } return true; } @@ -1718,10 +2166,28 @@ bool Session::Receive(Store&& store, return false; } case NGTCP2_ERR_DRAINING: { - // Connection has entered the draining state, no further data should be - // sent. This happens when the remote peer has already sent a - // CONNECTION_CLOSE. - Debug(this, "Receiving packet failed: Session is draining"); + // Connection has entered the draining state, no further data + // should be sent. This can happen for two reasons: + // + // 1. The remote peer sent a CONNECTION_CLOSE. In this case we + // start the draining timer and let OnTimeout handle the + // close, extracting the peer's error via FromConnectionClose. + // + // 2. The remote peer sent a stateless reset. ngtcp2 set the + // draining state internally and invoked our informational + // on_receive_stateless_reset callback (which set the flag). + // There is no point in waiting for a draining period — the + // peer has no state. Close immediately with an error. + if (!is_destroyed()) [[likely]] { + if (impl_->state_->stateless_reset) { + Debug(this, "Session received stateless reset, closing"); + SetLastError(QuicError::ForNgtcp2Error(NGTCP2_ERR_DRAINING)); + Close(CloseMethod::SILENT); + } else { + Debug(this, "Session is draining, starting draining timer"); + UpdateTimer(); + } + } return false; } case NGTCP2_ERR_CLOSING: { @@ -1797,8 +2263,6 @@ void Session::Send(Packet::Ptr packet) { } Debug(this, "Session is sending %s", packet->ToString()); - auto& stats_ = impl_->stats_; - STAT_INCREMENT_N(Stats, bytes_sent, packet->length()); endpoint().Send(std::move(packet)); } @@ -1806,6 +2270,31 @@ void Session::Send(Packet::Ptr packet, const PathStorage& path) { DCHECK(!is_destroyed()); DCHECK(!is_in_draining_period()); UpdatePath(path); + + // Check if ngtcp2 wants this packet sent on a different path than the + // primary endpoint. This happens during path validation for preferred + // address or connection migration — e.g., a PATH_RESPONSE needs to be + // sent from the preferred address endpoint, not the primary. + if (path.path.local.addrlen > 0) { + SocketAddress local_addr(path.path.local.addr); + auto& mgr = BindingData::Get(env()).session_manager(); + Endpoint* target = mgr.FindEndpointForAddress(local_addr); + if (target != nullptr && target != &endpoint()) { + // Redirect the packet to the target endpoint. This updates the + // listener (for pending_callbacks accounting in the ArenaPool + // completion callback) and the destination address. + SocketAddress remote_addr(path.path.remote.addr); + packet->Redirect(static_cast(target), remote_addr); + if (can_send_packets()) [[likely]] { + Debug(this, + "Sending via non-primary endpoint for path %s", + local_addr.ToString()); + target->Send(std::move(packet)); + } + return; + } + } + Send(std::move(packet)); } @@ -1816,181 +2305,63 @@ datagram_id Session::SendDatagram(Store&& data) { // we just return 0 to indicate that the datagram was not sent an the // data is dropped on the floor. - if (!can_send_packets()) { - Debug(this, "Unable to send datagram"); + // If the session is destroyed, draining, or closing, we cannot send. + if (is_destroyed() || is_in_draining_period() || is_in_closing_period()) { return 0; } const ngtcp2_transport_params* tp = remote_transport_params(); - uint64_t max_datagram_size = tp->max_datagram_frame_size; + uint64_t max_datagram_size = MaxDatagramPayload(tp->max_datagram_frame_size); + + // These size and length checks should have been caught by the JavaScript + // side, but handle it gracefully here just in case. We might have some future + // case where datagram frames are sent from C++ code directly, so it's good to + // have these checks as a backstop regardless. if (max_datagram_size == 0) { Debug(this, "Datagrams are disabled"); return 0; } - if (data.length() > max_datagram_size) { + if (data.length() > max_datagram_size) [[unlikely]] { Debug(this, "Ignoring oversized datagram"); return 0; } - if (data.length() == 0) { + if (data.length() == 0) [[unlikely]] { Debug(this, "Ignoring empty datagram"); return 0; } - Packet::Ptr packet; - uint8_t* pos = nullptr; - int accepted = 0; - ngtcp2_vec vec = data; - PathStorage path; - int flags = NGTCP2_WRITE_DATAGRAM_FLAG_MORE; - datagram_id did = impl_->state_->last_datagram_id + 1; - - Debug(this, "Sending %zu-byte datagram %" PRIu64, data.length(), did); - - // Let's give it a max number of attempts to send the datagram. - static const int kMaxAttempts = 16; - int attempts = 0; - - auto on_exit = OnScopeLeave([&] { - UpdatePacketTxTime(); - UpdateTimer(); - UpdateDataStats(); - }); - - for (;;) { - // We may have to make several attempts at encoding and sending the - // datagram packet. On each iteration here we'll try to encode the - // datagram. It's entirely up to ngtcp2 whether to include the datagram - // in the packet on each call to ngtcp2_conn_writev_datagram. - if (!packet) { - packet = endpoint().CreatePacket( - impl_->remote_address_, - ngtcp2_conn_get_max_tx_udp_payload_size(*this), - "datagram"); - // Typically sending datagrams is best effort, but if we cannot create - // the packet, then we handle it as a fatal error as that indicates - // something else is likely very wrong. - if (!packet) { - SetLastError(QuicError::ForNgtcp2Error(NGTCP2_ERR_INTERNAL)); - Close(CloseMethod::SILENT); - return 0; - } - pos = packet->data(); - } - - ssize_t nwrite = ngtcp2_conn_writev_datagram(*this, - &path.path, - nullptr, - pos, - packet->length(), - &accepted, - flags, - did, - &vec, - 1, - uv_hrtime()); - - if (nwrite <= 0) { - // Nothing was written to the packet. - switch (nwrite) { - case 0: { - // We cannot send data because of congestion control or the data will - // not fit. Since datagrams are best effort, we are going to abandon - // the attempt and just return. - DCHECK_EQ(accepted, 0); - return 0; - } - case NGTCP2_ERR_WRITE_MORE: { - // The library wants us to keep writing more data to the packet. - // This is typically an indication that the packet is not yet - // full enough. - continue; - } - case NGTCP2_ERR_INVALID_STATE: { - // The remote endpoint does not want to accept datagrams. That's ok, - // just return 0. - DCHECK_EQ(accepted, 0); - return 0; - } - case NGTCP2_ERR_INVALID_ARGUMENT: { - // The datagram is too large. That should have been caught above but - // that's ok. We'll just abandon the attempt and return. - DCHECK_EQ(accepted, 0); - return 0; - } - case NGTCP2_ERR_PKT_NUM_EXHAUSTED: { - // We've exhausted the packet number space. Sadly we have to treat it - // as a fatal condition (which we will do after the switch) - DCHECK_EQ(accepted, 0); - Debug(this, - "ngtcp2_conn_writev_datagram failed: Packet number " - "exhausted"); - break; - } - case NGTCP2_ERR_CALLBACK_FAILURE: { - // There was an internal failure. Sadly we have to treat it as a fatal - // condition. (which we will do after the switch) - Debug(this, - "ngtcp2_conn_writev_datagram failed: Callback " - "failure"); - break; - } - case NGTCP2_ERR_NOMEM: { - // Out of memory. Sadly we have to treat it as a fatal condition. - // (which we will do after the switch) - Debug(this, "ngtcp2_conn_writev_datagram failed: Out of memory"); - break; - } - default: { - // Some other unknown, and unexpected failure. - // We have to treat it as a fatal condition. - Debug(this, - "ngtcp2_conn_writev_datagram failed with an unexpected " - "error: %zd", - nwrite); - break; - } - } - SetLastError(QuicError::ForTransport(nwrite)); - Close(CloseMethod::SILENT); - return 0; - } - - // In this case, a complete packet was written and we need to send it along. - // Note that this doesn't mean that the packet actually contains the - // datagram! We'll check that next by checking the accepted value. - packet->Truncate(nwrite); - Send(std::move(packet)); - // packet is now empty; next loop iteration creates a new one. - - if (accepted) { - // Yay! The datagram was accepted into the packet we just sent and we can - // return the datagram ID. Note that per the spec, datagrams cannot be - // fragmented, so if it was accepted, the entire datagram was sent. - Debug(this, "Datagram %" PRIu64 " sent", did); - auto& stats_ = impl_->stats_; - STAT_INCREMENT(Stats, datagrams_sent); - STAT_INCREMENT_N(Stats, bytes_sent, vec.len); - impl_->state_->last_datagram_id = did; - return did; - } + // Assign the datagram ID. + datagram_id did = ++impl_->state_->last_datagram_id; - // We sent a packet, but it wasn't the datagram packet. That can happen. - // Let's loop around and try again. We will limit the number of retries - // we do here to avoid looping indefinitely. - if (++attempts == kMaxAttempts) [[unlikely]] { - Debug(this, "Too many attempts to send datagram. Canceling."); - // Too many attempts to send the datagram. - break; + // Check queue capacity. Apply the drop policy when full. + auto max_pending = impl_->state_->max_pending_datagrams; + if (max_pending > 0 && impl_->pending_datagrams_.size() >= max_pending) { + auto drop_policy = impl_->config_.options.datagram_drop_policy; + if (drop_policy == DatagramDropPolicy::DROP_OLDEST) { + auto& oldest = impl_->pending_datagrams_.front(); + Debug(this, + "Datagram queue full, dropping oldest datagram %" PRIu64, + oldest.id); + DatagramStatus(oldest.id, DatagramStatus::ABANDONED); + impl_->pending_datagrams_.pop_front(); + } else { + // DROP_NEWEST: reject the incoming datagram. + Debug( + this, "Datagram queue full, dropping newest datagram %" PRIu64, did); + DatagramStatus(did, DatagramStatus::ABANDONED); + return did; } - - // If we get here that means the datagram has not yet been sent. - // We're going to loop around to try again. } - return 0; + // Queue the datagram. It will be serialized into packets by + // SendPendingData alongside stream data. + Debug(this, "Queuing %zu-byte datagram %" PRIu64, data.length(), did); + impl_->pending_datagrams_.push_back({did, std::move(data)}); + + return did; } void Session::UpdatePacketTxTime() { @@ -2017,6 +2388,11 @@ BaseObjectPtr Session::FindStream(stream_id id) const { return it->second; } +Session::StreamsMap Session::streams() const { + if (is_destroyed()) return {}; + return impl_->streams_; +} + BaseObjectPtr Session::CreateStream( stream_id id, CreateStreamOption option, @@ -2115,8 +2491,19 @@ void Session::AddStream(BaseObjectPtr stream, ngtcp2_conn_set_stream_user_data(*this, id, stream.get()); + // If the stream already has outbound data (body was provided at creation + // time), resume it now that it is registered in the streams map and can + // be found by FindStream. + if (stream->has_outbound()) { + ResumeStream(id); + } + if (option == CreateStreamOption::NOTIFY) { EmitStream(stream); + // EmitStream triggers the JS onstream callback via MakeCallback. + // If the callback throws, safeCallbackInvoke calls session.destroy() + // which resets impl_. We must bail out if that happened. + if (is_destroyed()) return; } // Update tracking statistics for the number of streams associated with this @@ -2225,7 +2612,42 @@ void Session::CollectSessionTicketAppData( SessionTicket::AppData::Status Session::ExtractSessionTicketAppData( const SessionTicket::AppData& app_data, Flag flag) { DCHECK(!is_destroyed()); - return application().ExtractSessionTicketAppData(app_data, flag); + // If the application is already selected (client side, or server after + // ALPN), delegate directly. + if (impl_->application_) { + return application().ExtractSessionTicketAppData(app_data, flag); + } + // The application is not yet selected (server during ClientHello + // processing, before ALPN). Parse the ticket data now while the + // SSL_SESSION is still valid, and stash the result for validation + // after ALPN negotiation in SetApplication(). + auto data = app_data.Get(); + if (!data.has_value() || data->len == 0) { + // No app data in the ticket. Accept optimistically. + return flag == Flag::STATUS_RENEW + ? SessionTicket::AppData::Status::TICKET_USE_RENEW + : SessionTicket::AppData::Status::TICKET_USE; + } + auto parsed = Application::ParseTicketData(*data); + if (!parsed.has_value()) { + return SessionTicket::AppData::Status::TICKET_IGNORE_RENEW; + } + // Pre-validate the ticket data against the current application options. + // If the stored settings are more permissive than the current config + // (e.g., a feature was enabled when the ticket was issued but is now + // disabled), reject the ticket so 0-RTT is not used. This must happen + // here (during TLS ticket processing) rather than in SetApplication, + // because by SetApplication time the TLS layer has already accepted + // the ticket and told the client 0-RTT is ok. + if (!Application::ValidateTicketData(*parsed, + config().options.application_options)) { + Debug(this, "Session ticket app data incompatible with current settings"); + return SessionTicket::AppData::Status::TICKET_IGNORE_RENEW; + } + impl_->pending_ticket_data_ = std::move(parsed); + return flag == Flag::STATUS_RENEW + ? SessionTicket::AppData::Status::TICKET_USE_RENEW + : SessionTicket::AppData::Status::TICKET_USE; } void Session::MemoryInfo(MemoryTracker* tracker) const { @@ -2233,12 +2655,6 @@ void Session::MemoryInfo(MemoryTracker* tracker) const { tracker->TrackField("impl", impl_); } tracker->TrackField("tls_session", tls_session_); - if (qlog_stream_) { - tracker->TrackField("qlog_stream", qlog_stream_); - } - if (keylog_stream_) { - tracker->TrackField("keylog_stream", keylog_stream_); - } } bool Session::is_in_closing_period() const { @@ -2252,7 +2668,9 @@ bool Session::is_in_draining_period() const { } bool Session::wants_session_ticket() const { - return !is_destroyed() && impl_->state_->session_ticket == 1; + return !is_destroyed() && + HasListenerFlag(impl_->state_->listener_flags, + SessionListenerFlags::SESSION_TICKET); } void Session::SetStreamOpenAllowed() { @@ -2260,11 +2678,22 @@ void Session::SetStreamOpenAllowed() { impl_->state_->stream_open_allowed = 1; } +void Session::PopulateEarlyTransportParamsState() { + DCHECK(!is_destroyed()); + const ngtcp2_transport_params* tp = remote_transport_params(); + if (tp != nullptr) { + impl_->state_->max_datagram_size = + MaxDatagramPayload(tp->max_datagram_frame_size); + } +} + bool Session::can_send_packets() const { - // We can send packets if we're not in the middle of a ngtcp2 callback, - // we're not destroyed, we're not in a draining or closing period, and - // endpoint is set. - return !is_destroyed() && !NgTcp2CallbackScope::in_ngtcp2_callback(env()) && + // We can send packets if we're not in the middle of a ngtcp2 callback + // on THIS session, we're not destroyed, and we're not in a draining + // or closing period. The callback scope check is per-session so that + // one session's ngtcp2 callback does not block unrelated sessions + // from sending. + return !is_destroyed() && !in_ngtcp2_callback_scope_ && !is_in_draining_period() && !is_in_closing_period(); } @@ -2315,7 +2744,30 @@ void Session::ExtendOffset(size_t amount) { ngtcp2_conn_extend_max_offset(*this, amount); } +bool Session::HasPendingDatagrams() const { + return impl_ && !impl_->pending_datagrams_.empty(); +} + +Session::PendingDatagram& Session::PeekPendingDatagram() { + return impl_->pending_datagrams_.front(); +} + +void Session::PopPendingDatagram() { + impl_->pending_datagrams_.pop_front(); +} + +size_t Session::PendingDatagramCount() const { + return impl_ ? impl_->pending_datagrams_.size() : 0; +} + +void Session::DatagramSent(datagram_id id) { + Debug(this, "Datagram %" PRIu64 " sent", id); + auto& stats_ = impl_->stats_; + STAT_INCREMENT(Stats, datagrams_sent); +} + void Session::UpdateDataStats() { + if (is_destroyed()) return; Debug(this, "Updating data stats"); auto& stats_ = impl_->stats_; ngtcp2_conn_info info; @@ -2327,6 +2779,15 @@ void Session::UpdateDataStats() { STAT_SET(Stats, rttvar, info.rttvar); STAT_SET(Stats, smoothed_rtt, info.smoothed_rtt); STAT_SET(Stats, ssthresh, info.ssthresh); + STAT_SET(Stats, pkt_sent, info.pkt_sent); + STAT_SET(Stats, bytes_sent, info.bytes_sent); + STAT_SET(Stats, pkt_recv, info.pkt_recv); + STAT_SET(Stats, bytes_recv, info.bytes_recv); + STAT_SET(Stats, pkt_lost, info.pkt_lost); + STAT_SET(Stats, bytes_lost, info.bytes_lost); + STAT_SET(Stats, ping_recv, info.ping_recv); + STAT_SET(Stats, pkt_discarded, info.pkt_discarded); + STAT_SET( Stats, max_bytes_in_flight, @@ -2334,9 +2795,12 @@ void Session::UpdateDataStats() { } void Session::SendConnectionClose() { - // Method is a non-op if the session is in a state where packets cannot - // be transmitted to the remote peer. - if (!can_send_packets()) return; + // Method is a non-op if the session is already destroyed or the + // endpoint cannot send. Note: we intentionally do NOT check + // can_send_packets() here because ngtcp2_conn_write_connection_close + // puts the connection into the closing period, and the resulting packet + // must still be sent to the endpoint. + if (is_destroyed()) return; Debug(this, "Sending connection close packet to peer"); @@ -2350,7 +2814,9 @@ void Session::SendConnectionClose() { if (auto packet = Packet::CreateConnectionClosePacket( endpoint(), impl_->remote_address_, *this, impl_->last_error_)) [[likely]] { - return Send(std::move(packet)); + // Send directly to endpoint, bypassing Session::Send which + // would drop the packet because we're now in the closing period. + return endpoint().Send(std::move(packet)); } // If we are unable to create a connection close packet then @@ -2384,27 +2850,60 @@ void Session::SendConnectionClose() { } packet->Truncate(nwrite); - return Send(std::move(packet)); + // Send directly to endpoint — ngtcp2 has entered the closing period + // at this point, so Session::Send() would drop the packet. + return endpoint().Send(std::move(packet)); } void Session::OnTimeout() { - DCHECK(!is_destroyed()); + if (is_destroyed()) return; + if (!impl_->application_) return; HandleScope scope(env()->isolate()); - int ret = ngtcp2_conn_handle_expiry(*this, uv_hrtime()); + int ret; + { + NgTcp2CallbackScope callback_scope(this); + ret = ngtcp2_conn_handle_expiry(*this, uv_hrtime()); + } + // handle_expiry can trigger ngtcp2 callbacks that invoke MakeCallback, + // which can synchronously destroy the session. Guard before proceeding. + if (is_destroyed()) return; if (NGTCP2_OK(ret) && !is_in_closing_period() && !is_in_draining_period()) { - return application().SendPendingData(); + application().SendPendingData(); + return; } + if (is_destroyed()) return; Debug(this, "Session timed out"); - SetLastError(QuicError::ForNgtcp2Error(ret)); + + // When the draining period expires, the peer has already sent + // CONNECTION_CLOSE. Use their close error so a clean close (code 0) + // propagates as no-error, allowing stream.closed promises to resolve. + if (is_in_draining_period()) { + SetLastError(QuicError::FromConnectionClose(*this)); + } else { + SetLastError(QuicError::ForNgtcp2Error(ret)); + } Close(CloseMethod::SILENT); } void Session::UpdateTimer() { DCHECK(!is_destroyed()); // Both uv_hrtime and ngtcp2_conn_get_expiry return nanosecond units. - uint64_t expiry = ngtcp2_conn_get_expiry(*this); uint64_t now = uv_hrtime(); + uint64_t expiry; + + if (is_in_draining_period()) { + // RFC 9000 Section 10.2: The draining state SHOULD persist for at + // least three times the current Probe Timeout (PTO). ngtcp2 does + // not set a draining timer internally — the application must + // compute it. + ngtcp2_duration pto = ngtcp2_conn_get_pto(*this); + uint8_t multiplier = impl_->config_.options.draining_period_multiplier; + expiry = now + multiplier * pto; + } else { + expiry = ngtcp2_conn_get_expiry(*this); + } + Debug( this, "Updating timer. Expiry: %" PRIu64 ", now: %" PRIu64, expiry, now); @@ -2436,8 +2935,16 @@ void Session::DatagramStatus(datagram_id datagramId, STAT_INCREMENT(Stats, datagrams_lost); break; } + case DatagramStatus::ABANDONED: { + Debug(this, "Datagram %" PRIu64 " was abandoned", datagramId); + STAT_INCREMENT(Stats, datagrams_lost); + break; + } + } + if (HasListenerFlag(impl_->state_->listener_flags, + SessionListenerFlags::DATAGRAM_STATUS)) { + EmitDatagramStatus(datagramId, status); } - EmitDatagramStatus(datagramId, status); } void Session::DatagramReceived(const uint8_t* data, @@ -2446,7 +2953,10 @@ void Session::DatagramReceived(const uint8_t* data, DCHECK(!is_destroyed()); // If there is nothing watching for the datagram on the JavaScript side, // or if the datagram is zero-length, we just drop it on the floor. - if (impl_->state_->datagram == 0 || datalen == 0) return; + if (!HasListenerFlag(impl_->state_->listener_flags, + SessionListenerFlags::DATAGRAM) || + datalen == 0) + return; Debug(this, "Session is receiving datagram of size %zu", datalen); auto& stats_ = impl_->stats_; @@ -2458,7 +2968,7 @@ void Session::DatagramReceived(const uint8_t* data, void Session::GenerateNewConnectionId(ngtcp2_cid* cid, size_t len, - uint8_t* token) { + ngtcp2_stateless_reset_token* token) { DCHECK(!is_destroyed()); CID cid_ = impl_->config_.options.cid_factory->GenerateInto(cid, len); Debug(this, "Generated new connection id %s", cid_); @@ -2478,6 +2988,12 @@ bool Session::HandshakeCompleted() { STAT_RECORD_TIMESTAMP(Stats, handshake_completed_at); SetStreamOpenAllowed(); + // Capture the peer's max datagram frame size from the remote transport + // parameters so JavaScript can check it without a C++ round-trip. + const ngtcp2_transport_params* tp = remote_transport_params(); + impl_->state_->max_datagram_size = + MaxDatagramPayload(tp->max_datagram_frame_size); + // If early data was attempted but rejected by the server, // tell ngtcp2 so it can retransmit the data as 1-RTT. // The status of early data will only be rejected if an @@ -2649,6 +3165,26 @@ void Session::EmitClose(const QuicError& error) { CHECK(is_destroyed()); } +void Session::set_max_datagram_size(uint16_t size) { + if (!is_destroyed()) { + impl_->state_->max_datagram_size = size; + } +} + +void Session::EmitGoaway(stream_id last_stream_id) { + if (is_destroyed()) return; + if (!env()->can_call_into_js()) return; + + CallbackScope cb_scope(this); + + Local argv[] = { + BigInt::New(env()->isolate(), last_stream_id), + }; + + MakeCallback( + BindingData::Get(env()).session_goaway_callback(), arraysize(argv), argv); +} + void Session::EmitDatagram(Store&& datagram, DatagramReceivedFlags flag) { DCHECK(!is_destroyed()); if (!env()->can_call_into_js()) return; @@ -2678,6 +3214,8 @@ void Session::EmitDatagramStatus(datagram_id id, quic::DatagramStatus status) { return state.acknowledged_string(); case DatagramStatus::LOST: return state.lost_string(); + case DatagramStatus::ABANDONED: + return state.abandoned_string(); } UNREACHABLE(); })(); @@ -2744,7 +3282,8 @@ void Session::EmitPathValidation(PathValidationResult result, if (!env()->can_call_into_js()) return; - if (impl_->state_->path_validation == 0) [[likely]] { + if (!HasListenerFlag(impl_->state_->listener_flags, + SessionListenerFlags::PATH_VALIDATION)) [[likely]] { return; } @@ -2770,7 +3309,8 @@ void Session::EmitPathValidation(PathValidationResult result, SocketAddressBase::Create(env(), newPath.remote)->object(), Undefined(isolate), Undefined(isolate), - Boolean::New(isolate, flags.preferredAddress)}; + is_server() ? Undefined(isolate) + : Boolean::New(isolate, flags.preferredAddress)}; if (oldPath.has_value()) { argv[3] = SocketAddressBase::Create(env(), oldPath->local)->object(); @@ -2788,17 +3328,28 @@ void Session::EmitSessionTicket(Store&& ticket) { // If there is nothing listening for the session ticket, don't bother // emitting. - if (impl_->state_->session_ticket == 0) [[likely]] { + if (!HasListenerFlag(impl_->state_->listener_flags, + SessionListenerFlags::SESSION_TICKET)) [[likely]] { Debug(this, "Session ticket was discarded"); return; } CallbackScope cb_scope(this); - auto& remote_params = remote_transport_params(); - Store transport_params; - if (remote_params) { - if (auto transport_params = remote_params.Encode(env())) { + // Encode the 0-RTT transport params using ngtcp2's matched pair format. + // This must use ngtcp2_conn_encode_0rtt_transport_params (not the + // generic ngtcp2_transport_params_encode_versioned) so that the + // receiver can decode with ngtcp2_conn_decode_and_set_0rtt_transport_params. + ssize_t tp_size = ngtcp2_conn_encode_0rtt_transport_params(*this, nullptr, 0); + if (tp_size > 0) { + JS_TRY_ALLOCATE_BACKING(env(), tp_backing, static_cast(tp_size)) + ssize_t tp_written = ngtcp2_conn_encode_0rtt_transport_params( + *this, + static_cast(tp_backing->Data()), + static_cast(tp_size)); + if (tp_written > 0) { + Store transport_params(std::move(tp_backing), + static_cast(tp_written)); SessionTicket session_ticket(std::move(ticket), std::move(transport_params)); Local argv; @@ -2810,8 +3361,33 @@ void Session::EmitSessionTicket(Store&& ticket) { } } +void Session::DestroyAllStreams(const QuicError& error) { + DCHECK(!is_destroyed()); + // Copy the streams map since streams remove themselves during + // destruction. Each Destroy() call triggers MakeCallback which + // can destroy impl_ via JS re-entrancy. + StreamsMap streams = impl_->streams_; + for (auto& stream : streams) { + if (is_destroyed()) return; + stream.second->Destroy(error); + } +} + +void Session::EmitEarlyDataRejected() { + DCHECK(!is_destroyed()); + if (!env()->can_call_into_js()) return; + + CallbackScope cb_scope(this); + MakeCallback(BindingData::Get(env()).session_early_data_rejected_callback(), + 0, + nullptr); +} + void Session::EmitNewToken(const uint8_t* token, size_t len) { DCHECK(!is_destroyed()); + if (!HasListenerFlag(impl_->state_->listener_flags, + SessionListenerFlags::NEW_TOKEN)) + return; if (!env()->can_call_into_js()) return; CallbackScope cb_scope(this); @@ -2883,13 +3459,44 @@ void Session::EmitVersionNegotiation(const ngtcp2_pkt_hd& hd, argv); } +void Session::EmitOrigins(std::vector&& origins) { + DCHECK(!is_destroyed()); + if (!HasListenerFlag(impl_->state_->listener_flags, + SessionListenerFlags::ORIGIN)) + return; + if (!env()->can_call_into_js()) return; + + CallbackScope cb_scope(this); + + auto isolate = env()->isolate(); + + LocalVector elements(env()->isolate(), origins.size()); + for (size_t i = 0; i < origins.size(); i++) { + Local str; + if (!ToV8Value(env()->context(), origins[i]).ToLocal(&str)) [[unlikely]] { + return; + } + elements[i] = str; + } + + Local argv[] = {Array::New(isolate, elements.data(), elements.size())}; + MakeCallback( + BindingData::Get(env()).session_origin_callback(), arraysize(argv), argv); +} + void Session::EmitKeylog(const char* line) { + DCHECK(!is_destroyed()); if (!env()->can_call_into_js()) return; - if (keylog_stream_) { - Debug(this, "Emitting keylog line"); - env()->SetImmediate([ptr = keylog_stream_, data = std::string(line) + "\n"]( - Environment* env) { ptr->Emit(data); }); + + auto str = std::string(line); + Local argv[] = {Undefined(env()->isolate())}; + if (!ToV8Value(env()->context(), str).ToLocal(&argv[0])) { + Debug(this, "Failed to convert keylog line to V8 string"); + return; } + + MakeCallback( + BindingData::Get(env()).session_keylog_callback(), arraysize(argv), argv); } // ============================================================================ diff --git a/src/quic/session.h b/src/quic/session.h index 92055e856fac60..650e8f79ba1428 100644 --- a/src/quic/session.h +++ b/src/quic/session.h @@ -16,7 +16,6 @@ #include "cid.h" #include "data.h" #include "defs.h" -#include "logstream.h" #include "packet.h" #include "preferredaddress.h" #include "sessionticket.h" @@ -74,9 +73,9 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source { // HTTP/3 specific options. uint64_t max_field_section_size = 0; - uint64_t qpack_max_dtable_capacity = 0; - uint64_t qpack_encoder_max_dtable_capacity = 0; - uint64_t qpack_blocked_streams = 0; + uint64_t qpack_max_dtable_capacity = 4096; + uint64_t qpack_encoder_max_dtable_capacity = 4096; + uint64_t qpack_blocked_streams = 100; bool enable_connect_protocol = true; bool enable_datagrams = true; @@ -112,6 +111,12 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source { // (ALPN negotiated during handshake). Must be called before any // application data is received. void SetApplication(std::unique_ptr app); + // Controls which datagram to drop when the pending datagram queue is full. + enum class DatagramDropPolicy : uint8_t { + DROP_OLDEST = 0, // Drop the oldest queued datagram (default). + DROP_NEWEST = 1, // Drop the incoming datagram. + }; + // The options used to configure a session. Most of these deal directly with // the transport parameters that are exchanged with the remote peer during // handshake. @@ -151,6 +156,11 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source { // completion of the tls handshake. uint64_t handshake_timeout = UINT64_MAX; + // The keep-alive timeout in milliseconds. When set to a non-zero value, + // ngtcp2 will automatically send PING frames to keep the connection alive + // before the idle timeout fires. Set to 0 to disable (default). + uint64_t keep_alive_timeout = 0; + // Maximum initial flow control window size for a stream. uint64_t max_stream_window = 0; @@ -180,6 +190,21 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source { // is the better of the two for our needs. ngtcp2_cc_algo cc_algorithm = CC_ALGO_CUBIC; + // Controls which datagram to drop when the pending queue is full. + DatagramDropPolicy datagram_drop_policy = DatagramDropPolicy::DROP_OLDEST; + + // Maximum number of SendPendingData attempts before a datagram is + // abandoned. When a datagram cannot be sent due to congestion control + // or packet size constraints, it remains in the queue and the counter + // is incremented. Once the limit is reached, the datagram is dropped + // and reported as abandoned. Range: 1-255. Default: 5. + uint8_t max_datagram_send_attempts = 5; + + // Multiplier for the Probe Timeout (PTO) used to compute the draining + // period duration after receiving CONNECTION_CLOSE. RFC 9000 Section + // 10.2 requires at least 3x PTO. Range: 3-255. Default: 3. + uint8_t draining_period_multiplier = 3; + // An optional NEW_TOKEN from a previous connection to the same // server. When set, the token is included in the Initial packet // to skip address validation. Client-side only. @@ -312,6 +337,7 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source { struct Stats; void HandleQlog(uint32_t flags, const void* data, size_t len); + void EmitQlog(uint32_t flags, std::string_view data); private: struct Impl; @@ -335,6 +361,18 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source { void Send(Packet::Ptr packet, const PathStorage& path); datagram_id SendDatagram(Store&& data); + // Pending datagram accessors for use by SendPendingData. + struct PendingDatagram { + datagram_id id; + Store data; + uint8_t send_attempts = 0; + }; + bool HasPendingDatagrams() const; + PendingDatagram& PeekPendingDatagram(); + void PopPendingDatagram(); + size_t PendingDatagramCount() const; + void DatagramSent(datagram_id id); + // A non-const variation to allow certain modifications. Config& config(); @@ -343,6 +381,9 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source { DO_NOT_NOTIFY, }; BaseObjectPtr FindStream(stream_id id) const; + // Returns a copy of the streams map (safe for iteration while streams + // are being destroyed). + StreamsMap streams() const; BaseObjectPtr CreateStream( stream_id id, CreateStreamOption option = CreateStreamOption::NOTIFY, @@ -422,6 +463,12 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source { bool wants_session_ticket() const; void SetStreamOpenAllowed(); + // Populate state buffer fields from the 0-RTT transport params. + // Called after ngtcp2_conn_decode_and_set_0rtt_transport_params + // succeeds, so that values like maxDatagramSize are available + // before the handshake completes. + void PopulateEarlyTransportParamsState(); + // It's a terrible name but "wrapped" here means that the Session has been // passed out to JavaScript and should be "wrapped" by whatever handler is // defined there to manage it. @@ -471,10 +518,17 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source { // JavaScript callouts void EmitClose(const QuicError& error = QuicError()); + void EmitGoaway(stream_id last_stream_id); + + // Sets the max datagram payload size in the shared state. Used by + // Http3ApplicationImpl to block datagram sends when the peer's + // SETTINGS_H3_DATAGRAM=0 (RFC 9297 §3). + void set_max_datagram_size(uint16_t size); void EmitDatagram(Store&& datagram, DatagramReceivedFlags flag); void EmitDatagramStatus(datagram_id id, DatagramStatus status); void EmitHandshakeComplete(); void EmitKeylog(const char* line); + void EmitOrigins(std::vector&& origins); struct ValidatedPath { std::shared_ptr local; @@ -487,6 +541,8 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source { const std::optional& oldPath); void EmitSessionTicket(Store&& ticket); void EmitNewToken(const uint8_t* token, size_t len); + void EmitEarlyDataRejected(); + void DestroyAllStreams(const QuicError& error); void EmitStream(const BaseObjectWeakPtr& stream); void EmitVersionNegotiation(const ngtcp2_pkt_hd& hd, const uint32_t* sv, @@ -495,7 +551,9 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source { void DatagramReceived(const uint8_t* data, size_t datalen, DatagramReceivedFlags flag); - void GenerateNewConnectionId(ngtcp2_cid* cid, size_t len, uint8_t* token); + void GenerateNewConnectionId(ngtcp2_cid* cid, + size_t len, + ngtcp2_stateless_reset_token* token); bool HandshakeCompleted(); void HandshakeConfirmed(); void SelectPreferredAddress(PreferredAddress* preferredAddress); @@ -503,17 +561,26 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source { QuicConnectionPointer InitConnection(); Side side_; - ngtcp2_mem allocator_; + const ngtcp2_mem* allocator_; std::unique_ptr impl_; + // These flags live on Session (not Impl) so that the NgTcp2CallbackScope + // and NgHttp3CallbackScope destructors can safely clear them even after + // Impl has been destroyed via MakeCallback re-entrancy during a callback. + // The scope is placed at the ngtcp2/nghttp3 entry point (e.g. Receive, + // OnTimeout) rather than on individual callbacks, so the deferred destroy + // only fires after all callbacks for that entry point have completed. + bool in_ngtcp2_callback_scope_ = false; + bool in_nghttp3_callback_scope_ = false; + bool destroy_deferred_ = false; QuicConnectionPointer connection_; std::unique_ptr tls_session_; - BaseObjectPtr qlog_stream_; - BaseObjectPtr keylog_stream_; - + friend struct NgTcp2CallbackScope; + friend struct NgHttp3CallbackScope; friend class Application; friend class DefaultApplication; friend class Http3ApplicationImpl; friend class Endpoint; + friend class SessionManager; friend class Stream; friend class PendingStream; friend class TLSContext; diff --git a/src/quic/session_manager.cc b/src/quic/session_manager.cc new file mode 100644 index 00000000000000..4345e726576e69 --- /dev/null +++ b/src/quic/session_manager.cc @@ -0,0 +1,170 @@ +#if HAVE_OPENSSL && HAVE_QUIC +#include "guard.h" +#ifndef OPENSSL_NO_QUIC +#include +#include +#include +#include "endpoint.h" +#include "session.h" +#include "session_manager.h" + +namespace node::quic { + +SessionManager::SessionManager(Environment* env) : env_(env) {} + +SessionManager::~SessionManager() = default; + +BaseObjectPtr SessionManager::FindSession(const CID& cid) { + // Direct SCID match. + auto it = sessions_.find(cid); + if (it != sessions_.end()) return it->second; + + // Cross-endpoint CID mapping (locally-generated CIDs for preferred + // address, multipath, etc.). + auto scid_it = dcid_to_scid_.find(cid); + if (scid_it != dcid_to_scid_.end()) { + it = sessions_.find(scid_it->second); + if (it != sessions_.end()) return it->second; + // Stale mapping — clean up. + dcid_to_scid_.erase(scid_it); + } + + return {}; +} + +void SessionManager::AddSession(const CID& scid, + BaseObjectPtr session) { + sessions_[scid] = std::move(session); +} + +void SessionManager::AssociateCID(const CID& cid, const CID& scid) { + if (cid && scid && cid != scid) { + dcid_to_scid_[cid] = scid; + } +} + +void SessionManager::DisassociateCID(const CID& cid) { + if (cid) { + dcid_to_scid_.erase(cid); + } +} + +void SessionManager::RemoveSession(const CID& scid) { + auto it = sessions_.find(scid); + if (it != sessions_.end()) { + primary_map_.erase(it->second.get()); + sessions_.erase(it); + } +} + +void SessionManager::AssociateStatelessResetToken( + const StatelessResetToken& token, Session* session) { + token_map_[token] = session; +} + +void SessionManager::DisassociateStatelessResetToken( + const StatelessResetToken& token) { + token_map_.erase(token); +} + +Session* SessionManager::FindSessionByStatelessResetToken( + const StatelessResetToken& token) const { + auto it = token_map_.find(token); + if (it != token_map_.end()) return it->second; + return nullptr; +} + +void SessionManager::RegisterEndpoint(Endpoint* endpoint, + const SocketAddress& local_address) { + endpoints_.insert(endpoint); + endpoint_addrs_[endpoint] = local_address; +} + +void SessionManager::UnregisterEndpoint(Endpoint* endpoint) { + endpoints_.erase(endpoint); + endpoint_addrs_.erase(endpoint); + // If no endpoints remain, destroy all sessions. + if (endpoints_.empty()) { + DestroyAllSessions(); + } +} + +bool SessionManager::HasEndpoints() const { + return !endpoints_.empty(); +} + +size_t SessionManager::endpoint_count() const { + return endpoints_.size(); +} + +Endpoint* SessionManager::FindEndpointForAddress( + const SocketAddress& local_addr) const { + // First pass: exact match. + for (const auto& [endpoint, addr] : endpoint_addrs_) { + if (addr == local_addr) return endpoint; + } + // Second pass: wildcard fallback. An endpoint bound to 0.0.0.0:port + // or [::]:port can serve any address on that port. + int port = SocketAddress::GetPort(local_addr.data()); + for (const auto& [endpoint, addr] : endpoint_addrs_) { + if (SocketAddress::GetPort(addr.data()) == port) { + auto host = addr.address(); + if (host == "0.0.0.0" || host == "::") { + return endpoint; + } + } + } + return nullptr; +} + +void SessionManager::SetPrimaryEndpoint(Session* session, Endpoint* endpoint) { + primary_map_[session] = endpoint; +} + +Endpoint* SessionManager::GetPrimaryEndpoint(Session* session) const { + auto it = primary_map_.find(session); + if (it != primary_map_.end()) return it->second; + return nullptr; +} + +void SessionManager::CloseAllSessionsFor(Endpoint* endpoint) { + // Collect sessions whose primary is this endpoint, then close them. + // We collect first because closing a session modifies primary_map_. + std::vector> to_close; + for (const auto& [session, ep] : primary_map_) { + if (ep == endpoint) { + // Look up the owning reference from sessions_ so the session + // stays alive during close. + for (const auto& [cid, sess_ptr] : sessions_) { + if (sess_ptr.get() == session) { + to_close.push_back(sess_ptr); + break; + } + } + } + } + for (auto& session : to_close) { + session->Close(Session::CloseMethod::SILENT); + } +} + +void SessionManager::DestroyAllSessions() { + // Copy the map since closing sessions will modify it. + auto sessions = sessions_; + for (auto& [cid, session] : sessions) { + session->Close(Session::CloseMethod::SILENT); + } + sessions.clear(); + token_map_.clear(); + dcid_to_scid_.clear(); + primary_map_.clear(); +} + +bool SessionManager::is_empty() const { + return sessions_.empty(); +} + +} // namespace node::quic + +#endif // OPENSSL_NO_QUIC +#endif // HAVE_OPENSSL && HAVE_QUIC diff --git a/src/quic/session_manager.h b/src/quic/session_manager.h new file mode 100644 index 00000000000000..760dc7e95415e9 --- /dev/null +++ b/src/quic/session_manager.h @@ -0,0 +1,109 @@ +#pragma once + +#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS + +#include +#include +#include +#include +#include "cid.h" +#include "tokens.h" + +namespace node::quic { + +class Endpoint; +class Session; + +// SessionManager is a per-Realm singleton that centralizes QUIC session +// routing. It holds the authoritative CID -> Session mapping, enabling +// any Endpoint to route packets to any session. This decouples session +// lifetime from individual endpoints, which is required for preferred +// address, connection migration, and multi-path QUIC. +// +// SessionManager is held by BindingData and lazily created on first access. +// It is not exposed to JavaScript. +class SessionManager final { + public: + explicit SessionManager(Environment* env); + ~SessionManager(); + + // Session routing. The sessions_ map holds BaseObjectPtr (owning + // references). SessionManager is the single authority for session ownership. + BaseObjectPtr FindSession(const CID& dcid); + void AddSession(const CID& scid, BaseObjectPtr session); + void RemoveSession(const CID& scid); + + // Cross-endpoint CID association. This map holds locally-generated CIDs + // that need to be routable from any endpoint (e.g., preferred address CID, + // multipath NEW_CONNECTION_ID CIDs). Peer-chosen CIDs from connection + // establishment (config.dcid, config.ocid) go in Endpoint::dcid_to_scid_ + // instead, because those values can collide across endpoints. + void AssociateCID(const CID& cid, const CID& scid); + void DisassociateCID(const CID& cid); + + // Stateless reset token association. The token_map_ holds raw (non-owning) + // pointers. Entries are valid only while the corresponding session exists + // in sessions_. Sessions clean up their tokens during teardown. + void AssociateStatelessResetToken(const StatelessResetToken& token, + Session* session); + void DisassociateStatelessResetToken(const StatelessResetToken& token); + Session* FindSessionByStatelessResetToken( + const StatelessResetToken& token) const; + + // Endpoint registry. Endpoints register themselves when they start + // receiving and unregister when they close. + void RegisterEndpoint(Endpoint* endpoint, const SocketAddress& local_address); + void UnregisterEndpoint(Endpoint* endpoint); + bool HasEndpoints() const; + size_t endpoint_count() const; + + // Find the endpoint bound to a given local address. Used by the session + // send path to route packets through the correct endpoint based on the + // ngtcp2 packet path. Tries exact match first, then wildcard fallback + // (0.0.0.0 or [::] on the same port). + Endpoint* FindEndpointForAddress(const SocketAddress& local_addr) const; + + // Primary endpoint tracking. Each session has one primary endpoint + // responsible for its lifecycle. + void SetPrimaryEndpoint(Session* session, Endpoint* endpoint); + Endpoint* GetPrimaryEndpoint(Session* session) const; + + // Close all sessions whose primary endpoint is the given endpoint. + // Used by Endpoint::Destroy(). + void CloseAllSessionsFor(Endpoint* endpoint); + + // Destroy all sessions. Used when the last endpoint is removed. + void DestroyAllSessions(); + + bool is_empty() const; + + private: + Environment* env_; + + // The sessions_ map holds strong owning references keyed by locally- + // generated SCIDs. This is the single source of truth for session + // ownership. + CID::Map> sessions_; + + // Cross-endpoint CID -> primary SCID mapping. Contains locally-generated + // CIDs that need to be routable from any endpoint. Peer-chosen CIDs + // from connection establishment are in Endpoint::dcid_to_scid_ instead. + CID::Map dcid_to_scid_; + + // Stateless reset token -> Session (non-owning). + StatelessResetToken::Map token_map_; + + // All registered endpoints. + std::unordered_set endpoints_; + + // Endpoint -> bound local address, for FindEndpointForAddress lookups. + std::unordered_map endpoint_addrs_; + + // Session -> primary Endpoint mapping (non-owning both directions; + // sessions are owned by sessions_, endpoints are externally owned). + std::unordered_map primary_map_; +}; + +} // namespace node::quic + +#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS diff --git a/src/quic/sessionticket.cc b/src/quic/sessionticket.cc index ac394fd572765b..5d9c4104cffcdd 100644 --- a/src/quic/sessionticket.cc +++ b/src/quic/sessionticket.cc @@ -136,25 +136,33 @@ SSL_TICKET_RETURN SessionTicket::DecryptedCallback(SSL* ssl, case SSL_TICKET_NO_DECRYPT: return SSL_TICKET_RETURN_IGNORE_RENEW; case SSL_TICKET_SUCCESS_RENEW: - [[fallthrough]]; + return static_cast( + AppData::Extract(ssl, session, AppData::Source::Flag::STATUS_RENEW)); case SSL_TICKET_SUCCESS: - return static_cast(AppData::Extract(ssl)); + return static_cast(AppData::Extract(ssl, session)); } } -SessionTicket::AppData::AppData(SSL* ssl) : ssl_(ssl) {} +SessionTicket::AppData::AppData(SSL* ssl, SSL_SESSION* session) + : ssl_(ssl), session_(session) {} + +SSL_SESSION* SessionTicket::AppData::GetSession() const { + return session_ != nullptr ? session_ : SSL_get0_session(ssl_); +} bool SessionTicket::AppData::Set(const uv_buf_t& data) { if (set_ || data.base == nullptr || data.len == 0) return false; set_ = true; - SSL_SESSION_set1_ticket_appdata(SSL_get0_session(ssl_), data.base, data.len); + SSL_SESSION_set1_ticket_appdata(GetSession(), data.base, data.len); return set_; } std::optional SessionTicket::AppData::Get() const { + auto* sess = GetSession(); + if (sess == nullptr) return std::nullopt; uv_buf_t buf; int ret = - SSL_SESSION_get0_ticket_appdata(SSL_get0_session(ssl_), + SSL_SESSION_get0_ticket_appdata(sess, reinterpret_cast(&buf.base), reinterpret_cast(&buf.len)); if (ret != 1) return std::nullopt; @@ -168,11 +176,12 @@ void SessionTicket::AppData::Collect(SSL* ssl) { } } -SessionTicket::AppData::Status SessionTicket::AppData::Extract(SSL* ssl) { +SessionTicket::AppData::Status SessionTicket::AppData::Extract( + SSL* ssl, SSL_SESSION* session, Source::Flag flag) { auto source = GetAppDataSource(ssl); if (source != nullptr) { - AppData app_data(ssl); - return source->ExtractSessionTicketAppData(app_data); + AppData app_data(ssl, session); + return source->ExtractSessionTicketAppData(app_data, flag); } return Status::TICKET_IGNORE; } diff --git a/src/quic/sessionticket.h b/src/quic/sessionticket.h index 2e795cbbcd4869..8c46470a153ca4 100644 --- a/src/quic/sessionticket.h +++ b/src/quic/sessionticket.h @@ -72,7 +72,7 @@ class SessionTicket::AppData final { TICKET_USE_RENEW = SSL_TICKET_RETURN_USE_RENEW, }; - explicit AppData(SSL* session); + explicit AppData(SSL* ssl, SSL_SESSION* session = nullptr); DISALLOW_COPY_AND_MOVE(AppData) bool Set(const uv_buf_t& data); @@ -94,11 +94,15 @@ class SessionTicket::AppData final { }; static void Collect(SSL* ssl); - static Status Extract(SSL* ssl); + static Status Extract(SSL* ssl, + SSL_SESSION* session, + Source::Flag flag = Source::Flag::STATUS_NONE); private: + SSL_SESSION* GetSession() const; bool set_ = false; SSL* ssl_; + SSL_SESSION* session_; }; } // namespace node::quic diff --git a/src/quic/streams.cc b/src/quic/streams.cc index 6edbb97d829f9c..dd7f7ecbb3880e 100644 --- a/src/quic/streams.cc +++ b/src/quic/streams.cc @@ -1,7 +1,7 @@ +#include "ngtcp2/ngtcp2.h" #if HAVE_OPENSSL && HAVE_QUIC #include "guard.h" #ifndef OPENSSL_NO_QUIC -#include "streams.h" #include #include #include @@ -9,18 +9,22 @@ #include #include #include +#include #include #include "application.h" #include "bindingdata.h" #include "defs.h" #include "session.h" +#include "streams.h" namespace node { using v8::Array; using v8::ArrayBuffer; using v8::ArrayBufferView; +using v8::BackingStore; using v8::BigInt; +using v8::FunctionCallbackInfo; using v8::Global; using v8::Integer; using v8::Just; @@ -30,6 +34,7 @@ using v8::Nothing; using v8::Object; using v8::ObjectTemplate; using v8::SharedArrayBuffer; +using v8::Uint32; using v8::Uint8Array; using v8::Value; @@ -43,6 +48,7 @@ namespace quic { V(READ_ENDED, read_ended, uint8_t) \ V(WRITE_ENDED, write_ended, uint8_t) \ V(RESET, reset, uint8_t) \ + V(RESET_CODE, reset_code, uint64_t) \ V(HAS_OUTBOUND, has_outbound, uint8_t) \ V(HAS_READER, has_reader, uint8_t) \ /* Set when the stream has a block event handler */ \ @@ -52,7 +58,11 @@ namespace quic { /* Set when the stream has a reset event handler */ \ V(WANTS_RESET, wants_reset, uint8_t) \ /* Set when the stream has a trailers event handler */ \ - V(WANTS_TRAILERS, wants_trailers, uint8_t) + V(WANTS_TRAILERS, wants_trailers, uint8_t) \ + /* True when 0-RTT early data was received */ \ + V(RECEIVED_EARLY_DATA, received_early_data, uint8_t) \ + V(WRITE_DESIRED_SIZE, write_desired_size, uint32_t) \ + V(HIGH_WATER_MARK, high_water_mark, uint32_t) #define STREAM_STATS(V) \ /* Marks the timestamp when the stream object was created. */ \ @@ -144,31 +154,23 @@ STAT_STRUCT(Stream, STREAM) // ============================================================================ namespace { -// Creates an in-memory DataQueue entry from an ArrayBuffer by either -// detaching it (zero-copy) or copying its contents if detach is not -// possible (e.g., SharedArrayBuffer-backed or non-detachable). -// Returns nullptr on failure (error already thrown if allocation failed). +// Creates an in-memory DataQueue entry by copying the requested range of +// the given ArrayBuffer into a fresh BackingStore. The caller's buffer is +// not detached or otherwise modified, so callers can safely reuse or +// mutate it after the call returns. Callers that want to ensure their +// buffer cannot be mutated after handing it off can call +// `ArrayBuffer.prototype.transfer()` themselves before calling into the +// QUIC API. +// Returns nullptr on zero length or allocation failure. std::unique_ptr CreateEntryFromBuffer( Environment* env, Local buffer, size_t offset, size_t length) { if (length == 0) return nullptr; - std::shared_ptr backing; - if (buffer->IsDetachable()) { - backing = buffer->GetBackingStore(); - if (buffer->Detach(Local()).IsNothing()) { - backing.reset(); - } - } - if (!backing) { - // Buffer is not detachable or detach failed. Copy the data. - JS_TRY_ALLOCATE_BACKING_OR_RETURN(env, copy, length, nullptr); - memcpy(copy->Data(), - static_cast(buffer->Data()) + offset, - length); - offset = 0; - backing = std::move(copy); - } + JS_TRY_ALLOCATE_BACKING_OR_RETURN(env, copy, length, nullptr); + memcpy(copy->Data(), + static_cast(buffer->Data()) + offset, + length); return DataQueue::CreateInMemoryEntryFromBackingStore( - std::move(backing), offset, length); + std::move(copy), 0, length); } } // namespace @@ -226,10 +228,43 @@ Maybe> Stream::GetDataQueueFromSource( JS_TRY_ALLOCATE_BACKING_OR_RETURN( env, backing, str.length(), Nothing>()); memcpy(backing->Data(), *str, str.length()); + auto len = backing->ByteLength(); entries.push_back(DataQueue::CreateInMemoryEntryFromBackingStore( - std::move(backing), 0, backing->ByteLength())); + std::move(backing), 0, len)); return Just(DataQueue::CreateIdempotent(std::move(entries))); } + // FileHandle — create an fd-backed DataQueue from the file path. + // The JS side validates and locks the FileHandle before passing + // the C++ handle here. We detect FileHandle by checking if the + // object's constructor name is "FileHandle". + if (value->IsObject()) { + auto obj = value.As(); + Local ctor_name; + auto maybe_name = obj->GetConstructorName(); + if (!maybe_name.IsEmpty()) { + ctor_name = maybe_name; + Utf8Value name(env->isolate(), ctor_name); + if (strcmp(*name, "FileHandle") == 0) { + fs::FileHandle* file_handle; + ASSIGN_OR_RETURN_UNWRAP( + &file_handle, value, Nothing>()); + Local path; + if (!v8::String::NewFromUtf8(env->isolate(), + file_handle->original_name().c_str()) + .ToLocal(&path)) { + return Nothing>(); + } + auto entry = DataQueue::CreateFdEntry(env, path); + if (!entry) return Nothing>(); + size_t size = entry->size().value_or(0); + auto queue = DataQueue::Create(); + if (!queue) return Nothing>(); + queue->append(std::move(entry)); + queue->cap(size); + return Just(std::move(queue)); + } + } + } // TODO(jasnell): Add streaming sources... THROW_ERR_INVALID_ARG_TYPE(env, "Invalid data source type"); return Nothing>(); @@ -247,6 +282,14 @@ struct Stream::Impl { std::shared_ptr dataqueue; if (GetDataQueueFromSource(env, args[0]).To(&dataqueue)) { stream->set_outbound(std::move(dataqueue)); + // set_outbound does not call ResumeStream because during + // construction the stream is not yet registered with the session. + // When attaching a source after creation (via setBody), the + // stream is already registered and must be resumed to enter the + // send queue. + if (!stream->is_pending()) { + stream->session().ResumeStream(stream->id()); + } } } @@ -254,7 +297,7 @@ struct Stream::Impl { JS_METHOD(Destroy) { Stream* stream; ASSIGN_OR_RETURN_UNWRAP(&stream, args.This()); - if (args.Length() > 1) { + if (args.Length() >= 1) { CHECK(args[0]->IsBigInt()); bool lossless = false; uint64_t code = args[0].As()->Uint64Value(&lossless); @@ -272,8 +315,7 @@ struct Stream::Impl { // Sends a block of headers to the peer. If the stream is not yet open, // the headers will be queued and sent immediately when the stream is - // opened. If the application does not support sending headers on streams, - // they will be ignored and dropped on the floor. + // opened. Returns false if the application does not support headers. JS_METHOD(SendHeaders) { Stream* stream; ASSIGN_OR_RETURN_UNWRAP(&stream, args.This()); @@ -287,8 +329,13 @@ struct Stream::Impl { // If the stream is pending, the headers will be queued until the // stream is opened, at which time the queued header block will be - // immediately sent when the stream is opened. + // immediately sent when the stream is opened. If we already know + // that the application does not support headers, return false + // immediately so the JS side can throw an appropriate error. if (stream->is_pending()) { + if (!stream->session().application().SupportsHeaders()) { + return args.GetReturnValue().Set(false); + } stream->EnqueuePendingHeaders(kind, headers, flags); return args.GetReturnValue().Set(true); } @@ -355,18 +402,22 @@ struct Stream::Impl { JS_METHOD(SetPriority) { Stream* stream; ASSIGN_OR_RETURN_UNWRAP(&stream, args.This()); - CHECK(args[0]->IsUint32()); // Priority - CHECK(args[1]->IsUint32()); // Priority flag + CHECK(args[0]->IsUint32()); // Packed: (urgency << 1) | incremental - StreamPriority priority = FromV8Value(args[0]); - StreamPriorityFlags flags = FromV8Value(args[1]); + uint32_t packed = args[0].As()->Value(); + StreamPriority priority = static_cast(packed >> 1); + StreamPriorityFlags flags = (packed & 1) + ? StreamPriorityFlags::INCREMENTAL + : StreamPriorityFlags::NON_INCREMENTAL; - if (stream->is_pending()) { - stream->pending_priority_ = PendingPriority{ - .priority = priority, - .flags = flags, - }; - } else { + // Always update the stored priority on the stream. + stream->priority_ = StoredPriority{ + .priority = priority, + .flags = flags, + .pending = stream->is_pending(), + }; + + if (!stream->is_pending()) { stream->session().application().SetStreamPriority( *stream, priority, flags); } @@ -376,13 +427,23 @@ struct Stream::Impl { Stream* stream; ASSIGN_OR_RETURN_UNWRAP(&stream, args.This()); - if (stream->is_pending()) { - return args.GetReturnValue().Set( - static_cast(StreamPriority::DEFAULT)); + // On the client side, priority is always read from the stream's + // stored value since the client is the one setting it. On the + // server side, we delegate to the application which can read + // the peer's requested priority (e.g., from PRIORITY_UPDATE + // frames in HTTP/3). + if (!stream->session().is_server()) { + auto& pri = stream->priority_; + uint32_t packed = (static_cast(pri.priority) << 1) | + (pri.flags == StreamPriorityFlags::INCREMENTAL ? 1 : 0); + return args.GetReturnValue().Set(packed); } - auto priority = stream->session().application().GetStreamPriority(*stream); - args.GetReturnValue().Set(static_cast(priority)); + auto result = stream->session().application().GetStreamPriority(*stream); + uint32_t packed = + (static_cast(result.priority) << 1) | + (result.flags == StreamPriorityFlags::INCREMENTAL ? 1 : 0); + args.GetReturnValue().Set(packed); } // Returns a Blob::Reader that can be used to read data that has been @@ -391,9 +452,9 @@ struct Stream::Impl { Stream* stream; ASSIGN_OR_RETURN_UNWRAP(&stream, args.This()); BaseObjectPtr reader = stream->get_reader(); - if (reader) return args.GetReturnValue().Set(reader->object()); - THROW_ERR_INVALID_STATE(Environment::GetCurrent(args), - "Unable to get a reader for the stream"); + if (reader) args.GetReturnValue().Set(reader->object()); + // Returns undefined when the stream is not readable (e.g. a local + // unidirectional stream). The JS side checks for this. } JS_METHOD(InitStreamingSource) { @@ -505,13 +566,24 @@ class Stream::Outbound final : public MemoryRetainer { bool is_streaming() const { return streaming_; } size_t total() const { return total_; } + size_t uncommitted() const { return uncommitted_; } + + // Total bytes in the pipeline: data appended to the DataQueue that + // hasn't been pulled yet, plus data pulled but not yet acknowledged. + // This is the number to compare against highWaterMark for backpressure. + size_t queued_bytes() const { return queued_ + total_; } // Appends an entry to the underlying DataQueue. Only valid when // the Outbound was created in streaming mode. bool AppendEntry(std::unique_ptr entry) { if (!streaming_ || !queue_) return false; + auto size = entry->size(); auto result = queue_->append(std::move(entry)); - return result.has_value() && result.value(); + if (result.has_value() && result.value()) { + if (size.has_value()) queued_ += size.value(); + return true; + } + return false; } int Pull(bob::Next next, @@ -520,6 +592,14 @@ class Stream::Outbound final : public MemoryRetainer { size_t count, size_t max_count_hint) { if (next_pending_) { + // An async read is in flight, but there may be uncommitted bytes + // from a previous read that ngtcp2 didn't accept (nwrite=0 due + // to pacing/congestion). Return those bytes so the send loop can + // retry rather than blocking until the async read completes. + if (uncommitted_ > 0) { + PullUncommitted(std::move(next)); + return bob::Status::STATUS_CONTINUE; + } std::move(next)(bob::Status::STATUS_BLOCK, nullptr, 0, [](int) {}); return bob::Status::STATUS_BLOCK; } @@ -557,9 +637,6 @@ class Stream::Outbound final : public MemoryRetainer { // that the pull is sync but allow for it to be async. int ret = reader_->Pull( [this](auto status, auto vecs, auto count, auto done) { - // Always make sure next_pending_ is false when we're done. - auto on_exit = OnScopeLeave([this] { next_pending_ = false; }); - // The status should never be wait here. DCHECK_NE(status, bob::Status::STATUS_WAIT); @@ -568,6 +645,7 @@ class Stream::Outbound final : public MemoryRetainer { // being asynchronous, our stream is blocking waiting for the data, // but we have an error! oh no! We need to error the stream. if (next_pending_) { + next_pending_ = false; stream_->Destroy( QuicError::ForNgtcp2Error(NGTCP2_INTERNAL_ERROR)); // We do not need to worry about calling MarkErrored in this case @@ -586,7 +664,10 @@ class Stream::Outbound final : public MemoryRetainer { // Here, there is no more data to read, but we will might have data // in the uncommitted queue. We'll resume the stream so that the // session will try to read from it again. + // We must clear next_pending_ before calling ResumeStream because + // ResumeStream can synchronously re-enter Outbound::Pull. if (next_pending_) { + next_pending_ = false; stream_->session().ResumeStream(stream_->id()); } return; @@ -610,7 +691,10 @@ class Stream::Outbound final : public MemoryRetainer { // being asynchronous, our stream is blocking waiting for the data. // Now that we have data, let's resume the stream so the session will // pull from it again. + // We must clear next_pending_ before calling ResumeStream because + // ResumeStream can synchronously re-enter Outbound::Pull. if (next_pending_) { + next_pending_ = false; stream_->session().ResumeStream(stream_->id()); } }, @@ -667,9 +751,17 @@ class Stream::Outbound final : public MemoryRetainer { // Reads here are generally expected to be synchronous. If we have a reader // that insists on providing data asynchronously, then we'll have to block - // until the data is actually available. + // until the data is actually available. However, if there are uncommitted + // bytes already buffered (from a previous async read), return those now + // rather than blocking — the async callback will resume the stream when + // more data arrives. if (ret == bob::Status::STATUS_WAIT) { next_pending_ = true; + if (uncommitted_ > 0) { + PullUncommitted(std::move(next)); + return bob::Status::STATUS_CONTINUE; + } + std::move(next)(bob::Status::STATUS_BLOCK, nullptr, 0, [](int) {}); return bob::Status::STATUS_BLOCK; } @@ -751,6 +843,11 @@ class Stream::Outbound final : public MemoryRetainer { count_++; total_ += vectors[n].len; uncommitted_ += vectors[n].len; + if (queued_ >= vectors[n].len) { + queued_ -= vectors[n].len; + } else { + queued_ = 0; + } } } @@ -797,6 +894,10 @@ class Stream::Outbound final : public MemoryRetainer { // waiting to be acknowledged. When we receive acknowledgement, we will // automatically free held bytes from the buffer. size_t uncommitted_ = 0; + + // Bytes appended to the DataQueue that haven't been pulled yet. + // Decremented in Pull() when data moves from the queue to the buffer. + size_t queued_ = 0; }; // ============================================================================ @@ -865,7 +966,6 @@ void Stream::InitPerContext(Realm* realm, Local target) { } Stream* Stream::From(void* stream_user_data) { - DCHECK_NOT_NULL(stream_user_data); return static_cast(stream_user_data); } @@ -913,6 +1013,7 @@ Stream::Stream(BaseObjectWeakPtr session, set_outbound(std::move(source)); + STAT_RECORD_TIMESTAMP(Stats, created_at); auto params = ngtcp2_conn_get_local_transport_params(this->session()); STAT_SET(Stats, max_offset, params->initial_max_data); STAT_SET(Stats, opened_at, stats_->created_at); @@ -945,6 +1046,7 @@ Stream::Stream(BaseObjectWeakPtr session, set_outbound(std::move(source)); + STAT_RECORD_TIMESTAMP(Stats, created_at); auto params = ngtcp2_conn_get_local_transport_params(this->session()); STAT_SET(Stats, max_offset, params->initial_max_data); } @@ -969,27 +1071,36 @@ void Stream::NotifyStreamOpened(stream_id id) { CHECK_EQ(ngtcp2_conn_set_stream_user_data(this->session(), id, this), 0); maybe_pending_stream_.reset(); - if (pending_priority_) { - auto& priority = pending_priority_.value(); + if (priority_.pending) { session().application().SetStreamPriority( - *this, priority.priority, priority.flags); - pending_priority_ = std::nullopt; + *this, priority_.priority, priority_.flags); + priority_.pending = false; } - decltype(pending_headers_queue_) queue; - pending_headers_queue_.swap(queue); - for (auto& headers : queue) { - // TODO(@jasnell): What if the application does not support headers? - session().application().SendHeaders(*this, - headers->kind, - headers->headers.Get(env()->isolate()), - headers->flags); + if (!pending_headers_queue_.empty()) { + if (!session().application().SupportsHeaders()) { + // Headers were enqueued while the application was not yet known + // (headers_supported == 0), and the negotiated application does + // not support headers. This is a fatal mismatch. + Destroy(QuicError::ForApplication(0)); + return; + } + decltype(pending_headers_queue_) queue; + pending_headers_queue_.swap(queue); + for (auto& headers : queue) { + session().application().SendHeaders( + *this, + headers->kind, + headers->headers.Get(env()->isolate()), + headers->flags); + } } // If the stream is not a local undirectional stream and is_readable is // false, then we should shutdown the streams readable side now. if (!is_local_unidirectional() && !is_readable()) { NotifyReadableEnded(pending_close_read_code_); } - if (!is_remote_unidirectional() && !is_writable()) { + if (!is_remote_unidirectional() && !is_writable() && + !session_->application().stream_fin_managed_by_application()) { NotifyWritableEnded(pending_close_write_code_); } @@ -1003,7 +1114,7 @@ void Stream::NotifyStreamOpened(stream_id id) { void Stream::NotifyReadableEnded(error_code code) { CHECK(!is_pending()); Session::SendPendingDataScope send_scope(&session()); - ngtcp2_conn_shutdown_stream_read(session(), 0, id(), code); + CHECK_EQ(ngtcp2_conn_shutdown_stream_read(session(), 0, id(), code), 0); } void Stream::NotifyWritableEnded(error_code code) { @@ -1061,6 +1172,14 @@ bool Stream::is_eos() const { return state_->fin_sent; } +bool Stream::wants_trailers() const { + return state_->wants_trailers; +} + +void Stream::set_early() { + state_->received_early_data = 1; +} + bool Stream::is_writable() const { // Remote unidirectional streams are never writable, and remote streams can // never be pending. @@ -1071,6 +1190,18 @@ bool Stream::is_writable() const { return state_->write_ended == 0; } +bool Stream::has_outbound() const { + return outbound_ != nullptr; +} + +bool Stream::has_reader() const { + return reader_ != nullptr; +} + +Blob::Reader* Stream::reader() const { + return reader_.get(); +} + bool Stream::is_readable() const { // Local unidirectional streams are never readable, and remote streams can // never be pending. @@ -1102,7 +1233,11 @@ void Stream::set_outbound(std::shared_ptr source) { DCHECK_NULL(outbound_); outbound_ = std::make_unique(this, std::move(source)); state_->has_outbound = 1; - if (!is_pending()) session_->ResumeStream(id()); + // Note: We intentionally do NOT call ResumeStream here. During + // construction, the stream has not yet been added to the session's + // streams map, so FindStream would fail. The caller (CreateStream / + // AddStream) is responsible for calling ResumeStream after the + // stream is registered. } void Stream::InitStreaming() { @@ -1120,7 +1255,7 @@ void Stream::InitStreaming() { if (!is_pending()) session_->ResumeStream(id()); } -void Stream::WriteStreamData(const v8::FunctionCallbackInfo& args) { +void Stream::WriteStreamData(const FunctionCallbackInfo& args) { auto env = this->env(); if (outbound_ == nullptr || !outbound_->is_streaming()) { return THROW_ERR_INVALID_STATE(env, "Streaming source is not initialized"); @@ -1161,6 +1296,7 @@ void Stream::WriteStreamData(const v8::FunctionCallbackInfo& args) { if (!is_pending()) session_->ResumeStream(id()); + UpdateWriteDesiredSize(); args.GetReturnValue().Set(static_cast(outbound_->total())); } @@ -1179,9 +1315,8 @@ void Stream::EndWriting() { } void Stream::EntryRead(size_t amount) { - // Tells us that amount bytes we're reading from inbound_ - // We use this as a signal to extend the flow control - // window to receive more bytes. + // Called when the JS consumer reads data from the inbound DataQueue. + // Extend the flow control window so the sender can transmit more. session().ExtendStreamOffset(id(), amount); session().ExtendOffset(amount); } @@ -1250,12 +1385,12 @@ void Stream::Acknowledge(size_t datalen) { // ngtcp2 guarantees that offset must always be greater than the previously // received offset. - DCHECK_GE(datalen, STAT_GET(Stats, max_offset_ack)); - STAT_SET(Stats, max_offset_ack, datalen); + STAT_INCREMENT_N(Stats, max_offset_ack, datalen); // Consumes the given number of bytes in the buffer. outbound_->Acknowledge(datalen); STAT_RECORD_TIMESTAMP(Stats, acked_at); + UpdateWriteDesiredSize(); } void Stream::Commit(size_t datalen, bool fin) { @@ -1280,8 +1415,10 @@ void Stream::EndReadable(std::optional maybe_final_size) { state_->read_ended = 1; set_final_size(maybe_final_size.value_or(STAT_GET(Stats, bytes_received))); inbound_->cap(STAT_GET(Stats, final_size)); - // Notify the JS reader so it can see EOS. - if (reader_) reader_->NotifyPull(); + // Notify the JS reader so it can see EOS. Pass fin=true so the + // wakeup promise resolves with a value the iterator can check to + // avoid waiting for another wakeup that will never come. + if (reader_) reader_->NotifyPull(true); } void Stream::Destroy(QuicError error) { @@ -1327,7 +1464,9 @@ void Stream::Destroy(QuicError error) { auto session = session_; session_.reset(); - session->RemoveStream(id()); + // EmitClose above triggers MakeCallback which can destroy the session + // via JS re-entrancy. The weak pointer may now be null. + if (session) session->RemoveStream(id()); // Critically, make sure that the RemoveStream call is the last thing // trying to use this stream object. Once that call is made, the stream @@ -1342,14 +1481,13 @@ void Stream::ReceiveData(const uint8_t* data, ReceiveDataFlags flags) { // If reading has ended, or there is no data, there's nothing to do but maybe // end the readable side if this is the last bit of data we've received. - Debug(this, "Receiving %zu bytes of data", len); - if (state_->read_ended == 1 || len == 0) { if (flags.fin) EndReadable(); return; } + if (flags.early) state_->received_early_data = 1; STAT_INCREMENT_N(Stats, bytes_received, len); STAT_SET(Stats, max_offset_received, STAT_GET(Stats, bytes_received)); STAT_RECORD_TIMESTAMP(Stats, received_at); @@ -1365,12 +1503,19 @@ void Stream::ReceiveData(const uint8_t* data, } void Stream::ReceiveStopSending(QuicError error) { - // Note that this comes from *this* endpoint, not the other side. We handle it - // if we haven't already shutdown our *receiving* side of the stream. - if (state_->read_ended) return; + // STOP_SENDING from the peer asks us to stop sending. Per RFC 9000 + // §3.5 the receiver SHOULD respond with RESET_STREAM, which is what + // ngtcp2_conn_shutdown_stream_write below schedules. If our + // writable side has already been shut down (e.g. we already sent + // RESET_STREAM ourselves or finished sending with FIN) there is + // nothing more to do here. The previous guard checked + // `state_->read_ended` which is unrelated to the writable side and + // suppressed STOP_SENDING handling whenever a sibling RESET_STREAM + // frame had been processed first within the same packet. + if (state_->write_ended) return; Debug(this, "Received stop sending with error %s", error); - ngtcp2_conn_shutdown_stream_read(session(), 0, id(), error.code()); - EndReadable(); + ngtcp2_conn_shutdown_stream_write(session(), 0, id(), error.code()); + EndWritable(); } void Stream::ReceiveStreamReset(uint64_t final_size, QuicError error) { @@ -1383,6 +1528,7 @@ void Stream::ReceiveStreamReset(uint64_t final_size, QuicError error) { "Received stream reset with final size %" PRIu64 " and error %s", final_size, error); + state_->reset_code = error.code(); EndReadable(final_size); EmitReset(error); } @@ -1400,6 +1546,58 @@ void Stream::EmitBlocked() { MakeCallback(BindingData::Get(env()).stream_blocked_callback(), 0, nullptr); } +void Stream::EmitDrain() { + if (!env()->can_call_into_js()) return; + CallbackScope cb_scope(this); + MakeCallback(BindingData::Get(env()).stream_drain_callback(), 0, nullptr); +} + +void Stream::UpdateWriteDesiredSize() { + if (!outbound_ || !outbound_->is_streaming()) return; + + uint64_t available; + uint64_t hwm = state_->high_water_mark; + + if (is_pending()) { + // Pending streams don't have a stream ID yet, so ngtcp2 can't + // report their flow control window. Use the high water mark as + // the available capacity so writes can proceed while pending. + available = hwm > 0 ? hwm : std::numeric_limits::max(); + } else { + // Calculate available capacity based on QUIC flow control. + // The effective limit is the minimum of stream-level and + // connection-level flow control remaining. + ngtcp2_conn* conn = session(); + uint64_t stream_left = ngtcp2_conn_get_max_stream_data_left(conn, id()); + uint64_t conn_left = ngtcp2_conn_get_max_data_left(conn); + available = std::min(stream_left, conn_left); + + // Apply the high water mark as an additional ceiling. + if (hwm > 0) { + available = std::min(available, hwm); + } + } + + // Total bytes in the pipeline: data in the DataQueue (not yet pulled by + // ngtcp2) plus data pulled but not yet acknowledged. Using queued_bytes() + // ensures that data appended via writeSync is accounted for in + // backpressure even before ngtcp2 pulls it. + uint64_t buffered = outbound_->queued_bytes(); + uint64_t desired = (available > buffered) ? (available - buffered) : 0; + + // Clamp to uint32 range since write_desired_size is uint32_t. + uint32_t clamped = static_cast( + std::min(desired, std::numeric_limits::max())); + + uint32_t old_size = state_->write_desired_size; + state_->write_desired_size = clamped; + + // Fire drain when transitioning from 0 to non-zero + if (old_size == 0 && desired > 0) { + EmitDrain(); + } +} + void Stream::EmitClose(const QuicError& error) { if (!env()->can_call_into_js()) return; CallbackScope cb_scope(this); @@ -1458,6 +1656,13 @@ void Stream::Schedule(Queue* queue) { if (outbound_ && stream_queue_.IsEmpty()) queue->PushBack(this); } +void Stream::Unschedule() { + // Remove this stream from the send queue. Used when the stream becomes + // flow-control blocked so that SendPendingData does not spin retrying it. + Debug(this, "Unscheduled"); + stream_queue_.Remove(); +} + } // namespace quic } // namespace node diff --git a/src/quic/streams.h b/src/quic/streams.h index 610aac2de334f4..0edeeed7a9209e 100644 --- a/src/quic/streams.h +++ b/src/quic/streams.h @@ -218,12 +218,27 @@ class Stream final : public AsyncWrap, // data to be acknowledged by the remote peer. bool is_eos() const; + // True if the stream wants to send trailing headers after the body. + bool wants_trailers() const; + + // Marks this stream as having received 0-RTT early data. + void set_early(); + // True if this stream is still in a readable state. bool is_readable() const; // True if this stream is still in a writable state. bool is_writable() const; + // True if an outbound data source has been configured. + bool has_outbound() const; + + // True if a Blob::Reader has been created for the inbound data. + bool has_reader() const; + + // Returns the Blob::Reader for the inbound data, or nullptr. + Blob::Reader* reader() const; + // Called by the session/application to indicate that the specified number // of bytes have been acknowledged by the peer. void Acknowledge(size_t datalen); @@ -326,6 +341,14 @@ class Stream final : public AsyncWrap, // blocked because of flow control restriction. void EmitBlocked(); + // Notifies the JavaScript side that the outbound buffer has capacity + // for more data. Fires when write_desired_size transitions from 0 to > 0. + void EmitDrain(); + + // Updates the write_desired_size state field based on current flow control + // and outbound buffer state. Emits drain if transitioning from 0 to > 0. + void UpdateWriteDesiredSize(); + // Delivers the set of inbound headers that have been collected. void EmitHeaders(); @@ -355,11 +378,14 @@ class Stream final : public AsyncWrap, error_code pending_close_read_code_ = 0; error_code pending_close_write_code_ = 0; - struct PendingPriority { - StreamPriority priority; - StreamPriorityFlags flags; + struct StoredPriority { + StreamPriority priority = StreamPriority::DEFAULT; + StreamPriorityFlags flags = StreamPriorityFlags::NON_INCREMENTAL; + bool pending = false; }; - std::optional pending_priority_ = std::nullopt; + StoredPriority priority_; + + const StoredPriority& stored_priority() const { return priority_; } // The headers_ field holds a block of headers that have been received and // are being buffered for delivery to the JavaScript side. @@ -393,6 +419,7 @@ class Stream final : public AsyncWrap, using Queue = ListHead; void Schedule(Queue* queue); + void Unschedule(); }; } // namespace node::quic diff --git a/src/quic/tlscontext.cc b/src/quic/tlscontext.cc index 358256329984b4..b563bae5071e0f 100644 --- a/src/quic/tlscontext.cc +++ b/src/quic/tlscontext.cc @@ -631,8 +631,16 @@ int TLSContext::OnSNI(SSL* ssl, int* ad, void* arg) { auto it = default_ctx->sni_contexts_.find(servername); if (it != default_ctx->sni_contexts_.end()) { SSL_set_SSL_CTX(ssl, it->second->ctx_.get()); + return SSL_TLSEXT_ERR_OK; } } + // No matching hostname found. If the default context has a certificate + // (from the sni['*'] wildcard identity), fall through to use it. + // Otherwise, reject the connection with an unrecognized_name alert. + if (SSL_CTX_get0_certificate(default_ctx->ctx_.get()) == nullptr) { + *ad = SSL_AD_UNRECOGNIZED_NAME; + return SSL_TLSEXT_ERR_ALERT_FATAL; + } return SSL_TLSEXT_ERR_OK; } @@ -697,9 +705,10 @@ Maybe TLSContext::Options::From(Environment* env, if (!SET(verify_client) || !SET(reject_unauthorized) || !SET(enable_early_data) || !SET(enable_tls_trace) || !SET(alpn) || !SET(servername) || !SET(ciphers) || !SET(groups) || - !SET(verify_private_key) || !SET(keylog) || - !SET_VECTOR(crypto::KeyObjectData, keys) || !SET_VECTOR(Store, certs) || - !SET_VECTOR(Store, ca) || !SET_VECTOR(Store, crl)) { + !SET(verify_private_key) || !SET(keylog) || !SET(port) || + !SET(authoritative) || !SET_VECTOR(crypto::KeyObjectData, keys) || + !SET_VECTOR(Store, certs) || !SET_VECTOR(Store, ca) || + !SET_VECTOR(Store, crl)) { return Nothing(); } @@ -840,15 +849,23 @@ void TLSSession::Initialize( // The early data will just be ignored if it's invalid. if (ossl_context_.set_session_ticket(ticket)) { - ngtcp2_vec rtp = sessionTicket.transport_params(); - if (ngtcp2_conn_decode_and_set_0rtt_transport_params( - *session_, rtp.base, rtp.len) == 0) { - if (!ossl_context_.set_early_data_enabled()) { - validation_error_ = "Failed to enable early data"; - ossl_context_.reset(); - return; + // Only enable 0-RTT if the option allows it. The session + // ticket is still used for TLS resumption (1-RTT) either way. + if (options.enable_early_data) { + ngtcp2_vec rtp = sessionTicket.transport_params(); + if (ngtcp2_conn_decode_and_set_0rtt_transport_params( + *session_, rtp.base, rtp.len) == 0) { + if (!ossl_context_.set_early_data_enabled()) { + validation_error_ = "Failed to enable early data"; + ossl_context_.reset(); + return; + } + session_->SetStreamOpenAllowed(); + // Populate the state buffer from the 0-RTT transport + // params so that maxDatagramSize and other values are + // available before the handshake completes. + session_->PopulateEarlyTransportParamsState(); } - session_->SetStreamOpenAllowed(); } } } diff --git a/src/quic/tlscontext.h b/src/quic/tlscontext.h index a667b8980da549..335f577e3994c5 100644 --- a/src/quic/tlscontext.h +++ b/src/quic/tlscontext.h @@ -241,6 +241,15 @@ class TLSContext final : public MemoryRetainer, // JavaScript option name "crl" std::vector crl; + // The port to advertise in ORIGIN frames for this hostname. + // Defaults to 443 (the standard HTTPS port). Only relevant for + // server-side SNI entries used with HTTP/3. + uint16_t port = 443; + + // Whether this hostname should be included in ORIGIN frames. + // Only relevant for server-side SNI entries. + bool authoritative = true; + void MemoryInfo(MemoryTracker* tracker) const override; SET_MEMORY_INFO_NAME(TLSContext::Options) SET_SELF_SIZE(Options) diff --git a/src/quic/tokens.cc b/src/quic/tokens.cc index 761c4a63d5ad6b..fb348b02e01b24 100644 --- a/src/quic/tokens.cc +++ b/src/quic/tokens.cc @@ -61,42 +61,59 @@ std::string TokenSecret::ToString() const { // ============================================================================ // StatelessResetToken -StatelessResetToken::StatelessResetToken() : ptr_(nullptr), buf_() {} +StatelessResetToken::StatelessResetToken() + : ngtcp2_stateless_reset_token(), ptr_(nullptr) {} -StatelessResetToken::StatelessResetToken(const uint8_t* token) : ptr_(token) {} +StatelessResetToken::StatelessResetToken(const uint8_t* token) + : ptr_(reinterpret_cast(token)) {} + +StatelessResetToken::StatelessResetToken( + const ngtcp2_stateless_reset_token* token) + : ptr_(token) {} StatelessResetToken::StatelessResetToken(const TokenSecret& secret, const CID& cid) - : ptr_(buf_) { + : ptr_(this) { CHECK_EQ(ngtcp2_crypto_generate_stateless_reset_token( - buf_, secret, kStatelessTokenLen, cid), + data, secret, kStatelessTokenLen, cid), 0); } StatelessResetToken::StatelessResetToken(uint8_t* token, const TokenSecret& secret, const CID& cid) - : ptr_(token) { + : ptr_(reinterpret_cast(token)) { CHECK_EQ(ngtcp2_crypto_generate_stateless_reset_token( token, secret, kStatelessTokenLen, cid), 0); } +StatelessResetToken::StatelessResetToken(ngtcp2_stateless_reset_token* token, + const TokenSecret& secret, + const CID& cid) + : ptr_(token) { + CHECK_EQ(ngtcp2_crypto_generate_stateless_reset_token( + token->data, secret, kStatelessTokenLen, cid), + 0); +} + StatelessResetToken::StatelessResetToken(const StatelessResetToken& other) - : ptr_(buf_) { + : ngtcp2_stateless_reset_token(), ptr_(other ? this : nullptr) { if (other) { - memcpy(buf_, other.ptr_, kStatelessTokenLen); - } else { - ptr_ = nullptr; + memcpy(data, other.ptr_->data, kStatelessTokenLen); } } StatelessResetToken::operator const uint8_t*() const { - return ptr_ != nullptr ? ptr_ : buf_; + return ptr_ != nullptr ? ptr_->data : data; +} + +StatelessResetToken::operator const ngtcp2_stateless_reset_token*() const { + return ptr_; } StatelessResetToken::operator const char*() const { - return reinterpret_cast(ptr_ != nullptr ? ptr_ : buf_); + return reinterpret_cast(ptr_ != nullptr ? ptr_->data : data); } StatelessResetToken::operator bool() const { @@ -109,7 +126,7 @@ bool StatelessResetToken::operator==(const StatelessResetToken& other) const { (ptr_ != nullptr && other.ptr_ == nullptr)) { return false; } - return CRYPTO_memcmp(ptr_, other.ptr_, kStatelessTokenLen) == 0; + return CRYPTO_memcmp(ptr_->data, other.ptr_->data, kStatelessTokenLen) == 0; } bool StatelessResetToken::operator!=(const StatelessResetToken& other) const { @@ -128,7 +145,7 @@ std::string StatelessResetToken::ToString() const { size_t StatelessResetToken::Hash::operator()( const StatelessResetToken& token) const { if (token.ptr_ == nullptr) return 0; - return HashBytes(token.ptr_, kStatelessTokenLen); + return HashBytes(token.ptr_->data, kStatelessTokenLen); } StatelessResetToken StatelessResetToken::kInvalid; diff --git a/src/quic/tokens.h b/src/quic/tokens.h index cfbaa94e344f8d..5438a4d5d8c414 100644 --- a/src/quic/tokens.h +++ b/src/quic/tokens.h @@ -70,7 +70,8 @@ class TokenSecret final : public MemoryRetainer { // // StatlessResetTokens are always kStatelessTokenLen bytes, // as are the secrets used to generate the token. -class StatelessResetToken final : public MemoryRetainer { +class StatelessResetToken final : public ngtcp2_stateless_reset_token, + public MemoryRetainer { public: static constexpr int kStatelessTokenLen = NGTCP2_STATELESS_RESET_TOKENLEN; @@ -78,30 +79,35 @@ class StatelessResetToken final : public MemoryRetainer { // Generates a stateless reset token using HKDF with the cid and token secret // as input. The token secret is either provided by user code when an Endpoint - // is created or is generated randomly. + // is created or is generated randomly. The token is stored in the inherited + // ngtcp2_stateless_reset_token::data and ptr_ is set to this. StatelessResetToken(const TokenSecret& secret, const CID& cid); - // Generates a stateless reset token using the given token storage. + // Generates a stateless reset token into the given external storage. // The StatelessResetToken wraps the token and does not take ownership. - // The token storage must be at least kStatelessTokenLen bytes in length. - // The length is not verified so care must be taken when using this - // constructor. StatelessResetToken(uint8_t* token, const TokenSecret& secret, const CID& cid); + // Generates a stateless reset token into the given external storage. + // The StatelessResetToken wraps the token and does not take ownership. + StatelessResetToken(ngtcp2_stateless_reset_token* token, + const TokenSecret& secret, + const CID& cid); + // Wraps the given token. Does not take over ownership of the token storage. - // The token must be at least kStatelessTokenLen bytes in length. - // The length is not verified so care must be taken when using this - // constructor. explicit StatelessResetToken(const uint8_t* token); + // Wraps the given token. Does not take over ownership of the token storage. + explicit StatelessResetToken(const ngtcp2_stateless_reset_token* token); + StatelessResetToken(const StatelessResetToken& other); DISALLOW_MOVE(StatelessResetToken) std::string ToString() const; operator const uint8_t*() const; + operator const ngtcp2_stateless_reset_token*() const; operator bool() const; bool operator==(const StatelessResetToken& other) const; @@ -124,8 +130,7 @@ class StatelessResetToken final : public MemoryRetainer { private: operator const char*() const; - const uint8_t* ptr_; - uint8_t buf_[NGTCP2_STATELESS_RESET_TOKENLEN]; + const ngtcp2_stateless_reset_token* ptr_; }; // A RETRY packet communicates a retry token to the client. Retry tokens are diff --git a/src/quic/transportparams.cc b/src/quic/transportparams.cc index da665ea01bf35a..372e9dc0828a10 100644 --- a/src/quic/transportparams.cc +++ b/src/quic/transportparams.cc @@ -1,6 +1,8 @@ #if HAVE_OPENSSL && HAVE_QUIC #include "guard.h" #ifndef OPENSSL_NO_QUIC +#include +#include #include #include #include @@ -10,6 +12,7 @@ #include "defs.h" #include "endpoint.h" #include "session.h" +#include "session_manager.h" #include "tokens.h" #include "transportparams.h" @@ -69,10 +72,49 @@ Maybe TransportParams::Options::From( #undef SET - // TODO(@jasnell): We are not yet exposing the ability to set the preferred - // adddress via the options, tho the underlying support is here in the class. - options.preferred_address_ipv4 = std::nullopt; - options.preferred_address_ipv6 = std::nullopt; + // Parse the preferred address options. These are SocketAddress objects + // (or undefined to skip). Only meaningful for server sessions. + Local preferred_ipv4; + if (!params->Get(env->context(), state.preferred_address_ipv4_string()) + .ToLocal(&preferred_ipv4)) { + return Nothing(); + } + if (!preferred_ipv4->IsUndefined()) { + if (!SocketAddressBase::HasInstance(env, preferred_ipv4)) { + THROW_ERR_INVALID_ARG_TYPE( + env, "transportParams.preferredAddressIpv4 must be a SocketAddress"); + return Nothing(); + } + auto* addr = BaseObject::FromJSObject( + preferred_ipv4.As()); + if (addr->address()->family() != AF_INET) { + THROW_ERR_INVALID_ARG_VALUE( + env, "transportParams.preferredAddressIpv4 must be an IPv4 address"); + return Nothing(); + } + options.preferred_address_ipv4 = *addr->address(); + } + + Local preferred_ipv6; + if (!params->Get(env->context(), state.preferred_address_ipv6_string()) + .ToLocal(&preferred_ipv6)) { + return Nothing(); + } + if (!preferred_ipv6->IsUndefined()) { + if (!SocketAddressBase::HasInstance(env, preferred_ipv6)) { + THROW_ERR_INVALID_ARG_TYPE( + env, "transportParams.preferredAddressIpv6 must be a SocketAddress"); + return Nothing(); + } + auto* addr = BaseObject::FromJSObject( + preferred_ipv6.As()); + if (addr->address()->family() != AF_INET6) { + THROW_ERR_INVALID_ARG_VALUE( + env, "transportParams.preferredAddressIpv6 must be an IPv6 address"); + return Nothing(); + } + options.preferred_address_ipv6 = *addr->address(); + } return Just(options); } @@ -113,8 +155,6 @@ std::string TransportParams::Options::ToString() const { res += prefix + "max ack delay: " + std::to_string(max_ack_delay); res += prefix + "max datagram frame size: " + std::to_string(max_datagram_frame_size); - res += prefix + "disable active migration: " + - (disable_active_migration ? std::string("yes") : std::string("no")); res += indent.Close(); return res; } @@ -151,8 +191,8 @@ TransportParams::TransportParams(const Config& config, const Options& options) SET_PARAM(ack_delay_exponent); SET_PARAM(max_datagram_frame_size); SET_PARAM_V(max_idle_timeout, options.max_idle_timeout * NGTCP2_SECONDS); - SET_PARAM_V(disable_active_migration, - options.disable_active_migration ? 1 : 0); + SET_PARAM_V(disable_active_migration, 0); + SET_PARAM_V(grease_quic_bit, 1); SET_PARAM_V(preferred_addr_present, 0); SET_PARAM_V(stateless_reset_token_present, 0); SET_PARAM_V(retry_scid_present, 0); @@ -172,11 +212,13 @@ TransportParams::TransportParams(const Config& config, const Options& options) #undef SET_PARAM #undef SET_PARAM_V - if (options.preferred_address_ipv4.has_value()) + if (options.preferred_address_ipv4.has_value()) { SetPreferredAddress(options.preferred_address_ipv4.value()); + } - if (options.preferred_address_ipv6.has_value()) + if (options.preferred_address_ipv6.has_value()) { SetPreferredAddress(options.preferred_address_ipv6.value()); + } } TransportParams::TransportParams(const ngtcp2_vec& vec, Version version) @@ -288,6 +330,12 @@ void TransportParams::GeneratePreferredAddressToken(Session* session) { params_.preferred_addr.stateless_reset_token, config.preferred_address_cid), session); + // Register the preferred address CID with SessionManager for + // cross-endpoint routing. This is a locally-generated CID that needs + // to be routable from the preferred address endpoint (which may be + // different from the primary endpoint). + auto& mgr = BindingData::Get(session->env()).session_manager(); + mgr.AssociateCID(config.preferred_address_cid, config.scid); } } diff --git a/src/quic/transportparams.h b/src/quic/transportparams.h index 45ee0d49e79a15..1f3cd545cdd209 100644 --- a/src/quic/transportparams.h +++ b/src/quic/transportparams.h @@ -114,16 +114,9 @@ class TransportParams final { // The maximum size of DATAGRAM frames that the endpoint will accept. // Setting the value to 0 will disable DATAGRAM support. // https://datatracker.ietf.org/doc/html/rfc9221#section-3 - uint64_t max_datagram_frame_size = kDefaultMaxPacketLength; + uint16_t max_datagram_frame_size = kDefaultMaxPacketLength; // When true, communicates that the Session does not support active - // connection migration. See the QUIC specification for more details on - // connection migration. - // https://www.rfc-editor.org/rfc/rfc9000.html#section-18.2-4.30.1 - // TODO(@jasnell): Active connection migration is not yet implemented. - // This will be revisited in a future update. - bool disable_active_migration = true; - static const Options kDefault; void MemoryInfo(MemoryTracker* tracker) const override; diff --git a/test/cctest/test_dataqueue.cc b/test/cctest/test_dataqueue.cc index 73488fcab0a4d1..7c75bf9bfc42d9 100644 --- a/test/cctest/test_dataqueue.cc +++ b/test/cctest/test_dataqueue.cc @@ -495,25 +495,10 @@ TEST(DataQueue, NonIdempotentDataQueue) { CHECK(!waitingForPull); CHECK_EQ(status, node::bob::STATUS_CONTINUE); - // We can read the expected data from reader1. Because the entries are - // InMemoryEntry instances, reads will be fully synchronous here. + // The next read produces buffer2. When the first entry's reader returns + // EOS, the NonIdempotentDataQueueReader immediately pulls from the next + // entry (recursive Pull), so the transition is seamless. waitingForPull = true; - - status = reader->Pull( - [&](int status, const DataQueue::Vec* vecs, size_t count, auto done) { - waitingForPull = false; - CHECK_EQ(status, node::bob::STATUS_CONTINUE); - CHECK_EQ(count, 0); - }, - node::bob::OPTIONS_SYNC, - nullptr, - 0, - node::bob::kMaxCountHint); - - CHECK(!waitingForPull); - CHECK_EQ(status, node::bob::STATUS_CONTINUE); - - // The next read produces buffer2, and should be the end. status = reader->Pull( [&](int status, const DataQueue::Vec* vecs, size_t count, auto done) { waitingForPull = false; @@ -628,6 +613,9 @@ TEST(DataQueue, DataQueueEntry) { CHECK(!pullIsPending); CHECK_EQ(status, node::bob::STATUS_CONTINUE); + // Cap the queue so the reader can reach EOS after draining all entries. + data_queue2->cap(); + // Read to completion... while (status != node::bob::STATUS_EOS) { status = reader->Pull( diff --git a/test/cctest/test_quic_tokens.cc b/test/cctest/test_quic_tokens.cc index 1003b1a0e8005f..f24e0fc50dfc7a 100644 --- a/test/cctest/test_quic_tokens.cc +++ b/test/cctest/test_quic_tokens.cc @@ -56,7 +56,7 @@ TEST(StatelessResetToken, Basic) { CHECK_EQ(token, token2); - // Let's pretend out secret is also a token just for the sake + // Let's pretend our secret is also a token just for the sake // of the test. That's ok because they're the same length. StatelessResetToken token3(secret); @@ -85,6 +85,83 @@ TEST(StatelessResetToken, Basic) { CHECK_EQ(found->second, token); } +TEST(StatelessResetToken, Ngtcp2StructIntegration) { + uint8_t secret[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6}; + uint8_t cid_data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0}; + ngtcp2_cid cid_; + ngtcp2_cid_init(&cid_, cid_data, 10); + TokenSecret fixed_secret(secret); + CID cid(cid_); + + // Owning token — generated into the inherited ngtcp2_stateless_reset_token + StatelessResetToken owning(fixed_secret, cid); + CHECK(owning); + + // The ngtcp2_stateless_reset_token* conversion operator should return + // a valid pointer to the token data. + const ngtcp2_stateless_reset_token* as_struct = owning; + CHECK_NE(as_struct, nullptr); + // The struct's data should match the uint8_t* conversion. + const uint8_t* as_bytes = owning; + CHECK_EQ( + memcmp( + as_struct->data, as_bytes, StatelessResetToken::kStatelessTokenLen), + 0); + + // Non-owning from const ngtcp2_stateless_reset_token* — wraps an + // existing struct without copying. + StatelessResetToken from_struct(as_struct); + CHECK(from_struct); + CHECK_EQ(from_struct, owning); + // The pointer should be the same (non-owning wraps, doesn't copy). + const ngtcp2_stateless_reset_token* from_struct_ptr = from_struct; + CHECK_EQ(from_struct_ptr, as_struct); + + // Owning into external ngtcp2_stateless_reset_token — generates the + // token into a caller-provided struct. + ngtcp2_stateless_reset_token external_struct{}; + StatelessResetToken into_struct(&external_struct, fixed_secret, cid); + CHECK(into_struct); + CHECK_EQ(into_struct, owning); + // The external struct should now contain the generated token. + CHECK_EQ(memcmp(external_struct.data, + as_bytes, + StatelessResetToken::kStatelessTokenLen), + 0); + // The conversion operator should return a pointer to the external struct. + const ngtcp2_stateless_reset_token* into_struct_ptr = into_struct; + CHECK_EQ(into_struct_ptr, &external_struct); + + // Copy of an owning token should itself be owning (independent copy). + StatelessResetToken copy_of_owning = owning; + CHECK_EQ(copy_of_owning, owning); + const ngtcp2_stateless_reset_token* copy_ptr = copy_of_owning; + // Should NOT point to the same memory as the original. + CHECK_NE(copy_ptr, as_struct); + // But data should match. + CHECK_EQ( + memcmp(copy_ptr->data, as_bytes, StatelessResetToken::kStatelessTokenLen), + 0); + + // Copy of a non-owning token should become owning (copies data). + StatelessResetToken copy_of_non_owning = from_struct; + CHECK_EQ(copy_of_non_owning, from_struct); + const ngtcp2_stateless_reset_token* copy_no_ptr = copy_of_non_owning; + // Should NOT point to the original non-owning source. + CHECK_NE(copy_no_ptr, from_struct_ptr); + + // kInvalid conversions. + const ngtcp2_stateless_reset_token* invalid_ptr = + StatelessResetToken::kInvalid; + CHECK_EQ(invalid_ptr, nullptr); + const uint8_t* invalid_bytes = StatelessResetToken::kInvalid; + // When ptr_ is null, falls back to inherited data (zeroed). + uint8_t zeroed[StatelessResetToken::kStatelessTokenLen]{}; + CHECK_EQ( + memcmp(invalid_bytes, zeroed, StatelessResetToken::kStatelessTokenLen), + 0); +} + TEST(RetryToken, Basic) { auto& random = CID::Factory::random(); TokenSecret secret; diff --git a/test/cctest/test_sockaddr.cc b/test/cctest/test_sockaddr.cc index 68b8739f97e1fc..d4d3a32c3671f6 100644 --- a/test/cctest/test_sockaddr.cc +++ b/test/cctest/test_sockaddr.cc @@ -1,5 +1,5 @@ -#include "node_sockaddr-inl.h" #include "gtest/gtest.h" +#include "node_sockaddr-inl.h" using node::SocketAddress; using node::SocketAddressBlockList; @@ -43,6 +43,85 @@ TEST(SocketAddress, SocketAddress) { CHECK_EQ(map[addr], 2); } +TEST(SocketAddress, IpHashAndIpEqual) { + sockaddr_storage s1, s2, s3, s4; + // Same IP, different ports. + SocketAddress::ToSockAddr(AF_INET, "10.0.0.1", 443, &s1); + SocketAddress::ToSockAddr(AF_INET, "10.0.0.1", 8080, &s2); + // Different IP. + SocketAddress::ToSockAddr(AF_INET, "10.0.0.2", 443, &s3); + + SocketAddress addr1(reinterpret_cast(&s1)); + SocketAddress addr2(reinterpret_cast(&s2)); + SocketAddress addr3(reinterpret_cast(&s3)); + + SocketAddress::IpHash ip_hash; + SocketAddress::IpEqual ip_equal; + + // Same IP, different port: should hash equal and compare equal. + CHECK_EQ(ip_hash(addr1), ip_hash(addr2)); + CHECK(ip_equal(addr1, addr2)); + + // Different IP: should not compare equal. + CHECK(!ip_equal(addr1, addr3)); + + // Full Hash (includes port) should differ for same IP, different port. + CHECK_NE(SocketAddress::Hash()(addr1), SocketAddress::Hash()(addr2)); + + // IpMap should treat same-IP-different-port as the same key. + SocketAddress::IpMap map; + map[addr1] = 1; + map[addr2]++; // Same IP as addr1, should increment the same entry. + CHECK_EQ(map[addr1], 2); + CHECK_EQ(map.size(), 1); + + map[addr3] = 10; + CHECK_EQ(map.size(), 2); + CHECK_EQ(map[addr3], 10); +} + +TEST(SocketAddress, IpHashIPv6) { + sockaddr_storage s1, s2, s3; + SocketAddress::ToSockAddr(AF_INET6, "::1", 443, &s1); + SocketAddress::ToSockAddr(AF_INET6, "::1", 8080, &s2); + SocketAddress::ToSockAddr(AF_INET6, "::2", 443, &s3); + + SocketAddress addr1(reinterpret_cast(&s1)); + SocketAddress addr2(reinterpret_cast(&s2)); + SocketAddress addr3(reinterpret_cast(&s3)); + + SocketAddress::IpHash ip_hash; + SocketAddress::IpEqual ip_equal; + + // Same IPv6, different port: equal. + CHECK_EQ(ip_hash(addr1), ip_hash(addr2)); + CHECK(ip_equal(addr1, addr2)); + + // Different IPv6: not equal. + CHECK(!ip_equal(addr1, addr3)); + + // IpMap with IPv6 keys. + SocketAddress::IpMap map; + map[addr1] = 5; + map[addr2]++; + CHECK_EQ(map[addr1], 6); + CHECK_EQ(map.size(), 1); +} + +TEST(SocketAddress, IpEqualCrossFamily) { + sockaddr_storage s1, s2; + SocketAddress::ToSockAddr(AF_INET, "127.0.0.1", 443, &s1); + SocketAddress::ToSockAddr(AF_INET6, "::1", 443, &s2); + + SocketAddress addr1(reinterpret_cast(&s1)); + SocketAddress addr2(reinterpret_cast(&s2)); + + SocketAddress::IpEqual ip_equal; + + // Different address families should never be equal. + CHECK(!ip_equal(addr1, addr2)); +} + TEST(SocketAddress, SocketAddressIPv6) { sockaddr_storage storage; SocketAddress::ToSockAddr(AF_INET6, "::1", 443, &storage); @@ -85,7 +164,6 @@ TEST(SocketAddressLRU, SocketAddressLRU) { SocketAddress::ToSockAddr(AF_INET, "123.123.123.125", 443, &storage[2]); SocketAddress::ToSockAddr(AF_INET, "123.123.123.123", 443, &storage[3]); - SocketAddress addr1(reinterpret_cast(&storage[0])); SocketAddress addr2(reinterpret_cast(&storage[1])); SocketAddress addr3(reinterpret_cast(&storage[2])); @@ -197,12 +275,10 @@ TEST(SocketAddressBlockList, Simple) { sockaddr_storage storage[2]; SocketAddress::ToSockAddr(AF_INET, "10.0.0.1", 0, &storage[0]); SocketAddress::ToSockAddr(AF_INET, "10.0.0.2", 0, &storage[1]); - std::shared_ptr addr1 = - std::make_shared( - reinterpret_cast(&storage[0])); - std::shared_ptr addr2 = - std::make_shared( - reinterpret_cast(&storage[1])); + std::shared_ptr addr1 = std::make_shared( + reinterpret_cast(&storage[0])); + std::shared_ptr addr2 = std::make_shared( + reinterpret_cast(&storage[1])); bl.AddSocketAddress(addr1); bl.AddSocketAddress(addr2); diff --git a/test/common/quic.mjs b/test/common/quic.mjs new file mode 100644 index 00000000000000..7bc7a427b992ac --- /dev/null +++ b/test/common/quic.mjs @@ -0,0 +1,57 @@ +// Shared helpers for QUIC tests. +// +// Usage: +// import { key, cert, listen, connect } from '../common/quic.mjs'; +// +// Provides pre-loaded TLS credentials and thin wrappers around node:quic +// listen/connect that apply default options suitable for most tests. + +import * as fixtures from '../common/fixtures.mjs'; + +const { createPrivateKey } = await import('node:crypto'); +const quic = await import('node:quic'); + +// Pre-loaded TLS credentials from the standard agent1 fixture pair. +const key = createPrivateKey(fixtures.readKey('agent1-key.pem')); +const cert = fixtures.readKey('agent1-cert.pem'); + +/** + * Start a QUIC server with sensible test defaults. + * @param {Function} callback The session callback (receives QuicSession). + * @param {object} [options] Options forwarded to quic.listen(). The + * following defaults are applied when not specified: + * - sni: { '*': { keys: [key], certs: [cert] } } + * - alpn: ['quic-test'] + * @returns {Promise} + */ +async function listen(callback, options = {}) { + const { + sni = { '*': { keys: [key], certs: [cert] } }, + alpn = ['quic-test'], + ...rest + } = options; + return quic.listen(callback, { sni, alpn, ...rest }); +} + +/** + * Connect a QUIC client with sensible test defaults. + * @param {SocketAddress|string} address The server address. + * @param {object} [options] Options forwarded to quic.connect(). The + * following defaults are applied when not specified: + * - alpn: 'quic-test' + * @returns {Promise} + */ +async function connect(address, options = {}) { + const { + alpn = 'quic-test', + ...rest + } = options; + return quic.connect(address, { alpn, ...rest }); +} + +export { + key, + cert, + listen, + connect, +}; diff --git a/test/fixtures/keys/Makefile b/test/fixtures/keys/Makefile index d255b5eea80e6a..def378b70fef92 100644 --- a/test/fixtures/keys/Makefile +++ b/test/fixtures/keys/Makefile @@ -2,6 +2,7 @@ all: \ ca1-cert.pem \ ca2-cert.pem \ ca2-crl.pem \ + ca2-crl-agent3.pem \ ca3-cert.pem \ ca4-cert.pem \ ca5-cert.pem \ @@ -529,6 +530,28 @@ ca2-crl.pem: ca2-key.pem ca2-cert.pem ca2.cnf agent4-cert.pem -out ca2-crl.pem \ -passin 'pass:password' +# +# Make CRL with agent3 being rejected +# Uses a separate temporary database so the ca2-crl.pem revocation of agent4 +# does not contaminate this CRL. +# +ca2-crl-agent3.pem: ca2-key.pem ca2-cert.pem ca2.cnf agent3-cert.pem + @> ca2-crl-agent3-database.txt + @sed 's/ca2-database/ca2-crl-agent3-database/' ca2.cnf > ca2-crl-agent3.cnf + openssl ca -revoke agent3-cert.pem \ + -keyfile ca2-key.pem \ + -cert ca2-cert.pem \ + -config ca2-crl-agent3.cnf \ + -passin 'pass:password' + openssl ca \ + -keyfile ca2-key.pem \ + -cert ca2-cert.pem \ + -config ca2-crl-agent3.cnf \ + -gencrl \ + -out ca2-crl-agent3.pem \ + -passin 'pass:password' + @rm -f ca2-crl-agent3.cnf ca2-crl-agent3-database.txt* + # # agent5 is signed by ca2 (client cert) # @@ -1161,7 +1184,7 @@ irrelevant_san_correct_subject-key.pem: openssl ecparam -name prime256v1 -genkey -noout -out irrelevant_san_correct_subject-key.pem clean: - rm -f *.pfx *.pem *.srl ca2-database.txt ca2-serial fake-startcom-root-serial *.print *.old fake-startcom-root-issued-certs/*.pem + rm -f *.pfx *.pem *.srl ca2-database.txt ca2-crl-agent3-database.txt* ca2-crl-agent3.cnf ca2-serial fake-startcom-root-serial *.print *.old fake-startcom-root-issued-certs/*.pem @> fake-startcom-root-database.txt test: agent1-verify agent2-verify agent3-verify agent4-verify agent5-verify agent6-verify agent7-verify agent8-verify agent10-verify ec10-verify diff --git a/test/fixtures/keys/ca2-crl-agent3.pem b/test/fixtures/keys/ca2-crl-agent3.pem new file mode 100644 index 00000000000000..9dcb4568d8a84a --- /dev/null +++ b/test/fixtures/keys/ca2-crl-agent3.pem @@ -0,0 +1,13 @@ +-----BEGIN X509 CRL----- +MIIB/jCB5wIBATANBgkqhkiG9w0BAQ0FADB6MQswCQYDVQQGEwJVUzELMAkGA1UE +CAwCQ0ExCzAJBgNVBAcMAlNGMQ8wDQYDVQQKDAZKb3llbnQxEDAOBgNVBAsMB05v +ZGUuanMxDDAKBgNVBAMMA2NhMjEgMB4GCSqGSIb3DQEJARYRcnlAdGlueWNsb3Vk +cy5vcmcXDTI2MDQxNjA0MDM1MloYDzIwNTMwOTAxMDQwMzUyWjAnMCUCFHtnB1Iw +05rTKjL+Xc+x+pXi6jGdFw0yNjA0MTYwNDAzNTJaoA4wDDAKBgNVHRQEAwIBATAN +BgkqhkiG9w0BAQ0FAAOCAQEAS7PnQxPHv+VXvmCOcTQOYWns16+G5cmaY8/fYjwM +6zOQPTItJTH+S2EJ3JvqES3Xm3KH+2Qh/8gAiiGNL9zdBpuNcJyUlJpIPuvWPd0P +Bup7u2YEvc9NjuP8thslf267A8tieFf4mF+AO1lvFp+CGoyRSwtNGOWCMkFDGgGn +ZOVXw5Q782PhUwThozGjR40zDkNjW/uFPJjMkz/RZFEmWshGf9t3VzahRs8PUApr +XTdatufBUPrWiTWyQAuME50ajzq/tfuj2kokqfOvy1mkoNwtySVxKSlwGjejd5Xj +yV/v4a5FDjXw4AwqEe+Cul9J2eyBb1jHkc+R9rutHTKEZA== +-----END X509 CRL----- diff --git a/test/parallel/test-quic-address-validation.mjs b/test/parallel/test-quic-address-validation.mjs new file mode 100644 index 00000000000000..7f6c57dfee8f52 --- /dev/null +++ b/test/parallel/test-quic-address-validation.mjs @@ -0,0 +1,48 @@ +// Flags: --experimental-quic --no-warnings + +// Test: validateAddress triggers Retry flow. +// When the server endpoint has validateAddress: true, it should send +// a Retry packet before accepting the connection. The handshake still +// completes successfully. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { strictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect, QuicEndpoint } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); + +const endpoint = new QuicEndpoint({ validateAddress: true }); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + const info = await serverSession.opened; + // The handshake should complete despite the Retry flow. + strictEqual(info.protocol, 'quic-test'); + serverSession.close(); +}), { + endpoint, + sni: { '*': { keys: [key], certs: [cert] } }, + alpn: ['quic-test'], +}); + +const clientSession = await connect(serverEndpoint.address, { + alpn: 'quic-test', + servername: 'localhost', +}); + +const info = await clientSession.opened; +strictEqual(info.protocol, 'quic-test'); + +// The serverEndpoint must be closed after we wait for the clientSession to close. +await clientSession.closed; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-alpn-h3.mjs b/test/parallel/test-quic-alpn-h3.mjs index 9a473352d7ed87..ba76d138b99673 100644 --- a/test/parallel/test-quic-alpn-h3.mjs +++ b/test/parallel/test-quic-alpn-h3.mjs @@ -4,6 +4,9 @@ import { hasQuic, skip, mustCall } from '../common/index.mjs'; import assert from 'node:assert'; import * as fixtures from '../common/fixtures.mjs'; +const { strictEqual, notStrictEqual } = assert; +const { readKey } = fixtures; + if (!hasQuic) { skip('QUIC is not enabled'); } @@ -11,34 +14,33 @@ if (!hasQuic) { const { listen, connect } = await import('node:quic'); const { createPrivateKey } = await import('node:crypto'); -const key = createPrivateKey(fixtures.readKey('agent1-key.pem')); -const cert = fixtures.readKey('agent1-cert.pem'); +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); // Test h3 ALPN negotiation with Http3ApplicationImpl. // Both server and client use the default ALPN (h3). const serverOpened = Promise.withResolvers(); -const clientOpened = Promise.withResolvers(); - -const serverEndpoint = await listen(mustCall((serverSession) => { - serverSession.opened.then(mustCall((info) => { - assert.strictEqual(info.protocol, 'h3'); - serverOpened.resolve(); - serverSession.close(); - })); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + const info = await serverSession.opened; + strictEqual(info.protocol, 'h3'); + serverOpened.resolve(); + serverSession.close(); }), { sni: { '*': { keys: [key], certs: [cert] } }, }); -assert.ok(serverEndpoint.address !== undefined); +notStrictEqual(serverEndpoint.address, undefined); const clientSession = await connect(serverEndpoint.address, { servername: 'localhost', }); -clientSession.opened.then(mustCall((info) => { - assert.strictEqual(info.protocol, 'h3'); - clientOpened.resolve(); -})); -await Promise.all([serverOpened.promise, clientOpened.promise]); +async function checkClient() { + const info = await clientSession.opened; + strictEqual(info.protocol, 'h3'); +} + +await Promise.all([serverOpened.promise, checkClient()]); clientSession.close(); diff --git a/test/parallel/test-quic-alpn-mismatch.mjs b/test/parallel/test-quic-alpn-mismatch.mjs new file mode 100644 index 00000000000000..5dfff57219e0aa --- /dev/null +++ b/test/parallel/test-quic-alpn-mismatch.mjs @@ -0,0 +1,50 @@ +// Flags: --experimental-quic --no-warnings + +// Test: ALPN mismatch causes connection failure. +// The server offers 'quic-test' but the client requests 'nonexistent'. +// The handshake should fail. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { rejects, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const onerror = mustCall((err) => { + strictEqual(err.code, 'ERR_QUIC_TRANSPORT_ERROR'); +}, 2); +const transportParams = { maxIdleTimeout: 1 }; + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await rejects(serverSession.opened, { + code: 'ERR_QUIC_TRANSPORT_ERROR', + }); + await rejects(serverSession.closed, { + code: 'ERR_QUIC_TRANSPORT_ERROR', + }); +}), { + transportParams, + onerror, +}); + +// Client requests an ALPN the server doesn't offer. +const clientSession = await connect(serverEndpoint.address, { + alpn: 'nonexistent-protocol', + transportParams, + onerror, +}); + +await rejects(clientSession.opened, { + code: 'ERR_QUIC_TRANSPORT_ERROR', +}); + +// The handshake should fail — opened may reject or never resolve. +// The session should close with an error. +await rejects(clientSession.closed, { + code: 'ERR_QUIC_TRANSPORT_ERROR', +}); diff --git a/test/parallel/test-quic-alpn.mjs b/test/parallel/test-quic-alpn.mjs index b5eedf65373e1c..a077d1cfb610d2 100644 --- a/test/parallel/test-quic-alpn.mjs +++ b/test/parallel/test-quic-alpn.mjs @@ -4,6 +4,9 @@ import { hasQuic, skip, mustCall } from '../common/index.mjs'; import assert from 'node:assert'; import * as fixtures from '../common/fixtures.mjs'; +const { notStrictEqual, strictEqual } = assert; +const { readKey } = fixtures; + if (!hasQuic) { skip('QUIC is not enabled'); } @@ -11,37 +14,34 @@ if (!hasQuic) { const { listen, connect } = await import('node:quic'); const { createPrivateKey } = await import('node:crypto'); -const key = createPrivateKey(fixtures.readKey('agent1-key.pem')); -const cert = fixtures.readKey('agent1-cert.pem'); +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); // Server offers multiple ALPNs. Client requests one that the server supports. // Verify the negotiated protocol matches on both sides. const serverOpened = Promise.withResolvers(); -const clientOpened = Promise.withResolvers(); - -const serverEndpoint = await listen(mustCall((serverSession) => { - serverSession.opened.then(mustCall((info) => { - // The server should negotiate proto-b (client's choice from server's list) - assert.strictEqual(info.protocol, 'proto-b'); - serverOpened.resolve(); - serverSession.close(); - })); + +async function checkSession(session) { + const info = await session.opened; + // The client should negotiate proto-b (the only protocol it requested) + strictEqual(info.protocol, 'proto-b'); +} + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await checkSession(serverSession); + serverOpened.resolve(); }), { sni: { '*': { keys: [key], certs: [cert] } }, alpn: ['proto-a', 'proto-b', 'proto-c'], }); -assert.ok(serverEndpoint.address !== undefined); +notStrictEqual(serverEndpoint.address, undefined); const clientSession = await connect(serverEndpoint.address, { alpn: 'proto-b', servername: 'localhost', }); -clientSession.opened.then(mustCall((info) => { - assert.strictEqual(info.protocol, 'proto-b'); - clientOpened.resolve(); -})); -await Promise.all([serverOpened.promise, clientOpened.promise]); -clientSession.close(); +await Promise.all([serverOpened.promise, checkSession(clientSession)]); +await clientSession.close(); diff --git a/test/parallel/test-quic-callback-error-onblocked.mjs b/test/parallel/test-quic-callback-error-onblocked.mjs new file mode 100644 index 00000000000000..11aad4017a699f --- /dev/null +++ b/test/parallel/test-quic-callback-error-onblocked.mjs @@ -0,0 +1,45 @@ +// Flags: --experimental-quic --no-warnings + +// Test: onblocked callback error handling. +// A sync throw in stream.onblocked destroys the stream via +// safeCallbackInvoke. The stream.closed promise rejects with the error. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { rejects } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const testError = new Error('onblocked throw'); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; +}), { + // Small stream window to trigger flow control blocking. + transportParams: { + maxIdleTimeout: 1, + initialMaxStreamDataBidiRemote: 256, + }, +}); + +const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxIdleTimeout: 1 }, +}); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream(); + +stream.onblocked = mustCall(() => { + throw testError; +}); + +// Body larger than the 256-byte flow control window triggers onblocked. +stream.setBody(new Uint8Array(4096)); + +// The stream's closed promise should reject with the error from the throw. +await rejects(stream.closed, testError); diff --git a/test/parallel/test-quic-callback-error-ondatagram-async.mjs b/test/parallel/test-quic-callback-error-ondatagram-async.mjs new file mode 100644 index 00000000000000..4e6f814906fb40 --- /dev/null +++ b/test/parallel/test-quic-callback-error-ondatagram-async.mjs @@ -0,0 +1,46 @@ +// Flags: --experimental-quic --no-warnings + +// Test: async rejection in ondatagram destroys session. +// safeCallbackInvoke detects the returned promise and attaches a +// rejection handler that calls session.destroy(err). The error is +// delivered to the onerror callback. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const testError = new Error('async ondatagram rejection'); +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await assert.rejects(serverSession.closed, testError); + serverDone.resolve(); +}), { + transportParams: { maxDatagramFrameSize: 1200 }, + ondatagram: mustCall(async () => { + throw testError; + }), + onerror: mustCall((err) => { + assert.strictEqual(err, testError); + }), +}); + +const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxIdleTimeout: 1, maxDatagramFrameSize: 1200 }, +}); +await clientSession.opened; + +await clientSession.sendDatagram(new Uint8Array([1, 2, 3])); + +await serverDone.promise; +// The server session was destroyed abruptly (no CONNECTION_CLOSE sent). +// The client may receive a stateless reset if it sends any packet +// before its idle timeout fires, so closed may reject. +await assert.rejects(clientSession.closed, { code: 'ERR_QUIC_TRANSPORT_ERROR' }); +serverEndpoint.close(); +await serverEndpoint.closed; diff --git a/test/parallel/test-quic-callback-error-ondatagram.mjs b/test/parallel/test-quic-callback-error-ondatagram.mjs new file mode 100644 index 00000000000000..f0253f22768380 --- /dev/null +++ b/test/parallel/test-quic-callback-error-ondatagram.mjs @@ -0,0 +1,48 @@ +// Flags: --experimental-quic --no-warnings + +// Test: ondatagram callback error handling. +// A sync throw in ondatagram destroys the session via safeCallbackInvoke. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { rejects, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const testError = new Error('ondatagram throw'); +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + // The session is destroyed by the ondatagram throw. The closed promise + // rejects with testError. Verify that and signal completion. + await rejects(serverSession.closed, testError); + serverDone.resolve(); +}), { + transportParams: { maxDatagramFrameSize: 1200 }, + ondatagram() { + throw testError; + }, + onerror: mustCall((err) => { + strictEqual(err, testError); + }), +}); + +const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxIdleTimeout: 1, maxDatagramFrameSize: 1200 }, +}); +await clientSession.opened; + +// Send a datagram to trigger the server's ondatagram callback. +await clientSession.sendDatagram(new Uint8Array([1, 2, 3])); + +await serverDone.promise; +// The server session was destroyed abruptly (no CONNECTION_CLOSE sent). +// The client may receive a stateless reset if it sends any packet +// before its idle timeout fires, so closed may reject. +await rejects(clientSession.closed, { code: 'ERR_QUIC_TRANSPORT_ERROR' }); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-callback-error-ondatagramstatus.mjs b/test/parallel/test-quic-callback-error-ondatagramstatus.mjs new file mode 100644 index 00000000000000..17e2b500720cc3 --- /dev/null +++ b/test/parallel/test-quic-callback-error-ondatagramstatus.mjs @@ -0,0 +1,40 @@ +// Flags: --experimental-quic --no-warnings + +// Test: ondatagramstatus callback error handling. +// A sync throw in ondatagramstatus destroys the session via safeCallbackInvoke. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { rejects, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const testError = new Error('ondatagramstatus throw'); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; +}), { + transportParams: { maxIdleTimeout: 1, maxDatagramFrameSize: 1200 }, +}); + +const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxIdleTimeout: 1, maxDatagramFrameSize: 1200 }, + ondatagramstatus() { + throw testError; + }, + onerror: mustCall((err) => { + strictEqual(err, testError); + }), +}); +await clientSession.opened; + +// Send a datagram. The status callback fires when the peer ACKs it. +await clientSession.sendDatagram(new Uint8Array([1, 2, 3])); + +// The session's closed should reject with the error from the throw. +await rejects(clientSession.closed, testError); diff --git a/test/parallel/test-quic-callback-error-onerror-option.mjs b/test/parallel/test-quic-callback-error-onerror-option.mjs new file mode 100644 index 00000000000000..29b9e707d52845 --- /dev/null +++ b/test/parallel/test-quic-callback-error-onerror-option.mjs @@ -0,0 +1,36 @@ +// Flags: --experimental-quic --no-warnings + +// Test: onerror set via connect() options. +// The onerror callback can be provided in the options object at +// session creation time to avoid race conditions with errors that +// occur during or immediately after the handshake. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { rejects, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const transportParams = { maxIdleTimeout: 1 }; +const testError = new Error('destroy with error'); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; +}), { transportParams }); + +const clientSession = await connect(serverEndpoint.address, { + transportParams, + onerror: mustCall((err) => { + strictEqual(err, testError); + }), +}); +await clientSession.opened; + +clientSession.destroy(testError); + +await rejects(clientSession.closed, testError); diff --git a/test/parallel/test-quic-callback-error-onerror-validation.mjs b/test/parallel/test-quic-callback-error-onerror-validation.mjs new file mode 100644 index 00000000000000..e695c1d761ac78 --- /dev/null +++ b/test/parallel/test-quic-callback-error-onerror-validation.mjs @@ -0,0 +1,62 @@ +// Flags: --experimental-quic --no-warnings + +// Test: onerror setter validation. +// Setting onerror to a non-function (including null) throws. +// Setting to undefined clears it. Setting to a function works. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual, throws } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const errorCheck = { + code: 'ERR_INVALID_ARG_TYPE', +}; + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.opened; + + // Session onerror validation: non-functions throw. + throws(() => { serverSession.onerror = 'not a function'; }, errorCheck); + throws(() => { serverSession.onerror = 42; }, errorCheck); + throws(() => { serverSession.onerror = null; }, errorCheck); + + // Setting to a function works. + const fn = () => {}; + serverSession.onerror = fn; + // The getter returns the bound version, not the original. + strictEqual(typeof serverSession.onerror, 'function'); + + // Setting to undefined clears it. + serverSession.onerror = undefined; + strictEqual(serverSession.onerror, undefined); + + serverSession.close(); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// Client-side stream onerror validation. +const stream = await clientSession.createBidirectionalStream({ + body: new TextEncoder().encode('x'), +}); + +throws(() => { stream.onerror = 'not a function'; }, errorCheck); +throws(() => { stream.onerror = 42; }, errorCheck); +throws(() => { stream.onerror = null; }, errorCheck); + +// Setting to a function works. +stream.onerror = () => {}; +strictEqual(typeof stream.onerror, 'function'); + +// Setting to undefined clears it. +stream.onerror = undefined; +strictEqual(stream.onerror, undefined); + +await clientSession.closed; diff --git a/test/parallel/test-quic-callback-error-onerror.mjs b/test/parallel/test-quic-callback-error-onerror.mjs new file mode 100644 index 00000000000000..536efdc92c7cd4 --- /dev/null +++ b/test/parallel/test-quic-callback-error-onerror.mjs @@ -0,0 +1,76 @@ +// Flags: --experimental-quic --no-warnings + +// Test: onerror callback behavior +// session.onerror fires when session is destroyed with error. +// session.onerror receives the original error as argument. +// session.closed rejects with the original error after onerror. +// session.onerror not called when destroy() has no error. + +import { hasQuic, skip, mustCall, mustNotCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import dc from 'node:diagnostics_channel'; + +const { ok, rejects, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +// quic.session.error fires when a session is destroyed with an error. +// It should fire once for the first client session (destroyed with error) +// and not for the second (destroyed without error). +dc.subscribe('quic.session.error', mustCall((msg) => { + ok(msg.session, 'session.error should include session'); + ok(msg.error, 'session.error should include error'); +})); + +const transportParams = { maxIdleTimeout: 1 }; + +// All tested using a single endpoint with two client sessions. +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; +}, 2), { transportParams }); + +// First client: destroy WITH error — onerror fires. +{ + const testError = new Error('destroy with error'); + const clientSession = await connect(serverEndpoint.address, { + transportParams, + }); + await clientSession.opened; + + let onerrorCalled = false; + clientSession.onerror = mustCall((err) => { + // Receives the original error. + strictEqual(err, testError); + onerrorCalled = true; + }); + + clientSession.destroy(testError); + + // Onerror was called synchronously during destroy. + strictEqual(onerrorCalled, true); + + // Closed rejects with the original error. + await rejects(clientSession.closed, testError); +} + +// Second client: destroy WITHOUT error — onerror should NOT fire. +{ + const clientSession = await connect(serverEndpoint.address, { + transportParams, + }); + await clientSession.opened; + + clientSession.onerror = mustNotCall('onerror should not be called'); + + clientSession.destroy(); + + // Closed resolves (no error). + await clientSession.closed; +} + +serverEndpoint.close(); +await serverEndpoint.closed; diff --git a/test/parallel/test-quic-callback-error-onhandshake.mjs b/test/parallel/test-quic-callback-error-onhandshake.mjs new file mode 100644 index 00000000000000..7c69be5f69ee98 --- /dev/null +++ b/test/parallel/test-quic-callback-error-onhandshake.mjs @@ -0,0 +1,36 @@ +// Flags: --experimental-quic --no-warnings + +// Test: onhandshake callback error handling. +// A sync throw in onhandshake destroys the session via safeCallbackInvoke. +// The error is delivered to the onerror callback and the session's +// closed promise rejects with the error. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const testError = new Error('onhandshake throw'); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; +}), { transportParams: { maxIdleTimeout: 1 } }); + +const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxIdleTimeout: 1 }, + onhandshake() { + throw testError; + }, + onerror: mustCall((err) => { + assert.strictEqual(err, testError); + }), +}); + +// The session's closed should reject with the error from the throw. +await assert.rejects(clientSession.closed, testError); + +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-callback-error-onnewtoken.mjs b/test/parallel/test-quic-callback-error-onnewtoken.mjs new file mode 100644 index 00000000000000..882752adc01dab --- /dev/null +++ b/test/parallel/test-quic-callback-error-onnewtoken.mjs @@ -0,0 +1,42 @@ +// Flags: --experimental-quic --no-warnings + +// Test: onnewtoken callback error handling. +// A sync throw in onnewtoken destroys the session via safeCallbackInvoke. +// The server submits a NEW_TOKEN after handshake completes; the client +// receives it via the onnewtoken callback. Since the session ticket and +// NEW_TOKEN both arrive after the handshake, session.opened is already +// resolved and there is no unhandled rejection / uncaught exception. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { rejects, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const testError = new Error('onnewtoken throw'); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; +}), { transportParams: { maxIdleTimeout: 1 } }); + +const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxIdleTimeout: 1 }, + onnewtoken() { + throw testError; + }, + onerror: mustCall((err) => { + strictEqual(err, testError); + }), +}); + +await clientSession.opened; + +// The session's closed should reject with the error from the throw. +await rejects(clientSession.closed, testError); + +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-callback-error-onpathvalidation.mjs b/test/parallel/test-quic-callback-error-onpathvalidation.mjs new file mode 100644 index 00000000000000..e4f4cb4de8b14f --- /dev/null +++ b/test/parallel/test-quic-callback-error-onpathvalidation.mjs @@ -0,0 +1,53 @@ +// Flags: --experimental-quic --no-warnings + +// Test: onpathvalidation callback error handling. +// A sync throw in onpathvalidation destroys the session via +// safeCallbackInvoke. The error is delivered to the onerror +// callback and the session's closed promise rejects. + +import { hasQuic, skip, mustCall, mustNotCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { rejects, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const testError = new Error('onpathvalidation throw'); + +// The preferred endpoint never receives a new session — it only +// routes PATH_CHALLENGE packets via SessionManager. +const preferredEndpoint = await listen(mustNotCall(), {}); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + // The server session closes with a transport error when the + // client is destroyed by the throw. That's expected. + await rejects(serverSession.closed, { + code: 'ERR_QUIC_TRANSPORT_ERROR', + }); +}), { + transportParams: { + preferredAddressIpv4: preferredEndpoint.address, + }, +}); + +const clientSession = await connect(serverEndpoint.address, { + reuseEndpoint: false, + onpathvalidation() { + throw testError; + }, + onerror: mustCall((err) => { + // The error from the throw should be delivered here. + strictEqual(err, testError); + }), +}); +await clientSession.opened; + +// The session's closed should reject with the thrown error. +await rejects(clientSession.closed, testError); + +await serverEndpoint.close(); +await preferredEndpoint.close(); diff --git a/test/parallel/test-quic-callback-error-onreset.mjs b/test/parallel/test-quic-callback-error-onreset.mjs new file mode 100644 index 00000000000000..798d916be6f2e6 --- /dev/null +++ b/test/parallel/test-quic-callback-error-onreset.mjs @@ -0,0 +1,66 @@ +// Flags: --experimental-quic --no-warnings + +// Test: onreset callback error handling. +// A sync throw in stream.onreset destroys the STREAM (not the session) +// via safeCallbackInvoke. The stream.onerror fires with the original +// error, and stream.closed rejects. The session remains alive. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { rejects, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const encoder = new TextEncoder(); +const testError = new Error('onreset throw'); + +const serverReady = Promise.withResolvers(); +const serverStreamDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + // The stream's onerror should fire with the throw from onreset. + stream.onerror = mustCall((err) => { + strictEqual(err, testError); + }); + + stream.onreset = () => { + throw testError; + }; + + serverReady.resolve(); + + // Stream closed rejects because the onreset throw destroyed it. + await rejects(stream.closed, testError); + serverStreamDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode('trigger onstream'), +}); + +// Wait for the server to have the stream before resetting. +await serverReady.promise; +stream.resetStream(1n); + +// Wait for the server stream to be destroyed by the onreset throw. +await serverStreamDone.promise; + +// The client stream was reset. Destroy it explicitly to clean up +// (resetStream only shuts the write side; the read side is still open +// waiting for the server which won't send anything now). +stream.destroy(); +await stream.closed; + +// Close both sides. +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-callback-error-onsessionticket.mjs b/test/parallel/test-quic-callback-error-onsessionticket.mjs new file mode 100644 index 00000000000000..cc514286fd5fe0 --- /dev/null +++ b/test/parallel/test-quic-callback-error-onsessionticket.mjs @@ -0,0 +1,41 @@ +// Flags: --experimental-quic --no-warnings + +// Test: onsessionticket callback error handling. +// A sync throw in onsessionticket destroys the session via safeCallbackInvoke. +// Unlike onhandshake throws, no uncaughtException is produced because the +// session ticket arrives after the handshake completes (session.opened is +// already resolved so there is no unhandled rejection). + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { rejects, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const testError = new Error('onsessionticket throw'); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; +}), { transportParams: { maxIdleTimeout: 1 } }); + +const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxIdleTimeout: 1 }, + onsessionticket() { + throw testError; + }, + onerror: mustCall((err) => { + strictEqual(err, testError); + }), +}); + +await clientSession.opened; + +// The session's closed should reject with the error from the throw. +await rejects(clientSession.closed, testError); + +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-callback-error-onstream-async.mjs b/test/parallel/test-quic-callback-error-onstream-async.mjs new file mode 100644 index 00000000000000..1505643e69a733 --- /dev/null +++ b/test/parallel/test-quic-callback-error-onstream-async.mjs @@ -0,0 +1,46 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: async rejection in onstream destroys session. +// safeCallbackInvoke detects the returned promise and attaches a +// rejection handler that calls session.destroy(err). The error is +// delivered to the onerror callback. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual, rejects } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const testError = new Error('async onstream rejection'); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + serverSession.onerror = mustCall((err) => { + strictEqual(err, testError); + }); + + serverSession.onstream = async () => { + throw testError; + }; + + // Session closed rejects with the error from the async rejection. + await rejects(serverSession.closed, testError); +}), { transportParams: { maxIdleTimeout: 1 } }); + +const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxIdleTimeout: 1 }, +}); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream({ + body: new TextEncoder().encode('trigger onstream'), +}); + +// The client session closes via CONNECTION_CLOSE or idle timeout +// after the server session is destroyed by the async rejection. +await Promise.all([stream.closed, clientSession.closed]); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-callback-error-onstream.mjs b/test/parallel/test-quic-callback-error-onstream.mjs new file mode 100644 index 00000000000000..116b3136fc6e4e --- /dev/null +++ b/test/parallel/test-quic-callback-error-onstream.mjs @@ -0,0 +1,49 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: callback error handling for onstream. +// Sync throw in onstream destroys the session. +// safeCallbackInvoke catches the throw and calls session.destroy(error). +// The error is delivered to the onerror callback. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { rejects, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const encoder = new TextEncoder(); + +const testError = new Error('sync onstream throw'); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + serverSession.onerror = mustCall((err) => { + strictEqual(err, testError); + }); + + serverSession.onstream = () => { + throw testError; + }; + + // The session's closed rejects with the error from destroy(). + await rejects(serverSession.closed, testError); +}), { transportParams: { maxIdleTimeout: 1 } }); + +const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxIdleTimeout: 1 }, +}); +await clientSession.opened; + +// Send data to trigger onstream on the server. +const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode('trigger onstream'), +}); + +// The client session will close via CONNECTION_CLOSE or idle timeout +// after the server session is destroyed. +await Promise.all([stream.closed, clientSession.closed]); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-callback-error-stream-onerror.mjs b/test/parallel/test-quic-callback-error-stream-onerror.mjs new file mode 100644 index 00000000000000..51cb89b6b1f692 --- /dev/null +++ b/test/parallel/test-quic-callback-error-stream-onerror.mjs @@ -0,0 +1,83 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: stream.onerror callback behavior. +// * stream.onerror fires when stream is destroyed with error. +// * stream.onerror receives the original error as argument. +// * stream.closed rejects with the original error after onerror. +// * stream.onerror not called when destroy() has no error. + +import { hasQuic, skip, mustCall, mustNotCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { rejects, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const encoder = new TextEncoder(); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +{ + const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode('will error'), + }); + + const testError = new Error('stream destroy error'); + + let onerrorCalled = false; + stream.onerror = mustCall((err) => { + // Receives the original error. + strictEqual(err, testError); + onerrorCalled = true; + }); + + stream.destroy(testError); + + // The onerror was called synchronously during destroy. + strictEqual(onerrorCalled, true); + + // The stream.closed rejects with the original error. + await rejects(stream.closed, testError); +} + +// The stream.onerror not called when destroy() has no error. +// Create a stream with no body — use the writer API so the server sees +// it and can close cleanly. +{ + const stream = await clientSession.createBidirectionalStream(); + const w = stream.writer; + + stream.onerror = mustNotCall('stream.onerror should not be called'); + + // Send data so the server's onstream fires, then end. + w.writeSync('no error'); + w.endSync(); + + // Wait for the server to process and close its side. + await serverDone.promise; + + // Now destroy without error. + stream.destroy(); + + // Closed should resolve (not reject). + await stream.closed; +} + +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-callback-error-suppressed-async.mjs b/test/parallel/test-quic-callback-error-suppressed-async.mjs new file mode 100644 index 00000000000000..f1578908e7d6b8 --- /dev/null +++ b/test/parallel/test-quic-callback-error-suppressed-async.mjs @@ -0,0 +1,53 @@ +// Flags: --experimental-quic --no-warnings + +// Test: SuppressedError when async onerror rejects. +// When session.onerror returns a Promise that rejects, a SuppressedError +// wrapping both the rejection reason and the original error is thrown +// via process.nextTick as an uncaught exception. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok, rejects, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const originalError = new Error('original destroy error'); +const onerrorRejection = new Error('async onerror rejected'); + +const transportParams = { maxIdleTimeout: 1 }; + +// The SuppressedError is thrown via process.nextTick after the +// onerror promise rejects, so it appears as an uncaught exception. +process.on('uncaughtException', mustCall((err) => { + ok(err instanceof SuppressedError); + // .error is the onerror rejection reason + strictEqual(err.error, onerrorRejection); + // .suppressed is the original error that triggered destroy + strictEqual(err.suppressed, originalError); +})); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; +}), { transportParams }); + +const clientSession = await connect(serverEndpoint.address, { + transportParams, +}); +await clientSession.opened; + +// Async onerror: returns a promise that rejects. +clientSession.onerror = mustCall(async () => { + throw onerrorRejection; +}); + +clientSession.destroy(originalError); + +// Closed rejects with the original error (not the SuppressedError). +await rejects(clientSession.closed, originalError); + +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-callback-error-suppressed.mjs b/test/parallel/test-quic-callback-error-suppressed.mjs new file mode 100644 index 00000000000000..fcc4d0fcc7f304 --- /dev/null +++ b/test/parallel/test-quic-callback-error-suppressed.mjs @@ -0,0 +1,52 @@ +// Flags: --experimental-quic --no-warnings + +// Test: SuppressedError when onerror throws. +// If session.onerror throws synchronously, a SuppressedError +// wrapping both the onerror error and the original error is +// thrown via process.nextTick as an uncaught exception. +// The SuppressedError's .error is the onerror failure and +// .suppressed is the original error. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok, rejects, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const originalError = new Error('original destroy error'); +const onerrorError = new Error('onerror itself threw'); + +const transportParams = { maxIdleTimeout: 1 }; + +// The SuppressedError is thrown via process.nextTick, so it appears +// as an uncaught exception. +process.on('uncaughtException', mustCall((err) => { + ok(err instanceof SuppressedError); + // .error is the onerror failure + strictEqual(err.error, onerrorError); + // .suppressed is the original error that triggered destroy + strictEqual(err.suppressed, originalError); +})); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; +}), { transportParams }); + +const clientSession = await connect(serverEndpoint.address, { + transportParams, +}); +await clientSession.opened; + +clientSession.onerror = mustCall(() => { + throw onerrorError; +}); + +clientSession.destroy(originalError); + +// Closed rejects with the original error (not the SuppressedError). +await rejects(clientSession.closed, originalError); diff --git a/test/parallel/test-quic-cc-algorithm.mjs b/test/parallel/test-quic-cc-algorithm.mjs new file mode 100644 index 00000000000000..36e96c2fc15bcb --- /dev/null +++ b/test/parallel/test-quic-cc-algorithm.mjs @@ -0,0 +1,52 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: congestion control algorithm selection. +// Verify that each CC algorithm (reno, cubic, bbr) can be selected +// and that a session completes a data transfer successfully with each. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const encoder = new TextEncoder(); +const payload = encoder.encode('congestion control test'); +const payloadLength = payload.byteLength; + +for (const cc of ['reno', 'cubic', 'bbr']) { + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const data = await bytes(stream); + strictEqual(data.byteLength, payloadLength); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); + }), { cc }); + + const clientSession = await connect(serverEndpoint.address, { cc }); + await clientSession.opened; + + const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode('congestion control test'), + }); + + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + await Promise.all([stream.closed, serverDone.promise]); + + // Verify the session stats show congestion control was active. + ok(clientSession.stats.cwnd > 0n, `${cc}: cwnd should be > 0`); + + await clientSession.closed; + await serverEndpoint.close(); +} diff --git a/test/parallel/test-quic-connection-concurrent.mjs b/test/parallel/test-quic-connection-concurrent.mjs new file mode 100644 index 00000000000000..6cc75fd185309e --- /dev/null +++ b/test/parallel/test-quic-connection-concurrent.mjs @@ -0,0 +1,56 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: concurrent connections from multiple clients. +// Multiple clients connect to the same server simultaneously and each +// exchanges data successfully. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const encoder = new TextEncoder(); +const numClients = 5; +let serverStreamCount = 0; +const allDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + // Echo back the data. + const w = stream.writer; + w.writeSync(await bytes(stream)); + w.endSync(); + await stream.closed; + if (++serverStreamCount === numClients) { + allDone.resolve(); + } + }); +}, numClients)); + +// Connect all clients concurrently. +const clientPromises = []; +for (let i = 0; i < numClients; i++) { + clientPromises.push((async () => { + const cs = await connect(serverEndpoint.address, { reuseEndpoint: false }); + await cs.opened; + const message = `client ${i}`; + const stream = await cs.createBidirectionalStream({ + body: encoder.encode(message), + }); + const received = await bytes(stream); + strictEqual(new TextDecoder().decode(received), message); + await stream.closed; + cs.close(); + await cs.closed; + })()); +} + +await Promise.all([...clientPromises, allDone.promise]); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-connection-limits.mjs b/test/parallel/test-quic-connection-limits.mjs new file mode 100644 index 00000000000000..acb0f8065d4c78 --- /dev/null +++ b/test/parallel/test-quic-connection-limits.mjs @@ -0,0 +1,76 @@ +// Flags: --experimental-quic --no-warnings + +// Test: connection total limit enforcement. +// maxConnectionsTotal limits total concurrent connections. +// When the limit is exceeded, the server sends CONNECTION_REFUSED +// and the client's session is destroyed with ERR_QUIC_TRANSPORT_ERROR. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { rejects, strictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect, QuicEndpoint } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); + +// Create endpoint with maxConnectionsTotal = 1. +const endpoint = new QuicEndpoint({ maxConnectionsTotal: 1 }); + +// Verify the limits are readable and mutable. +strictEqual(endpoint.maxConnectionsTotal, 1); +strictEqual(endpoint.maxConnectionsPerHost, 0); +endpoint.maxConnectionsPerHost = 100; +strictEqual(endpoint.maxConnectionsPerHost, 100); +endpoint.maxConnectionsPerHost = 0; + +let sessionCount = 0; + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + sessionCount++; + await Promise.all([serverSession.opened, serverSession.closed]); +}), { + endpoint, + sni: { '*': { keys: [key], certs: [cert] } }, + alpn: ['quic-test'], + transportParams: { maxIdleTimeout: 2 }, +}); + +// First connection should succeed. +const cs1 = await connect(serverEndpoint.address, { + alpn: 'quic-test', + transportParams: { maxIdleTimeout: 2 }, +}); +await cs1.opened; + +// Second connection — server rejects with CONNECTION_REFUSED. +const cs2 = await connect(serverEndpoint.address, { + alpn: 'quic-test', + transportParams: { maxIdleTimeout: 1 }, + onerror: mustCall((err) => { + strictEqual(err.code, 'ERR_QUIC_TRANSPORT_ERROR'); + }), +}); + +await Promise.all([ + rejects(cs2.opened, { + code: 'ERR_QUIC_TRANSPORT_ERROR', + }), + rejects(cs2.closed, { + code: 'ERR_QUIC_TRANSPORT_ERROR', + }), +]); + +// Only 1 session should have been accepted by the server. +strictEqual(sessionCount, 1); + +await cs1.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-datagram-abandoned.mjs b/test/parallel/test-quic-datagram-abandoned.mjs new file mode 100644 index 00000000000000..e99c3bd9754702 --- /dev/null +++ b/test/parallel/test-quic-datagram-abandoned.mjs @@ -0,0 +1,64 @@ +// Flags: --experimental-quic --no-warnings + +// Test: datagram abandoned status for queue overflow. +// When the datagram pending queue is full and a new datagram is sent, +// the drop policy causes a datagram to be dropped. The dropped datagram +// should be reported with status 'abandoned' (not 'lost'), indicating +// it was never actually sent on the wire. + +import { hasQuic, skip, mustCall, mustCallAtLeast } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { notStrictEqual, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +let serverSession; + +const serverEndpoint = await listen(mustCall((session) => { + serverSession = session; +}), { + transportParams: { maxDatagramFrameSize: 1200 }, +}); + +const ids = [0n, 0n, 0n]; +let abandoned = false; + +const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxDatagramFrameSize: 1200 }, + ondatagramstatus: mustCallAtLeast((id, status) => { + if (status === 'abandoned') { + strictEqual(id, ids[0]); + abandoned = true; + } + // We'll likely only get status for one other datagram. + }), +}); +await clientSession.opened; + +// Set a very small queue so overflow happens immediately. +clientSession.maxPendingDatagrams = 2; + +// Send 3 datagrams with a queue size of 2. The first datagram should +// be abandoned when the third is sent (drop-oldest policy is default). +ids[0] = await clientSession.sendDatagram(new Uint8Array([1])); +ids[1] = await clientSession.sendDatagram(new Uint8Array([2])); +ids[2] = await clientSession.sendDatagram(new Uint8Array([3])); + +notStrictEqual(ids[0], 0n); +notStrictEqual(ids[1], 0n); +notStrictEqual(ids[2], 0n); + +// The abandoned status fires synchronously during sendDatagram when the +// queue overflows. It should already be set +strictEqual(abandoned, true); + +await Promise.all([ + serverSession.close(), + clientSession.close(), +]); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-datagram-drop-newest.mjs b/test/parallel/test-quic-datagram-drop-newest.mjs new file mode 100644 index 00000000000000..45f568af91687a --- /dev/null +++ b/test/parallel/test-quic-datagram-drop-newest.mjs @@ -0,0 +1,82 @@ +// Flags: --experimental-quic --no-warnings + +// Test: datagram drop-newest policy. +// With maxPendingDatagrams=2 and drop-newest, sending 5 datagrams +// rapidly should reject the newest when the queue is full. The +// server should receive the oldest datagrams. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { ok, strictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); + +const allReceived = Promise.withResolvers(); +const allStatusReceived = Promise.withResolvers(); + +let serverCounter = 0; +let clientAbandonCounter = 0; +let clientAckCounter = 0; + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await Promise.all([serverSession.opened, allStatusReceived.promise]); + serverSession.close(); + await serverSession.closed; +}), { + sni: { '*': { keys: [key], certs: [cert] } }, + alpn: ['quic-test'], + transportParams: { maxDatagramFrameSize: 1200 }, + ondatagram: mustCall(function(data, early) { + // We whould only receive datagrams 1 and 2 + strictEqual(data.length, 1); + ok(data[0] === 0 || data[0] === 1); + ok(!early); + if (++serverCounter === 2) allReceived.resolve(); + }, 2), +}); + +const clientSession = await connect(serverEndpoint.address, { + alpn: 'quic-test', + transportParams: { maxDatagramFrameSize: 1200 }, + datagramDropPolicy: 'drop-newest', + ondatagramstatus: mustCall((_, status) => { + if (status === 'abandoned') { + clientAbandonCounter++; + } else if (status === 'acknowledged') { + clientAckCounter++; + } + if (clientAbandonCounter + clientAckCounter === 5) { + allStatusReceived.resolve(); + } + }, 5), +}); + +await clientSession.opened; + +clientSession.maxPendingDatagrams = 2; + +// Send 5 datagrams. With drop-newest, the 3rd/4th/5th are rejected +// (the queue holds the 1st and 2nd). +for (let i = 0; i < 5; i++) { + await clientSession.sendDatagram(new Uint8Array([i])); +} + +await Promise.all([allReceived.promise, allStatusReceived.promise]); + +// 3 abandoned (datagrams 1, 2, 3) and 2 acknowledged (datagrams 4, 5). +strictEqual(clientAbandonCounter, 3); +strictEqual(clientAckCounter, 2); + +await clientSession.closed; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-datagram-drop-oldest.mjs b/test/parallel/test-quic-datagram-drop-oldest.mjs new file mode 100644 index 00000000000000..1471323caf2e06 --- /dev/null +++ b/test/parallel/test-quic-datagram-drop-oldest.mjs @@ -0,0 +1,83 @@ +// Flags: --experimental-quic + +// Test: datagram drop-oldest policy. +// With maxPendingDatagrams=2 and drop-oldest, sending 5 datagrams +// rapidly should drop the oldest when the queue overflows. The +// server should receive the most recent datagrams (4th and 5th). + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { ok, strictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); + +const allReceived = Promise.withResolvers(); +const allStatusReceived = Promise.withResolvers(); + +let serverCounter = 0; +let clientAbandonCounter = 0; +let clientAckCounter = 0; + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await Promise.all([serverSession.opened, allStatusReceived.promise]); + await serverSession.close(); +}), { + sni: { '*': { keys: [key], certs: [cert] } }, + alpn: ['quic-test'], + transportParams: { maxDatagramFrameSize: 1200 }, + ondatagram: mustCall(function(data, early) { + // With drop-oldest, the queue keeps the newest. After 5 sends with + // queue size 2, only datagrams 4 and 5 (values 3 and 4) remain. + strictEqual(data.length, 1); + ok(data[0] === 3 || data[0] === 4); + ok(!early); + if (++serverCounter === 2) allReceived.resolve(); + }, 2), +}); + +const clientSession = await connect(serverEndpoint.address, { + alpn: 'quic-test', + transportParams: { maxDatagramFrameSize: 1200 }, + datagramDropPolicy: 'drop-oldest', + ondatagramstatus: mustCall((_, status) => { + if (status === 'abandoned') { + clientAbandonCounter++; + } else if (status === 'acknowledged') { + clientAckCounter++; + } + if (clientAbandonCounter + clientAckCounter === 5) { + allStatusReceived.resolve(); + } + }, 5), +}); + +await clientSession.opened; + +clientSession.maxPendingDatagrams = 2; + +// Send 5 datagrams. With drop-oldest and queue size 2: +// 1 queued, 2 queued, 3 arrives → 1 dropped, 4 arrives → 2 dropped, +// 5 arrives → 3 dropped. Queue ends with [4, 5]. +for (let i = 0; i < 5; i++) { + await clientSession.sendDatagram(new Uint8Array([i])); +} + +await Promise.all([allReceived.promise, allStatusReceived.promise]); + +// 3 abandoned (datagrams 1, 2, 3) and 2 acknowledged (datagrams 4, 5). +strictEqual(clientAbandonCounter, 3); +strictEqual(clientAckCounter, 2); + +await clientSession.closed; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-datagram-echo.mjs b/test/parallel/test-quic-datagram-echo.mjs new file mode 100644 index 00000000000000..ad6a08b67443c8 --- /dev/null +++ b/test/parallel/test-quic-datagram-echo.mjs @@ -0,0 +1,70 @@ +// Flags: --experimental-quic --no-warnings + +// Test: datagram server-to-client and echo round-trip +// Server sends datagram, client receives via ondatagram. +// Datagram echo — client sends, server echoes back in +// its ondatagram callback (queued, flushed via SendPendingData). + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; +const { setTimeout } = await import('node:timers/promises'); + +const { ok, strictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); + +const serverGot = Promise.withResolvers(); +const clientGot = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await Promise.all([serverSession.opened, serverGot.promise]); + // Give time for the echo to be sent before closing. + await setTimeout(100); + await serverSession.close(); +}), { + sni: { '*': { keys: [key], certs: [cert] } }, + alpn: ['quic-test'], + transportParams: { maxDatagramFrameSize: 10 }, + // Server echoes received datagram data back to client. + // The sendDatagram call happens inside ondatagram (ngtcp2 callback + // scope). The datagram is queued and flushed by SendPendingData. + ondatagram: mustCall((data, early, session) => { + ok(data instanceof Uint8Array); + ok(!early); + session.sendDatagram(data); + serverGot.resolve(); + }), +}); + +const clientSession = await connect(serverEndpoint.address, { + alpn: 'quic-test', + transportParams: { maxDatagramFrameSize: 10 }, + // Client receives datagram from server. + ondatagram: mustCall(function(data) { + ok(data instanceof Uint8Array); + strictEqual(data.byteLength, 3); + strictEqual(data[0], 10); + strictEqual(data[1], 20); + strictEqual(data[2], 30); + clientGot.resolve(); + }), +}); + +await clientSession.opened; + +// Client sends datagram to trigger the echo. +await clientSession.sendDatagram(new Uint8Array([10, 20, 30])); + +await Promise.all([serverGot.promise, clientGot.promise, clientSession.closed]); + +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-datagram-edge-cases.mjs b/test/parallel/test-quic-datagram-edge-cases.mjs new file mode 100644 index 00000000000000..1abf9f80c7f311 --- /dev/null +++ b/test/parallel/test-quic-datagram-edge-cases.mjs @@ -0,0 +1,93 @@ +// Flags: --experimental-quic --no-warnings + +// Test: datagram edge cases. +// DGRAM-08 / DGIMP-08: Zero-length datagram returns 0n (not sent). +// DGC-01 / DGIMP-09: maxDatagramFrameSize: 0 disables datagrams entirely. +// Datagram arrives with no ondatagram callback — no crash. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import { setTimeout } from 'node:timers/promises'; + +const { strictEqual, notStrictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +// --- DGRAM-08 / DGIMP-08: Zero-length datagram returns 0n --- +{ + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; + }), { + transportParams: { maxIdleTimeout: 1, maxDatagramFrameSize: 1200 }, + }); + + const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxIdleTimeout: 1, maxDatagramFrameSize: 1200 }, + }); + await clientSession.opened; + + // Zero-length ArrayBufferView + const zeroId = await clientSession.sendDatagram(new Uint8Array(0)); + strictEqual(zeroId, 0n); + + // Zero-length string + const emptyStringId = await clientSession.sendDatagram(''); + strictEqual(emptyStringId, 0n); + + await clientSession.close(); + await serverEndpoint.close(); +} + +// --- DGC-01 / DGIMP-09: maxDatagramFrameSize: 0 disables datagrams --- +{ + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; + }), { + // Server advertises 0 — no datagrams accepted. + transportParams: { maxIdleTimeout: 1, maxDatagramFrameSize: 0 }, + }); + + const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxIdleTimeout: 1, maxDatagramFrameSize: 10 }, + }); + await clientSession.opened; + + // maxDatagramSize reflects the peer's (server's) transport param. + strictEqual(clientSession.maxDatagramSize, 0); + + // Sending returns 0n immediately — datagram not sent. + const id = await clientSession.sendDatagram(new Uint8Array([1, 2, 3])); + strictEqual(id, 0n); + + await clientSession.close(); + await serverEndpoint.close(); +} + +// --- DGRAM-11: No ondatagram callback — no crash --- +{ + const serverEndpoint = await listen(mustCall(async (serverSession) => { + // No ondatagram set — datagrams arrive but are silently discarded. + await serverSession.opened; + // Give time for the datagram to arrive and be processed without crash. + await setTimeout(200); + await serverSession.close(); + }), { + transportParams: { maxDatagramFrameSize: 1200 }, + }); + + const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxDatagramFrameSize: 1200 }, + }); + await clientSession.opened; + + // Send a datagram even though the server has no ondatagram handler. + const id = await clientSession.sendDatagram(new Uint8Array([1, 2, 3])); + notStrictEqual(id, 0n); + + await clientSession.closed; + await serverEndpoint.close(); +} diff --git a/test/parallel/test-quic-datagram-frame-size-validation.mjs b/test/parallel/test-quic-datagram-frame-size-validation.mjs new file mode 100644 index 00000000000000..b6cdea66e37f9c --- /dev/null +++ b/test/parallel/test-quic-datagram-frame-size-validation.mjs @@ -0,0 +1,58 @@ +// Flags: --experimental-quic --no-warnings + +// Test: maxDatagramFrameSize transport param validation. +// The maxDatagramFrameSize transport parameter must be a uint16 +// (0-65535). Values outside this range or of the wrong type should +// be rejected. + +import { hasQuic, skip, mustNotCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { rejects } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); +const sni = { '*': { keys: [key], certs: [cert] } }; +const alpn = ['quic-test']; + +// Invalid values for maxDatagramFrameSize — must be rejected. +const invalid = [ + -1, + 65536, + 1.5, + 'a', + null, + false, + true, + {}, + [], + () => {}, +]; + +for (const maxDatagramFrameSize of invalid) { + const transportParams = { maxDatagramFrameSize }; + await rejects( + listen(mustNotCall(), { sni, alpn, transportParams }), + { code: 'ERR_INVALID_ARG_VALUE' }, + `listen should reject maxDatagramFrameSize: ${maxDatagramFrameSize}`, + ); +} + +// Valid values — should not throw. +const valid = [0, 1, 100, 1200, 65535]; + +for (const maxDatagramFrameSize of valid) { + const transportParams = { maxDatagramFrameSize }; + const ep = await listen(mustNotCall(), { sni, alpn, transportParams }); + ep.close(); + await ep.closed; +} diff --git a/test/parallel/test-quic-datagram-multiple.mjs b/test/parallel/test-quic-datagram-multiple.mjs new file mode 100644 index 00000000000000..f8deef3ead2cd9 --- /dev/null +++ b/test/parallel/test-quic-datagram-multiple.mjs @@ -0,0 +1,84 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: multiple datagrams and datagrams alongside streams +// Client sends multiple datagrams. +// Datagrams sent alongside an active bidi stream. +// Datagrams are unreliable — we verify at least some arrive. +// The stream is opened first to establish bidirectional traffic, +// keeping the congestion window healthy for datagram sends. + +import { hasQuic, skip, mustCall, mustCallAtLeast } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { ok } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); +const { bytes } = await import('stream/iter'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); + +const numDatagrams = 5; +let serverDatagramCount = 0; +const gotSomeDg = Promise.withResolvers(); +const streamDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.opened; + + // Server receives stream data alongside datagrams. + serverSession.onstream = mustCall(async (stream) => { + stream.writer.endSync(); + await bytes(stream); + await stream.closed; + streamDone.resolve(); + }); + + await Promise.all([gotSomeDg.promise, streamDone.promise]); + await serverSession.close(); +}), { + sni: { '*': { keys: [key], certs: [cert] } }, + alpn: ['quic-test'], + transportParams: { maxDatagramFrameSize: 1200 }, + ondatagram: mustCallAtLeast((data) => { + ok(data instanceof Uint8Array); + serverDatagramCount++; + gotSomeDg.resolve(); + }), +}); + +const clientSession = await connect(serverEndpoint.address, { + alpn: 'quic-test', + transportParams: { maxDatagramFrameSize: 1200 }, +}); + +await clientSession.opened; + +// Open a stream FIRST to establish bidirectional traffic. +// This ensures ACKs flow back from the server, keeping the +// congestion window open for subsequent datagram sends. +const stream = await clientSession.createBidirectionalStream({ + body: new TextEncoder().encode('hello'), +}); + +// Send multiple datagrams alongside the active stream. +for (let i = 0; i < numDatagrams; i++) { + await clientSession.sendDatagram(new Uint8Array([i])); +} + +// Complete the stream. +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars +await stream.closed; + +// At least some datagrams should have arrived. +ok(serverDatagramCount > 0, 'Server should have received at least one datagram'); + +await clientSession.closed; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-datagram-no-detach.mjs b/test/parallel/test-quic-datagram-no-detach.mjs new file mode 100644 index 00000000000000..cdcbe53691d678 --- /dev/null +++ b/test/parallel/test-quic-datagram-no-detach.mjs @@ -0,0 +1,72 @@ +// Flags: --experimental-quic --no-warnings + +// session.sendDatagram() must not detach the caller's underlying +// ArrayBuffer. The bytes are copied into an internal buffer on every +// send, so the caller's source ArrayBuffer remains live and may be +// reused for further sends, mutated, or sliced into additional views. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual, deepStrictEqual, notStrictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const received = []; +const allReceived = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await allReceived.promise; + await serverSession.close(); +}), { + transportParams: { maxDatagramFrameSize: 1200 }, + ondatagram: mustCall((data) => { + received.push(Buffer.from(data)); + if (received.length === 3) allReceived.resolve(); + }, 3), +}); + +const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxDatagramFrameSize: 1200 }, +}); +await clientSession.opened; + +// A full-buffer Uint8Array. The same source must be reusable across +// multiple sendDatagram calls. +const source = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]); + +const firstId = await clientSession.sendDatagram(source); +notStrictEqual(firstId, 0n); +strictEqual(source.buffer.detached, false, + 'source ArrayBuffer must not be detached after sendDatagram'); + +const secondId = await clientSession.sendDatagram(source); +notStrictEqual(secondId, 0n); +strictEqual(source.buffer.detached, false, + 'source ArrayBuffer must remain live after second sendDatagram'); + +// Mutating the source after the previous sendDatagram returned must +// not affect what the peer ultimately receives — the bytes have +// already been copied into the QUIC layer's internal buffer. +source[0] = 99; +const thirdId = await clientSession.sendDatagram(source); +notStrictEqual(thirdId, 0n); + +await allReceived.promise; + +// Datagrams are unreliable and may be reordered, but the test fixture +// does not exercise loss or reordering — assert by sorting. +const sorted = received.map((b) => b.toString('hex')).sort(); +const expected = [ + Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]).toString('hex'), + Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]).toString('hex'), + Buffer.from([99, 2, 3, 4, 5, 6, 7, 8]).toString('hex'), +].sort(); +deepStrictEqual(sorted, expected); + +await clientSession.closed; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-datagram-size-limits.mjs b/test/parallel/test-quic-datagram-size-limits.mjs new file mode 100644 index 00000000000000..026df4cb1cbeaa --- /dev/null +++ b/test/parallel/test-quic-datagram-size-limits.mjs @@ -0,0 +1,64 @@ +// Flags: --experimental-quic --no-warnings + +// Test: datagram size limit enforcement. +// Datagram larger than maxDatagramSize returns 0n (not sent). +// Datagram at exactly maxDatagramSize is accepted and delivered. +// Same as DGRAM-03 via sendDatagram return value. +// maxDatagramSize reflects the maximum datagram payload the peer can +// receive, accounting for DATAGRAM frame overhead (type byte + varint +// length encoding). It is derived from the peer's maxDatagramFrameSize +// transport parameter minus the frame overhead. +// We use maxDatagramFrameSize: 200 so that the exact-max datagram fits +// comfortably within a QUIC packet (which has its own header + AEAD +// overhead on top of the DATAGRAM frame). + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok, strictEqual, notStrictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const serverGot = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverGot.promise; + serverSession.close(); + await serverSession.closed; +}), { + transportParams: { maxDatagramFrameSize: 200 }, + ondatagram: mustCall((data) => { + ok(data instanceof Uint8Array); + serverGot.resolve(); + }), +}); + +const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxDatagramFrameSize: 200 }, +}); +await clientSession.opened; + +const maxSize = clientSession.maxDatagramSize; + +// maxDatagramSize should be less than maxDatagramFrameSize due to +// the DATAGRAM frame overhead (1 byte type + varint length encoding). +ok(maxSize > 0); +ok(maxSize < 200); + +// DGRAM-03 / DGIMP-10: Datagram too large — returns 0n. +const oversized = new Uint8Array(maxSize + 1); +const tooLargeId = await clientSession.sendDatagram(oversized); +strictEqual(tooLargeId, 0n); + +// Datagram at exactly maxDatagramSize — accepted and delivered. +const exactMax = new Uint8Array(maxSize); +exactMax[0] = 42; +const exactId = await clientSession.sendDatagram(exactMax); +notStrictEqual(exactId, 0n); + +await Promise.all([serverGot.promise, clientSession.closed]); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-datagram-sources.mjs b/test/parallel/test-quic-datagram-sources.mjs new file mode 100644 index 00000000000000..55122f53354c1f --- /dev/null +++ b/test/parallel/test-quic-datagram-sources.mjs @@ -0,0 +1,220 @@ +// Flags: --experimental-quic --no-warnings + +// Test: sendDatagram with various input source types. +// String with custom encoding (e.g., 'hex'). +// Promise input — resolves then sends. +// Promise input — session closes during await, returns 0n. +// SharedArrayBuffer copies instead of transfers. +// Pooled Buffer (partial view) copies correctly. +// DataView input. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { deepStrictEqual, notStrictEqual, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +// --- DGIMP-01: String with custom encoding --- +{ + const received = []; + const allReceived = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await allReceived.promise; + await serverSession.close(); + }), { + transportParams: { maxDatagramFrameSize: 1200 }, + ondatagram: mustCall((data) => { + received.push(Buffer.from(data)); + if (received.length === 2) allReceived.resolve(); + }, 2), + }); + + const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxDatagramFrameSize: 1200 }, + }); + await clientSession.opened; + + // Send hex-encoded string — '48656c6c6f' is 'Hello' in hex. + const hexId = await clientSession.sendDatagram('48656c6c6f', 'hex'); + notStrictEqual(hexId, 0n); + + // Send base64-encoded string — 'V29ybGQ=' is 'World' in base64. + const b64Id = await clientSession.sendDatagram('V29ybGQ=', 'base64'); + notStrictEqual(b64Id, 0n); + + await allReceived.promise; + + deepStrictEqual(received[0], Buffer.from('Hello')); + deepStrictEqual(received[1], Buffer.from('World')); + + await clientSession.closed; + await serverEndpoint.close(); +} + +// --- DGIMP-02: Promise input --- +{ + const serverGot = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverGot.promise; + await serverSession.close(); + }), { + transportParams: { maxDatagramFrameSize: 1200 }, + ondatagram: mustCall((data) => { + deepStrictEqual(Buffer.from(data), Buffer.from([42])); + serverGot.resolve(); + }), + }); + + const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxDatagramFrameSize: 1200 }, + }); + await clientSession.opened; + + // Send a Promise that resolves to a Uint8Array. + const promiseId = await clientSession.sendDatagram( + Promise.resolve(new Uint8Array([42])), + ); + notStrictEqual(promiseId, 0n); + + await Promise.all([serverGot.promise, clientSession.closed]); + await serverEndpoint.close(); +} + +// --- DGIMP-03: Promise input, session closes during await --- +{ + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; + }), { + transportParams: { maxIdleTimeout: 1, maxDatagramFrameSize: 1200 }, + onerror() {}, + }); + + const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxIdleTimeout: 1, maxDatagramFrameSize: 1200 }, + }); + await clientSession.opened; + + // Create a promise that resolves after the session starts closing. + // sendDatagram passes the initial checks, then awaits the promise. + // While awaiting, the session closes. When the promise resolves, + // sendDatagram finds the session closed and returns 0n. + const slowPromise = new Promise((resolve) => { + setImmediate(mustCall(async () => { + await clientSession.close(); + resolve(new Uint8Array([1])); + })); + }); + + const id = await clientSession.sendDatagram(slowPromise); + strictEqual(id, 0n); + + await serverEndpoint.close(); +} + +// --- DGIMP-04: SharedArrayBuffer --- +{ + const serverGot = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverGot.promise; + await serverSession.close(); + }), { + transportParams: { maxDatagramFrameSize: 1200 }, + ondatagram: mustCall((data) => { + deepStrictEqual(Buffer.from(data), Buffer.from([10, 20, 30])); + serverGot.resolve(); + }), + }); + + const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxDatagramFrameSize: 1200 }, + }); + await clientSession.opened; + + // Create a SharedArrayBuffer-backed view. + const sab = new SharedArrayBuffer(3); + const view = new Uint8Array(sab); + view[0] = 10; + view[1] = 20; + view[2] = 30; + + const id = await clientSession.sendDatagram(view); + notStrictEqual(id, 0n); + + // The SharedArrayBuffer should still be usable (copied, not transferred). + strictEqual(view[0], 10); + + await Promise.all([serverGot.promise, clientSession.closed]); + await serverEndpoint.close(); +} + +// --- DGIMP-05: Pooled Buffer (partial view) --- +{ + const serverGot = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverGot.promise; + await serverSession.close(); + }), { + transportParams: { maxDatagramFrameSize: 1200 }, + ondatagram: mustCall((data) => { + // The received data should match the slice content. + deepStrictEqual(Buffer.from(data), Buffer.from('hello')); + serverGot.resolve(); + }), + }); + + const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxDatagramFrameSize: 1200 }, + }); + await clientSession.opened; + + // Buffer.from('hello') creates a pooled buffer — its backing + // ArrayBuffer is larger and the view has a non-zero offset. + const pooledBuf = Buffer.from('hello'); + const id = await clientSession.sendDatagram(pooledBuf); + notStrictEqual(id, 0n); + + await Promise.all([serverGot.promise, clientSession.closed]); + await serverEndpoint.close(); +} + +// --- DGIMP-06: DataView --- +{ + const serverGot = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverGot.promise; + await serverSession.close(); + }), { + transportParams: { maxDatagramFrameSize: 1200 }, + ondatagram: mustCall((data) => { + deepStrictEqual(Buffer.from(data), Buffer.from([0xCA, 0xFE])); + serverGot.resolve(); + }), + }); + + const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxDatagramFrameSize: 1200 }, + }); + await clientSession.opened; + + const ab = new ArrayBuffer(4); + const fullView = new Uint8Array(ab); + fullView.set([0xDE, 0xAD, 0xCA, 0xFE]); + + // DataView over bytes [2, 3] of the buffer. + const dv = new DataView(ab, 2, 2); + const id = await clientSession.sendDatagram(dv); + notStrictEqual(id, 0n); + + await Promise.all([serverGot.promise, clientSession.closed]); + await serverEndpoint.close(); +} diff --git a/test/parallel/test-quic-datagram-status.mjs b/test/parallel/test-quic-datagram-status.mjs new file mode 100644 index 00000000000000..b3391b7655ff23 --- /dev/null +++ b/test/parallel/test-quic-datagram-status.mjs @@ -0,0 +1,76 @@ +// Flags: --experimental-quic --no-warnings + +// Test: ondatagramstatus callback. +// After sending a datagram, the ondatagramstatus callback fires +// with the datagram ID and either 'acknowledged' or 'lost'. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; +const { setTimeout } = await import('node:timers/promises'); + +const { ok, strictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); + +const serverGot = Promise.withResolvers(); +const statusReceived = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await Promise.all([serverSession.opened, serverGot.promise]); + // Give a moment for the ACK to propagate to the client so the + // ondatagramstatus callback fires before the session closes. + await setTimeout(100); + await serverSession.close(); +}), { + sni: { '*': { keys: [key], certs: [cert] } }, + alpn: ['quic-test'], + transportParams: { maxDatagramFrameSize: 1200 }, + ondatagram: mustCall(function() { + serverGot.resolve(); + }), +}); + +let statusId; +let statusValue; + +const clientSession = await connect(serverEndpoint.address, { + alpn: 'quic-test', + transportParams: { maxDatagramFrameSize: 1200 }, + ondatagramstatus: mustCall((id, status) => { + strictEqual(typeof id, 'bigint'); + strictEqual(typeof status, 'string'); + ok( + status === 'acknowledged' || status === 'lost' || status === 'abandoned', + `status should be 'acknowledged', 'lost', or 'abandoned', got '${status}'`, + ); + + statusId = id; + statusValue = status; + statusReceived.resolve(); + }), +}); + +await clientSession.opened; +const id = await clientSession.sendDatagram(new Uint8Array([1, 2, 3])); + +// Wait for the server to receive and the status callback to fire. +await Promise.all([serverGot.promise, statusReceived.promise]); + +// The status callback should have been called with the same ID. +strictEqual(statusId, id); +// On localhost the datagram should be acknowledged, not lost. +strictEqual(statusValue, 'acknowledged'); + +await clientSession.closed; + +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-datagram-utf8.mjs b/test/parallel/test-quic-datagram-utf8.mjs new file mode 100644 index 00000000000000..c0051ff6f6b95e --- /dev/null +++ b/test/parallel/test-quic-datagram-utf8.mjs @@ -0,0 +1,46 @@ +// Flags: --experimental-quic --no-warnings + +// Test: string datagram with multi-byte UTF-8 characters. +// Verifies that sendDatagram with a string containing multi-byte UTF-8 +// characters (CJK, emoji, etc.) encodes correctly and the receiver +// gets the exact bytes. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok, deepStrictEqual, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const message = '\u4f60\u597d\u4e16\u754c'; // "Hello World" in Chinese +const expected = Buffer.from(message, 'utf8'); + +const serverGot = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverGot.promise; + await serverSession.close(); +}), { + transportParams: { maxDatagramFrameSize: 1200 }, + ondatagram: mustCall((data) => { + ok(data instanceof Uint8Array); + // Verify the received bytes match the UTF-8 encoding. + deepStrictEqual(Buffer.from(data), expected); + serverGot.resolve(); + }), +}); + +const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxDatagramFrameSize: 1200 }, +}); +await clientSession.opened; + +const id = await clientSession.sendDatagram(message); +strictEqual(id, 1n); + +await Promise.all([serverGot.promise, clientSession.closed]); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-datagram.mjs b/test/parallel/test-quic-datagram.mjs new file mode 100644 index 00000000000000..f35966b19be3ec --- /dev/null +++ b/test/parallel/test-quic-datagram.mjs @@ -0,0 +1,62 @@ +// Flags: --experimental-quic --no-warnings + +// Test: basic datagram send and receive. +// Client sends datagram, server receives via ondatagram. +// maxDatagramSize reflects peer's transport param. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { ok, strictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); + +const serverGot = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.opened; + // maxDatagramSize reflects peer's max payload (frame size + // minus DATAGRAM frame overhead of type byte + varint length). + ok(serverSession.maxDatagramSize > 0); + ok(serverSession.maxDatagramSize < 1200); + // Wait for the datagram before closing. + await serverGot.promise; + await serverSession.close(); +}), { + sni: { '*': { keys: [key], certs: [cert] } }, + alpn: ['quic-test'], + transportParams: { maxDatagramFrameSize: 1200 }, + ondatagram: mustCall((data) => { + ok(data instanceof Uint8Array); + strictEqual(data.byteLength, 3); + serverGot.resolve(); + }), +}); + +const clientSession = await connect(serverEndpoint.address, { + alpn: 'quic-test', + transportParams: { maxDatagramFrameSize: 1200 }, +}); + +await clientSession.opened; + +// Client maxDatagramSize reflects actual payload max. +ok(clientSession.maxDatagramSize > 0); +ok(clientSession.maxDatagramSize < 1200); + +// Client sends datagram. +const id = await clientSession.sendDatagram(new Uint8Array([1, 2, 3])); +assert.strictEqual(id, 1n); + +await Promise.all([serverGot.promise, clientSession.closed]); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-default-stream-limits.mjs b/test/parallel/test-quic-default-stream-limits.mjs new file mode 100644 index 00000000000000..d6198d50403a7a --- /dev/null +++ b/test/parallel/test-quic-default-stream-limits.mjs @@ -0,0 +1,55 @@ +// Flags: --experimental-quic --no-warnings + +// Test: default transport parameter limits are reasonable. +// Verify that the default transport parameters have sane values: +// not zero (which would prevent streams), and not excessively large +// (which could waste resources). + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + const info = await serverSession.opened; + + // The handshake info should be available. + ok(info, 'handshake info should be available'); + + await serverSession.closed; +})); + +const clientSession = await connect(serverEndpoint.address, { + reuseEndpoint: false, +}); +const info = await clientSession.opened; + +// Verify the handshake completed and we can inspect the session. +ok(info, 'handshake info should be available'); + +// Check that the session has reasonable default stream limits by +// verifying we can create at least one bidirectional and one +// unidirectional stream. +const bidiStream = await clientSession.createBidirectionalStream(); +ok(bidiStream, 'should be able to create a bidi stream'); +bidiStream.destroy(); + +const uniStream = await clientSession.createUnidirectionalStream(); +ok(uniStream, 'should be able to create a uni stream'); +uniStream.destroy(); + +// Check the endpoint's maxConnectionsPerHost and maxConnectionsTotal +// defaults are either 0 (unlimited) or a reasonable positive number. +const maxPerHost = serverEndpoint.maxConnectionsPerHost; +const maxTotal = serverEndpoint.maxConnectionsTotal; +ok(maxPerHost >= 0, 'maxConnectionsPerHost should be non-negative'); +ok(maxTotal >= 0, 'maxConnectionsTotal should be non-negative'); + +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-diagnostics-channel-busy.mjs b/test/parallel/test-quic-diagnostics-channel-busy.mjs new file mode 100644 index 00000000000000..df680aa51d5b1a --- /dev/null +++ b/test/parallel/test-quic-diagnostics-channel-busy.mjs @@ -0,0 +1,44 @@ +// Flags: --experimental-quic --no-warnings + +// Test: diagnostics_channel endpoint busy change. +// quic.endpoint.busy.change fires on endpoint.busy toggle. + +import { hasQuic, skip, mustCall, mustNotCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import dc from 'node:diagnostics_channel'; +import * as fixtures from '../common/fixtures.mjs'; + +const { ok, strictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, QuicEndpoint } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); + +let busyChangeCount = 0; +dc.subscribe('quic.endpoint.busy.change', mustCall((msg) => { + busyChangeCount++; + ok(msg.endpoint); + strictEqual(typeof msg.busy, 'boolean'); +}, 2)); + +const endpoint = new QuicEndpoint(); +const serverEndpoint = await listen(mustNotCall(), { + endpoint, + sni: { '*': { keys: [key], certs: [cert] } }, + alpn: ['quic-test'], +}); + +// Toggle busy on and off. +endpoint.busy = true; +endpoint.busy = false; + +strictEqual(busyChangeCount, 2); + +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-diagnostics-channel-datagram-status.mjs b/test/parallel/test-quic-diagnostics-channel-datagram-status.mjs new file mode 100644 index 00000000000000..73610746a47966 --- /dev/null +++ b/test/parallel/test-quic-diagnostics-channel-datagram-status.mjs @@ -0,0 +1,48 @@ +// Flags: --experimental-quic --no-warnings + +// Test: diagnostics_channel datagram status event. +// quic.session.receive.datagram.status fires with ack/lost status. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import dc from 'node:diagnostics_channel'; + +const { ok, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const statusDone = Promise.withResolvers(); + +// quic.session.receive.datagram.status fires with status. +dc.subscribe('quic.session.receive.datagram.status', mustCall((msg) => { + ok(msg.session); + ok(msg.id); + strictEqual(msg?.status, 'acknowledged'); + statusDone.resolve(); +})); + +const serverEndpoint = await listen(async (serverSession) => { + // Server stays alive until the client closes so the ACK + // has time to propagate back to the client. + await serverSession.closed; +}, { + transportParams: { maxDatagramFrameSize: 1200 }, + ondatagram() {}, +}); + +const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxDatagramFrameSize: 1200 }, + ondatagramstatus() {}, +}); +await clientSession.opened; + +await clientSession.sendDatagram(new Uint8Array([1, 2, 3])); + +// Wait for the status event before closing. +await statusDone.promise; +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-diagnostics-channel-datagram.mjs b/test/parallel/test-quic-diagnostics-channel-datagram.mjs new file mode 100644 index 00000000000000..572cbe3e099f6a --- /dev/null +++ b/test/parallel/test-quic-diagnostics-channel-datagram.mjs @@ -0,0 +1,52 @@ +// Flags: --experimental-quic --no-warnings + +// Test: diagnostics_channel datagram events. +// quic.session.receive.datagram fires on datagram receipt. +// quic.session.send.datagram fires on datagram send. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import dc from 'node:diagnostics_channel'; + +const { ok } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const serverGot = Promise.withResolvers(); + +// quic.session.send.datagram fires on send. +dc.subscribe('quic.session.send.datagram', mustCall((msg) => { + ok(msg.session); + ok(msg.id); + ok(msg.length > 0); +})); + +// quic.session.receive.datagram fires on receipt. +dc.subscribe('quic.session.receive.datagram', mustCall((msg) => { + ok(msg.session); + ok(msg.length > 0); +})); + +const serverEndpoint = await listen(async (serverSession) => { + await serverSession.closed; +}, { + transportParams: { maxDatagramFrameSize: 1200 }, + ondatagram() { + serverGot.resolve(); + }, +}); + +const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxDatagramFrameSize: 1200 }, +}); +await clientSession.opened; + +await clientSession.sendDatagram(new Uint8Array([1, 2, 3])); + +await serverGot.promise; +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-diagnostics-channel-error.mjs b/test/parallel/test-quic-diagnostics-channel-error.mjs new file mode 100644 index 00000000000000..49644ef437d05f --- /dev/null +++ b/test/parallel/test-quic-diagnostics-channel-error.mjs @@ -0,0 +1,50 @@ +// Flags: --experimental-quic --no-warnings + +// Test: diagnostics_channel endpoint error event. +// quic.endpoint.error fires on endpoint error. +// Trigger a bind failure (port conflict) and verify the channel fires. + +import { hasQuic, skip, mustCall, mustNotCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import dc from 'node:diagnostics_channel'; +import * as fixtures from '../common/fixtures.mjs'; + +const { readKey } = fixtures; + +const { ok, rejects, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); +const sni = { '*': { keys: [key], certs: [cert] } }; +const alpn = ['quic-test']; + +dc.subscribe('quic.endpoint.error', mustCall((msg) => { + ok(msg.endpoint); + ok(msg.error); +})); + +// Create first endpoint to occupy a port. +const ep1 = await listen(mustNotCall(), { sni, alpn }); +const { port } = ep1.address; + +// Create second endpoint on the same port — triggers bind error. +const ep2 = await listen(mustNotCall(), { + sni, + alpn, + endpoint: { address: `127.0.0.1:${port}` }, +}); + +// ep2 is destroyed due to bind failure. +strictEqual(ep2.destroyed, true); +await rejects(ep2.closed, { + code: 'ERR_QUIC_ENDPOINT_CLOSED', + message: /Bind failure/, +}); +await ep1.close(); diff --git a/test/parallel/test-quic-diagnostics-channel-path.mjs b/test/parallel/test-quic-diagnostics-channel-path.mjs new file mode 100644 index 00000000000000..a5464c07076101 --- /dev/null +++ b/test/parallel/test-quic-diagnostics-channel-path.mjs @@ -0,0 +1,59 @@ +// Flags: --experimental-quic --no-warnings + +// Test: diagnostics_channel path validation event. +// quic.session.path.validation fires when path validation completes +// during preferred address migration. + +import { hasQuic, skip, mustCall, mustNotCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import dc from 'node:diagnostics_channel'; + +const { ok } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const clientChannelFired = Promise.withResolvers(); + +// Subscribe to the path validation diagnostics channel. +// Verify the client-side event fires with the correct properties. +dc.subscribe('quic.session.path.validation', (msg) => { + ok(msg.session, 'message should have session'); + ok(msg.result, 'message should have result'); + ok(msg.newLocalAddress, 'message should have newLocalAddress'); + ok(msg.newRemoteAddress, 'message should have newRemoteAddress'); + if (msg.preferredAddress === true) { + clientChannelFired.resolve(); + } +}); + +const preferredEndpoint = await listen(mustNotCall(), { + onpathvalidation() {}, + onerror() {}, +}); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; +}), { + transportParams: { + preferredAddressIpv4: preferredEndpoint.address, + }, + onpathvalidation() {}, + onerror() {}, +}); + +const clientSession = await connect(serverEndpoint.address, { + reuseEndpoint: false, + // The onpathvalidation must be set for the JS handler to fire, + // which in turn publishes to the diagnostics channel. + onpathvalidation: mustCall(), +}); + +await Promise.all([clientSession.opened, clientChannelFired.promise]); + +await clientSession.close(); +await serverEndpoint.close(); +await preferredEndpoint.close(); diff --git a/test/parallel/test-quic-diagnostics-channel-session.mjs b/test/parallel/test-quic-diagnostics-channel-session.mjs new file mode 100644 index 00000000000000..3d11687f1e7006 --- /dev/null +++ b/test/parallel/test-quic-diagnostics-channel-session.mjs @@ -0,0 +1,49 @@ +// Flags: --experimental-quic --no-warnings + +// Test: diagnostics_channel session events. +// quic.session.handshake fires when handshake completes. +// quic.session.update.key fires on key update. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import dc from 'node:diagnostics_channel'; + +const { ok, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +// quic.session.handshake fires on both sides. +let handshakeCount = 0; +dc.subscribe('quic.session.handshake', mustCall((msg) => { + handshakeCount++; + ok(msg.session); + // The handshake info should include standard TLS fields. + strictEqual(typeof msg.protocol, 'string'); + strictEqual(typeof msg.servername, 'string'); +}, 2)); + +// quic.session.update.key fires on key update. +dc.subscribe('quic.session.update.key', mustCall((msg) => { + ok(msg.session); +})); + +const serverEndpoint = await listen(async (serverSession) => { + await serverSession.opened; + await serverSession.close(); +}); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// Trigger a key update to fire a key update event. +clientSession.updateKey(); + +await clientSession.closed; +await serverEndpoint.close(); + +// Both client and server handshakes should have fired. +strictEqual(handshakeCount, 2); diff --git a/test/parallel/test-quic-diagnostics-channel-stream.mjs b/test/parallel/test-quic-diagnostics-channel-stream.mjs new file mode 100644 index 00000000000000..9d6d4e08b2e98b --- /dev/null +++ b/test/parallel/test-quic-diagnostics-channel-stream.mjs @@ -0,0 +1,67 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: diagnostics_channel stream and handshake events +// quic.session.handshake fires on handshake complete (not in +// the channel list but we test the opened event path). +// quic.session.open.stream fires when a stream is created locally. +// quic.session.received.stream fires when a remote stream arrives. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import dc from 'node:diagnostics_channel'; + +const { ok, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const encoder = new TextEncoder(); + +// Fires when the client creates a stream. +dc.subscribe('quic.session.open.stream', mustCall((msg) => { + ok(msg.stream); + ok(msg.session); + strictEqual(msg.direction, 'bidi', 'open.stream direction should be bidi'); +})); + +// Fires when the server receives a stream. +dc.subscribe('quic.session.received.stream', mustCall((msg) => { + ok(msg.stream); + ok(msg.session); + strictEqual(msg.direction, 'bidi', 'received.stream direction should be bidi'); +})); + +// Fires when a stream is destroyed. +dc.subscribe('quic.stream.closed', mustCall((msg) => { + ok(msg.stream); + ok(msg.session); + ok(msg.stats, 'stream.closed should include stats'); +}, 2)); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + await bytes(stream); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode('diagnostics test'), +}); + +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + +await Promise.all([stream.closed, serverDone.promise, clientSession.closed]); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-diagnostics-channel-token.mjs b/test/parallel/test-quic-diagnostics-channel-token.mjs new file mode 100644 index 00000000000000..a2b4cdc5486a58 --- /dev/null +++ b/test/parallel/test-quic-diagnostics-channel-token.mjs @@ -0,0 +1,54 @@ +// Flags: --experimental-quic --no-warnings + +// Test: diagnostics_channel token/ticket events. +// quic.session.ticket fires when session ticket received. +// quic.session.new.token fires when NEW_TOKEN received. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import dc from 'node:diagnostics_channel'; + +const { ok } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const allDone = Promise.withResolvers(); +let ticketFired = false; +let tokenFired = false; + +function checkDone() { + if (ticketFired && tokenFired) allDone.resolve(); +} + +// quic.session.ticket fires when session ticket received. +dc.subscribe('quic.session.ticket', mustCall((msg) => { + ok(msg.session); + ok(msg.ticket); + ticketFired = true; + checkDone(); +})); + +// quic.session.new.token fires when NEW_TOKEN received. +dc.subscribe('quic.session.new.token', mustCall((msg) => { + ok(msg.session); + ok(msg.token); + ok(msg.address); + tokenFired = true; + checkDone(); +})); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; +})); + +const clientSession = await connect(serverEndpoint.address, { + onsessionticket: mustCall((ticket) => { ok(ticket); }), + onnewtoken: mustCall((token) => { ok(token); }), +}); +await Promise.all([clientSession.opened, allDone.promise]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-diagnostics-channel.mjs b/test/parallel/test-quic-diagnostics-channel.mjs new file mode 100644 index 00000000000000..7768c02e79a0e0 --- /dev/null +++ b/test/parallel/test-quic-diagnostics-channel.mjs @@ -0,0 +1,106 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: diagnostics_channel events. +// quic.endpoint.created fires when endpoint is created. +// quic.endpoint.listen fires when endpoint starts listening. +// quic.endpoint.closing fires when endpoint begins closing. +// quic.endpoint.closed fires when endpoint finishes closing. +// quic.session.created.client fires for client sessions. +// quic.session.created.server fires for server sessions. +// quic.session.closing fires when session begins closing. +// quic.session.closed fires when session finishes closing. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import dc from 'node:diagnostics_channel'; + +const { ok } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const events = []; + +// endpoint.created fires for both server and client endpoints. +dc.subscribe('quic.endpoint.created', mustCall((msg) => { + events.push('endpoint.created'); + ok(msg.endpoint); +}, 2)); + +// endpoint.listen fires once (server only). +dc.subscribe('quic.endpoint.listen', mustCall((msg) => { + events.push('endpoint.listen'); + ok(msg.endpoint); +})); + +// endpoint.closing fires once (server endpoint closes). +dc.subscribe('quic.endpoint.closing', mustCall((msg) => { + events.push('endpoint.closing'); + ok(msg.endpoint); +})); + +// endpoint.closed fires once (server endpoint closed). +dc.subscribe('quic.endpoint.closed', mustCall((msg) => { + events.push('endpoint.closed'); + ok(msg.endpoint); + ok(msg.stats, 'endpoint.closed should include stats'); +})); + +// endpoint.connect fires before a client session is created. +dc.subscribe('quic.endpoint.connect', mustCall((msg) => { + events.push('endpoint.connect'); + ok(msg.endpoint); + ok(msg.address); + ok(msg.options); +})); + +// session.created.client fires for the client session. +dc.subscribe('quic.session.created.client', mustCall((msg) => { + events.push('session.created.client'); + ok(msg.session); +})); + +// session.created.server fires for the server session. +dc.subscribe('quic.session.created.server', mustCall((msg) => { + events.push('session.created.server'); + ok(msg.session); + ok(msg.address, 'server session should include remote address'); +})); + +// session.closing fires when session.close() is called. +// Only fires for sessions where close() is explicitly called (the server). +// The client session closes via CONNECTION_CLOSE without going through close(). +dc.subscribe('quic.session.closing', mustCall((msg) => { + events.push('session.closing'); + ok(msg.session); +})); + +// session.closed fires when session is fully closed. +dc.subscribe('quic.session.closed', mustCall((msg) => { + events.push('session.closed'); + ok(msg.session); + ok(msg.stats, 'session.closed should include stats'); +}, 2)); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.opened; + serverSession.close(); + await serverSession.closed; +})); + +const clientSession = await connect(serverEndpoint.address); +await Promise.all([clientSession.opened, clientSession.closed]); + +await serverEndpoint.close(); + +// Verify key events occurred. +ok(events.includes('endpoint.created'), 'missing endpoint.created'); +ok(events.includes('endpoint.listen'), 'missing endpoint.listen'); +ok(events.includes('endpoint.connect'), 'missing endpoint.connect'); +ok(events.includes('session.created.client'), 'missing session.created.client'); +ok(events.includes('session.created.server'), 'missing session.created.server'); +ok(events.includes('endpoint.closing'), 'missing endpoint.closing'); +ok(events.includes('endpoint.closed'), 'missing endpoint.closed'); diff --git a/test/parallel/test-quic-draining-period.mjs b/test/parallel/test-quic-draining-period.mjs new file mode 100644 index 00000000000000..46a04f676902c9 --- /dev/null +++ b/test/parallel/test-quic-draining-period.mjs @@ -0,0 +1,103 @@ +// Flags: --experimental-quic --no-warnings + +// Test: drainingPeriodMultiplier option validation and behavior. +// 1. Default value (3) results in prompt session close after peer closes. +// 2. Custom value is accepted and affects draining duration. +// 3. Values below 3 are clamped to 3. +// 4. Invalid values are rejected. + +import { hasQuic, skip, mustCall, mustNotCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +// Test 1: Default drainingPeriodMultiplier (3) — session closes promptly +// after server closes, not after the full idle timeout. +{ + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.opened; + await serverSession.close(); + })); + + const clientSession = await connect(serverEndpoint.address); + await clientSession.opened; + + // Measure how long clientSession.closed takes to resolve. + const start = Date.now(); + await clientSession.closed; + const elapsed = Date.now() - start; + + // With 3x PTO on localhost (~1-4ms RTT), the draining period should + // be well under 1 second. The idle timeout is 10 seconds. If the + // draining period fix is working, elapsed should be much less than 10s. + ok(elapsed < 2000, `Expected draining to complete in < 2s, took ${elapsed}ms`); + + await serverEndpoint.close(); +} + +// Test 2: Custom drainingPeriodMultiplier is accepted. +{ + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.opened; + await serverSession.close(); + })); + + const clientSession = await connect(serverEndpoint.address, { + drainingPeriodMultiplier: 10, + }); + await clientSession.opened; + + const start = Date.now(); + await clientSession.closed; + const elapsed = Date.now() - start; + + // 10x PTO is still very short on localhost. Should complete promptly. + ok(elapsed < 2000, `Expected draining to complete in < 2s, took ${elapsed}ms`); + + await serverEndpoint.close(); +} + +// Test 3: Values below 3 are rejected by JS validation. +{ + const serverEndpoint = await listen(mustNotCall()); + + await assert.rejects( + connect(serverEndpoint.address, { + drainingPeriodMultiplier: 1, + }), + { code: 'ERR_OUT_OF_RANGE' }, + ); + + await serverEndpoint.close(); +} + +// Test 4: Invalid types are rejected. +{ + const serverEndpoint = await listen(mustNotCall(), { + transportParams: { maxIdleTimeout: 1 }, + }); + + await assert.rejects( + connect(serverEndpoint.address, { + drainingPeriodMultiplier: 'fast', + transportParams: { maxIdleTimeout: 1 }, + }), + { code: 'ERR_INVALID_ARG_TYPE' }, + ); + + await assert.rejects( + connect(serverEndpoint.address, { + drainingPeriodMultiplier: 300, + transportParams: { maxIdleTimeout: 1 }, + }), + { code: 'ERR_OUT_OF_RANGE' }, + ); + + await serverEndpoint.close(); +} diff --git a/test/parallel/test-quic-edge-closing-ops.mjs b/test/parallel/test-quic-edge-closing-ops.mjs new file mode 100644 index 00000000000000..812c4be1d515c3 --- /dev/null +++ b/test/parallel/test-quic-edge-closing-ops.mjs @@ -0,0 +1,50 @@ +// Flags: --experimental-quic --no-warnings + +// Test: operations on a closing session. +// createBidirectionalStream on closing session throws. +// sendDatagram on closing session throws. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { rejects } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; +}), { + transportParams: { maxDatagramFrameSize: 1200 }, +}); + +const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxDatagramFrameSize: 1200 }, +}); +await clientSession.opened; + +// Initiate graceful close. +clientSession.close(); + +// Creating a stream on a closing session rejects. +await rejects( + clientSession.createBidirectionalStream(), + { code: 'ERR_INVALID_STATE' }, +); + +await rejects( + clientSession.createUnidirectionalStream(), + { code: 'ERR_INVALID_STATE' }, +); + +// sendDatagram on a closing session throws. +await rejects( + clientSession.sendDatagram(new Uint8Array([1, 2, 3])), + { code: 'ERR_INVALID_STATE' }, +); + +await clientSession.closed; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-edge-concurrent-close.mjs b/test/parallel/test-quic-edge-concurrent-close.mjs new file mode 100644 index 00000000000000..120ab0ccafbd54 --- /dev/null +++ b/test/parallel/test-quic-edge-concurrent-close.mjs @@ -0,0 +1,41 @@ +// Flags: --experimental-quic --no-warnings + +// Test: concurrent close() from both client and server. +// Both sides initiate close simultaneously. Neither should crash +// and both closed promises should settle. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + // Once the stream arrives, both sides close simultaneously. + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + }); + await serverSession.closed; + serverDone.resolve(); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// Open a stream so the server session has work, then close from both sides. +const stream = await clientSession.createBidirectionalStream(); +stream.writer.endSync(); +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars +await stream.closed; + +// Client close happens around the same time as server close above. +await clientSession.close(); + +await serverDone.promise; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-edge-destroyed-ops.mjs b/test/parallel/test-quic-edge-destroyed-ops.mjs new file mode 100644 index 00000000000000..9fb8a8cefcfcb6 --- /dev/null +++ b/test/parallel/test-quic-edge-destroyed-ops.mjs @@ -0,0 +1,55 @@ +// Flags: --experimental-quic --no-warnings + +// Test: operations on destroyed session/stream. +// Operations on a destroyed session return gracefully. +// Operations on a destroyed stream return gracefully. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { rejects, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream(); + +// Destroy the stream, then try operations on it. +stream.destroy(); +strictEqual(stream.destroyed, true); + +// Operations on destroyed stream should not throw. +stream.destroy(); // Idempotent. +stream.writer.endSync(); // No-op on destroyed. + +// Destroy the session, then try operations on it. +clientSession.destroy(); +strictEqual(clientSession.destroyed, true); + +// Properties should return null/undefined gracefully. +strictEqual(clientSession.endpoint, null); +strictEqual(clientSession.path, undefined); +strictEqual(clientSession.certificate, undefined); +strictEqual(clientSession.peerCertificate, undefined); +strictEqual(clientSession.ephemeralKeyInfo, undefined); + +// destroy() again is idempotent. +clientSession.destroy(); + +// sendDatagram on destroyed session throws ERR_INVALID_STATE. +await rejects( + clientSession.sendDatagram(new Uint8Array([1])), + { code: 'ERR_INVALID_STATE' }, +); + +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-edge-endpoint-destroy-active.mjs b/test/parallel/test-quic-edge-endpoint-destroy-active.mjs new file mode 100644 index 00000000000000..c5790def6f187f --- /dev/null +++ b/test/parallel/test-quic-edge-endpoint-destroy-active.mjs @@ -0,0 +1,55 @@ +// Flags: --experimental-quic --no-warnings + +// Test: endpoint closed while sessions are active. +// When endpoint.close() is called while sessions are active, the +// endpoint waits for sessions to finish. When the client closes +// its session, the server session closes (via CONNECTION_CLOSE), +// and the endpoint finishes closing. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const encoder = new TextEncoder(); +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + stream.writer.endSync(); + await stream.closed; + }); + await serverSession.closed; + serverDone.resolve(); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// Create a stream so there's active work. +const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode('hello'), +}); +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars +await stream.closed; + +// Close the endpoint while the server session is still active +// (the session is open but the stream is done). +serverEndpoint.close(); +strictEqual(serverEndpoint.closing, true); +strictEqual(serverEndpoint.destroyed, false); + +// The endpoint is waiting for the server session. Close the +// client session to trigger the server session to close. +await clientSession.close(); + +// The server session should close from the CONNECTION_CLOSE. +await Promise.all([serverDone.promise, serverEndpoint.closed]); +strictEqual(serverEndpoint.destroyed, true); diff --git a/test/parallel/test-quic-edge-idempotent.mjs b/test/parallel/test-quic-edge-idempotent.mjs new file mode 100644 index 00000000000000..8cb448facc501f --- /dev/null +++ b/test/parallel/test-quic-edge-idempotent.mjs @@ -0,0 +1,53 @@ +// Flags: --experimental-quic --no-warnings + +// Test: double close/destroy are idempotent. +// Double close() on session is idempotent. +// Double close() on endpoint is idempotent. +// Double destroy() on session is idempotent. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + }); + await serverSession.closed; +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// Signal server to close via stream first (before we close). +const stream = await clientSession.createBidirectionalStream(); +stream.writer.endSync(); +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars +await stream.closed; + +// Double close() on session — both return the same promise. +const p1 = clientSession.close(); +const p2 = clientSession.close(); +strictEqual(p1, p2); +await clientSession.closed; + +// Double destroy() — second call is no-op. +clientSession.destroy(); +strictEqual(clientSession.destroyed, true); +clientSession.destroy(); // Should not throw. +strictEqual(clientSession.destroyed, true); + +// Double close() on endpoint. +const ep1 = serverEndpoint.close(); +const ep2 = serverEndpoint.close(); +strictEqual(ep1, ep2); +await serverEndpoint.closed; diff --git a/test/parallel/test-quic-edge-session-close-immediate.mjs b/test/parallel/test-quic-edge-session-close-immediate.mjs new file mode 100644 index 00000000000000..35fdbe5d2629dc --- /dev/null +++ b/test/parallel/test-quic-edge-session-close-immediate.mjs @@ -0,0 +1,27 @@ +// Flags: --experimental-quic --no-warnings + +// Test: session created and immediately closed. +// Calling close() on a session right after creation (before handshake +// completes) should gracefully close the session without crashing. + +import { hasQuic, skip } from '../common/index.mjs'; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const serverEndpoint = await listen(async (serverSession) => { + await serverSession.closed; +}, { + transportParams: { maxIdleTimeout: 1 }, +}); + +const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxIdleTimeout: 1 }, +}); + +// Close immediately without waiting for opened. +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-edge-session-destroy-immediate.mjs b/test/parallel/test-quic-edge-session-destroy-immediate.mjs new file mode 100644 index 00000000000000..db4cbf3eedafc7 --- /dev/null +++ b/test/parallel/test-quic-edge-session-destroy-immediate.mjs @@ -0,0 +1,37 @@ +// Flags: --experimental-quic --no-warnings + +// Test: session created and immediately destroyed. +// Calling destroy() on a session that hasn't completed handshake should +// not crash. The opened and closed promises should settle appropriately. + +import { hasQuic, skip, mustNotCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +// The client destroys before handshake completes, so the server +// should never see a session. +const serverEndpoint = await listen(mustNotCall(), { + transportParams: { maxIdleTimeout: 1 }, +}); + +const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxIdleTimeout: 1 }, +}); + +// Destroy immediately without waiting for opened. +clientSession.destroy(); + +strictEqual(clientSession.destroyed, true); + +// Opened may reject (session destroyed before handshake completed) +// or resolve if handshake completed fast enough. +// Closed should resolve (destroy without error). +await clientSession.closed; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-enable-early-data.mjs b/test/parallel/test-quic-enable-early-data.mjs new file mode 100644 index 00000000000000..d2b140c20d6cbd --- /dev/null +++ b/test/parallel/test-quic-enable-early-data.mjs @@ -0,0 +1,58 @@ +// Flags: --experimental-quic --no-warnings + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { rejects, strictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); + +// enableEarlyData must be a boolean +await rejects(connect({ port: 1234 }, { + alpn: 'quic-test', + enableEarlyData: 'yes', +}), { + code: 'ERR_INVALID_ARG_TYPE', +}); + +// With enableEarlyData: false, early data should not be attempted. +// (Without a session ticket, early data is never attempted regardless, +// but this verifies the option is functional and passes through to C++.) + +const serverOpened = Promise.withResolvers(); +const clientOpened = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.opened.then(mustCall((info) => { + serverOpened.resolve(); + serverSession.close(); + })); +}), { + sni: { '*': { keys: [key], certs: [cert] } }, + alpn: ['quic-test'], + enableEarlyData: false, +}); + +const clientSession = await connect(serverEndpoint.address, { + alpn: 'quic-test', + servername: 'localhost', + enableEarlyData: false, +}); +clientSession.opened.then(mustCall((info) => { + strictEqual(info.earlyDataAttempted, false); + strictEqual(info.earlyDataAccepted, false); + clientOpened.resolve(); +})); + +await Promise.all([serverOpened.promise, clientOpened.promise]); +clientSession.close(); diff --git a/test/parallel/test-quic-endpoint-async-dispose.mjs b/test/parallel/test-quic-endpoint-async-dispose.mjs new file mode 100644 index 00000000000000..e97915aca5e258 --- /dev/null +++ b/test/parallel/test-quic-endpoint-async-dispose.mjs @@ -0,0 +1,39 @@ +// Flags: --experimental-quic --no-warnings + +// Test: Symbol.asyncDispose for endpoint and session. +// endpoint[Symbol.asyncDispose] closes the endpoint. +// session[Symbol.asyncDispose] closes the session. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + // Wait for the session to close (triggered by the client's close). + await serverSession.closed; + serverDone.resolve(); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// session[Symbol.asyncDispose] closes the session. +strictEqual(typeof clientSession[Symbol.asyncDispose], 'function'); +await clientSession[Symbol.asyncDispose](); +strictEqual(clientSession.destroyed, true); + +await serverDone.promise; + +// endpoint[Symbol.asyncDispose] closes the endpoint. +strictEqual(typeof serverEndpoint[Symbol.asyncDispose], 'function'); +await serverEndpoint[Symbol.asyncDispose](); +strictEqual(serverEndpoint.destroyed, true); diff --git a/test/parallel/test-quic-endpoint-bind-failure.mjs b/test/parallel/test-quic-endpoint-bind-failure.mjs new file mode 100644 index 00000000000000..60ddb6dd9295b9 --- /dev/null +++ b/test/parallel/test-quic-endpoint-bind-failure.mjs @@ -0,0 +1,49 @@ +// Flags: --experimental-quic --no-warnings + +// Test: ERR_QUIC_ENDPOINT_CLOSED on bind failure. +// Attempting to listen on a port that's already in use by another +// QUIC endpoint produces ERR_QUIC_ENDPOINT_CLOSED with a +// 'Bind failure' context. The listen() call may return an endpoint +// that is immediately destroyed — the error surfaces via the +// endpoint's closed promise. + +import { hasQuic, skip, mustNotCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { strictEqual, ok, rejects } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); +const sni = { '*': { keys: [key], certs: [cert] } }; +const alpn = ['quic-test']; + +// Bind first endpoint to get an assigned port. +const ep1 = await listen(mustNotCall(), { sni, alpn }); +const { port } = ep1.address; +ok(port > 0); + +// Attempt to listen on the same port — should fail with bind error. +// listen() returns an endpoint that is immediately destroyed. +const ep2 = await listen(mustNotCall(), { + sni, + alpn, + endpoint: { address: `127.0.0.1:${port}` }, +}); +strictEqual(ep2.destroyed, true); + +// The bind failure surfaces as a rejected closed promise. +await rejects(ep2.closed, { + code: 'ERR_QUIC_ENDPOINT_CLOSED', + message: /Bind failure/, +}); + +await ep1.close(); diff --git a/test/parallel/test-quic-endpoint-bind.mjs b/test/parallel/test-quic-endpoint-bind.mjs new file mode 100644 index 00000000000000..0f9c359075db75 --- /dev/null +++ b/test/parallel/test-quic-endpoint-bind.mjs @@ -0,0 +1,55 @@ +// Flags: --experimental-quic --no-warnings + +// Test: endpoint binding options. +// Binding to specific address. +// Binding to specific port. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { strictEqual, ok } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect, QuicEndpoint } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); + +// Binding to a specific port. +{ + const endpoint = new QuicEndpoint({ + address: { address: '127.0.0.1', port: 0 }, + }); + + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; + }), { + endpoint, + sni: { '*': { keys: [key], certs: [cert] } }, + alpn: ['quic-test'], + transportParams: { maxIdleTimeout: 1 }, + }); + + // The address should reflect what we bound to. + const addr = serverEndpoint.address; + strictEqual(addr.address, '127.0.0.1'); + strictEqual(addr.family, 'ipv4'); + strictEqual(typeof addr.port, 'number'); + ok(addr.port > 0, 'port should be assigned'); + + // Verify a client can connect to the bound address. + const clientSession = await connect(serverEndpoint.address, { + alpn: 'quic-test', + transportParams: { maxIdleTimeout: 1 }, + }); + await clientSession.opened; + await clientSession.close(); + + await serverEndpoint.close(); +} diff --git a/test/parallel/test-quic-endpoint-busy.mjs b/test/parallel/test-quic-endpoint-busy.mjs new file mode 100644 index 00000000000000..b6c874943a0164 --- /dev/null +++ b/test/parallel/test-quic-endpoint-busy.mjs @@ -0,0 +1,71 @@ +// Flags: --experimental-quic --no-warnings + +// Test: endpoint.busy rejects new sessions. +// When the busy flag is set, the server sends CONNECTION_REFUSED +// for new connection attempts. Existing sessions are not affected. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { rejects, strictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect, QuicEndpoint } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); + +const endpoint = new QuicEndpoint(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.opened; + await serverSession.closed; +}), { + endpoint, + sni: { '*': { keys: [key], certs: [cert] } }, + alpn: ['quic-test'], + transportParams: { maxIdleTimeout: 2 }, +}); + +// First connection before busy — should succeed. +const cs1 = await connect(serverEndpoint.address, { + alpn: 'quic-test', + transportParams: { maxIdleTimeout: 2 }, +}); +await cs1.opened; + +// Set the endpoint busy. +strictEqual(endpoint.busy, false); +endpoint.busy = true; +strictEqual(endpoint.busy, true); + +// Second connection while busy — server rejects. +const cs2 = await connect(serverEndpoint.address, { + alpn: 'quic-test', + transportParams: { maxIdleTimeout: 1 }, + onerror: mustCall((err) => { + strictEqual(err.code, 'ERR_QUIC_TRANSPORT_ERROR'); + }), +}); + +await rejects(cs2.opened, { + code: 'ERR_QUIC_TRANSPORT_ERROR', +}); + +await rejects(cs2.closed, { + code: 'ERR_QUIC_TRANSPORT_ERROR', +}); + +// Unset busy. +endpoint.busy = false; +strictEqual(endpoint.busy, false); + +// Clean up. +await cs1.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-endpoint-close-destroy.mjs b/test/parallel/test-quic-endpoint-close-destroy.mjs new file mode 100644 index 00000000000000..28eb069552086d --- /dev/null +++ b/test/parallel/test-quic-endpoint-close-destroy.mjs @@ -0,0 +1,79 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: endpoint close and destroy lifecycle. +// endpoint.close() waits for active sessions to finish. +// endpoint.destroy() forcefully closes all sessions. +// endpoint.closing property reflects close state. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +const { setTimeout } = await import('node:timers/promises'); +const { bytes } = await import('stream/iter'); + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const encoder = new TextEncoder(); + +{ + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (serverSession) => { + // Set onstream before awaiting anything so the callback isn't + // missed if data arrives quickly. + const streamDone = Promise.withResolvers(); + serverSession.onstream = mustCall(async (stream) => { + await bytes(stream); + stream.writer.endSync(); + await stream.closed; + streamDone.resolve(); + }); + + await serverSession.opened; + + // Before close, closing is false. + strictEqual(serverEndpoint.closing, false); + + // Initiate endpoint close — it should wait for this session. + serverEndpoint.close(); + + // After close() is called, closing is true. + strictEqual(serverEndpoint.closing, true); + + // The endpoint's closed promise should NOT resolve yet — session is open. + let endpointClosed = false; + serverEndpoint.closed.then(mustCall(() => { endpointClosed = true; })); + + // Give a tick to confirm endpoint hasn't closed yet. + await setTimeout(100); + strictEqual(endpointClosed, false); + + // Wait for the stream to complete, then close the session. + await streamDone.promise; + serverSession.close(); + serverDone.resolve(); + }), { + transportParams: { maxIdleTimeout: 1 }, + }); + + const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxIdleTimeout: 1 }, + }); + await clientSession.opened; + + // Send some data so the server session has work to do. + const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode('test'), + }); + + await Promise.all([serverDone.promise, + stream.closed, + serverEndpoint.closed]); + + strictEqual(serverEndpoint.destroyed, true); +} diff --git a/test/parallel/test-quic-endpoint-destroy-after-close.mjs b/test/parallel/test-quic-endpoint-destroy-after-close.mjs new file mode 100644 index 00000000000000..66e1f22accbdab --- /dev/null +++ b/test/parallel/test-quic-endpoint-destroy-after-close.mjs @@ -0,0 +1,66 @@ +// Flags: --experimental-quic --no-warnings + +// Test: When `endpoint.destroy(err)` is called *after* `endpoint.close()` +// has already initiated graceful shutdown, the error must still surface +// on `endpoint.closed` instead of being swallowed. First-error-wins +// semantics: a fatal error reported via `destroy(err)` after a +// graceful close was already in flight is still propagated through +// `endpoint.closed`. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { rejects } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +// Hold the connection open for a while so that close() has actual work +// to wait on. +const transportParams = { maxIdleTimeout: 5000 }; + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + // Don't observe `serverSession.closed` directly here - the cascade + // from `endpoint.destroy(err)` will reject it, and the outer + // `markPromiseAsHandled` in the cascade keeps that from surfacing as + // an unhandled rejection. We just need this callback to keep running + // until the test ends. + try { + await serverSession.closed; + } catch { + // Expected: the cascade destroys the session with an error. + } + serverDone.resolve(); +}), { transportParams }); + +const clientSession = await connect(serverEndpoint.address, { + transportParams, +}); +await clientSession.opened; + +// Step 1: kick off a graceful close. After this, the endpoint is in +// the "closing" state - so `#isClosedOrClosing` is true and the +// pre-fix `destroy()` would skip recording `#pendingError`. +const closingPromise = serverEndpoint.close(); + +// Step 2: while the graceful close is in flight, call destroy(err). +// With the fix, the error is still recorded and surfaces on +// `endpoint.closed`. Without the fix, it'd be silently dropped. +const destroyError = new Error('destroy after close'); +const closedAssertion = rejects(serverEndpoint.closed, destroyError); + +serverEndpoint.destroy(destroyError); + +await closedAssertion; + +// `endpoint.close()` returns the same promise as `endpoint.closed`, so +// it should reject with the same error as well. +await rejects(closingPromise, destroyError); + +await serverDone.promise; +clientSession.destroy(); diff --git a/test/parallel/test-quic-endpoint-destroy-cascade-close-frame.mjs b/test/parallel/test-quic-endpoint-destroy-cascade-close-frame.mjs new file mode 100644 index 00000000000000..0cf59bb65e2007 --- /dev/null +++ b/test/parallel/test-quic-endpoint-destroy-cascade-close-frame.mjs @@ -0,0 +1,86 @@ +// Flags: --experimental-quic --no-warnings + +// Test: when `endpoint.destroy(err)` is called on a side that has open, +// fully-handshaked sessions, the cascade through `session.destroy(err)` +// passes close options derived from the error so each session emits a +// CONNECTION_CLOSE on the wire. The peer learns about the teardown via +// that frame, not via its own idle timer. +// +// How the test distinguishes the two cases: +// +// * If CONNECTION_CLOSE is sent, the client's `session.closed` +// rejects after the network round-trip with an +// `ERR_QUIC_TRANSPORT_ERROR` carrying the cascaded code. +// * If CONNECTION_CLOSE is NOT sent, the client only learns of the +// teardown via its own idle timer, which hits `[kFinishClose]` +// case 3 (`/* Idle close */`) and resolves `session.closed` +// *cleanly*. The `mustCall` rejection-handler would then never +// fire and the test fails. +// +// A short `maxIdleTimeout` keeps the failure mode fast. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { rejects, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +// `maxIdleTimeout` is measured in seconds. One second is far longer +// than CONNECTION_CLOSE on loopback needs to win, while still short +// enough that a regression in which `CONNECTION_CLOSE` is *not* sent +// fails the test promptly: the idle-close path takes the +// `[kFinishClose]` case-3 branch and resolves `session.closed` cleanly +// instead of rejecting, so the rejection-handler `mustCall` below +// would fail with "expected exactly 1, actual 0". +const transportParams = { maxIdleTimeout: 1 }; + +const serverError = new Error('cascade close frame test'); + +// Capture the server-side session and wait for *its* `onhandshake` to +// fire before triggering the cascade. The client's `session.opened` +// resolves as soon as the client receives the server's TLS Finished, +// which can land slightly *before* the server has processed the +// client's reciprocal Finished. Without this synchronization the +// server-side `kHandshakeCompleted` flag may still be `false` at +// destroy time and the cascade would skip emitting `CONNECTION_CLOSE` +// (which is the regression this test is designed to catch). +const serverHandshake = Promise.withResolvers(); +const onsession = mustCall((serverSession) => { + serverSession.onhandshake = mustCall(() => { + serverHandshake.resolve(); + }); +}); +const serverEndpoint = await listen(onsession, { transportParams }); + +const clientSession = await connect(serverEndpoint.address, { + transportParams, +}); +await clientSession.opened; +await serverHandshake.promise; + +// Attach the rejection handlers BEFORE triggering destroy so neither +// `serverEndpoint.closed` (rejects with `serverError` via the +// `#pendingError` semantics from B7) nor `clientSession.closed` +// (rejects with the transport error decoded from the CONNECTION_CLOSE +// frame) ends up as an unhandled rejection in the brief window before +// this test gets back to awaiting them. +const serverClosedAssertion = rejects(serverEndpoint.closed, serverError); +const clientClosedAssertion = rejects(clientSession.closed, mustCall((err) => { + strictEqual(err.code, 'ERR_QUIC_TRANSPORT_ERROR'); + return true; +})); + +serverEndpoint.destroy(serverError); + +await clientClosedAssertion; +await serverClosedAssertion; + +// Explicit cleanup: the client-side session has been rejected via +// CONNECTION_CLOSE but the underlying client endpoint is still alive. +// Tear it down so the event loop drains promptly. +clientSession.destroy(); diff --git a/test/parallel/test-quic-endpoint-idle-timeout.mjs b/test/parallel/test-quic-endpoint-idle-timeout.mjs new file mode 100644 index 00000000000000..aa75d16a82b7ed --- /dev/null +++ b/test/parallel/test-quic-endpoint-idle-timeout.mjs @@ -0,0 +1,77 @@ +// Flags: --experimental-quic --no-warnings + +// Test: endpoint idle timeout behavior. +// When an endpoint has idleTimeout > 0 and becomes idle (no sessions, +// not listening), it stays alive for the timeout duration before +// being destroyed. With idleTimeout = 0 (default), the endpoint is +// destroyed immediately when idle. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import { setTimeout } from 'node:timers/promises'; + +const { ok } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { QuicEndpoint } = await import('node:quic'); +const { listen, connect } = await import('../common/quic.mjs'); + +// --- Test 1: Default idleTimeout (0) --- endpoint becomes idle +// immediately when it has no sessions and is not listening. The +// UDP handle is unref'd so it won't block process exit. +{ + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; + })); + + // Create a client with an explicit endpoint so we can track it. + const clientEndpoint = new QuicEndpoint(); + const client = await connect(serverEndpoint.address, { + endpoint: clientEndpoint, + }); + await client.opened; + + // Endpoint is alive while the session is active. + ok(!clientEndpoint.destroyed, 'endpoint should be alive'); + + await client.close(); + + // The endpoint's UDP handle is unref'd when all sessions close, + // so it won't block process exit. Explicitly close it for cleanup. + await clientEndpoint.close(); + ok(clientEndpoint.destroyed, 'endpoint should be destroyed after close'); + + await serverEndpoint.close(); +} + +// --- Test 2: idleTimeout > 0 --- endpoint stays alive briefly +{ + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; + })); + + // Create endpoint with a 1-second idle timeout. + const clientEndpoint = new QuicEndpoint({ idleTimeout: 1 }); + const client = await connect(serverEndpoint.address, { + endpoint: clientEndpoint, + }); + await client.opened; + await client.close(); + + // The endpoint should NOT be immediately destroyed — idle timer + // is running. + ok(!clientEndpoint.destroyed, + 'endpoint should still be alive during idle timeout'); + + // Wait for the idle timeout to fire (1 second + margin). + // Use a ref'd timer to keep the event loop alive while the + // unref'd idle timer runs. + await setTimeout(2000); + ok(clientEndpoint.destroyed, + 'endpoint should be destroyed after idle timeout'); + + await serverEndpoint.close(); +} diff --git a/test/parallel/test-quic-endpoint-onsession-throws.mjs b/test/parallel/test-quic-endpoint-onsession-throws.mjs new file mode 100644 index 00000000000000..aa6e5722534642 --- /dev/null +++ b/test/parallel/test-quic-endpoint-onsession-throws.mjs @@ -0,0 +1,74 @@ +// Flags: --experimental-quic --no-warnings + +// Test: When the user's `onsession` callback throws synchronously or +// returns a rejected promise, the endpoint is destroyed with that +// error rather than surfacing as an unhandled exception/rejection out +// of the C++ -> JS callback boundary. The error is observable through +// `endpoint.closed` rejecting with the thrown value. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { rejects } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const transportParams = { maxIdleTimeout: 1 }; + +// ------------------------------------------------------------------- +// 1. Synchronous throw in onsession -> endpoint.closed rejects with +// that error. +// ------------------------------------------------------------------- +{ + const sessionError = new Error('sync onsession failure'); + + const serverEndpoint = await listen(mustCall(() => { + throw sessionError; + }), { transportParams }); + + // Attach the rejection handler BEFORE initiating the connection so + // there is no window where serverEndpoint.closed is rejected without + // a handler attached. The throw inside `onsession` is delivered + // synchronously from the C++ -> JS callback, so the rejection can + // arrive on the very next microtask after `connect()` returns. + const closedAssertion = rejects(serverEndpoint.closed, sessionError); + + const clientSession = await connect(serverEndpoint.address, { + transportParams, + }); + + await closedAssertion; + + // Explicitly tear down the client side. Even though the endpoint + // cascade now sends CONNECTION_CLOSE so the client learns about the + // teardown promptly, dropping our reference here keeps the test + // robust to network-dropped close packets and stops the event loop + // from waiting on the client's idle timer to expire. + clientSession.destroy(); +} + +// ------------------------------------------------------------------- +// 2. onsession returns a rejected promise -> endpoint.closed rejects +// with that error. +// ------------------------------------------------------------------- +{ + const sessionError = new Error('async onsession failure'); + + const serverEndpoint = await listen(mustCall(async () => { + throw sessionError; + }), { transportParams, onerror() {} }); + + const closedAssertion = rejects(serverEndpoint.closed, sessionError); + + const clientSession = await connect(serverEndpoint.address, { + transportParams, + }); + + await closedAssertion; + + clientSession.destroy(); +} diff --git a/test/parallel/test-quic-endpoint-reuse.mjs b/test/parallel/test-quic-endpoint-reuse.mjs new file mode 100644 index 00000000000000..fc4af988595c4b --- /dev/null +++ b/test/parallel/test-quic-endpoint-reuse.mjs @@ -0,0 +1,89 @@ +// Flags: --experimental-quic --no-warnings + +// Test: endpoint reuse behavior for connect(). +// 1. Multiple connect() calls without explicit endpoint share +// the same endpoint (connection pooling). +// 2. connect() with reuseEndpoint: false creates a separate endpoint. +// 3. connect() to the same address as a listening endpoint does NOT +// reuse the listening endpoint (self-connect exclusion). +// 4. connect() to a different address with a listening endpoint in +// the registry reuses the listening endpoint (dual-role). + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual, notStrictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +// --- Test 1: connect() reuses endpoints by default --- +{ + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; + }, 2)); + + const client1 = await connect(serverEndpoint.address); + await client1.opened; + + const client2 = await connect(serverEndpoint.address); + await client2.opened; + + // Both client sessions should share the same endpoint because + // findSuitableEndpoint returns the first available non-listening + // non-closing endpoint. After client1 is created, its endpoint + // is available for client2. + strictEqual(client1.endpoint, client2.endpoint, + 'client sessions should share an endpoint'); + + await client1.close(); + await client2.close(); + await serverEndpoint.close(); +} + +// --- Test 2: reuseEndpoint: false creates separate endpoints --- +{ + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; + }, 2)); + + const client1 = await connect(serverEndpoint.address, { + reuseEndpoint: false, + }); + await client1.opened; + + const client2 = await connect(serverEndpoint.address, { + reuseEndpoint: false, + }); + await client2.opened; + + notStrictEqual(client1.endpoint, client2.endpoint, + 'client sessions should have separate endpoints'); + + await client1.close(); + await client2.close(); + await serverEndpoint.close(); +} + +// --- Test 3: connect() to a listening endpoint's address is not reused --- +{ + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; + })); + + const client = await connect(serverEndpoint.address); + await client.opened; + + // The client endpoint should NOT be the server endpoint, even though + // the server endpoint is in the registry. Self-connect is excluded + // because the client's DCID associations would collide with the + // server's session routing on the same endpoint. + notStrictEqual(client.endpoint, serverEndpoint, + 'client should not reuse the server endpoint'); + + await client.close(); + await serverEndpoint.close(); +} diff --git a/test/parallel/test-quic-endpoint-state-transitions.mjs b/test/parallel/test-quic-endpoint-state-transitions.mjs new file mode 100644 index 00000000000000..559356893379ff --- /dev/null +++ b/test/parallel/test-quic-endpoint-state-transitions.mjs @@ -0,0 +1,84 @@ +// Flags: --expose-internals --experimental-quic --no-warnings + +// Test: endpoint state transitions. +// State transitions: created → bound → receiving → listening → closing. +// Binding to 0.0.0.0 (all interfaces). +// Binding to ::1 (IPv6 loopback). + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { ok, strictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect, QuicEndpoint } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); + +{ + const endpoint = new QuicEndpoint(); + + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.opened; + serverSession.close(); + await serverSession.closed; + }), { + endpoint, + sni: { '*': { keys: [key], certs: [cert] } }, + alpn: ['quic-test'], + }); + + // After listen, the endpoint should be listening. + strictEqual(serverEndpoint.listening, true); + strictEqual(serverEndpoint.closing, false); + strictEqual(serverEndpoint.destroyed, false); + + const cs = await connect(serverEndpoint.address, { alpn: 'quic-test' }); + await cs.opened; + await cs.close(); + + // After close(), closing transitions to true. The endpoint is still + // "listening" in the sense that it holds the socket, but closing is true. + serverEndpoint.close(); + strictEqual(serverEndpoint.closing, true); + + await serverEndpoint.closed; + strictEqual(serverEndpoint.destroyed, true); +} + +// Binding to 0.0.0.0. +{ + const endpoint = new QuicEndpoint({ + address: { address: '0.0.0.0', port: 0 }, + }); + + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; + }), { + endpoint, + sni: { '*': { keys: [key], certs: [cert] } }, + alpn: ['quic-test'], + transportParams: { maxIdleTimeout: 1 }, + }); + + const addr = serverEndpoint.address; + strictEqual(addr.address, '0.0.0.0'); + ok(addr.port > 0); + + // Connect via 127.0.0.1 since 0.0.0.0 listens on all interfaces. + const cs = await connect(`127.0.0.1:${addr.port}`, { + alpn: 'quic-test', + transportParams: { maxIdleTimeout: 1 }, + }); + await cs.opened; + await cs.close(); + + await serverEndpoint.close(); +} diff --git a/test/parallel/test-quic-error-class.mjs b/test/parallel/test-quic-error-class.mjs new file mode 100644 index 00000000000000..d8f01c6cbd6724 --- /dev/null +++ b/test/parallel/test-quic-error-class.mjs @@ -0,0 +1,160 @@ +// Flags: --experimental-quic --no-warnings + +// Test: QuicError class. Validates the public surface of the new +// `QuicError` class exported from `node:quic`: +// * Required `message` and `options.errorCode`. +// * `errorCode` accepts bigint or number; coerces to bigint. +// * `errorCode` is range-checked against the QUIC 62-bit varint +// maximum. +// * `type` defaults to 'application' and is restricted to +// 'application' | 'transport'. +// * `code` defaults to 'ERR_QUIC_STREAM_ABORTED' and may be +// overridden with any Node.js-style error code string. + +import { hasQuic, skip } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual, throws, ok } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { QuicError } = await import('node:quic'); + +// Sanity: QuicError is a function (class) and extends Error. +strictEqual(typeof QuicError, 'function'); +ok(new QuicError('msg', { errorCode: 0n }) instanceof Error); + +// Required arguments. +// `message` must be a string -> validateString throws ERR_INVALID_ARG_TYPE. +throws(() => new QuicError(), { code: 'ERR_INVALID_ARG_TYPE' }); +// `options` defaults to an empty object, so `errorCode` is missing. +throws(() => new QuicError('msg'), { code: 'ERR_MISSING_ARGS' }); +// Explicit non-object options -> validateObject throws ERR_INVALID_ARG_TYPE. +throws(() => new QuicError('msg', null), { code: 'ERR_INVALID_ARG_TYPE' }); +// Empty options -> errorCode missing -> ERR_MISSING_ARGS. +throws(() => new QuicError('msg', {}), { code: 'ERR_MISSING_ARGS' }); + +// `message` must be a string. +throws(() => new QuicError(42, { errorCode: 0n }), { + code: 'ERR_INVALID_ARG_TYPE', +}); + +// `errorCode` must be bigint or number. +throws(() => new QuicError('msg', { errorCode: 'oops' }), { + code: 'ERR_INVALID_ARG_TYPE', +}); +throws(() => new QuicError('msg', { errorCode: true }), { + code: 'ERR_INVALID_ARG_TYPE', +}); +// `null` is preserved by destructuring (only `undefined` triggers the +// default), so it flows through to the type check rather than the +// missing-args check. +throws(() => new QuicError('msg', { errorCode: null }), { + code: 'ERR_INVALID_ARG_TYPE', +}); + +// `errorCode` range checks. +throws(() => new QuicError('msg', { errorCode: -1 }), { + code: 'ERR_OUT_OF_RANGE', +}); +throws(() => new QuicError('msg', { errorCode: -1n }), { + code: 'ERR_OUT_OF_RANGE', +}); +// 2**62 is the first invalid value (max varint is 2**62 - 1). +throws(() => new QuicError('msg', { errorCode: 1n << 62n }), { + code: 'ERR_OUT_OF_RANGE', +}); + +// `type` validation. +throws(() => new QuicError('msg', { errorCode: 0n, type: 'bogus' }), { + code: 'ERR_INVALID_ARG_VALUE', +}); +throws(() => new QuicError('msg', { errorCode: 0n, type: 42 }), { + code: 'ERR_INVALID_ARG_VALUE', +}); + +// `code` (Node.js error code) must be a string when supplied. +throws(() => new QuicError('msg', { errorCode: 0n, code: 42 }), { + code: 'ERR_INVALID_ARG_TYPE', +}); +throws(() => new QuicError('msg', { errorCode: 0n, code: null }), { + code: 'ERR_INVALID_ARG_TYPE', +}); + +// Happy paths. + +// 1. Bigint errorCode, default type, default Node code. +{ + const err = new QuicError('something broke', { errorCode: 0x42n }); + strictEqual(err.message, 'something broke'); + strictEqual(err.code, 'ERR_QUIC_STREAM_ABORTED'); + strictEqual(err.errorCode, 0x42n); + strictEqual(err.type, 'application'); + ok(err instanceof Error); + ok(err instanceof QuicError); +} + +// 2. Number errorCode, coerced to bigint. +{ + const err = new QuicError('numeric code', { errorCode: 5 }); + strictEqual(err.errorCode, 5n); + strictEqual(typeof err.errorCode, 'bigint'); +} + +// 3. Boundary: 0n is allowed. +{ + const err = new QuicError('zero', { errorCode: 0n }); + strictEqual(err.errorCode, 0n); +} + +// 4. Boundary: 2**62 - 1 is allowed (largest valid 62-bit varint). +{ + const max = (1n << 62n) - 1n; + const err = new QuicError('max', { errorCode: max }); + strictEqual(err.errorCode, max); +} + +// 5. Explicit type='transport'. +{ + const err = new QuicError('transport-level', { + errorCode: 0x1n, + type: 'transport', + }); + strictEqual(err.type, 'transport'); +} + +// 6. Explicit type='application' (default). +{ + const err = new QuicError('app-level', { + errorCode: 0x102n, + type: 'application', + }); + strictEqual(err.type, 'application'); +} + +// 7. Custom Node.js error code string via options.code. +{ + const err = new QuicError('custom', { + errorCode: 0x10cn, + code: 'ERR_CUSTOM_QUIC_FAILURE', + }); + strictEqual(err.code, 'ERR_CUSTOM_QUIC_FAILURE'); + strictEqual(err.errorCode, 0x10cn); +} + +// 8. Properties are read-only via getters (errorCode, type backed by +// private fields). The base Error's message is writable but the +// QuicError-specific accessors must not be assignable through the +// prototype. +{ + const err = new QuicError('msg', { errorCode: 0x1n }); + // The getters live on the prototype; assigning through the instance + // is silently ignored in non-strict mode (modules are strict, so + // this throws TypeError). We just assert the value is unchanged. + throws(() => { err.errorCode = 0xffn; }, { name: 'TypeError' }); + throws(() => { err.type = 'transport'; }, { name: 'TypeError' }); + strictEqual(err.errorCode, 0x1n); + strictEqual(err.type, 'application'); +} diff --git a/test/parallel/test-quic-error-destroy-rejects-promises.mjs b/test/parallel/test-quic-error-destroy-rejects-promises.mjs new file mode 100644 index 00000000000000..e8ec070f3baa06 --- /dev/null +++ b/test/parallel/test-quic-error-destroy-rejects-promises.mjs @@ -0,0 +1,59 @@ +// Flags: --experimental-quic --no-warnings + +// Test: session.destroy(error) rejects both opened and closed promises +// . +// When destroyed before the handshake completes, both opened and closed +// reject. When destroyed after, opened stays resolved and closed rejects. + +import { hasQuic, skip } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { rejects } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const transportParams = { maxIdleTimeout: 1 }; + +// The server may see 1 or 2 sessions — the first client destroys before +// the handshake completes, so the server session may or may not be created. +const serverEndpoint = await listen(async (serverSession) => { + await serverSession.closed; +}, { transportParams }); + +// First client: destroy BEFORE the handshake completes. +{ + const testError = new Error('early destroy'); + const clientSession = await connect(serverEndpoint.address, { + transportParams, + }); + + // Destroy immediately — the handshake hasn't completed yet. + clientSession.destroy(testError); + + // Both opened and closed should reject with the same error. + await rejects(clientSession.opened, testError); + await rejects(clientSession.closed, testError); +} + +// Second client: destroy AFTER the handshake completes. +{ + const testError = new Error('late destroy'); + const clientSession = await connect(serverEndpoint.address, { + transportParams, + }); + await clientSession.opened; + + clientSession.destroy(testError); + + // Opened already resolved — stays resolved. + await clientSession.opened; + + // Closed rejects with the error. + await rejects(clientSession.closed, testError); +} + +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-exports-constants.mjs b/test/parallel/test-quic-exports-constants.mjs new file mode 100644 index 00000000000000..da1269723f8008 --- /dev/null +++ b/test/parallel/test-quic-exports-constants.mjs @@ -0,0 +1,49 @@ +// Flags: --experimental-quic --no-warnings + +// Test: node:quic exports and constants. + +import { hasQuic, skip } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual, throws, ok } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const quic = await import('node:quic'); + +// Top-level exports. +strictEqual(typeof quic.listen, 'function'); +strictEqual(typeof quic.connect, 'function'); +strictEqual(typeof quic.QuicEndpoint, 'function'); +strictEqual(typeof quic.QuicSession, 'function'); +strictEqual(typeof quic.QuicStream, 'function'); +strictEqual(typeof quic.constants, 'object'); + +// Congestion control constants. +strictEqual(quic.constants.cc.RENO, 'reno'); +strictEqual(quic.constants.cc.CUBIC, 'cubic'); +strictEqual(quic.constants.cc.BBR, 'bbr'); + +// DEFAULT_CIPHERS. +strictEqual(typeof quic.constants.DEFAULT_CIPHERS, 'string'); +ok(quic.constants.DEFAULT_CIPHERS.length > 0); +ok(quic.constants.DEFAULT_CIPHERS.includes('TLS_AES_128_GCM_SHA256')); + +// DEFAULT_GROUPS. +strictEqual(typeof quic.constants.DEFAULT_GROUPS, 'string'); +ok(quic.constants.DEFAULT_GROUPS.length > 0); + +// QuicEndpoint can be constructed directly. +// QuicSession and QuicStream cannot — they throw ERR_ILLEGAL_CONSTRUCTOR. +{ + const ep = new quic.QuicEndpoint(); + ok(ep instanceof quic.QuicEndpoint); +} +throws(() => new quic.QuicSession(), { + code: 'ERR_ILLEGAL_CONSTRUCTOR', +}); +throws(() => new quic.QuicStream(), { + code: 'ERR_ILLEGAL_CONSTRUCTOR', +}); diff --git a/test/parallel/test-quic-exports.mjs b/test/parallel/test-quic-exports.mjs index d977d452d7d43c..7ae0001ee37095 100644 --- a/test/parallel/test-quic-exports.mjs +++ b/test/parallel/test-quic-exports.mjs @@ -2,6 +2,8 @@ import { hasQuic, skip } from '../common/index.mjs'; import assert from 'node:assert'; +const { strictEqual, throws } = assert; + if (!hasQuic) { skip('QUIC is not enabled'); } @@ -9,35 +11,35 @@ if (!hasQuic) { const quic = await import('node:quic'); // Test that the main exports exist and are of the correct type. -assert.strictEqual(typeof quic.connect, 'function'); -assert.strictEqual(typeof quic.listen, 'function'); -assert.strictEqual(typeof quic.QuicEndpoint, 'function'); -assert.strictEqual(typeof quic.QuicSession, 'function'); -assert.strictEqual(typeof quic.QuicStream, 'function'); -assert.strictEqual(typeof quic.QuicEndpoint.Stats, 'function'); -assert.strictEqual(typeof quic.QuicSession.Stats, 'function'); -assert.strictEqual(typeof quic.QuicStream.Stats, 'function'); -assert.strictEqual(typeof quic.constants, 'object'); -assert.strictEqual(typeof quic.constants.cc, 'object'); +strictEqual(typeof quic.connect, 'function'); +strictEqual(typeof quic.listen, 'function'); +strictEqual(typeof quic.QuicEndpoint, 'function'); +strictEqual(typeof quic.QuicSession, 'function'); +strictEqual(typeof quic.QuicStream, 'function'); +strictEqual(typeof quic.QuicEndpoint.Stats, 'function'); +strictEqual(typeof quic.QuicSession.Stats, 'function'); +strictEqual(typeof quic.QuicStream.Stats, 'function'); +strictEqual(typeof quic.constants, 'object'); +strictEqual(typeof quic.constants.cc, 'object'); // Test that the constants exist and are of the correct type. -assert.strictEqual(quic.constants.cc.RENO, 'reno'); -assert.strictEqual(quic.constants.cc.CUBIC, 'cubic'); -assert.strictEqual(quic.constants.cc.BBR, 'bbr'); -assert.strictEqual(quic.constants.DEFAULT_CIPHERS, - 'TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:' + +strictEqual(quic.constants.cc.RENO, 'reno'); +strictEqual(quic.constants.cc.CUBIC, 'cubic'); +strictEqual(quic.constants.cc.BBR, 'bbr'); +strictEqual(quic.constants.DEFAULT_CIPHERS, + 'TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:' + 'TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_CCM_SHA256'); -assert.strictEqual(quic.constants.DEFAULT_GROUPS, 'X25519:P-256:P-384:P-521'); +strictEqual(quic.constants.DEFAULT_GROUPS, 'X25519:P-256:P-384:P-521'); // Ensure the constants are.. well, constant. -assert.throws(() => { quic.constants.cc.RENO = 'foo'; }, TypeError); -assert.strictEqual(quic.constants.cc.RENO, 'reno'); +throws(() => { quic.constants.cc.RENO = 'foo'; }, TypeError); +strictEqual(quic.constants.cc.RENO, 'reno'); -assert.throws(() => { quic.constants.cc.NEW_CONSTANT = 'bar'; }, TypeError); -assert.strictEqual(quic.constants.cc.NEW_CONSTANT, undefined); +throws(() => { quic.constants.cc.NEW_CONSTANT = 'bar'; }, TypeError); +strictEqual(quic.constants.cc.NEW_CONSTANT, undefined); -assert.throws(() => { quic.constants.DEFAULT_CIPHERS = 123; }, TypeError); -assert.strictEqual(typeof quic.constants.DEFAULT_CIPHERS, 'string'); +throws(() => { quic.constants.DEFAULT_CIPHERS = 123; }, TypeError); +strictEqual(typeof quic.constants.DEFAULT_CIPHERS, 'string'); -assert.throws(() => { quic.constants.NEW_CONSTANT = 456; }, TypeError); -assert.strictEqual(quic.constants.NEW_CONSTANT, undefined); +throws(() => { quic.constants.NEW_CONSTANT = 456; }, TypeError); +strictEqual(quic.constants.NEW_CONSTANT, undefined); diff --git a/test/parallel/test-quic-flow-control-blob.mjs b/test/parallel/test-quic-flow-control-blob.mjs new file mode 100644 index 00000000000000..e0ce18f32a381e --- /dev/null +++ b/test/parallel/test-quic-flow-control-blob.mjs @@ -0,0 +1,50 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: blob body larger than stream data window. +// A Blob body that exceeds the initial stream data window should +// still complete successfully — ngtcp2 handles the flow control +// extensions transparently for one-shot body sources. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { deepStrictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +// 8KB blob, 1KB stream window — requires flow control extension. +const data = new Uint8Array(8192); +for (let i = 0; i < data.length; i++) data[i] = i & 0xFF; +const blob = new Blob([data]); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + deepStrictEqual(received, data); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +}), { + transportParams: { initialMaxStreamDataBidiRemote: 1024 }, +}); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream({ + body: blob, +}); + +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars +await Promise.all([stream.closed, serverDone.promise]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-flow-control-block-resume.mjs b/test/parallel/test-quic-flow-control-block-resume.mjs new file mode 100644 index 00000000000000..df8630877589a7 --- /dev/null +++ b/test/parallel/test-quic-flow-control-block-resume.mjs @@ -0,0 +1,52 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: small flow control window blocks sender, resumes after FC +// update. +// With a very small initialMaxStreamDataBidiRemote, the sender +// blocks when the window is exhausted. The transfer completes +// successfully after the receiver extends the window. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const dataLength = 8192; +const data = new Uint8Array(dataLength); +for (let i = 0; i < dataLength; i++) data[i] = i & 0xff; + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + // Read all data — this extends the flow control window. + const received = await bytes(stream); + strictEqual(received.byteLength, dataLength); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +}), { + // Very small window — sender will block multiple times. + transportParams: { initialMaxStreamDataBidiRemote: 128 }, +}); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream(); +stream.setBody(data); + +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + +await Promise.all([stream.closed, serverDone.promise, clientSession.closed]); + +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-flow-control-params.mjs b/test/parallel/test-quic-flow-control-params.mjs new file mode 100644 index 00000000000000..72fe43263a8cd3 --- /dev/null +++ b/test/parallel/test-quic-flow-control-params.mjs @@ -0,0 +1,72 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: flow control transport parameters. +// initialMaxData limits total connection-level data. +// initialMaxStreamDataBidiLocal limits stream data for locally +// initiated bidi streams (server perspective for server-opened). +// initialMaxStreamDataBidiRemote limits stream data for remotely +// initiated bidi streams (server perspective for client-opened). +// These tests verify that data transfers complete successfully even when +// flow control windows are very small, proving that flow control extension +// (MAX_DATA / MAX_STREAM_DATA) works correctly. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes, drainableProtocol: dp } = await import('stream/iter'); + +const encoder = new TextEncoder(); + +// Small initialMaxStreamDataBidiRemote — limits how much the +// client can send initially before the server extends flow control. +{ + const message = 'a]'.repeat(2048); // 4KB, larger than the 1KB window + const expected = encoder.encode(message); + + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + strictEqual(received.byteLength, expected.byteLength); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); + }), { + // Very small stream window — forces multiple flow control extensions. + transportParams: { initialMaxStreamDataBidiRemote: 1024 }, + }); + + const clientSession = await connect(serverEndpoint.address); + await clientSession.opened; + + const stream = await clientSession.createBidirectionalStream({ + highWaterMark: 512, + }); + const w = stream.writer; + + // Write in small chunks, respecting backpressure. + const chunkSize = 256; + for (let offset = 0; offset < expected.byteLength; offset += chunkSize) { + const chunk = expected.slice(offset, offset + chunkSize); + while (!w.writeSync(chunk)) { + const drain = w[dp](); + if (drain) await drain; + } + } + w.endSync(); + + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + await Promise.all([stream.closed, serverDone.promise]); + await clientSession.close(); + await serverEndpoint.close(); +} diff --git a/test/parallel/test-quic-flow-control-uni.mjs b/test/parallel/test-quic-flow-control-uni.mjs new file mode 100644 index 00000000000000..11685700d6da1e --- /dev/null +++ b/test/parallel/test-quic-flow-control-uni.mjs @@ -0,0 +1,58 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: uni stream flow control. +// initialMaxStreamDataUni limits the flow control window for +// unidirectional streams. Data transfer still completes because +// the receiver extends the window. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes, drainableProtocol: dp } = await import('stream/iter'); + +const encoder = new TextEncoder(); +const message = 'x'.repeat(4096); // 4KB, larger than the 1KB window +const expected = encoder.encode(message); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + strictEqual(received.byteLength, expected.byteLength); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +}), { + transportParams: { initialMaxStreamDataUni: 1024 }, +}); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createUnidirectionalStream({ + highWaterMark: 512, +}); +const w = stream.writer; + +const chunkSize = 256; +for (let offset = 0; offset < expected.byteLength; offset += chunkSize) { + const chunk = expected.slice(offset, offset + chunkSize); + while (!w.writeSync(chunk)) { + const drain = w[dp](); + if (drain) await drain; + } +} +w.endSync(); + +await Promise.all([stream.closed, serverDone.promise]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-h3-callback-errors.mjs b/test/parallel/test-quic-h3-callback-errors.mjs new file mode 100644 index 00000000000000..b6fa8e9422dfaf --- /dev/null +++ b/test/parallel/test-quic-h3-callback-errors.mjs @@ -0,0 +1,278 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: HTTP/3 callback error handling. +// Sync throw in onorigin callback destroys the session +// Sync throw in onheaders callback destroys the stream +// Async rejection in onheaders callback destroys the stream +// Sync throw in ontrailers callback destroys the stream +// Sync throw in onwanttrailers callback destroys the stream + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { strictEqual, rejects } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); +const encoder = new TextEncoder(); + +async function makeServer(onheadersHandler, extraOpts = {}) { + const done = Promise.withResolvers(); + const ep = await listen(mustCall(async (ss) => { + ss.onstream = mustCall((stream) => { + // The server completes its response before the client's + // callback throws, so the server stream always resolves. + stream.closed.then(mustCall()); + }); + await ss.closed; + done.resolve(); + }), { + sni: { '*': { keys: [key], certs: [cert] } }, + transportParams: { maxIdleTimeout: 1 }, + onheaders: onheadersHandler, + ...extraOpts, + }); + return { ep, done }; +} + +// Sync throw in onheaders callback destroys the stream. +{ + const { ep, done } = await makeServer( + mustCall(function(headers) { + this.sendHeaders({ ':status': '200' }); + this.writer.writeSync(encoder.encode('ok')); + this.writer.endSync(); + }), + ); + + const c = await connect(ep.address, { + servername: 'localhost', + transportParams: { maxIdleTimeout: 1 }, + }); + await c.opened; + + const s = await c.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/', + ':scheme': 'https', + ':authority': 'localhost', + }, + onheaders: mustCall(function() { + throw new Error('onheaders sync error'); + }), + }); + + await rejects(s.closed, mustCall((err) => { + strictEqual(err.message, 'onheaders sync error'); + return true; + })); + strictEqual(s.destroyed, true); + + c.close(); + await done.promise; + ep.close(); +} + +// Async rejection in onheaders callback destroys the stream. +{ + const { ep, done } = await makeServer( + mustCall(function(headers) { + this.sendHeaders({ ':status': '200' }); + this.writer.writeSync(encoder.encode('ok')); + this.writer.endSync(); + }), + ); + + const c = await connect(ep.address, { + servername: 'localhost', + transportParams: { maxIdleTimeout: 1 }, + }); + await c.opened; + + const s = await c.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/', + ':scheme': 'https', + ':authority': 'localhost', + }, + onheaders: mustCall(async function() { + throw new Error('onheaders async error'); + }), + }); + + await rejects(s.closed, mustCall((err) => { + strictEqual(err.message, 'onheaders async error'); + return true; + })); + strictEqual(s.destroyed, true); + + c.close(); + await done.promise; + ep.close(); +} + +// Sync throw in ontrailers callback destroys the stream. +{ + const { ep, done } = await makeServer( + mustCall(function(headers) { + this.sendHeaders({ ':status': '200' }); + this.writer.writeSync(encoder.encode('body')); + this.writer.endSync(); + }), + { + onwanttrailers: mustCall(function() { + this.sendTrailers({ 'x-trailer': 'value' }); + }), + }, + ); + + const c = await connect(ep.address, { + servername: 'localhost', + transportParams: { maxIdleTimeout: 1 }, + }); + await c.opened; + + const s = await c.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/', + ':scheme': 'https', + ':authority': 'localhost', + }, + onheaders: mustCall(function(headers) { + strictEqual(headers[':status'], '200'); + }), + ontrailers: mustCall(function() { + throw new Error('ontrailers sync error'); + }), + }); + + await rejects(s.closed, mustCall((err) => { + strictEqual(err.message, 'ontrailers sync error'); + return true; + })); + strictEqual(s.destroyed, true); + + c.close(); + await done.promise; + ep.close(); +} + +// Sync throw in onorigin callback destroys the session. +{ + const serverEndpoint = await listen(mustCall(async (ss) => { + await ss.closed; + }), { + sni: { + '*': { keys: [key], certs: [cert] }, + 'example.com': { keys: [key], certs: [cert] }, + }, + transportParams: { maxIdleTimeout: 1 }, + onheaders(headers) { + this.sendHeaders({ ':status': '200' }); + this.writer.endSync(); + }, + }); + + const clientSession = await connect(serverEndpoint.address, { + servername: 'example.com', + transportParams: { maxIdleTimeout: 1 }, + onorigin: mustCall(function() { + throw new Error('onorigin error'); + }), + onerror: mustCall(function(error) { + strictEqual(error.message, 'onorigin error'); + }), + }); + await clientSession.opened; + + const stream = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/', + ':scheme': 'https', + ':authority': 'example.com', + }, + }); + + // The session is destroyed by the callback error, which + // destroys the stream with the same error. + await rejects(stream.closed, mustCall((err) => { + strictEqual(err.message, 'onorigin error'); + return true; + })); + + await rejects(clientSession.closed, mustCall(() => true)); + + serverEndpoint.close(); +} + +// Sync throw in onwanttrailers callback destroys the +// server stream. The server stream's closed promise rejects with +// the thrown error. +{ + const serverStreamRejected = Promise.withResolvers(); + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (ss) => { + ss.onstream = mustCall(async (stream) => { + // The server stream rejects because onwanttrailers threw. + await rejects(stream.closed, mustCall((err) => { + strictEqual(err.message, 'onwanttrailers error'); + serverStreamRejected.resolve(); + return true; + })); + }); + await ss.closed; + serverDone.resolve(); + }), { + sni: { '*': { keys: [key], certs: [cert] } }, + transportParams: { maxIdleTimeout: 1 }, + onheaders: mustCall(function(headers) { + this.sendHeaders({ ':status': '200' }); + this.writer.writeSync(encoder.encode('body')); + this.writer.endSync(); + }), + onwanttrailers: mustCall(function() { + throw new Error('onwanttrailers error'); + }), + }); + + const clientSession = await connect(serverEndpoint.address, { + servername: 'localhost', + transportParams: { maxIdleTimeout: 1 }, + }); + await clientSession.opened; + + const stream = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/', + ':scheme': 'https', + ':authority': 'localhost', + }, + onheaders: mustCall(function(headers) { + strictEqual(headers[':status'], '200'); + }), + }); + + // Verify the server stream was destroyed by the throw. + await serverStreamRejected.promise; + + // The client stream is still open (server error doesn't propagate + // to client automatically). Closing the client session destroys it. + clientSession.close(); + await Promise.all([stream.closed, serverDone.promise]); + await serverEndpoint.close(); +} diff --git a/test/parallel/test-quic-h3-close-behavior.mjs b/test/parallel/test-quic-h3-close-behavior.mjs new file mode 100644 index 00000000000000..6b36909a9f6b1c --- /dev/null +++ b/test/parallel/test-quic-h3-close-behavior.mjs @@ -0,0 +1,94 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: HTTP/3 close behavior. +// session.close() with open streams - streams complete cleanly +// Graceful H3 shutdown uses H3_NO_ERROR (0x100) + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { strictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); +const { bytes } = await import('stream/iter'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); +const decoder = new TextDecoder(); + +// Two streams. The graceful close waits for both streams to complete, +// then sends CONNECTION_CLOSE with H3_NO_ERROR. +{ + let serverSession; + let requestCount = 0; + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (ss) => { + serverSession = ss; + ss.onstream = mustCall(2); + }), { + sni: { '*': { keys: [key], certs: [cert] } }, + onheaders: mustCall((headers, stream) => { + stream.sendHeaders({ ':status': '200' }); + stream.writer.writeSync(headers[':path']); + stream.writer.endSync(); + + // Close after both responses are written. The + // close is deferred to exit the nghttp3 callback scope. + if (++requestCount === 2) { + setImmediate(mustCall(() => { + serverSession.close(); + serverDone.resolve(); + })); + } + }, 2), + }); + + const clientSession = await connect(serverEndpoint.address, { + servername: 'localhost', + }); + await clientSession.opened; + + const stream1 = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/one', + ':scheme': 'https', + ':authority': 'localhost', + }, + onheaders: mustCall((headers) => { + strictEqual(headers[':status'], '200'); + }), + }); + + const stream2 = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/two', + ':scheme': 'https', + ':authority': 'localhost', + }, + onheaders: mustCall((headers) => { + strictEqual(headers[':status'], '200'); + }), + }); + + // Both streams should complete normally despite the close. + const bodies = await Promise.all([bytes(stream1), bytes(stream2)]); + strictEqual(decoder.decode(bodies[0]), '/one'); + strictEqual(decoder.decode(bodies[1]), '/two'); + + await Promise.all([stream1.closed, + stream2.closed, + serverDone.promise, + clientSession.closed]); + + serverEndpoint.close(); +} diff --git a/test/parallel/test-quic-h3-concurrent-requests.mjs b/test/parallel/test-quic-h3-concurrent-requests.mjs new file mode 100644 index 00000000000000..a52137e5cb9362 --- /dev/null +++ b/test/parallel/test-quic-h3-concurrent-requests.mjs @@ -0,0 +1,90 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: Multiple concurrent HTTP/3 requests on a single session. +// Client opens several bidi streams in parallel, each with different +// request paths. Server responds to each with a path-specific body. +// Verifies: +// - Multiple streams can be opened concurrently on one session +// - Each stream receives the correct response (no cross-talk) +// - All streams complete independently + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { strictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); +const { bytes } = await import('stream/iter'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); + +const decoder = new TextDecoder(); + +const REQUEST_COUNT = 5; +let serverStreamsCompleted = 0; +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + serverSession.onstream = mustCall((stream) => { + stream.closed.then(mustCall(() => { + if (++serverStreamsCompleted === REQUEST_COUNT) { + serverSession.close(); + serverDone.resolve(); + } + })); + }, REQUEST_COUNT); +}), { + sni: { '*': { keys: [key], certs: [cert] } }, + onheaders: mustCall(function(headers) { + const path = headers[':path']; + this.sendHeaders({ + ':status': '200', + 'content-type': 'text/plain', + }); + const w = this.writer; + w.writeSync(`response for ${path}`); + w.endSync(); + }, REQUEST_COUNT), +}); + +const clientSession = await connect(serverEndpoint.address, { + servername: 'localhost', +}); +await clientSession.opened; + +// Open all requests concurrently. +const paths = Array.from({ length: REQUEST_COUNT }, (_, i) => `/path/${i}`); + +const requests = paths.map(mustCall(async (path) => { + const headersReceived = Promise.withResolvers(); + + const stream = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': path, + ':scheme': 'https', + ':authority': 'localhost', + }, + onheaders: mustCall((headers) => { + strictEqual(headers[':status'], '200'); + headersReceived.resolve(); + }), + }); + + await headersReceived.promise; + const body = await bytes(stream); + const text = decoder.decode(body); + strictEqual(text, `response for ${path}`); + await stream.closed; +}, REQUEST_COUNT)); + +await Promise.all([...requests, serverDone.promise]); +clientSession.close(); diff --git a/test/parallel/test-quic-h3-datagram.mjs b/test/parallel/test-quic-h3-datagram.mjs new file mode 100644 index 00000000000000..cdc4ac65529610 --- /dev/null +++ b/test/parallel/test-quic-h3-datagram.mjs @@ -0,0 +1,171 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: HTTP/3 datagrams with SETTINGS_H3_DATAGRAM negotiation. +// Verifies that QUIC datagrams work correctly with H3 sessions, including +// the SETTINGS_H3_DATAGRAM negotiation required by RFC 9297. +// 1. Both sides enableDatagrams: true — datagrams work alongside H3 streams +// 2. Server enableDatagrams: false — client should not be able to send +// datagrams (peer's SETTINGS_H3_DATAGRAM=0) + +import { hasQuic, skip, mustCall, mustNotCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; +const { readKey } = fixtures; + +const { ok, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); +const { bytes } = await import('stream/iter'); +const { setTimeout: sleep } = await import('timers/promises'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); +const decoder = new TextDecoder(); + +// Test 1: H3 datagrams with enableDatagrams: true on both sides. +// Datagrams work alongside H3 request/response. +{ + const serverGotDatagram = Promise.withResolvers(); + const clientGotDatagram = Promise.withResolvers(); + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (ss) => { + ss.onstream = mustCall(async (stream) => { + await stream.closed; + }); + await serverGotDatagram.promise; + await sleep(50); + ss.close(); + serverDone.resolve(); + }), { + sni: { '*': { keys: [key], certs: [cert] } }, + application: { enableDatagrams: true }, + transportParams: { maxDatagramFrameSize: 100 }, + // Server echoes received datagram back to client. + ondatagram: mustCall(function(data) { + ok(data instanceof Uint8Array); + strictEqual(data.byteLength, 3); + strictEqual(data[0], 10); + strictEqual(data[1], 20); + strictEqual(data[2], 30); + // Echo it back. + this.sendDatagram(new Uint8Array([42, 43, 44])); + serverGotDatagram.resolve(); + }), + onheaders: mustCall(function(headers) { + this.sendHeaders({ ':status': '200' }); + this.writer.writeSync('ok'); + this.writer.endSync(); + }), + }); + + const clientSession = await connect(serverEndpoint.address, { + servername: 'localhost', + application: { enableDatagrams: true }, + transportParams: { maxDatagramFrameSize: 100 }, + // Client receives datagram from server. + ondatagram: mustCall(function(data) { + ok(data instanceof Uint8Array); + strictEqual(data.byteLength, 3); + strictEqual(data[0], 42); + strictEqual(data[1], 43); + strictEqual(data[2], 44); + clientGotDatagram.resolve(); + }), + }); + await clientSession.opened; + + // Datagrams work alongside H3 request/response. + const stream = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/with-datagram', + ':scheme': 'https', + ':authority': 'localhost', + }, + onheaders: mustCall(function(headers) { + strictEqual(headers[':status'], '200'); + }), + }); + + // Send datagram from client. + await clientSession.sendDatagram(new Uint8Array([10, 20, 30])); + + // H3 response body is received. + const body = await bytes(stream); + strictEqual(decoder.decode(body), 'ok'); + await stream.closed; + + // Both sides received their datagram. + await Promise.all([serverGotDatagram.promise, clientGotDatagram.promise]); + + await serverDone.promise; + clientSession.close(); +} + +// Test 2: Server has enableDatagrams: false. The peer's H3 SETTINGS +// should indicate SETTINGS_H3_DATAGRAM=0. The client's datagram send +// should return 0 (no datagram sent) because the peer doesn't support +// H3 datagrams. +{ + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (ss) => { + ss.onstream = mustCall(async (stream) => { + await stream.closed; + ss.close(); + serverDone.resolve(); + }); + }), { + sni: { '*': { keys: [key], certs: [cert] } }, + // Server explicitly disables H3 datagrams. + application: { enableDatagrams: false }, + // But transport-level datagrams ARE supported. + transportParams: { maxDatagramFrameSize: 100 }, + // Server should NOT receive any datagrams. + ondatagram: mustNotCall(), + onheaders: mustCall((headers, stream) => { + stream.sendHeaders({ ':status': '200' }); + stream.writer.writeSync('no-dgram'); + stream.writer.endSync(); + }), + }); + + const clientSession = await connect(serverEndpoint.address, { + servername: 'localhost', + application: { enableDatagrams: true }, + transportParams: { maxDatagramFrameSize: 100 }, + }); + await clientSession.opened; + + const stream = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/no-datagram', + ':scheme': 'https', + ':authority': 'localhost', + }, + onheaders: mustCall((headers) => { + strictEqual(headers[':status'], '200'); + }), + }); + + // The H3 request triggers SETTINGS exchange. After the server's + // SETTINGS (with h3_datagram=0) arrive, the client should know + // the peer doesn't support H3 datagrams. + const body = await bytes(stream); + strictEqual(decoder.decode(body), 'no-dgram'); + + // Attempt to send a datagram. Since the peer's H3 SETTINGS + // indicate h3_datagram=0, this should return 0 (not sent). + const dgId = await clientSession.sendDatagram(new Uint8Array([1, 2, 3])); + strictEqual(dgId, 0n); + + await Promise.all([stream.closed, serverDone.promise]); + clientSession.close(); +} diff --git a/test/parallel/test-quic-h3-error-codes.mjs b/test/parallel/test-quic-h3-error-codes.mjs new file mode 100644 index 00000000000000..aaea8f93e880a9 --- /dev/null +++ b/test/parallel/test-quic-h3-error-codes.mjs @@ -0,0 +1,122 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: HTTP/3 error code handling. +// H3 application error codes are propagated correctly +// Graceful close uses H3_NO_ERROR - streams complete cleanly + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { strictEqual, rejects } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); +const { bytes } = await import('stream/iter'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); +const decoder = new TextDecoder(); + +// Server closes with explicit application error code. +// Client's session closed rejects with the error. +{ + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (ss) => { + ss.onstream = mustCall(async (stream) => { + await stream.closed; + // Close with an explicit H3 application error code. + ss.close({ code: 0x101, type: 'application' }); + serverDone.resolve(); + }); + }), { + sni: { '*': { keys: [key], certs: [cert] } }, + onheaders: mustCall(function(headers) { + this.sendHeaders({ ':status': '200' }); + this.writer.writeSync('ok'); + this.writer.endSync(); + }), + }); + + const clientSession = await connect(serverEndpoint.address, { + servername: 'localhost', + }); + await clientSession.opened; + + const stream = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/', + ':scheme': 'https', + ':authority': 'localhost', + }, + onheaders: mustCall(function(headers) { + strictEqual(headers[':status'], '200'); + }), + }); + + const body = await bytes(stream); + strictEqual(decoder.decode(body), 'ok'); + await Promise.all([stream.closed, serverDone.promise]); + + // Client sees the application error code. + await rejects(clientSession.closed, { + code: 'ERR_QUIC_APPLICATION_ERROR', + }); + + serverEndpoint.close(); +} + +// Graceful close with no explicit error code. +// Both streams complete normally. The close uses H3_NO_ERROR +// which is treated as a clean shutdown (not an error). +{ + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (ss) => { + ss.onstream = mustCall(async (stream) => { + await stream.closed; + ss.close(); + serverDone.resolve(); + }); + }), { + sni: { '*': { keys: [key], certs: [cert] } }, + onheaders: mustCall(function(headers) { + this.sendHeaders({ ':status': '200' }); + this.writer.writeSync('ok'); + this.writer.endSync(); + }), + }); + + const clientSession = await connect(serverEndpoint.address, { + servername: 'localhost', + }); + await clientSession.opened; + + const stream = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/', + ':scheme': 'https', + ':authority': 'localhost', + }, + onheaders: mustCall(function(headers) { + strictEqual(headers[':status'], '200'); + }), + }); + + const body = await bytes(stream); + strictEqual(decoder.decode(body), 'ok'); + await stream.closed; + + // Graceful close - session close promise resolves + // because H3_NO_ERROR is a clean close. + await serverDone.promise; + clientSession.close(); +} diff --git a/test/parallel/test-quic-h3-goaway-non-h3.mjs b/test/parallel/test-quic-h3-goaway-non-h3.mjs new file mode 100644 index 00000000000000..d0956625cf995f --- /dev/null +++ b/test/parallel/test-quic-h3-goaway-non-h3.mjs @@ -0,0 +1,65 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: Non-H3 session close does not fire ongoaway. +// GOAWAY is an HTTP/3 concept. When a non-H3 session closes, the +// ongoaway callback must not fire. + +import { hasQuic, skip, mustCall, mustNotCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import { setImmediate } from 'node:timers/promises'; +import * as fixtures from '../common/fixtures.mjs'; + +const { strictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); +const { bytes } = await import('stream/iter'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); +const encoder = new TextEncoder(); +const decoder = new TextDecoder(); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (ss) => { + ss.onstream = mustCall(async (stream) => { + // Read client data, send response, close stream. + const data = await bytes(stream); + strictEqual(decoder.decode(data), 'ping'); + stream.writer.writeSync('pong'); + stream.writer.endSync(); + await stream.closed; + ss.close(); + serverDone.resolve(); + }); +}), { + sni: { '*': { keys: [key], certs: [cert] } }, + alpn: 'quic-test', +}); + +const clientSession = await connect(serverEndpoint.address, { + servername: 'localhost', + alpn: 'quic-test', + // Ongoaway must NOT fire for non-H3 sessions. + ongoaway: mustNotCall(), +}); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode('ping'), +}); + +const response = await bytes(stream); +strictEqual(decoder.decode(response), 'pong'); +await Promise.all([stream.closed, serverDone.promise]); + +// Wait a tick for any deferred callbacks to fire. +await setImmediate(); + +clientSession.close(); diff --git a/test/parallel/test-quic-h3-goaway.mjs b/test/parallel/test-quic-h3-goaway.mjs new file mode 100644 index 00000000000000..ef9564fc084754 --- /dev/null +++ b/test/parallel/test-quic-h3-goaway.mjs @@ -0,0 +1,148 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: HTTP/3 GOAWAY handling. +// Graceful close sends GOAWAY - client receives ongoaway callback +// After GOAWAY, new stream creation fails +// Existing streams continue and complete after GOAWAY +// Opens two concurrent streams. Server responds to the first immediately +// and holds the second response. The server session.close() is called from +// the main test body (not a callback) after the client confirms both +// streams' headers were received. The second stream is still active, +// ensuring the GOAWAY is sent separately from CONNECTION_CLOSE. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import dc from 'node:diagnostics_channel'; +import * as fixtures from '../common/fixtures.mjs'; +const { readKey } = fixtures; + +const { ok, strictEqual, rejects } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); +const { bytes } = await import('stream/iter'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); +const encoder = new TextEncoder(); +const decoder = new TextDecoder(); + +// quic.session.goaway fires when the peer sends GOAWAY. +dc.subscribe('quic.session.goaway', mustCall((msg) => { + ok(msg.session, 'goaway should include session'); + strictEqual(typeof msg.lastStreamId, 'bigint', 'goaway should include lastStreamId'); +})); + +{ + let serverSession; + let pendingSecondStream; + const goawayReceived = Promise.withResolvers(); + const completeSecondResponse = Promise.withResolvers(); + const bothHeadersReceived = Promise.withResolvers(); + let clientHeaderCount = 0; + + const serverEndpoint = await listen(mustCall(async (ss) => { + serverSession = ss; + ss.onstream = mustCall(2); + }), { + sni: { '*': { keys: [key], certs: [cert] } }, + onheaders: mustCall(function(headers) { + const path = headers[':path']; + this.sendHeaders({ ':status': '200' }); + + if (path === '/first') { + // Respond immediately to the first request. + this.writer.writeSync(encoder.encode('first')); + this.writer.endSync(); + } else if (path === '/second') { + // Hold the second response until signaled. + pendingSecondStream = this; + completeSecondResponse.promise.then(mustCall(() => { + pendingSecondStream.writer.writeSync(encoder.encode('second')); + pendingSecondStream.writer.endSync(); + })); + } + }, 2), + }); + + const clientSession = await connect(serverEndpoint.address, { + servername: 'localhost', + // Ongoaway fires when the peer sends GOAWAY. + ongoaway: mustCall(function(lastStreamId) { + strictEqual(lastStreamId, -1n); + goawayReceived.resolve(); + }), + }); + await clientSession.opened; + + const onClientHeaders = mustCall(function(headers) { + strictEqual(headers[':status'], '200'); + if (++clientHeaderCount === 2) { + bothHeadersReceived.resolve(); + } + }, 2); + + const stream1 = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/first', + ':scheme': 'https', + ':authority': 'localhost', + }, + onheaders: onClientHeaders, + }); + + const stream2 = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/second', + ':scheme': 'https', + ':authority': 'localhost', + }, + onheaders: onClientHeaders, + }); + + // First stream completes immediately. + const body1 = await bytes(stream1); + strictEqual(decoder.decode(body1), 'first'); + + // Wait for both streams' headers to arrive on the client, confirming + // the server has processed both requests. + await bothHeadersReceived.promise; + + // Close the server session from the main test body. The second + // stream's body is still pending, so the graceful close sends + // GOAWAY (shutdown notice) separately from CONNECTION_CLOSE. + serverSession.close(); + + // Wait for GOAWAY notification on the client. + await goawayReceived.promise; + + // After GOAWAY, new stream creation should fail. + await rejects( + clientSession.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/new', + ':scheme': 'https', + ':authority': 'localhost', + }, + }), + { code: 'ERR_INVALID_STATE' }, + ); + + // Signal the server to complete the second response. + completeSecondResponse.resolve(); + + // Second stream also completes despite GOAWAY. + const body2 = await bytes(stream2); + strictEqual(decoder.decode(body2), 'second'); + + // Both streams close cleanly. + await Promise.all([stream1.closed, stream2.closed]); + clientSession.close(); +} diff --git a/test/parallel/test-quic-h3-header-validation.mjs b/test/parallel/test-quic-h3-header-validation.mjs new file mode 100644 index 00000000000000..57e6981f35fea7 --- /dev/null +++ b/test/parallel/test-quic-h3-header-validation.mjs @@ -0,0 +1,157 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: HTTP/3 header validation (RFC 9114 §4.2-4.3). +// H3V-01: Header names are lowercased on send. +// H3V-02 through H3V-14 (receive-side validations) are handled +// automatically by nghttp3. The library rejects Transfer-Encoding, +// Connection headers, misplaced pseudo-headers, missing required +// pseudo-headers, uppercase header names from peer, etc. These +// validations are always enabled and cannot be disabled. They are +// verified by nghttp3's own test suite. +// This test verifies: +// - H3V-01: Mixed-case header names are lowercased when received +// - Headers with various valid pseudo-header combinations work +// - Custom headers are delivered correctly + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { strictEqual, ok } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); +const { bytes } = await import('stream/iter'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); +const decoder = new TextDecoder(); + +// H3V-01: Header names are lowercased on send. +// Send headers with mixed case — the server should receive them +// lowercased (buildNgHeaderString lowercases before passing to nghttp3). +{ + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (ss) => { + ss.onstream = mustCall(async (stream) => { + await stream.closed; + ss.close(); + serverDone.resolve(); + }); + }), { + sni: { '*': { keys: [key], certs: [cert] } }, + onheaders: mustCall(function(headers) { + // H3V-01: All header names should be lowercase regardless + // of how the client sent them. + for (const name of Object.keys(headers)) { + strictEqual(name, name.toLowerCase(), + `Header name "${name}" should be lowercase`); + } + + // Verify specific headers arrived lowercased. + strictEqual(headers[':method'], 'GET'); + strictEqual(headers[':path'], '/test'); + strictEqual(headers['x-custom-header'], 'Value1'); + strictEqual(headers['content-type'], 'text/plain'); + strictEqual(headers['x-mixed-case'], 'MixedValue'); + + // Verify values are NOT lowercased — only names are. + strictEqual(headers['x-custom-header'], 'Value1'); + + this.sendHeaders({ + // Response with mixed-case names — should be lowercased. + ':status': '200', + 'Content-Type': 'text/html', + 'X-Response-Header': 'ResponseValue', + }); + this.writer.writeSync('ok'); + this.writer.endSync(); + }), + }); + + const clientSession = await connect(serverEndpoint.address, { + servername: 'localhost', + }); + await clientSession.opened; + + const stream = await clientSession.createBidirectionalStream({ + headers: { + // Mixed-case names — should be lowercased by buildNgHeaderString. + ':method': 'GET', + ':path': '/test', + ':scheme': 'https', + ':authority': 'localhost', + 'X-Custom-Header': 'Value1', + 'Content-Type': 'text/plain', + 'X-Mixed-Case': 'MixedValue', + }, + onheaders: mustCall(function(headers) { + // Client should also receive lowercased response header names. + strictEqual(headers[':status'], '200'); + strictEqual(headers['content-type'], 'text/html'); + strictEqual(headers['x-response-header'], 'ResponseValue'); + + // Verify all names are lowercase. + for (const name of Object.keys(headers)) { + strictEqual(name, name.toLowerCase(), + `Response header name "${name}" should be lowercase`); + } + }), + }); + + const body = await bytes(stream); + strictEqual(decoder.decode(body), 'ok'); + await Promise.all([stream.closed, serverDone.promise]); + clientSession.close(); +} + +// Verify multiple pseudo-header combinations work correctly. +{ + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (ss) => { + ss.onstream = mustCall(async (stream) => { + await stream.closed; + ss.close(); + serverDone.resolve(); + }); + }), { + sni: { '*': { keys: [key], certs: [cert] } }, + onheaders: mustCall(function(headers) { + // All four required pseudo-headers present. + ok(headers[':method']); + ok(headers[':path']); + ok(headers[':scheme']); + ok(headers[':authority']); + + this.sendHeaders({ ':status': '204' }); + this.writer.endSync(); + }), + }); + + const clientSession = await connect(serverEndpoint.address, { + servername: 'localhost', + }); + await clientSession.opened; + + const stream = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'POST', + ':path': '/api/data', + ':scheme': 'https', + ':authority': 'localhost', + }, + onheaders: mustCall((headers) => { + strictEqual(headers[':status'], '204'); + }), + }); + + await Promise.all([bytes(stream), stream.closed, serverDone.promise]); + clientSession.close(); +} diff --git a/test/parallel/test-quic-h3-headers-support.mjs b/test/parallel/test-quic-h3-headers-support.mjs new file mode 100644 index 00000000000000..159f5ba03faccf --- /dev/null +++ b/test/parallel/test-quic-h3-headers-support.mjs @@ -0,0 +1,95 @@ +// Flags: --experimental-quic --no-warnings + +// Test: Headers support detection for non-H3 sessions. +// headersSupported is UNSUPPORTED for non-H3 sessions +// Sending headers on non-H3 session throws ERR_INVALID_STATE +// Setting header callbacks on non-H3 stream throws ERR_INVALID_STATE + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; +const { readKey } = fixtures; + +const { throws } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); +const encoder = new TextEncoder(); + +const serverDone = Promise.withResolvers(); +const serverEndpoint = await listen(mustCall(async (serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + // Sending headers on non-H3 stream throws. + throws(() => { + stream.sendHeaders({ ':status': '200' }); + }, { code: 'ERR_INVALID_STATE' }); + + // Setting onheaders on non-H3 stream throws. + throws(() => { + stream.onheaders = () => {}; + }, { code: 'ERR_INVALID_STATE' }); + + // Setting ontrailers on non-H3 stream throws. + throws(() => { + stream.ontrailers = () => {}; + }, { code: 'ERR_INVALID_STATE' }); + + // Setting oninfo on non-H3 stream throws. + throws(() => { + stream.oninfo = () => {}; + }, { code: 'ERR_INVALID_STATE' }); + + // Setting onwanttrailers on non-H3 stream throws. + throws(() => { + stream.onwanttrailers = () => {}; + }, { code: 'ERR_INVALID_STATE' }); + + // sendInformationalHeaders throws on non-H3. + throws(() => { + stream.sendInformationalHeaders({ ':status': '103' }); + }, { code: 'ERR_INVALID_STATE' }); + + // sendTrailers throws on non-H3. + throws(() => { + stream.sendTrailers({ 'x-trailer': 'value' }); + }, { code: 'ERR_INVALID_STATE' }); + + try { await stream.closed; } catch { + // Stream may close with error. + } + serverSession.close(); + serverDone.resolve(); + }); +}), { + sni: { '*': { keys: [key], certs: [cert] } }, + alpn: 'quic-test', +}); + +const clientSession = await connect(serverEndpoint.address, { + servername: 'localhost', + alpn: 'quic-test', +}); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode('ping'), +}); +stream.closed.catch(() => {}); + +// Client side — sending headers on non-H3 stream throws. +throws(() => { + stream.sendHeaders({ ':method': 'GET' }); +}, { code: 'ERR_INVALID_STATE' }); + +try { await stream.closed; } catch { + // Stream may close with error. +} +await serverDone.promise; +clientSession.close(); diff --git a/test/parallel/test-quic-h3-informational-headers.mjs b/test/parallel/test-quic-h3-informational-headers.mjs new file mode 100644 index 00000000000000..8fbbd73d12ccd4 --- /dev/null +++ b/test/parallel/test-quic-h3-informational-headers.mjs @@ -0,0 +1,115 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: HTTP/3 informational (1xx) headers. +// Server sends a 103 Early Hints response before the final 200 response. +// Client receives the informational headers via oninfo, then the final +// response via onheaders. +// Verifies: +// - sendInformationalHeaders delivers 1xx headers to the client +// - oninfo callback fires with the informational headers +// - onheaders callback fires separately with the final response +// - Body data is delivered after the final response headers + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import dc from 'node:diagnostics_channel'; +import * as fixtures from '../common/fixtures.mjs'; + +const { ok, strictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); +const { bytes } = await import('stream/iter'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); + +const decoder = new TextDecoder(); +const responseBody = 'final response'; + +// quic.stream.info fires when informational (1xx) headers are received. +dc.subscribe('quic.stream.info', mustCall((msg) => { + ok(msg.stream, 'stream.info should include stream'); + ok(msg.session, 'stream.info should include session'); + ok(msg.headers, 'stream.info should include headers'); + strictEqual(msg.headers[':status'], '103'); +})); + +// quic.stream.headers also fires for the final response headers. +dc.subscribe('quic.stream.headers', mustCall((msg) => { + ok(msg.stream, 'stream.headers should include stream'); + ok(msg.headers, 'stream.headers should include headers'); +}, 2)); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +}), { + sni: { '*': { keys: [key], certs: [cert] } }, + onheaders: mustCall(function(headers) { + // Send 103 Early Hints before the final response. + this.sendInformationalHeaders({ + ':status': '103', + 'link': '; rel=preload; as=style', + }); + + // Send final response headers + body. + this.sendHeaders({ + ':status': '200', + 'content-type': 'text/plain', + }); + + const w = this.writer; + w.writeSync(responseBody); + w.endSync(); + }), +}); + +const clientSession = await connect(serverEndpoint.address, { + servername: 'localhost', +}); +await clientSession.opened; + +const clientInfoReceived = Promise.withResolvers(); +const clientHeadersReceived = Promise.withResolvers(); + +const stream = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/page', + ':scheme': 'https', + ':authority': 'localhost', + }, + oninfo: mustCall(function(headers) { + strictEqual(headers[':status'], '103'); + strictEqual(headers.link, '; rel=preload; as=style'); + clientInfoReceived.resolve(); + }), + onheaders: mustCall(function(headers) { + strictEqual(headers[':status'], '200'); + strictEqual(headers['content-type'], 'text/plain'); + clientHeadersReceived.resolve(); + }), +}); + +await Promise.all([clientInfoReceived.promise, clientHeadersReceived.promise]); + +// Read the response body. +const body = await bytes(stream); +strictEqual(decoder.decode(body), responseBody); + +// stream.headers should return the final (initial) headers, not 1xx. +strictEqual(stream.headers[':status'], '200'); + +await Promise.all([stream.closed, serverDone.promise]); +clientSession.close(); diff --git a/test/parallel/test-quic-h3-origin.mjs b/test/parallel/test-quic-h3-origin.mjs new file mode 100644 index 00000000000000..39fcdc2d49b1a7 --- /dev/null +++ b/test/parallel/test-quic-h3-origin.mjs @@ -0,0 +1,185 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: HTTP/3 ORIGIN frames (RFC 9412). +// Server with SNI entries sends ORIGIN frame +// Wildcard (*) SNI entries excluded from ORIGIN +// Client receives ORIGIN frame via onorigin callback + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { strictEqual, ok } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); +const { bytes } = await import('stream/iter'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); + +const encoder = new TextEncoder(); +const decoder = new TextDecoder(); + +// Server sends ORIGIN frame based on SNI entries. +// Wildcard entries are excluded. +{ + const originReceived = Promise.withResolvers(); + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (ss) => { + ss.onstream = mustCall(async (stream) => { + await stream.closed; + ss.close(); + serverDone.resolve(); + }); + }), { + sni: { + // Wildcard entry should NOT appear in ORIGIN frame. + '*': { keys: [key], certs: [cert] }, + // These specific hostnames should appear in ORIGIN. + 'example.com': { keys: [key], certs: [cert] }, + 'api.example.com': { keys: [key], certs: [cert] }, + }, + onheaders: mustCall(function(headers) { + this.sendHeaders({ ':status': '200' }); + this.writer.writeSync(encoder.encode('ok')); + this.writer.endSync(); + }), + }); + + const clientSession = await connect(serverEndpoint.address, { + servername: 'example.com', + // Client receives ORIGIN frame via onorigin callback. + onorigin: mustCall(function(origins) { + ok(Array.isArray(origins)); + // The origins should include the specific SNI hostnames. + ok(origins.length >= 2); + // The wildcard (*) should NOT be in the list. + const originStrings = origins.join(','); + ok(originStrings.includes('example.com'), 'should include example.com'); + ok(originStrings.includes('api.example.com'), + 'should include api.example.com'); + ok(!originStrings.includes('*'), 'should not include wildcard'); + originReceived.resolve(); + }), + }); + await clientSession.opened; + + const stream = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/', + ':scheme': 'https', + ':authority': 'example.com', + }, + onheaders: mustCall(function(headers) { + strictEqual(headers[':status'], '200'); + }), + }); + + const body = await bytes(stream); + strictEqual(decoder.decode(body), 'ok'); + + await Promise.all([originReceived.promise, stream.closed, serverDone.promise]); + clientSession.close(); +} + +// port: 8443 produces origin "https://hostname:8443" +// default port (443) omits port from origin string +// authoritative: false excluded from ORIGIN frame +// authoritative: true (default) included in ORIGIN frame +{ + const originReceived = Promise.withResolvers(); + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (ss) => { + ss.onstream = mustCall(async (stream) => { + await stream.closed; + ss.close(); + serverDone.resolve(); + }); + }), { + sni: { + '*': { keys: [key], certs: [cert] }, + // Non-default port → origin includes port. + 'custom-port.example.com': { keys: [key], certs: [cert], port: 8443 }, + // Default port (443) → origin omits port. + 'default-port.example.com': { keys: [key], certs: [cert], port: 443 }, + // authoritative: false → excluded from ORIGIN frame. + 'not-authoritative.example.com': { + keys: [key], certs: [cert], authoritative: false, + }, + // authoritative: true (explicit) → included. + 'authoritative.example.com': { + keys: [key], certs: [cert], authoritative: true, + }, + // Authoritative defaults to true when omitted. + 'default-auth.example.com': { keys: [key], certs: [cert] }, + }, + onheaders: mustCall(function(headers) { + this.sendHeaders({ ':status': '200' }); + this.writer.writeSync(encoder.encode('ok')); + this.writer.endSync(); + }), + }); + + const clientSession = await connect(serverEndpoint.address, { + servername: 'custom-port.example.com', + onorigin: mustCall(function(origins) { + ok(Array.isArray(origins)); + + // Custom port included in origin string. + ok(origins.includes('https://custom-port.example.com:8443'), + 'should include origin with custom port'); + + // Default port 443 omitted from origin string. + ok(origins.includes('https://default-port.example.com'), + 'should include origin without port for 443'); + // Verify port 443 is NOT appended. + const defaultPortOrigin = origins.find((o) => + o.includes('default-port.example.com')); + ok(!defaultPortOrigin.includes(':443'), + 'default port 443 should be omitted'); + + // Non-authoritative entry excluded. + const allOrigins = origins.join(','); + ok(!allOrigins.includes('not-authoritative'), + 'non-authoritative entry should be excluded'); + + // Explicitly authoritative entry included. + ok(allOrigins.includes('authoritative.example.com'), + 'explicitly authoritative entry should be included'); + + // Default authoritative (true when omitted) included. + ok(allOrigins.includes('default-auth.example.com'), + 'default authoritative entry should be included'); + + originReceived.resolve(); + }), + }); + await clientSession.opened; + + const stream = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/', + ':scheme': 'https', + ':authority': 'custom-port.example.com', + }, + onheaders: mustCall(function(headers) { + strictEqual(headers[':status'], '200'); + }), + }); + + const body = await bytes(stream); + strictEqual(decoder.decode(body), 'ok'); + + await Promise.all([originReceived.promise, stream.closed, serverDone.promise]); + clientSession.close(); +} diff --git a/test/parallel/test-quic-h3-pending-stream.mjs b/test/parallel/test-quic-h3-pending-stream.mjs new file mode 100644 index 00000000000000..ab414a559182e3 --- /dev/null +++ b/test/parallel/test-quic-h3-pending-stream.mjs @@ -0,0 +1,87 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: Pending H3 stream behavior. +// Priority set at creation time is applied to pending stream +// Headers enqueued at creation time are sent when stream opens + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { strictEqual, deepStrictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); +const { bytes } = await import('stream/iter'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); +const encoder = new TextEncoder(); +const decoder = new TextDecoder(); + +// The stream is initially pending (waiting for the QUIC handshake +// to open it). Priority and headers should be applied when it opens. +{ + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (ss) => { + ss.onstream = mustCall(async (stream) => { + await stream.closed; + ss.close(); + serverDone.resolve(); + }); + }), { + sni: { '*': { keys: [key], certs: [cert] } }, + onheaders: mustCall(function(headers) { + // Headers were enqueued before the stream opened + // and should arrive correctly. + strictEqual(headers[':method'], 'GET'); + strictEqual(headers[':path'], '/pending'); + + this.sendHeaders({ ':status': '200' }); + this.writer.writeSync(encoder.encode('ok')); + this.writer.endSync(); + }), + }); + + const clientSession = await connect(serverEndpoint.address, { + servername: 'localhost', + }); + + // Create the stream BEFORE awaiting opened. The stream is pending + // until the handshake completes and the QUIC stream can be opened. + const stream = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/pending', + ':scheme': 'https', + ':authority': 'localhost', + }, + // Priority set at creation time. + priority: 'high', + incremental: true, + onheaders: mustCall(function(headers) { + strictEqual(headers[':status'], '200'); + }), + }); + + // Priority should reflect what was set even while pending. + deepStrictEqual(stream.priority, { level: 'high', incremental: true }); + + // Now wait for the handshake. + await clientSession.opened; + + // Priority persists after stream opens. + deepStrictEqual(stream.priority, { level: 'high', incremental: true }); + + // Headers were sent and server responded. + const body = await bytes(stream); + strictEqual(decoder.decode(body), 'ok'); + await Promise.all([stream.closed, serverDone.promise]); + clientSession.close(); +} diff --git a/test/parallel/test-quic-h3-post-filehandle.mjs b/test/parallel/test-quic-h3-post-filehandle.mjs new file mode 100644 index 00000000000000..8264a55cecc30b --- /dev/null +++ b/test/parallel/test-quic-h3-post-filehandle.mjs @@ -0,0 +1,96 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: HTTP/3 POST request with FileHandle body. +// Client sends a POST with an fd-backed body source. Server reads the body +// and echoes it back in the response. Verifies that the FdEntry async I/O +// path works correctly through the H3 application layer. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; +import { writeFileSync } from 'node:fs'; +import { open } from 'node:fs/promises'; + +const tmpdir = await import('../common/tmpdir.js'); + +const { strictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); +const { bytes } = await import('stream/iter'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); + +const decoder = new TextDecoder(); +const testContent = 'Hello from a file!\nLine two.\n'; + +tmpdir.refresh(); +const testFile = tmpdir.resolve('quic-h3-fh-test.txt'); +writeFileSync(testFile, testContent); + +// FileHandle as POST body in createBidirectionalStream. +{ + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const body = await bytes(stream); + strictEqual(decoder.decode(body), testContent); + + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); + }), { + sni: { '*': { keys: [key], certs: [cert] } }, + onheaders: mustCall(function(headers) { + strictEqual(headers[':method'], 'POST'); + strictEqual(headers[':path'], '/upload'); + + this.sendHeaders({ ':status': '200' }); + this.writer.writeSync('ok'); + this.writer.endSync(); + }), + }); + + const clientSession = await connect(serverEndpoint.address, { + servername: 'localhost', + }); + + const info = await clientSession.opened; + strictEqual(info.protocol, 'h3'); + + const clientHeadersReceived = Promise.withResolvers(); + + const fh = await open(testFile, 'r'); + const stream = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'POST', + ':path': '/upload', + ':scheme': 'https', + ':authority': 'localhost', + }, + body: fh, + onheaders: mustCall(function(headers) { + strictEqual(headers[':status'], '200'); + clientHeadersReceived.resolve(); + }), + }); + + await clientHeadersReceived.promise; + + const responseBody = await bytes(stream); + strictEqual(decoder.decode(responseBody), 'ok'); + + await Promise.all([stream.closed, serverDone.promise]); + clientSession.close(); + await clientSession.closed; + await serverEndpoint.close(); + // FileHandle is closed automatically when the stream finishes. +} diff --git a/test/parallel/test-quic-h3-post-request.mjs b/test/parallel/test-quic-h3-post-request.mjs new file mode 100644 index 00000000000000..6cd9e047481d4d --- /dev/null +++ b/test/parallel/test-quic-h3-post-request.mjs @@ -0,0 +1,101 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: HTTP/3 request with body data (POST-like). +// Client sends request pseudo-headers plus a body, server reads the body +// and echoes it back in the response. +// Verifies: +// - Client can send request headers + body via createBidirectionalStream +// - Server receives the request body via async iteration +// - Server response with echoed body is delivered to the client +// - The terminal flag is correctly NOT set when body is provided + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { strictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); +const { bytes } = await import('stream/iter'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); + +const encoder = new TextEncoder(); +const decoder = new TextDecoder(); +const requestBody = 'Hello from the client'; + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + // Read the full request body from the client. + const body = await bytes(stream); + const text = decoder.decode(body); + strictEqual(text, requestBody); + + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +}), { + sni: { '*': { keys: [key], certs: [cert] } }, + onheaders: mustCall(function(headers) { + strictEqual(headers[':method'], 'POST'); + strictEqual(headers[':path'], '/submit'); + + // Echo the request body back in the response. + // At this point, request body hasn't arrived yet — we use onstream + // to read it. But we can send response headers immediately. + this.sendHeaders({ + ':status': '200', + 'content-type': 'text/plain', + }); + // Write echoed body after reading it in onstream. For simplicity, + // we write a fixed response here and verify the request body + // separately in onstream. + const w = this.writer; + w.writeSync(encoder.encode('echo:' + requestBody)); + w.endSync(); + }), +}); + +const clientSession = await connect(serverEndpoint.address, { + servername: 'localhost', +}); + +const info = await clientSession.opened; +strictEqual(info.protocol, 'h3'); + +const clientHeadersReceived = Promise.withResolvers(); + +// Send a POST request with body. When body is provided, terminal is NOT +// set on the HEADERS frame (body follows). +const stream = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'POST', + ':path': '/submit', + ':scheme': 'https', + ':authority': 'localhost', + }, + body: encoder.encode(requestBody), + onheaders: mustCall(function(headers) { + strictEqual(headers[':status'], '200'); + clientHeadersReceived.resolve(); + }), +}); + +await clientHeadersReceived.promise; + +// Read the response body. +const responseBody = await bytes(stream); +strictEqual(decoder.decode(responseBody), 'echo:' + requestBody); + +await Promise.all([stream.closed, serverDone.promise]); +clientSession.close(); diff --git a/test/parallel/test-quic-h3-priority.mjs b/test/parallel/test-quic-h3-priority.mjs new file mode 100644 index 00000000000000..8ddcab23a69d54 --- /dev/null +++ b/test/parallel/test-quic-h3-priority.mjs @@ -0,0 +1,239 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: HTTP/3 stream priority. +// Set priority at stream creation (priority/incremental options) +// setPriority({ level: 'high' }) on H3 stream +// setPriority({ incremental: true }) on H3 stream +// priority getter returns { level, incremental } on H3 +// priority getter on client H3 stream returns what was set +// Priority set at creation time reflects in stream.priority +// Server priority getter reflects peer's PRIORITY_UPDATE + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; +const { readKey } = fixtures; + +const { deepStrictEqual, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); +const { bytes } = await import('stream/iter'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); +const encoder = new TextEncoder(); +const decoder = new TextDecoder(); + +{ + let requestCount = 0; + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (ss) => { + ss.onstream = mustCall((stream) => { + // Server sees priority on the stream. + const pri = stream.priority; + strictEqual(typeof pri, 'object'); + strictEqual(typeof pri.level, 'string'); + strictEqual(typeof pri.incremental, 'boolean'); + }, 4); + }), { + sni: { '*': { keys: [key], certs: [cert] } }, + onheaders: mustCall(function(headers) { + this.sendHeaders({ ':status': '200' }); + this.writer.writeSync(encoder.encode(headers[':path'])); + this.writer.endSync(); + if (++requestCount === 4) { + serverDone.resolve(); + } + }, 4), + }); + + const clientSession = await connect(serverEndpoint.address, { + servername: 'localhost', + }); + await clientSession.opened; + + // Priority set at creation time via options. + const stream1 = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/high', + ':scheme': 'https', + ':authority': 'localhost', + }, + priority: 'high', + incremental: false, + onheaders: mustCall(function(headers) { + strictEqual(headers[':status'], '200'); + }), + }); + + // Priority reflects what was set at creation. + deepStrictEqual(stream1.priority, { level: 'high', incremental: false }); + + // Priority 'low' + incremental at creation. + const stream2 = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/low-inc', + ':scheme': 'https', + ':authority': 'localhost', + }, + priority: 'low', + incremental: true, + onheaders: mustCall(function(headers) { + strictEqual(headers[':status'], '200'); + }), + }); + deepStrictEqual(stream2.priority, { level: 'low', incremental: true }); + + // Default priority at creation. + const stream3 = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/default', + ':scheme': 'https', + ':authority': 'localhost', + }, + onheaders: mustCall(function(headers) { + strictEqual(headers[':status'], '200'); + }), + }); + deepStrictEqual(stream3.priority, { level: 'default', incremental: false }); + + // setPriority after creation. + const stream4 = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/changed', + ':scheme': 'https', + ':authority': 'localhost', + }, + onheaders: mustCall(function(headers) { + strictEqual(headers[':status'], '200'); + }), + }); + // Default priority initially. + deepStrictEqual(stream4.priority, { level: 'default', incremental: false }); + + // Change to high. + stream4.setPriority({ level: 'high' }); + deepStrictEqual(stream4.priority, { level: 'high', incremental: false }); + + // Change to incremental. + stream4.setPriority({ level: 'low', incremental: true }); + deepStrictEqual(stream4.priority, { level: 'low', incremental: true }); + + // Back to default. + stream4.setPriority({ level: 'default', incremental: false }); + deepStrictEqual(stream4.priority, { level: 'default', incremental: false }); + + // Read all bodies. + const allBodies = await Promise.all([ + bytes(stream1), + bytes(stream2), + bytes(stream3), + bytes(stream4), + ]); + + strictEqual(decoder.decode(allBodies[0]), '/high'); + strictEqual(decoder.decode(allBodies[1]), '/low-inc'); + strictEqual(decoder.decode(allBodies[2]), '/default'); + strictEqual(decoder.decode(allBodies[3]), '/changed'); + + await Promise.all([stream1.closed, + stream2.closed, + stream3.closed, + stream4.closed, + serverDone.promise]); + clientSession.close(); +} + +// Server priority getter reflects peer's PRIORITY_UPDATE. +// The client creates a stream with default priority, changes it to +// 'high', then sends body data as a signal. The server reads priority +// after receiving the body — by then the PRIORITY_UPDATE frame (sent +// on the control stream) has been processed by nghttp3 internally. +{ + const serverSawHighPriority = Promise.withResolvers(); + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (ss) => { + ss.onstream = mustCall(async (stream) => { + // Read the request body — this acts as a signal that the + // client's PRIORITY_UPDATE has been sent. The control stream + // (carrying PRIORITY_UPDATE) is processed before bidi stream + // data in nghttp3, so by the time body arrives the priority + // has been updated. + const body = await bytes(stream); + strictEqual(decoder.decode(body), 'signal'); + + // The server's priority getter should reflect the + // client's PRIORITY_UPDATE (high, incremental). + deepStrictEqual(stream.priority, { level: 'high', incremental: true }); + serverSawHighPriority.resolve(); + + await stream.closed; + ss.close(); + serverDone.resolve(); + }); + }), { + sni: { '*': { keys: [key], certs: [cert] } }, + onheaders: mustCall(function(headers) { + this.sendHeaders({ ':status': '200' }); + this.writer.writeSync(encoder.encode('ok')); + this.writer.endSync(); + }), + }); + + const clientSession = await connect(serverEndpoint.address, { + servername: 'localhost', + }); + await clientSession.opened; + + // Create stream with default priority and a body. The body serves + // as a signal — by the time it arrives at the server, the + // PRIORITY_UPDATE (sent on the control stream) will have been + // processed. setPriority is called BEFORE createBidirectionalStream + // so the PRIORITY_UPDATE is queued before the stream data. + // + // Note: setPriority must be called after createBidirectionalStream + // because the stream handle is needed. But the PRIORITY_UPDATE + // travels on the control stream which nghttp3 processes before + // bidi stream data, so the ordering is guaranteed. + const stream = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'POST', + ':path': '/pri-update', + ':scheme': 'https', + ':authority': 'localhost', + }, + body: encoder.encode('signal'), + onheaders: mustCall(function(headers) { + strictEqual(headers[':status'], '200'); + }), + }); + deepStrictEqual(stream.priority, { level: 'default', incremental: false }); + + // Change priority — this sends a PRIORITY_UPDATE frame on the + // control stream. The body data was already provided at creation + // but the PRIORITY_UPDATE travels on the control stream which + // nghttp3 prioritizes over bidi streams. + stream.setPriority({ level: 'high', incremental: true }); + deepStrictEqual(stream.priority, { level: 'high', incremental: true }); + + // Read the response. + const body = await bytes(stream); + strictEqual(decoder.decode(body), 'ok'); + + // Wait for server to confirm it saw the updated priority. + await Promise.all([serverSawHighPriority.promise, + stream.closed, + serverDone.promise]); + clientSession.close(); +} diff --git a/test/parallel/test-quic-h3-qpack-settings.mjs b/test/parallel/test-quic-h3-qpack-settings.mjs new file mode 100644 index 00000000000000..547e70f8c2d8a5 --- /dev/null +++ b/test/parallel/test-quic-h3-qpack-settings.mjs @@ -0,0 +1,119 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: HTTP/3 QPACK settings. +// Default dynamic table capacity is 4096 (implicit — H3 works) +// Default blocked streams is 100 (implicit — H3 works) +// Custom qpackMaxDTableCapacity overrides default +// Verifies that H3 sessions work with both default and custom QPACK +// settings. The defaults (4096 capacity, 100 blocked streams) are +// tested implicitly by all H3 tests. This test explicitly verifies +// custom values are accepted and functional. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { strictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); +const { bytes } = await import('stream/iter'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); +const encoder = new TextEncoder(); +const decoder = new TextDecoder(); + +async function makeRequest(clientSession, path) { + const stream = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': path, + ':scheme': 'https', + ':authority': 'localhost', + }, + onheaders: mustCall(function(headers) { + strictEqual(headers[':status'], '200'); + }), + }); + const body = await bytes(stream); + strictEqual(decoder.decode(body), path); + await stream.closed; +} + +// Custom qpackMaxDTableCapacity = 0 (disables dynamic table). +// QPACK compression still works via the static table, but the dynamic +// table is not used. Verifies the option is passed through to nghttp3. +{ + const serverDone = Promise.withResolvers(); + let requestCount = 0; + + const serverEndpoint = await listen(mustCall(async (ss) => { + ss.onstream = mustCall(2); + }), { + sni: { '*': { keys: [key], certs: [cert] } }, + // Server disables QPACK dynamic table. + application: { qpackMaxDTableCapacity: 0, qpackBlockedStreams: 0 }, + onheaders: mustCall(function(headers) { + this.sendHeaders({ ':status': '200' }); + this.writer.writeSync(encoder.encode(headers[':path'])); + this.writer.endSync(); + if (++requestCount === 2) { + serverDone.resolve(); + } + }, 2), + }); + + const clientSession = await connect(serverEndpoint.address, { + servername: 'localhost', + // Client also disables QPACK dynamic table. + application: { qpackMaxDTableCapacity: 0, qpackBlockedStreams: 0 }, + }); + await clientSession.opened; + + // Multiple requests to exercise header compression paths. + await makeRequest(clientSession, '/first'); + await makeRequest(clientSession, '/second'); + + await serverDone.promise; + clientSession.close(); +} + +// Custom qpackMaxDTableCapacity = 8192 (larger than default). +// Verifies large dynamic table capacity is accepted. +{ + const serverDone = Promise.withResolvers(); + let requestCount = 0; + + const serverEndpoint = await listen(mustCall(async (ss) => { + ss.onstream = mustCall(2); + }), { + sni: { '*': { keys: [key], certs: [cert] } }, + application: { qpackMaxDTableCapacity: 8192, qpackBlockedStreams: 200 }, + onheaders: mustCall(function(headers) { + this.sendHeaders({ ':status': '200' }); + this.writer.writeSync(encoder.encode(headers[':path'])); + this.writer.endSync(); + if (++requestCount === 2) { + serverDone.resolve(); + } + }, 2), + }); + + const clientSession = await connect(serverEndpoint.address, { + servername: 'localhost', + application: { qpackMaxDTableCapacity: 8192, qpackBlockedStreams: 200 }, + }); + await clientSession.opened; + + await makeRequest(clientSession, '/alpha'); + await makeRequest(clientSession, '/beta'); + + await serverDone.promise; + clientSession.close(); +} diff --git a/test/parallel/test-quic-h3-request-response.mjs b/test/parallel/test-quic-h3-request-response.mjs new file mode 100644 index 00000000000000..309489f2f16634 --- /dev/null +++ b/test/parallel/test-quic-h3-request-response.mjs @@ -0,0 +1,114 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: basic HTTP/3 request/response. +// Client sends a GET request with H3 pseudo-headers, server receives +// the request and sends back a 200 response with a text body. +// Verifies: +// - Request pseudo-headers are delivered to the server via onheaders +// - stream.headers property returns the initial headers +// - Response headers and status are delivered to the client +// - Response body data is readable + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; +const { readKey } = fixtures; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); +const { bytes } = await import('stream/iter'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); + +const encoder = new TextEncoder(); +const decoder = new TextDecoder(); +const responseBody = 'Hello from H3 server'; + +const serverDone = Promise.withResolvers(); + +// The onheaders callback signature is (headers, kind) with `this` bound +// to the stream. A regular function is used so `this` is accessible. +// safeCallbackInvoke(fn, owner, ...args) consumes the owner for error +// handling and forwards only ...args to fn. +const serverEndpoint = await listen(mustCall(async (serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +}), { + sni: { '*': { keys: [key], certs: [cert] } }, + // Default ALPN is h3 — omitted intentionally to exercise the default. + // + // onheaders is provided via listen options so it is applied to + // incoming streams (via kStreamCallbacks) BEFORE onstream fires. + // For H3, onheaders must be set because the H3 application delivers + // headers and stream[kHeaders] asserts the callback exists. + onheaders: mustCall(function(headers) { + // Verify request pseudo-headers. + strictEqual(headers[':method'], 'GET'); + strictEqual(headers[':path'], '/index.html'); + strictEqual(headers[':scheme'], 'https'); + strictEqual(headers[':authority'], 'localhost'); + + // After onheaders, stream.headers returns the initial headers. + // `this` is the stream (bound by the onheaders setter). + strictEqual(this.headers[':method'], 'GET'); + + // Send response headers (terminal: false is the default — body follows). + this.sendHeaders({ + ':status': '200', + 'content-type': 'text/plain', + }); + + // Write response body and close the write side. + const w = this.writer; + w.writeSync(encoder.encode(responseBody)); + w.endSync(); + }), +}); + +const clientSession = await connect(serverEndpoint.address, { + servername: 'localhost', + // Default ALPN is h3. +}); + +const info = await clientSession.opened; +strictEqual(info.protocol, 'h3'); + +const clientHeadersReceived = Promise.withResolvers(); + +// Send a GET request. With body omitted, the terminal flag is set +// automatically (END_STREAM on the HEADERS frame). +const stream = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/index.html', + ':scheme': 'https', + ':authority': 'localhost', + }, + onheaders: mustCall(function(headers) { + strictEqual(headers[':status'], '200'); + strictEqual(headers['content-type'], 'text/plain'); + clientHeadersReceived.resolve(); + }), +}); + +await clientHeadersReceived.promise; + +// Read the full response body. +const body = await bytes(stream); +strictEqual(decoder.decode(body), responseBody); + +// stream.headers should return the buffered response headers. +strictEqual(stream.headers[':status'], '200'); + +await Promise.all([stream.closed, serverDone.promise]); +clientSession.close(); diff --git a/test/parallel/test-quic-h3-settings.mjs b/test/parallel/test-quic-h3-settings.mjs new file mode 100644 index 00000000000000..d132f628a404e7 --- /dev/null +++ b/test/parallel/test-quic-h3-settings.mjs @@ -0,0 +1,185 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: HTTP/3 settings enforcement. +// maxHeaderPairs enforcement - reject headers exceeding pair count +// maxHeaderLength enforcement - reject headers exceeding byte length +// enableConnectProtocol setting (accepted without error) +// enableDatagrams setting (accepted without error) + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; +const { readKey } = fixtures; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); +const { bytes } = await import('stream/iter'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); +const encoder = new TextEncoder(); +const decoder = new TextDecoder(); + +// maxHeaderPairs enforcement. +// Server limits to 5 header pairs. Client sends 4 pseudo-headers + +// 2 custom headers = 6 pairs. The 6th pair is silently dropped. +{ + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (ss) => { + ss.onstream = mustCall(async (stream) => { + await stream.closed; + ss.close(); + serverDone.resolve(); + }); + }), { + sni: { '*': { keys: [key], certs: [cert] } }, + // Allow 5 header pairs: 4 pseudo-headers + 1 custom. + application: { maxHeaderPairs: 5 }, + onheaders: mustCall(function(headers) { + strictEqual(headers[':method'], 'GET'); + strictEqual(headers[':path'], '/limited'); + strictEqual(headers[':scheme'], 'https'); + strictEqual(headers[':authority'], 'localhost'); + // x-first is the 5th pair — accepted. + strictEqual(headers['x-first'], 'one'); + // x-second would be the 6th pair — dropped. + strictEqual(headers['x-second'], undefined); + + this.sendHeaders({ ':status': '200' }); + this.writer.writeSync(encoder.encode('ok')); + this.writer.endSync(); + }), + }); + + const clientSession = await connect(serverEndpoint.address, { + servername: 'localhost', + }); + await clientSession.opened; + + const stream = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/limited', + ':scheme': 'https', + ':authority': 'localhost', + 'x-first': 'one', + 'x-second': 'two', + }, + onheaders: mustCall(function(headers) { + strictEqual(headers[':status'], '200'); + }), + }); + + const body = await bytes(stream); + strictEqual(decoder.decode(body), 'ok'); + await stream.closed; + await serverDone.promise; + clientSession.close(); +} + +// maxHeaderLength enforcement. +// Server limits total header byte length (name chars + value chars). +// The 4 pseudo-headers take ~45 bytes. A long custom header value +// pushes the total over the limit. +{ + const serverDone = Promise.withResolvers(); + const longValue = 'x'.repeat(200); + + const serverEndpoint = await listen(mustCall(async (ss) => { + ss.onstream = mustCall(async (stream) => { + await stream.closed; + ss.close(); + serverDone.resolve(); + }); + }), { + sni: { '*': { keys: [key], certs: [cert] } }, + // Limit total header bytes. The 4 pseudo-headers fit within 100 + // bytes, but adding x-long (6 + 200 = 206 bytes) exceeds it. + application: { maxHeaderLength: 100 }, + onheaders: mustCall(function(headers) { + strictEqual(headers[':method'], 'GET'); + strictEqual(headers[':path'], '/length-limited'); + // x-long should be dropped — would push total over 100 bytes. + strictEqual(headers['x-long'], undefined); + + this.sendHeaders({ ':status': '200' }); + this.writer.writeSync(encoder.encode('ok')); + this.writer.endSync(); + }), + }); + + const clientSession = await connect(serverEndpoint.address, { + servername: 'localhost', + }); + await clientSession.opened; + + const stream = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/length-limited', + ':scheme': 'https', + ':authority': 'localhost', + 'x-long': longValue, + }, + onheaders: mustCall(function(headers) { + strictEqual(headers[':status'], '200'); + }), + }); + + const body = await bytes(stream); + strictEqual(decoder.decode(body), 'ok'); + await Promise.all([stream.closed, serverDone.promise]); + clientSession.close(); +} + +// enableConnectProtocol and enableDatagrams settings. +// Verify these options are accepted and H3 sessions work with them. +{ + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (ss) => { + ss.onstream = mustCall(async (stream) => { + await stream.closed; + ss.close(); + serverDone.resolve(); + }); + }), { + sni: { '*': { keys: [key], certs: [cert] } }, + application: { enableConnectProtocol: true, enableDatagrams: true }, + onheaders: mustCall(function(headers) { + this.sendHeaders({ ':status': '200' }); + this.writer.writeSync(encoder.encode('settings-ok')); + this.writer.endSync(); + }), + }); + + const clientSession = await connect(serverEndpoint.address, { + servername: 'localhost', + application: { enableConnectProtocol: true, enableDatagrams: true }, + }); + await clientSession.opened; + + const stream = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/settings', + ':scheme': 'https', + ':authority': 'localhost', + }, + onheaders: mustCall(function(headers) { + strictEqual(headers[':status'], '200'); + }), + }); + + const body = await bytes(stream); + strictEqual(decoder.decode(body), 'settings-ok'); + await Promise.all([stream.closed, serverDone.promise]); + clientSession.close(); +} diff --git a/test/parallel/test-quic-h3-stream-destroy-with-headers.mjs b/test/parallel/test-quic-h3-stream-destroy-with-headers.mjs new file mode 100644 index 00000000000000..a15668beae7dea --- /dev/null +++ b/test/parallel/test-quic-h3-stream-destroy-with-headers.mjs @@ -0,0 +1,58 @@ +// Flags: --experimental-quic --no-warnings + +// Test: Stream with pending headers destroyed before send. +// Creating an H3 stream with headers and immediately destroying it +// should clean up without crashing or leaking. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { strictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (ss) => { + // The server may or may not see the stream depending on timing. + // Either way, it should not crash. + await ss.closed; + serverDone.resolve(); +}), { + sni: { '*': { keys: [key], certs: [cert] } }, +}); + +const clientSession = await connect(serverEndpoint.address, { + servername: 'localhost', +}); +await clientSession.opened; + +// Create a stream with headers, then immediately destroy it. +const stream = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/destroyed', + ':scheme': 'https', + ':authority': 'localhost', + }, +}); + +// Destroy the stream before headers can be sent/processed. +stream.destroy(); + +// Verify the stream is destroyed without crash. +strictEqual(stream.destroyed, true); + +// Close everything cleanly. +clientSession.close(); +await serverDone.promise; diff --git a/test/parallel/test-quic-h3-trailing-headers.mjs b/test/parallel/test-quic-h3-trailing-headers.mjs new file mode 100644 index 00000000000000..99e23e01545b59 --- /dev/null +++ b/test/parallel/test-quic-h3-trailing-headers.mjs @@ -0,0 +1,122 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: HTTP/3 trailing headers. +// Server sends response headers, body data, then trailing headers. +// Client receives all three in order. +// Verifies: +// - onwanttrailers callback fires after body is sent +// - sendTrailers delivers trailing headers to the peer +// - ontrailers callback fires on the receiving side with kind 'trailing' +// - stream.headers still returns the initial headers (not trailers) + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import dc from 'node:diagnostics_channel'; +import * as fixtures from '../common/fixtures.mjs'; +const { readKey } = fixtures; + +const { ok, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); +const { bytes } = await import('stream/iter'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); + +const encoder = new TextEncoder(); +const decoder = new TextDecoder(); +const responseBody = 'body with trailers'; + +// quic.stream.headers fires when initial headers are received. +// Fires for both the server (request headers) and client (response headers). +dc.subscribe('quic.stream.headers', mustCall((msg) => { + ok(msg.stream, 'stream.headers should include stream'); + ok(msg.session, 'stream.headers should include session'); + ok(msg.headers, 'stream.headers should include headers'); +}, 2)); + +// quic.stream.trailers fires when trailing headers are received. +dc.subscribe('quic.stream.trailers', mustCall((msg) => { + ok(msg.stream, 'stream.trailers should include stream'); + ok(msg.session, 'stream.trailers should include session'); + ok(msg.trailers, 'stream.trailers should include trailers'); + strictEqual(msg.trailers['x-checksum'], 'abc123'); +})); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +}), { + sni: { '*': { keys: [key], certs: [cert] } }, + onheaders: mustCall(function(headers) { + // Send response headers. + this.sendHeaders({ + ':status': '200', + 'content-type': 'text/plain', + }); + + // Write body and close. + const w = this.writer; + w.writeSync(encoder.encode(responseBody)); + w.endSync(); + }), + // Fires after the body is fully sent (EOF + NO_END_STREAM). + // The server provides trailing headers here. + onwanttrailers: mustCall(function() { + this.sendTrailers({ + 'x-checksum': 'abc123', + 'x-request-id': '42', + }); + }), +}); + +const clientSession = await connect(serverEndpoint.address, { + servername: 'localhost', +}); +await clientSession.opened; + +const clientHeadersReceived = Promise.withResolvers(); +const clientTrailersReceived = Promise.withResolvers(); + +const stream = await clientSession.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/with-trailers', + ':scheme': 'https', + ':authority': 'localhost', + }, + onheaders: mustCall(function(headers) { + strictEqual(headers[':status'], '200'); + clientHeadersReceived.resolve(); + }), + ontrailers: mustCall(function(trailers) { + strictEqual(trailers['x-checksum'], 'abc123'); + strictEqual(trailers['x-request-id'], '42'); + clientTrailersReceived.resolve(); + }), +}); + +await clientHeadersReceived.promise; + +// Read the response body. +const body = await bytes(stream); +strictEqual(decoder.decode(body), responseBody); + +// Trailers arrive after the body. +await clientTrailersReceived.promise; + +// stream.headers should still be the initial headers, not trailers. +strictEqual(stream.headers[':status'], '200'); + +await Promise.all([stream.closed, serverDone.promise]); +clientSession.close(); diff --git a/test/parallel/test-quic-h3-zero-rtt-bogus-ticket.mjs b/test/parallel/test-quic-h3-zero-rtt-bogus-ticket.mjs new file mode 100644 index 00000000000000..de542310f0a011 --- /dev/null +++ b/test/parallel/test-quic-h3-zero-rtt-bogus-ticket.mjs @@ -0,0 +1,38 @@ +// Flags: --experimental-quic --no-warnings + +// Test: Bogus session ticket data is rejected gracefully. +// Providing random bytes as a session ticket throws ERR_INVALID_ARG_VALUE +// because the ticket format is validated before use. The connection +// cannot proceed with garbage ticket data. + +import { hasQuic, skip, mustNotCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { rejects } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey, randomBytes } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); + +const serverEndpoint = await listen(mustNotCall(), { + sni: { '*': { keys: [key], certs: [cert] } }, +}); + +// Bogus ticket data (random bytes) is rejected at the format level. +await rejects( + connect(serverEndpoint.address, { + servername: 'localhost', + sessionTicket: randomBytes(256), + }), + { code: 'ERR_INVALID_ARG_VALUE' }, +); + +serverEndpoint.close(); diff --git a/test/parallel/test-quic-h3-zero-rtt-rejected-settings.mjs b/test/parallel/test-quic-h3-zero-rtt-rejected-settings.mjs new file mode 100644 index 00000000000000..bbc0cd48fe13f5 --- /dev/null +++ b/test/parallel/test-quic-h3-zero-rtt-rejected-settings.mjs @@ -0,0 +1,177 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: H3 0-RTT rejected when server reduces application settings. +// 0-RTT rejected when max_field_section_size decreased +// 0-RTT rejected when enable_connect_protocol disabled +// 0-RTT rejected when enable_datagrams disabled +// Each test creates two endpoints with the same key/cert/tokenSecret. +// The first endpoint issues a ticket with generous H3 settings. The +// second endpoint has reduced settings, causing the H3 session ticket +// app data validation to reject 0-RTT. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { ok, strictEqual, rejects } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey, randomBytes } = await import('node:crypto'); +const { bytes } = await import('stream/iter'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); +const sni = { '*': { keys: [key], certs: [cert] } }; +const decoder = new TextDecoder(); + +// Helper: establish an H3 session, get a ticket, close. +async function getTicket(endpointOptions) { + let savedTicket; + let savedToken; + const gotTicket = Promise.withResolvers(); + const gotToken = Promise.withResolvers(); + + const ep = await listen(mustCall(async (ss) => { + ss.onstream = mustCall(async (stream) => { + await stream.closed; + ss.close(); + }); + }), { + sni, + ...endpointOptions, + onheaders: mustCall(function(headers) { + this.sendHeaders({ ':status': '200' }); + this.writer.writeSync('ok'); + this.writer.endSync(); + }), + }); + + const cs = await connect(ep.address, { + servername: 'localhost', + ...endpointOptions, + onsessionticket(ticket) { + ok(Buffer.isBuffer(ticket)); + savedTicket = ticket; + gotTicket.resolve(); + }, + onnewtoken(token) { + ok(Buffer.isBuffer(token)); + savedToken = token; + gotToken.resolve(); + }, + }); + await cs.opened; + await Promise.all([gotTicket.promise, gotToken.promise]); + + const s = await cs.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/ticket', + ':scheme': 'https', + ':authority': 'localhost', + }, + onheaders: mustCall(function(headers) { + strictEqual(headers[':status'], '200'); + }), + }); + const body = await bytes(s); + strictEqual(decoder.decode(body), 'ok'); + await Promise.all([s.closed, cs.closed]); + await ep.close(); + + return { ticket: savedTicket, token: savedToken }; +} + +// Helper: attempt 0-RTT with reduced settings, expect rejection. +// When 0-RTT is rejected, the H3 application is torn down and +// recreated (EarlyDataRejected destroys the nghttp3 connection). +// The initial 0-RTT stream may not survive this transition, so we +// only verify earlyDataAccepted is false and close cleanly. +async function attemptRejected0RTT(endpointOptions, ticket, token) { + const ep = await listen(mustCall(async (ss) => { + await ss.closed; + }), { + sni, + ...endpointOptions, + }); + + const cs = await connect(ep.address, { + servername: 'localhost', + ...endpointOptions, + sessionTicket: ticket, + token, + }); + + // Trigger the deferred handshake by opening a stream. + // With 0-RTT, the handshake is deferred until the first stream + // or datagram is sent. When 0-RTT is rejected, the stream is + // destroyed by EarlyDataRejected — its closed promise rejects + // with an application error. + const s = await cs.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/rejected', + ':scheme': 'https', + ':authority': 'localhost', + }, + }); + await rejects(s.closed, { + code: 'ERR_QUIC_APPLICATION_ERROR', + }); + + const info = await cs.opened; + strictEqual(info.earlyDataAttempted, true); + strictEqual(info.earlyDataAccepted, false); + + cs.close(); + ep.close(); +} + +const tokenSecret = randomBytes(16); + +// enable_connect_protocol disabled. +{ + const { ticket, token } = await getTicket({ + endpoint: { tokenSecret }, + application: { enableConnectProtocol: true }, + }); + + await attemptRejected0RTT({ + endpoint: { tokenSecret }, + // EnableConnectProtocol reduced from true to false. + application: { enableConnectProtocol: false }, + }, ticket, token); +} + +// enable_datagrams disabled. +{ + const { ticket, token } = await getTicket({ + endpoint: { tokenSecret }, + application: { enableDatagrams: true }, + }); + + await attemptRejected0RTT({ + endpoint: { tokenSecret }, + // EnableDatagrams reduced from true to false. + application: { enableDatagrams: false }, + }, ticket, token); +} + +// max_field_section_size decreased. +{ + const { ticket, token } = await getTicket({ + endpoint: { tokenSecret }, + application: { maxFieldSectionSize: 10000 }, + }); + + await attemptRejected0RTT({ + endpoint: { tokenSecret }, + // MaxFieldSectionSize reduced from 10000 to 100. + application: { maxFieldSectionSize: 100 }, + }, ticket, token); +} diff --git a/test/parallel/test-quic-h3-zero-rtt.mjs b/test/parallel/test-quic-h3-zero-rtt.mjs new file mode 100644 index 00000000000000..18a841eb938516 --- /dev/null +++ b/test/parallel/test-quic-h3-zero-rtt.mjs @@ -0,0 +1,131 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: HTTP/3 0-RTT session resumption with session ticket app data. +// Session ticket includes HTTP/3 settings +// H3 + 0-RTT: Client sends H3 request in 0-RTT flight +// Uses a single server endpoint for both connections so the TLS +// session ticket encryption key is shared. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; +const { readKey } = fixtures; + +const { ok, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); +const { bytes } = await import('stream/iter'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); +const encoder = new TextEncoder(); +const decoder = new TextDecoder(); + +let savedTicket; +let savedToken; +const gotTicket = Promise.withResolvers(); +const gotToken = Promise.withResolvers(); + +let serverSessionCount = 0; +const secondDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((ss) => { + const num = ++serverSessionCount; + ss.onstream = mustCall(async (stream) => { + if (num === 2) { + // Resolve with the stream so we can check stream.early after + // data has been received (the early flag is set after + // nghttp3 processes the 0-RTT headers, not at stream creation). + secondDone.resolve(stream); + } + await stream.closed; + ss.close(); + }); +}, 2), { + sni: { '*': { keys: [key], certs: [cert] } }, + onheaders: mustCall(function(headers) { + this.sendHeaders({ ':status': '200' }); + this.writer.writeSync(encoder.encode(headers[':path'])); + this.writer.endSync(); + }, 2), +}); + +// --- First connection: establish H3 session, receive ticket --- +const cs1 = await connect(serverEndpoint.address, { + servername: 'localhost', + onsessionticket: mustCall(function(ticket) { + ok(Buffer.isBuffer(ticket)); + ok(ticket.length > 0); + savedTicket = ticket; + gotTicket.resolve(); + }, 2), + onnewtoken: mustCall(function(token) { + ok(Buffer.isBuffer(token)); + savedToken = token; + gotToken.resolve(); + }), +}); + +const info1 = await cs1.opened; +strictEqual(info1.earlyDataAttempted, false); +strictEqual(info1.earlyDataAccepted, false); + +await Promise.all([gotTicket.promise, gotToken.promise]); + +const s1 = await cs1.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/first', + ':scheme': 'https', + ':authority': 'localhost', + }, + onheaders: mustCall(function(headers) { + strictEqual(headers[':status'], '200'); + }), +}); +const body1 = await bytes(s1); +strictEqual(decoder.decode(body1), '/first'); +await Promise.all([s1.closed, cs1.closed]); + +// Session ticket should have been received. +ok(savedTicket); +ok(savedToken); + +// --- Second connection: 0-RTT with H3 --- +const cs2 = await connect(serverEndpoint.address, { + servername: 'localhost', + sessionTicket: savedTicket, + token: savedToken, +}); + +// Send H3 request BEFORE handshake completes — true 0-RTT. +const s2 = await cs2.createBidirectionalStream({ + headers: { + ':method': 'GET', + ':path': '/early', + ':scheme': 'https', + ':authority': 'localhost', + }, + onheaders: mustCall(function(headers) { + strictEqual(headers[':status'], '200'); + }), +}); + +const info2 = await cs2.opened; +strictEqual(info2.earlyDataAttempted, true); +strictEqual(info2.earlyDataAccepted, true); + +const body2 = await bytes(s2); +strictEqual(decoder.decode(body2), '/early'); +await s2.closed; + +const earlyStream = await secondDone.promise; +strictEqual(earlyStream.early, true); + +await cs2.closed; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-handshake-ipv6-only.mjs b/test/parallel/test-quic-handshake-ipv6-only.mjs index 646cd9e4765e97..2101b769f4bbf0 100644 --- a/test/parallel/test-quic-handshake-ipv6-only.mjs +++ b/test/parallel/test-quic-handshake-ipv6-only.mjs @@ -4,6 +4,9 @@ import { hasQuic, hasIPv6, skip, mustCall } from '../common/index.mjs'; import assert from 'node:assert'; import * as fixtures from '../common/fixtures.mjs'; +const { partialDeepStrictEqual, strictEqual, ok } = assert; +const { readKey } = fixtures; + if (!hasQuic) { skip('QUIC is not enabled'); } @@ -16,8 +19,8 @@ if (!hasIPv6) { const { listen, connect } = await import('node:quic'); const { createPrivateKey } = await import('node:crypto'); -const key = createPrivateKey(fixtures.readKey('agent1-key.pem')); -const cert = fixtures.readKey('agent1-cert.pem'); +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); const check = { // The SNI value @@ -32,14 +35,12 @@ const check = { // The opened promise should resolve when the handshake is complete. const serverOpened = Promise.withResolvers(); -const clientOpened = Promise.withResolvers(); -const serverEndpoint = await listen(mustCall((serverSession) => { - serverSession.opened.then((info) => { - assert.partialDeepStrictEqual(info, check); - serverOpened.resolve(); - serverSession.close(); - }).then(mustCall()); +const serverEndpoint = await listen(mustCall(async (serverSession) => { + const info = await serverSession.opened; + partialDeepStrictEqual(info, check); + serverOpened.resolve(); + await serverSession.close(); }), { sni: { '*': { keys: [key], certs: [cert] } }, alpn: ['quic-test'], @@ -52,10 +53,10 @@ const serverEndpoint = await listen(mustCall((serverSession) => { }, }); // Buffer is not detached. -assert.strictEqual(cert.buffer.detached, false); +strictEqual(cert.buffer.detached, false); // The server must have an address to connect to after listen resolves. -assert.ok(serverEndpoint.address !== undefined); +ok(serverEndpoint.address !== undefined); const clientSession = await connect(serverEndpoint.address, { alpn: 'quic-test', @@ -66,10 +67,9 @@ const clientSession = await connect(serverEndpoint.address, { }, }, }); -clientSession.opened.then((info) => { - assert.partialDeepStrictEqual(info, check); - clientOpened.resolve(); -}).then(mustCall()); -await Promise.all([serverOpened.promise, clientOpened.promise]); +const info = await clientSession.opened; +partialDeepStrictEqual(info, check); + +await serverOpened.promise; clientSession.close(); diff --git a/test/parallel/test-quic-handshake-timeout.mjs b/test/parallel/test-quic-handshake-timeout.mjs new file mode 100644 index 00000000000000..51798950cdd50e --- /dev/null +++ b/test/parallel/test-quic-handshake-timeout.mjs @@ -0,0 +1,33 @@ +// Flags: --experimental-quic --no-warnings + +// Test: handshake timeout. +// The server accepts sessions but the client uses a very short idle +// timeout, causing the session to close before the handshake can +// complete on the server side. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; +}), { transportParams: { maxIdleTimeout: 1 } }); + +const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxIdleTimeout: 1 }, +}); + +// Don't send any data. Just wait for idle timeout. +await Promise.all([clientSession.opened, clientSession.closed]); + +// The session closed via idle timeout. Verify it was destroyed. +strictEqual(clientSession.destroyed, true); + +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-handshake.mjs b/test/parallel/test-quic-handshake.mjs index 7374d4c929398e..3ff6af08b868be 100644 --- a/test/parallel/test-quic-handshake.mjs +++ b/test/parallel/test-quic-handshake.mjs @@ -3,6 +3,9 @@ import { hasQuic, skip, mustCall } from '../common/index.mjs'; import assert from 'node:assert'; import * as fixtures from '../common/fixtures.mjs'; +const { readKey } = fixtures; + +const { partialDeepStrictEqual, strictEqual, ok } = assert; if (!hasQuic) { skip('QUIC is not enabled'); @@ -12,8 +15,8 @@ if (!hasQuic) { const { listen, connect } = await import('node:quic'); const { createPrivateKey } = await import('node:crypto'); -const key = createPrivateKey(fixtures.readKey('agent1-key.pem')); -const cert = fixtures.readKey('agent1-cert.pem'); +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); const check = { // The SNI value @@ -23,16 +26,18 @@ const check = { // The negotiated cipher suite cipher: 'TLS_AES_128_GCM_SHA256', cipherVersion: 'TLSv1.3', + // No session ticket provided, so early data was not attempted + earlyDataAttempted: false, + earlyDataAccepted: false, }; // The opened promise should resolve when the handshake is complete. const serverOpened = Promise.withResolvers(); -const clientOpened = Promise.withResolvers(); const serverEndpoint = await listen(mustCall((serverSession) => { serverSession.opened.then((info) => { - assert.partialDeepStrictEqual(info, check); + partialDeepStrictEqual(info, check); serverOpened.resolve(); serverSession.close(); }).then(mustCall()); @@ -42,18 +47,17 @@ const serverEndpoint = await listen(mustCall((serverSession) => { }); // Buffer is not detached. -assert.strictEqual(cert.buffer.detached, false); +strictEqual(cert.buffer.detached, false); // The server must have an address to connect to after listen resolves. -assert.ok(serverEndpoint.address !== undefined); +ok(serverEndpoint.address !== undefined); const clientSession = await connect(serverEndpoint.address, { alpn: 'quic-test', }); -clientSession.opened.then((info) => { - assert.partialDeepStrictEqual(info, check); - clientOpened.resolve(); -}).then(mustCall()); -await Promise.all([serverOpened.promise, clientOpened.promise]); +const info = await clientSession.opened; +partialDeepStrictEqual(info, check); + +await serverOpened.promise; clientSession.close(); diff --git a/test/parallel/test-quic-internal-endpoint-listen-defaults.mjs b/test/parallel/test-quic-internal-endpoint-listen-defaults.mjs index 68aa8332dccede..7dda0a6f28d865 100644 --- a/test/parallel/test-quic-internal-endpoint-listen-defaults.mjs +++ b/test/parallel/test-quic-internal-endpoint-listen-defaults.mjs @@ -1,10 +1,13 @@ // Flags: --expose-internals --experimental-quic --no-warnings -import { hasQuic, skip } from '../common/index.mjs'; +import { hasQuic, skip, mustNotCall } from '../common/index.mjs'; import assert from 'node:assert'; import * as fixtures from '../common/fixtures.mjs'; +const { readKey } = fixtures; import { SocketAddress } from 'node:net'; +const { strictEqual, rejects, ok, throws } = assert; + if (!hasQuic) { skip('QUIC is not enabled'); } @@ -14,65 +17,65 @@ const { listen, QuicEndpoint } = await import('node:quic'); const { createPrivateKey } = await import('node:crypto'); const { getQuicEndpointState } = (await import('internal/quic/quic')).default; -const key = createPrivateKey(fixtures.readKey('agent1-key.pem')); -const cert = fixtures.readKey('agent1-cert.pem'); +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); const sni = { '*': { keys: [key], certs: [cert] } }; const endpoint = new QuicEndpoint(); const state = getQuicEndpointState(endpoint); -assert.ok(!state.isBound); -assert.ok(!state.isReceiving); -assert.ok(!state.isListening); +ok(!state.isBound); +ok(!state.isReceiving); +ok(!state.isListening); -assert.strictEqual(endpoint.address, undefined); +strictEqual(endpoint.address, undefined); -await assert.rejects(listen(123, { sni, endpoint }), { +await rejects(listen(123, { sni, endpoint }), { code: 'ERR_INVALID_ARG_TYPE', }); // Buffer is not detached. -assert.strictEqual(cert.buffer.detached, false); +strictEqual(cert.buffer.detached, false); -await assert.rejects(listen(() => {}, 123), { +await rejects(listen(mustNotCall(), 123), { code: 'ERR_INVALID_ARG_TYPE', }); -await listen(() => {}, { sni, endpoint }); +await listen(mustNotCall(), { sni, endpoint }); // Buffer is not detached. -assert.strictEqual(cert.buffer.detached, false); +strictEqual(cert.buffer.detached, false); -await assert.rejects(listen(() => {}, { sni, endpoint }), { +await rejects(listen(mustNotCall(), { sni, endpoint }), { code: 'ERR_INVALID_STATE', }); // Buffer is not detached. -assert.strictEqual(cert.buffer.detached, false); +strictEqual(cert.buffer.detached, false); -assert.ok(state.isBound); -assert.ok(state.isReceiving); -assert.ok(state.isListening); +ok(state.isBound); +ok(state.isReceiving); +ok(state.isListening); const address = endpoint.address; -assert.ok(address instanceof SocketAddress); +ok(address instanceof SocketAddress); -assert.strictEqual(address.address, '127.0.0.1'); -assert.strictEqual(address.family, 'ipv4'); -assert.strictEqual(address.flowlabel, 0); -assert.ok(address.port !== 0); +strictEqual(address.address, '127.0.0.1'); +strictEqual(address.family, 'ipv4'); +strictEqual(address.flowlabel, 0); +ok(address.port !== 0); -assert.ok(!endpoint.destroyed); +ok(!endpoint.destroyed); endpoint.destroy(); -assert.strictEqual(endpoint.closed, endpoint.close()); +strictEqual(endpoint.closed, endpoint.close()); await endpoint.closed; -assert.ok(endpoint.destroyed); +ok(endpoint.destroyed); -await assert.rejects(listen(() => {}, { sni, endpoint }), { +await rejects(listen(mustNotCall(), { sni, endpoint }), { code: 'ERR_INVALID_STATE', }); // Buffer is not detached. -assert.strictEqual(cert.buffer.detached, false); +strictEqual(cert.buffer.detached, false); -assert.throws(() => { endpoint.busy = true; }, { +throws(() => { endpoint.busy = true; }, { code: 'ERR_INVALID_STATE', }); await endpoint[Symbol.asyncDispose](); -assert.strictEqual(endpoint.address, undefined); +strictEqual(endpoint.address, undefined); diff --git a/test/parallel/test-quic-internal-endpoint-options.mjs b/test/parallel/test-quic-internal-endpoint-options.mjs index b79ce4fc4cbaf6..306d0c523f4611 100644 --- a/test/parallel/test-quic-internal-endpoint-options.mjs +++ b/test/parallel/test-quic-internal-endpoint-options.mjs @@ -3,6 +3,8 @@ import { hasQuic, skip } from '../common/index.mjs'; import assert from 'node:assert'; import { inspect } from 'node:util'; +const { strictEqual, throws } = assert; + if (!hasQuic) { skip('QUIC is not enabled'); } @@ -12,7 +14,7 @@ const { QuicEndpoint } = await import('node:quic'); // Reject invalid options ['a', null, false, NaN].forEach((i) => { - assert.throws(() => new QuicEndpoint(i), { + throws(() => new QuicEndpoint(i), { code: 'ERR_INVALID_ARG_TYPE', }); }); @@ -39,16 +41,16 @@ const cases = [ { key: 'maxConnectionsPerHost', valid: [ - 1, 10, 100, 1000, 10000, 10000n, + 0, 1, 10, 100, 1000, 10000, 65535, ], - invalid: [-1, -1n, 'a', null, false, true, {}, [], () => {}] + invalid: [-1, 65536, 1.5, 'a', null, false, true, {}, [], () => {}] }, { key: 'maxConnectionsTotal', valid: [ - 1, 10, 100, 1000, 10000, 10000n, + 0, 1, 10, 100, 1000, 10000, 65535, ], - invalid: [-1, -1n, 'a', null, false, true, {}, [], () => {}] + invalid: [-1, 65536, 1.5, 'a', null, false, true, {}, [], () => {}] }, { key: 'maxStatelessResetsPerHost', @@ -147,7 +149,7 @@ for (const { key, valid, invalid } of cases) { for (const value of invalid) { const options = {}; options[key] = value; - assert.throws(() => new QuicEndpoint(options), { + throws(() => new QuicEndpoint(options), { message: new RegExp(`${RegExp.escape(key)}`), }, value); } @@ -155,7 +157,7 @@ for (const { key, valid, invalid } of cases) { // It can be inspected const endpoint = new QuicEndpoint({}); -assert.strictEqual(typeof inspect(endpoint), 'string'); +strictEqual(typeof inspect(endpoint), 'string'); endpoint.close(); await endpoint.closed; @@ -166,6 +168,6 @@ new QuicEndpoint({ new QuicEndpoint({ address: '127.0.0.1:0', }); -assert.throws(() => new QuicEndpoint({ address: 123 }), { +throws(() => new QuicEndpoint({ address: 123 }), { code: 'ERR_INVALID_ARG_TYPE', }); diff --git a/test/parallel/test-quic-internal-endpoint-stats-state.mjs b/test/parallel/test-quic-internal-endpoint-stats-state.mjs index 94b8167c2d751a..015155344fde42 100644 --- a/test/parallel/test-quic-internal-endpoint-stats-state.mjs +++ b/test/parallel/test-quic-internal-endpoint-stats-state.mjs @@ -3,6 +3,8 @@ import { hasQuic, skip } from '../common/index.mjs'; import { inspect } from 'node:util'; import assert from 'node:assert'; +const { strictEqual, deepStrictEqual, throws } = assert; + if (!hasQuic) { skip('QUIC is not enabled'); } @@ -28,27 +30,29 @@ const { const endpoint = new QuicEndpoint(); const state = getQuicEndpointState(endpoint); - assert.strictEqual(state.isBound, false); - assert.strictEqual(state.isReceiving, false); - assert.strictEqual(state.isListening, false); - assert.strictEqual(state.isClosing, false); - assert.strictEqual(state.isBusy, false); - assert.strictEqual(state.pendingCallbacks, 0n); + strictEqual(state.isBound, false); + strictEqual(state.isReceiving, false); + strictEqual(state.isListening, false); + strictEqual(state.isClosing, false); + strictEqual(state.isBusy, false); + strictEqual(state.pendingCallbacks, 0n); - assert.deepStrictEqual(JSON.parse(JSON.stringify(state)), { + deepStrictEqual(JSON.parse(JSON.stringify(state)), { isBound: false, isReceiving: false, isListening: false, isClosing: false, isBusy: false, + maxConnectionsPerHost: 0, + maxConnectionsTotal: 0, pendingCallbacks: '0', }); endpoint.busy = true; - assert.strictEqual(state.isBusy, true); + strictEqual(state.isBusy, true); endpoint.busy = false; - assert.strictEqual(state.isBusy, false); - assert.strictEqual(typeof inspect(state), 'string'); + strictEqual(state.isBusy, false); + strictEqual(typeof inspect(state), 'string'); } { @@ -56,7 +60,7 @@ const { const endpoint = new QuicEndpoint(); const state = getQuicEndpointState(endpoint); state[kFinishClose](); - assert.strictEqual(state.isBound, undefined); + strictEqual(state.isBound, undefined); } { @@ -64,7 +68,7 @@ const { const endpoint = new QuicEndpoint(); const state = getQuicEndpointState(endpoint); const StateCons = state.constructor; - assert.throws(() => new StateCons(kPrivateConstructor, 1), { + throws(() => new StateCons(kPrivateConstructor, 1), { code: 'ERR_INVALID_ARG_TYPE' }); } @@ -73,22 +77,22 @@ const { // Endpoint stats are readable and have expected properties const endpoint = new QuicEndpoint(); - assert.strictEqual(typeof endpoint.stats.isConnected, 'boolean'); - assert.strictEqual(typeof endpoint.stats.createdAt, 'bigint'); - assert.strictEqual(typeof endpoint.stats.destroyedAt, 'bigint'); - assert.strictEqual(typeof endpoint.stats.bytesReceived, 'bigint'); - assert.strictEqual(typeof endpoint.stats.bytesSent, 'bigint'); - assert.strictEqual(typeof endpoint.stats.packetsReceived, 'bigint'); - assert.strictEqual(typeof endpoint.stats.packetsSent, 'bigint'); - assert.strictEqual(typeof endpoint.stats.serverSessions, 'bigint'); - assert.strictEqual(typeof endpoint.stats.clientSessions, 'bigint'); - assert.strictEqual(typeof endpoint.stats.serverBusyCount, 'bigint'); - assert.strictEqual(typeof endpoint.stats.retryCount, 'bigint'); - assert.strictEqual(typeof endpoint.stats.versionNegotiationCount, 'bigint'); - assert.strictEqual(typeof endpoint.stats.statelessResetCount, 'bigint'); - assert.strictEqual(typeof endpoint.stats.immediateCloseCount, 'bigint'); - - assert.deepStrictEqual(Object.keys(endpoint.stats.toJSON()), [ + strictEqual(typeof endpoint.stats.isConnected, 'boolean'); + strictEqual(typeof endpoint.stats.createdAt, 'bigint'); + strictEqual(typeof endpoint.stats.destroyedAt, 'bigint'); + strictEqual(typeof endpoint.stats.bytesReceived, 'bigint'); + strictEqual(typeof endpoint.stats.bytesSent, 'bigint'); + strictEqual(typeof endpoint.stats.packetsReceived, 'bigint'); + strictEqual(typeof endpoint.stats.packetsSent, 'bigint'); + strictEqual(typeof endpoint.stats.serverSessions, 'bigint'); + strictEqual(typeof endpoint.stats.clientSessions, 'bigint'); + strictEqual(typeof endpoint.stats.serverBusyCount, 'bigint'); + strictEqual(typeof endpoint.stats.retryCount, 'bigint'); + strictEqual(typeof endpoint.stats.versionNegotiationCount, 'bigint'); + strictEqual(typeof endpoint.stats.statelessResetCount, 'bigint'); + strictEqual(typeof endpoint.stats.immediateCloseCount, 'bigint'); + + deepStrictEqual(Object.keys(endpoint.stats.toJSON()), [ 'connected', 'createdAt', 'destroyedAt', @@ -104,24 +108,24 @@ const { 'statelessResetCount', 'immediateCloseCount', ]); - assert.strictEqual(typeof inspect(endpoint.stats), 'string'); + strictEqual(typeof inspect(endpoint.stats), 'string'); } { // Stats are still readable after close const endpoint = new QuicEndpoint(); - assert.strictEqual(typeof endpoint.stats.toJSON(), 'object'); + strictEqual(typeof endpoint.stats.toJSON(), 'object'); endpoint.stats[kFinishClose](); - assert.strictEqual(endpoint.stats.isConnected, false); - assert.strictEqual(typeof endpoint.stats.destroyedAt, 'bigint'); - assert.strictEqual(typeof endpoint.stats.toJSON(), 'object'); + strictEqual(endpoint.stats.isConnected, false); + strictEqual(typeof endpoint.stats.destroyedAt, 'bigint'); + strictEqual(typeof endpoint.stats.toJSON(), 'object'); } { // Stats constructor argument is ArrayBuffer const endpoint = new QuicEndpoint(); const StatsCons = endpoint.stats.constructor; - assert.throws(() => new StatsCons(kPrivateConstructor, 1), { + throws(() => new StatsCons(kPrivateConstructor, 1), { code: 'ERR_INVALID_ARG_TYPE', }); } @@ -133,76 +137,88 @@ const { const streamState = new QuicStreamState(kPrivateConstructor, new ArrayBuffer(1024)); const sessionState = new QuicSessionState(kPrivateConstructor, new ArrayBuffer(1024)); -assert.strictEqual(streamState.pending, false); -assert.strictEqual(streamState.finSent, false); -assert.strictEqual(streamState.finReceived, false); -assert.strictEqual(streamState.readEnded, false); -assert.strictEqual(streamState.writeEnded, false); -assert.strictEqual(streamState.reset, false); -assert.strictEqual(streamState.hasReader, false); -assert.strictEqual(streamState.wantsBlock, false); -assert.strictEqual(streamState.wantsReset, false); - -assert.strictEqual(sessionState.hasPathValidationListener, false); -assert.strictEqual(sessionState.hasVersionNegotiationListener, false); -assert.strictEqual(sessionState.hasDatagramListener, false); -assert.strictEqual(sessionState.hasSessionTicketListener, false); -assert.strictEqual(sessionState.isClosing, false); -assert.strictEqual(sessionState.isGracefulClose, false); -assert.strictEqual(sessionState.isSilentClose, false); -assert.strictEqual(sessionState.isStatelessReset, false); -assert.strictEqual(sessionState.isHandshakeCompleted, false); -assert.strictEqual(sessionState.isHandshakeConfirmed, false); -assert.strictEqual(sessionState.isStreamOpenAllowed, false); -assert.strictEqual(sessionState.isPrioritySupported, false); -assert.strictEqual(sessionState.isWrapped, false); -assert.strictEqual(sessionState.lastDatagramId, 0n); - -assert.strictEqual(typeof streamState.toJSON(), 'object'); -assert.strictEqual(typeof sessionState.toJSON(), 'object'); -assert.strictEqual(typeof inspect(streamState), 'string'); -assert.strictEqual(typeof inspect(sessionState), 'string'); +strictEqual(streamState.pending, false); +strictEqual(streamState.finSent, false); +strictEqual(streamState.finReceived, false); +strictEqual(streamState.readEnded, false); +strictEqual(streamState.writeEnded, false); +strictEqual(streamState.reset, false); +strictEqual(streamState.hasReader, false); +strictEqual(streamState.wantsBlock, false); +strictEqual(streamState.wantsReset, false); + +strictEqual(sessionState.hasPathValidationListener, false); +strictEqual(sessionState.hasDatagramListener, false); +strictEqual(sessionState.hasDatagramStatusListener, false); +strictEqual(sessionState.hasSessionTicketListener, false); +strictEqual(sessionState.hasNewTokenListener, false); +strictEqual(sessionState.hasOriginListener, false); +strictEqual(sessionState.isClosing, false); +strictEqual(sessionState.isGracefulClose, false); +strictEqual(sessionState.isSilentClose, false); +strictEqual(sessionState.isStatelessReset, false); +strictEqual(sessionState.isHandshakeCompleted, false); +strictEqual(sessionState.isHandshakeConfirmed, false); +strictEqual(sessionState.isStreamOpenAllowed, false); +strictEqual(sessionState.isPrioritySupported, false); +strictEqual(sessionState.headersSupported, 0); +strictEqual(sessionState.isWrapped, false); +strictEqual(sessionState.maxDatagramSize, 0); +strictEqual(sessionState.lastDatagramId, 0n); + +strictEqual(typeof streamState.toJSON(), 'object'); +strictEqual(typeof sessionState.toJSON(), 'object'); +strictEqual(typeof inspect(streamState), 'string'); +strictEqual(typeof inspect(sessionState), 'string'); const streamStats = new QuicStreamStats(kPrivateConstructor, new ArrayBuffer(1024)); const sessionStats = new QuicSessionStats(kPrivateConstructor, new ArrayBuffer(1024)); -assert.strictEqual(streamStats.createdAt, 0n); -assert.strictEqual(streamStats.openedAt, 0n); -assert.strictEqual(streamStats.receivedAt, 0n); -assert.strictEqual(streamStats.ackedAt, 0n); -assert.strictEqual(streamStats.destroyedAt, 0n); -assert.strictEqual(streamStats.bytesReceived, 0n); -assert.strictEqual(streamStats.bytesSent, 0n); -assert.strictEqual(streamStats.maxOffset, 0n); -assert.strictEqual(streamStats.maxOffsetAcknowledged, 0n); -assert.strictEqual(streamStats.maxOffsetReceived, 0n); -assert.strictEqual(streamStats.finalSize, 0n); -assert.strictEqual(typeof streamStats.toJSON(), 'object'); -assert.strictEqual(typeof inspect(streamStats), 'string'); +strictEqual(streamStats.createdAt, 0n); +strictEqual(streamStats.openedAt, 0n); +strictEqual(streamStats.receivedAt, 0n); +strictEqual(streamStats.ackedAt, 0n); +strictEqual(streamStats.destroyedAt, 0n); +strictEqual(streamStats.bytesReceived, 0n); +strictEqual(streamStats.bytesSent, 0n); +strictEqual(streamStats.maxOffset, 0n); +strictEqual(streamStats.maxOffsetAcknowledged, 0n); +strictEqual(streamStats.maxOffsetReceived, 0n); +strictEqual(streamStats.finalSize, 0n); +strictEqual(typeof streamStats.toJSON(), 'object'); +strictEqual(typeof inspect(streamStats), 'string'); streamStats[kFinishClose](); -assert.strictEqual(typeof sessionStats.createdAt, 'bigint'); -assert.strictEqual(typeof sessionStats.closingAt, 'bigint'); -assert.strictEqual(typeof sessionStats.handshakeCompletedAt, 'bigint'); -assert.strictEqual(typeof sessionStats.handshakeConfirmedAt, 'bigint'); -assert.strictEqual(typeof sessionStats.bytesReceived, 'bigint'); -assert.strictEqual(typeof sessionStats.bytesSent, 'bigint'); -assert.strictEqual(typeof sessionStats.bidiInStreamCount, 'bigint'); -assert.strictEqual(typeof sessionStats.bidiOutStreamCount, 'bigint'); -assert.strictEqual(typeof sessionStats.uniInStreamCount, 'bigint'); -assert.strictEqual(typeof sessionStats.uniOutStreamCount, 'bigint'); -assert.strictEqual(typeof sessionStats.maxBytesInFlights, 'bigint'); -assert.strictEqual(typeof sessionStats.bytesInFlight, 'bigint'); -assert.strictEqual(typeof sessionStats.blockCount, 'bigint'); -assert.strictEqual(typeof sessionStats.cwnd, 'bigint'); -assert.strictEqual(typeof sessionStats.latestRtt, 'bigint'); -assert.strictEqual(typeof sessionStats.minRtt, 'bigint'); -assert.strictEqual(typeof sessionStats.rttVar, 'bigint'); -assert.strictEqual(typeof sessionStats.smoothedRtt, 'bigint'); -assert.strictEqual(typeof sessionStats.ssthresh, 'bigint'); -assert.strictEqual(typeof sessionStats.datagramsReceived, 'bigint'); -assert.strictEqual(typeof sessionStats.datagramsSent, 'bigint'); -assert.strictEqual(typeof sessionStats.datagramsAcknowledged, 'bigint'); -assert.strictEqual(typeof sessionStats.datagramsLost, 'bigint'); -assert.strictEqual(typeof sessionStats.toJSON(), 'object'); -assert.strictEqual(typeof inspect(sessionStats), 'string'); +strictEqual(typeof sessionStats.createdAt, 'bigint'); +strictEqual(typeof sessionStats.closingAt, 'bigint'); +strictEqual(typeof sessionStats.handshakeCompletedAt, 'bigint'); +strictEqual(typeof sessionStats.handshakeConfirmedAt, 'bigint'); +strictEqual(typeof sessionStats.bytesReceived, 'bigint'); +strictEqual(typeof sessionStats.bytesSent, 'bigint'); +strictEqual(typeof sessionStats.bidiInStreamCount, 'bigint'); +strictEqual(typeof sessionStats.bidiOutStreamCount, 'bigint'); +strictEqual(typeof sessionStats.uniInStreamCount, 'bigint'); +strictEqual(typeof sessionStats.uniOutStreamCount, 'bigint'); +strictEqual(typeof sessionStats.maxBytesInFlight, 'bigint'); +strictEqual(typeof sessionStats.bytesInFlight, 'bigint'); +strictEqual(typeof sessionStats.blockCount, 'bigint'); +strictEqual(typeof sessionStats.cwnd, 'bigint'); +strictEqual(typeof sessionStats.latestRtt, 'bigint'); +strictEqual(typeof sessionStats.minRtt, 'bigint'); +strictEqual(typeof sessionStats.rttVar, 'bigint'); +strictEqual(typeof sessionStats.smoothedRtt, 'bigint'); +strictEqual(typeof sessionStats.ssthresh, 'bigint'); +strictEqual(typeof sessionStats.pktSent, 'bigint'); +strictEqual(typeof sessionStats.bytesSent, 'bigint'); +strictEqual(typeof sessionStats.pktRecv, 'bigint'); +strictEqual(typeof sessionStats.bytesRecv, 'bigint'); +strictEqual(typeof sessionStats.pktLost, 'bigint'); +strictEqual(typeof sessionStats.bytesLost, 'bigint'); +strictEqual(typeof sessionStats.pingRecv, 'bigint'); +strictEqual(typeof sessionStats.pktDiscarded, 'bigint'); +strictEqual(typeof sessionStats.datagramsReceived, 'bigint'); +strictEqual(typeof sessionStats.datagramsSent, 'bigint'); +strictEqual(typeof sessionStats.datagramsAcknowledged, 'bigint'); +strictEqual(typeof sessionStats.datagramsLost, 'bigint'); +strictEqual(typeof sessionStats.toJSON(), 'object'); +strictEqual(typeof inspect(sessionStats), 'string'); streamStats[kFinishClose](); diff --git a/test/parallel/test-quic-internal-setcallbacks.mjs b/test/parallel/test-quic-internal-setcallbacks.mjs index cebbee43376d6e..a9f24207aeeed7 100644 --- a/test/parallel/test-quic-internal-setcallbacks.mjs +++ b/test/parallel/test-quic-internal-setcallbacks.mjs @@ -2,6 +2,8 @@ import { hasQuic, skip } from '../common/index.mjs'; import assert from 'node:assert'; +const { throws } = assert; + if (!hasQuic) { skip('QUIC is not enabled'); } @@ -19,10 +21,16 @@ const callbacks = { onSessionPathValidation() {}, onSessionTicket() {}, onSessionNewToken() {}, + onSessionKeyLog() {}, + onSessionQlog() {}, + onSessionEarlyDataRejected() {}, + onSessionOrigin() {}, + onSessionGoaway() {}, onSessionVersionNegotiation() {}, onStreamCreated() {}, onStreamBlocked() {}, onStreamClose() {}, + onStreamDrain() {}, onStreamReset() {}, onStreamHeaders() {}, onStreamTrailers() {}, @@ -31,7 +39,7 @@ const callbacks = { for (const fn of Object.keys(callbacks)) { // eslint-disable-next-line no-unused-vars const { [fn]: _, ...rest } = callbacks; - assert.throws(() => quic.setCallbacks(rest), { + throws(() => quic.setCallbacks(rest), { code: 'ERR_MISSING_ARGS', }); } diff --git a/test/parallel/test-quic-keepalive.mjs b/test/parallel/test-quic-keepalive.mjs new file mode 100644 index 00000000000000..e5e44cd6350939 --- /dev/null +++ b/test/parallel/test-quic-keepalive.mjs @@ -0,0 +1,68 @@ +// Flags: --experimental-quic --no-warnings + +// Test: keepAlive option. +// keepAlive keeps idle connection alive past default timeout. +// keepAlive: 0 (default) does not send PING frames. +// Keep-alive PING frames visible in session stats (pingRecv). + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import { setTimeout } from 'node:timers/promises'; + +const { ok, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +// KA-01/03: With keepAlive set, the connection stays alive and +// PING frames are sent. After a brief idle period, the peer's +// pingRecv stat should be > 0. +{ + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.opened; + // Wait for keep-alive PINGs to arrive. + await setTimeout(300); + // Server should have received PING frames. + ok(serverSession.stats.pingRecv > 0n, + 'Server should receive keep-alive PINGs'); + serverSession.close(); + serverDone.resolve(); + }), { + transportParams: { maxIdleTimeout: 10 }, + }); + + const clientSession = await connect(serverEndpoint.address, { + keepAlive: 100, // Send PING every 100ms. + transportParams: { maxIdleTimeout: 10 }, + }); + + await Promise.all([clientSession.opened, serverDone.promise, clientSession.closed]); + await serverEndpoint.close(); +} + +// Without keepAlive (default), no additional PINGs after handshake. +{ + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.opened; + // Record PINGs from handshake. + const handshakePings = serverSession.stats.pingRecv; + await setTimeout(200); + // No additional PINGs should arrive without keepAlive. + strictEqual(serverSession.stats.pingRecv, handshakePings); + serverSession.close(); + serverDone.resolve(); + })); + + const clientSession = await connect(serverEndpoint.address); + await clientSession.opened; + + await Promise.all([serverDone.promise, clientSession.closed]); + await serverEndpoint.close(); +} diff --git a/test/parallel/test-quic-key-update-peer.mjs b/test/parallel/test-quic-key-update-peer.mjs new file mode 100644 index 00000000000000..1474d15487865f --- /dev/null +++ b/test/parallel/test-quic-key-update-peer.mjs @@ -0,0 +1,50 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: peer-initiated key update handled transparently. +// The server initiates a key update. Data continues flowing on +// the client side without interruption. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const encoder = new TextEncoder(); +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.opened; + + // Server initiates key update. + serverSession.updateKey(); + + serverSession.onstream = mustCall(async (stream) => { + const data = await bytes(stream); + // Data should arrive correctly despite key update. + strictEqual(Buffer.from(data).toString(), 'after key update'); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// Send data after the server's key update — should work transparently. +const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode('after key update'), +}); +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars +await Promise.all([stream.closed, serverDone.promise]); + +await clientSession.closed; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-key-update.mjs b/test/parallel/test-quic-key-update.mjs new file mode 100644 index 00000000000000..1cdc667c5e0531 --- /dev/null +++ b/test/parallel/test-quic-key-update.mjs @@ -0,0 +1,50 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: session.updateKey() initiates key update, data continues +// flowing. +// After calling updateKey(), the session transitions to new encryption +// keys. Existing and new streams should continue to work normally. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const dataLength = 1024; +const data = new Uint8Array(dataLength); +for (let i = 0; i < dataLength; i++) data[i] = i & 0xff; + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + strictEqual(received.byteLength, dataLength); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// Initiate key update before sending data. +clientSession.updateKey(); + +// Open a stream and send data — should work with new keys. +const stream = await clientSession.createBidirectionalStream(); +stream.setBody(data); + +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars +await Promise.all([stream.closed, serverDone.promise]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-max-payload-size.mjs b/test/parallel/test-quic-max-payload-size.mjs new file mode 100644 index 00000000000000..c71a93206d03cd --- /dev/null +++ b/test/parallel/test-quic-max-payload-size.mjs @@ -0,0 +1,58 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: maxPayloadSize causes smaller packets. +// With a smaller maxPayloadSize, packets should be smaller. +// We verify by checking that more packets are needed to transfer +// the same amount of data compared to the default. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const dataLength = 4096; + +// Transfer with default maxPayloadSize (1200). +async function transferAndGetPacketCount(maxPayloadSize) { + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + strictEqual(received.byteLength, dataLength); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); + }), maxPayloadSize ? { maxPayloadSize } : {}); + + const clientSession = await connect(serverEndpoint.address, + maxPayloadSize ? { maxPayloadSize } : {}); + await clientSession.opened; + + const stream = await clientSession.createBidirectionalStream(); + stream.setBody(new Uint8Array(dataLength)); + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + await Promise.all([stream.closed, serverDone.promise]); + + const pktSent = clientSession.stats.pktSent; + await clientSession.closed; + await serverEndpoint.close(); + return pktSent; +} + +const defaultPkts = await transferAndGetPacketCount(); +const smallPkts = await transferAndGetPacketCount(1200); + +// With the same or default payload size, packet counts should be similar. +// The key assertion: the option is accepted and data transfers correctly. +ok(defaultPkts > 0n); +ok(smallPkts > 0n); diff --git a/test/parallel/test-quic-max-window.mjs b/test/parallel/test-quic-max-window.mjs new file mode 100644 index 00000000000000..51544d40142d22 --- /dev/null +++ b/test/parallel/test-quic-max-window.mjs @@ -0,0 +1,77 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: maxStreamWindow and maxWindow limits. +// maxStreamWindow limits per-stream receive window. +// maxWindow limits session-level receive window. +// With smaller windows, the transfer should still complete but may +// require more flow control updates. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const dataLength = 8192; + +// maxStreamWindow limits per-stream window. +{ + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + strictEqual(received.byteLength, dataLength); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); + }), { + // Small per-stream receive window. + maxStreamWindow: 1024, + }); + + const clientSession = await connect(serverEndpoint.address); + await clientSession.opened; + + const stream = await clientSession.createBidirectionalStream(); + stream.setBody(new Uint8Array(dataLength)); + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + await Promise.all([stream.closed, serverDone.promise, clientSession.closed]); + await serverEndpoint.close(); +} + +// maxWindow limits session-level window. +{ + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + strictEqual(received.byteLength, dataLength); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); + }), { + // Small session-level receive window. + maxWindow: 2048, + }); + + const clientSession = await connect(serverEndpoint.address); + await clientSession.opened; + + const stream = await clientSession.createBidirectionalStream(); + stream.setBody(new Uint8Array(dataLength)); + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + await Promise.all([stream.closed, serverDone.promise, clientSession.closed]); + await serverEndpoint.close(); +} diff --git a/test/parallel/test-quic-module-exports.mjs b/test/parallel/test-quic-module-exports.mjs new file mode 100644 index 00000000000000..73f69d6bcf8711 --- /dev/null +++ b/test/parallel/test-quic-module-exports.mjs @@ -0,0 +1,61 @@ +// Flags: --experimental-quic --no-warnings + +// Test: module exports completeness (CONST-06, CONST-07, CONST-08, +// CONST-09). +// Module exports are sealed. +// Stats classes exist on constructors. +// session ticket getter works after handshake. +// session token getter works after NEW_TOKEN. + +import { hasQuic, skip } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok, throws } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const quic = await import('node:quic'); +const { listen, connect } = await import('../common/quic.mjs'); + +// Module exports are frozen/sealed. +throws(() => { quic.newProperty = true; }, TypeError); + +// Stats classes exist. +ok(quic.QuicEndpoint); + +// CONST-08/09: Session ticket and token getters. +{ + let savedTicket; + let savedToken; + const gotTicket = Promise.withResolvers(); + const gotToken = Promise.withResolvers(); + + const serverEndpoint = await listen(async (serverSession) => { + await serverSession.closed; + }); + + const clientSession = await connect(serverEndpoint.address, { + onsessionticket(ticket) { + savedTicket = ticket; + gotTicket.resolve(); + }, + onnewtoken(token) { + savedToken = token; + gotToken.resolve(); + }, + }); + await Promise.all([clientSession.opened, gotTicket.promise, gotToken.promise]); + + // Session ticket is a Buffer. + ok(Buffer.isBuffer(savedTicket)); + ok(savedTicket.length > 0); + + // Token is a Buffer. + ok(Buffer.isBuffer(savedToken)); + ok(savedToken.length > 0); + + await clientSession.close(); + await serverEndpoint.close(); +} diff --git a/test/parallel/test-quic-new-token.mjs b/test/parallel/test-quic-new-token.mjs new file mode 100644 index 00000000000000..6351b154b39d00 --- /dev/null +++ b/test/parallel/test-quic-new-token.mjs @@ -0,0 +1,55 @@ +// Flags: --experimental-quic --no-warnings + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { ok, rejects } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); + +// The token option must be an ArrayBufferView if provided +await rejects(connect({ port: 1234 }, { + alpn: 'quic-test', + token: 'not-a-buffer', +}), { + code: 'ERR_INVALID_ARG_TYPE', +}); + +// After a successful handshake, the server automatically sends a +// NEW_TOKEN frame. The client should receive it via the onnewtoken +// callback set at connection time. + +const clientToken = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.opened.then(mustCall()); +}), { + sni: { '*': { keys: [key], certs: [cert] } }, + alpn: ['quic-test'], +}); + +const clientSession = await connect(serverEndpoint.address, { + alpn: 'quic-test', + servername: 'localhost', + // Set onnewtoken at connection time to avoid missing the event. + onnewtoken: mustCall(function(token, address) { + ok(Buffer.isBuffer(token), 'token should be a Buffer'); + ok(token.length > 0, 'token should not be empty'); + ok(address !== undefined, 'address should be defined'); + clientToken.resolve(); + }), +}); + +await Promise.all([clientSession.opened, clientToken.promise]); + +clientSession.close(); diff --git a/test/parallel/test-quic-perf-hooks.mjs b/test/parallel/test-quic-perf-hooks.mjs new file mode 100644 index 00000000000000..48352d8eedb9ad --- /dev/null +++ b/test/parallel/test-quic-perf-hooks.mjs @@ -0,0 +1,98 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: PerformanceObserver integration for QUIC. +// QuicEndpoint, QuicSession, and QuicStream emit PerformanceEntry +// objects with entryType 'quic' when a PerformanceObserver is active. + +import { hasQuic, skip, mustCall, mustCallAtLeast } from '../common/index.mjs'; +import assert from 'node:assert'; +import { PerformanceObserver } from 'node:perf_hooks'; + +const { ok, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const encoder = new TextEncoder(); +const entries = []; + +const observerDone = Promise.withResolvers(); + +// Collect all quic perf entries. +const obs = new PerformanceObserver(mustCallAtLeast((list) => { + for (const entry of list.getEntries()) { + entries.push(entry); + } + // We expect at least: 1 endpoint + 2 sessions + 2 streams = 5 entries. + // The observer may be called multiple times as entries arrive in batches. + // Resolve once we have enough entries. + if (entries.length >= 5) { + observerDone.resolve(); + } +})); +obs.observe({ entryTypes: ['quic'] }); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + await bytes(stream); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode('perf test'), +}); + +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars +await Promise.all([stream.closed, serverDone.promise, clientSession.closed]); +await serverEndpoint.close(); + +// Wait for the observer to collect all entries. +await observerDone.promise; +obs.disconnect(); + +// Verify we got all expected entry types. +const endpointEntries = entries.filter((e) => e.name === 'QuicEndpoint'); +const sessionEntries = entries.filter((e) => e.name === 'QuicSession'); +const streamEntries = entries.filter((e) => e.name === 'QuicStream'); + +ok(endpointEntries.length >= 1, `Expected QuicEndpoint entries, got ${endpointEntries.length}`); +ok(sessionEntries.length >= 2, `Expected >= 2 QuicSession entries, got ${sessionEntries.length}`); +ok(streamEntries.length >= 2, `Expected >= 2 QuicStream entries, got ${streamEntries.length}`); + +// Verify common fields on all entries. +for (const entry of entries) { + strictEqual(entry.entryType, 'quic'); + strictEqual(typeof entry.startTime, 'number'); + ok(entry.duration >= 0, `duration should be >= 0, got ${entry.duration}`); + ok(entry.detail, 'entry should have detail'); + ok(entry.detail.stats, 'entry.detail should have stats'); +} + +// Verify session-specific detail fields. +for (const entry of sessionEntries) { + // The handshake may be undefined if destroyed before handshake completes, + // but in this test both sessions complete handshakes. + ok(entry.detail.handshake, 'session entry should have handshake info'); + strictEqual(typeof entry.detail.handshake.protocol, 'string'); + strictEqual(typeof entry.detail.handshake.earlyDataAttempted, 'boolean'); + strictEqual(typeof entry.detail.handshake.earlyDataAccepted, 'boolean'); +} + +// Verify stream-specific detail fields. +for (const entry of streamEntries) { + ok(entry.detail.direction === 'bidi' || entry.detail.direction === 'uni', + `stream direction should be bidi or uni, got ${entry.detail.direction}`); +} diff --git a/test/parallel/test-quic-preferred-address-ignore.mjs b/test/parallel/test-quic-preferred-address-ignore.mjs new file mode 100644 index 00000000000000..f8067e660b5a78 --- /dev/null +++ b/test/parallel/test-quic-preferred-address-ignore.mjs @@ -0,0 +1,60 @@ +// Flags: --experimental-quic --no-warnings + +// Test: preferred address ignored by client. +// Server advertises a preferred address, but the client is configured +// with preferredAddressPolicy: 'ignore'. No path validation should +// occur and all data stays on the original path. + +import { hasQuic, skip, mustCall, mustNotCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual, ok } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const allStatusDone = Promise.withResolvers(); +const serverGot = Promise.withResolvers(); +let statusCount = 0; + +const preferredEndpoint = await listen(mustNotCall()); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await allStatusDone.promise; + await serverGot.promise; + await serverSession.close(); +}), { + transportParams: { + preferredAddressIpv4: preferredEndpoint.address, + }, + ondatagram: mustCall(() => { + serverGot.resolve(); + }, 2), +}); + +const clientSession = await connect(serverEndpoint.address, { + reuseEndpoint: false, + preferredAddressPolicy: 'ignore', + transportParams: { maxDatagramFrameSize: 1200 }, + // Path validation should NOT fire when ignoring preferred address. + onpathvalidation: mustNotCall(), + ondatagramstatus: mustCall((id, status) => { + if (++statusCount >= 2) allStatusDone.resolve(); + }, 2), +}); +await clientSession.opened; + +await clientSession.sendDatagram(new Uint8Array([1])); +await clientSession.sendDatagram(new Uint8Array([2])); + +await Promise.all([serverGot.promise, allStatusDone.promise]); + +strictEqual(clientSession.stats.datagramsSent, 2n); +ok(clientSession.stats.datagramsAcknowledged >= 1n); + +await clientSession.closed; +await serverEndpoint.close(); +await preferredEndpoint.close(); diff --git a/test/parallel/test-quic-qlog.mjs b/test/parallel/test-quic-qlog.mjs new file mode 100644 index 00000000000000..6bb7666d53e360 --- /dev/null +++ b/test/parallel/test-quic-qlog.mjs @@ -0,0 +1,94 @@ +// Flags: --experimental-quic --no-warnings + +// Test: qlog callback. +// When qlog: true, qlog data is delivered to the session.onqlog +// callback during the connection lifecycle. The final chunk is +// emitted synchronously during ngtcp2_conn destruction with +// fin=true. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import { setImmediate } from 'node:timers/promises'; + +const { ok, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const clientChunks = []; +const serverChunks = []; +let clientFinReceived = false; +let serverFinReceived = false; + +function assertQlogOutput(chunks, finReceived, side) { + ok(chunks.length > 0, `Expected ${side} qlog chunks, got ${chunks.length}`); + ok(finReceived, `Expected ${side} to receive fin`); + + for (const { data, fin } of chunks) { + strictEqual(typeof data, 'string', + `Each ${side} qlog chunk should be a string`); + strictEqual(typeof fin, 'boolean', + `Each ${side} fin flag should be a boolean`); + } + + // Only the last chunk should have fin=true. + for (let i = 0; i < chunks.length - 1; i++) { + strictEqual(chunks[i].fin, false, + `${side} chunk ${i} should not be fin`); + } + strictEqual(chunks[chunks.length - 1].fin, true, + `${side} last chunk should be fin`); + + // ngtcp2 emits qlog in JSON-SEQ format (RFC 7464): each record is + // prefixed with 0x1e (Record Separator) and terminated by a newline. + // Parse the individual records and verify the header has expected fields. + const joined = chunks.map((c) => c.data).join(''); + const records = joined.split('\x1e').filter((s) => s.trim().length > 0); + ok(records.length > 0, `${side} qlog should have at least one record`); + + // The first record is the qlog header with format metadata. + const header = JSON.parse(records[0]); + + ok(header.qlog_version !== undefined || header.qlog_format !== undefined, + `${side} qlog header should have qlog_version or qlog_format field`); + + for (let i = 1; i < records.length; i++) { + const record = JSON.parse(records[i]); + ok('name' in record); + ok('data' in record); + ok('time' in record); + } +} + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.opened; + serverSession.close(); +}), { + qlog: true, + onqlog(data, fin) { + serverChunks.push({ data, fin }); + if (fin) serverFinReceived = true; + }, +}); + +const clientSession = await connect(serverEndpoint.address, { + qlog: true, + onqlog(data, fin) { + clientChunks.push({ data, fin }); + if (fin) clientFinReceived = true; + }, +}); + +await Promise.all([clientSession.opened, clientSession.closed]); +await serverEndpoint.close(); + +// The final qlog chunk (fin=true) is delivered via SetImmediate because +// it is emitted during ngtcp2_conn destruction when MakeCallback is +// unsafe. Yield to let the deferred callback run before asserting. +await setImmediate(); + +assertQlogOutput(clientChunks, clientFinReceived, 'client'); +assertQlogOutput(serverChunks, serverFinReceived, 'server'); diff --git a/test/parallel/test-quic-reject-unauthorized.mjs b/test/parallel/test-quic-reject-unauthorized.mjs new file mode 100644 index 00000000000000..e9900fbf31d990 --- /dev/null +++ b/test/parallel/test-quic-reject-unauthorized.mjs @@ -0,0 +1,54 @@ +// Flags: --experimental-quic --no-warnings + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; +const { readKey } = fixtures; + +const { strictEqual, ok, rejects } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); + +// rejectUnauthorized must be a boolean +await rejects(connect({ port: 1234 }, { + alpn: 'quic-test', + rejectUnauthorized: 'yes', +}), { + code: 'ERR_INVALID_ARG_TYPE', +}); + +// With rejectUnauthorized: true (the default), connecting with self-signed +// certs and no CA should produce a validation error in the handshake info. + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.opened; + serverSession.close(); + await serverSession.closed; +}), { + sni: { '*': { keys: [key], certs: [cert] } }, + alpn: ['quic-test'], +}); + +const clientSession = await connect(serverEndpoint.address, { + alpn: 'quic-test', + servername: 'localhost', + // Default: rejectUnauthorized: true +}); + +const info = await clientSession.opened; +// Self-signed cert without CA should produce a validation error. +strictEqual(typeof info.validationErrorReason, 'string'); +ok(info.validationErrorReason.length > 0); +strictEqual(typeof info.validationErrorCode, 'string'); +ok(info.validationErrorCode.length > 0); + +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-session-close-error-code.mjs b/test/parallel/test-quic-session-close-error-code.mjs new file mode 100644 index 00000000000000..e907cd672c19d4 --- /dev/null +++ b/test/parallel/test-quic-session-close-error-code.mjs @@ -0,0 +1,159 @@ +// Flags: --experimental-quic --no-warnings + +// Test: session close/destroy with application and transport error codes +// . +// Application error propagated as ERR_QUIC_APPLICATION_ERROR. +// Session close with specific app error code — peer receives it. +// Verifies that close() and destroy() with { code, type, reason } options +// send the correct CONNECTION_CLOSE frame, and the peer receives the +// correct error type, code, and reason. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import { setTimeout } from 'node:timers/promises'; + +const { strictEqual, rejects } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +// --- Test 1: close() with application error code --- +// The client closes with an application error. The server receives +// ERR_QUIC_APPLICATION_ERROR with the exact code and reason. +{ + const serverGot = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (serverSession) => { + serverSession.onerror = mustCall((err) => { + strictEqual(err.code, 'ERR_QUIC_APPLICATION_ERROR'); + strictEqual(err.message.includes('42n'), true, + 'error message should contain the code'); + strictEqual(err.message.includes('client shutdown'), true, + 'error message should contain the reason'); + }); + await rejects(serverSession.closed, { + code: 'ERR_QUIC_APPLICATION_ERROR', + }); + serverGot.resolve(); + })); + + const clientSession = await connect(serverEndpoint.address, { + reuseEndpoint: false, + }); + await clientSession.opened; + + // Small delay to ensure handshake is fully confirmed so ngtcp2 + // generates the 1-RTT APPLICATION CONNECTION_CLOSE frame. + await setTimeout(100); + + // close() with application error — the client's closed promise + // resolves because the close was locally initiated (intentional). + // The peer receives the error code, but the local side is not in error. + await clientSession.close({ + code: 42n, + type: 'application', + reason: 'client shutdown', + }); + + await serverGot.promise; + await serverEndpoint.close(); +} + +// --- Test 2: close() with transport error code --- +// The client closes with a transport error. The server receives +// ERR_QUIC_TRANSPORT_ERROR with the exact code. +{ + const serverGot = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (serverSession) => { + serverSession.onerror = mustCall((err) => { + strictEqual(err.code, 'ERR_QUIC_TRANSPORT_ERROR'); + strictEqual(err.message.includes('1n'), true, + 'error message should contain the code'); + }); + await rejects(serverSession.closed, { + code: 'ERR_QUIC_TRANSPORT_ERROR', + }); + serverGot.resolve(); + })); + + const clientSession = await connect(serverEndpoint.address, { + reuseEndpoint: false, + }); + await clientSession.opened; + await setTimeout(100); + + // close() with transport error — resolves locally (intentional). + await clientSession.close({ code: 1n }); + + await serverGot.promise; + await serverEndpoint.close(); +} + +// --- Test 3: destroy() with application error code --- +// The client destroys with both a JS error and a QUIC error code. +// The peer receives the QUIC application error. +{ + const serverGot = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (serverSession) => { + serverSession.onerror = mustCall((err) => { + strictEqual(err.code, 'ERR_QUIC_APPLICATION_ERROR'); + strictEqual(err.message.includes('99n'), true); + }); + await rejects(serverSession.closed, { + code: 'ERR_QUIC_APPLICATION_ERROR', + }); + serverGot.resolve(); + })); + + const clientSession = await connect(serverEndpoint.address, { + reuseEndpoint: false, + onerror: mustCall((err) => { + // The JS error passed to destroy is delivered via onerror. + strictEqual(err.message, 'fatal error'); + }), + }); + await clientSession.opened; + await setTimeout(100); + + const jsError = new Error('fatal error'); + clientSession.destroy(jsError, { + code: 99n, + type: 'application', + reason: 'destroy with code', + }); + + // The closed promise rejects with the JS error, not the QUIC error. + await rejects(clientSession.closed, jsError); + + await serverGot.promise; + await serverEndpoint.close(); +} + +// --- Test 4: close() with no options (default behavior) --- +// Verify the default close sends NO_ERROR and the peer closes cleanly. +{ + const serverGot = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (serverSession) => { + // No onerror — clean close should not trigger errors. + await serverSession.closed; + serverGot.resolve(); + })); + + const clientSession = await connect(serverEndpoint.address, { + reuseEndpoint: false, + }); + await clientSession.opened; + await setTimeout(100); + + // Default close — no error code, clean shutdown. + await clientSession.close(); + + await serverGot.promise; + await serverEndpoint.close(); +} diff --git a/test/parallel/test-quic-session-close-graceful.mjs b/test/parallel/test-quic-session-close-graceful.mjs new file mode 100644 index 00000000000000..fef5384696960e --- /dev/null +++ b/test/parallel/test-quic-session-close-graceful.mjs @@ -0,0 +1,90 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: graceful session close with open streams. +// session.close() with open streams waits for streams to close +// before the session's closed promise resolves. +// After close() is called, no new streams can be created. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { rejects, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const encoder = new TextEncoder(); + +// ------------------------------------------------------------------- +// close() waits for open streams to finish. +// ------------------------------------------------------------------- +{ + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + strictEqual(received.byteLength, 5); + stream.writer.endSync(); + await stream.closed; + serverDone.resolve(); + }); + })); + + const clientSession = await connect(serverEndpoint.address); + await clientSession.opened; + + // Open a stream and send data. + const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode('hello'), + }); + + // Call close() while the stream is still open. The closed promise + // should NOT resolve until the stream finishes. + let closedResolved = false; + const closePromise = clientSession.close(); + closePromise.then(mustCall(() => { closedResolved = true; })); + + // Wait for the stream to complete normally. + await serverDone.promise; + for await (const batch of stream) { /* drain server FIN */ } // eslint-disable-line no-unused-vars + await stream.closed; + + // Now the closed promise should resolve. + await closePromise; + strictEqual(closedResolved, true); + strictEqual(clientSession.destroyed, true); + + await serverEndpoint.close(); +} + +// ------------------------------------------------------------------- +// No new streams after close() is called. +// ------------------------------------------------------------------- +{ + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; + })); + + const clientSession = await connect(serverEndpoint.address); + await clientSession.opened; + + clientSession.close(); + + // Attempting to create a stream after close() should reject. + await rejects( + clientSession.createBidirectionalStream({ + body: encoder.encode('too late'), + }), + { + code: 'ERR_INVALID_STATE', + }, + ); + + await clientSession.closed; + await serverEndpoint.close(); +} diff --git a/test/parallel/test-quic-session-close-sends-frame.mjs b/test/parallel/test-quic-session-close-sends-frame.mjs new file mode 100644 index 00000000000000..3d398726585b0b --- /dev/null +++ b/test/parallel/test-quic-session-close-sends-frame.mjs @@ -0,0 +1,44 @@ +// Flags: --experimental-quic --no-warnings + +// Test: active session sends CONNECTION_CLOSE when closing. +// When the server calls session.close() on an active session, the peer +// receives a CONNECTION_CLOSE frame with NO_ERROR. The client's closed +// promise resolves (clean close), rather than rejecting with an idle +// timeout or transport error. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const serverReady = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.opened; + // Signal to the client that the server is ready, then close. + serverReady.resolve(); + await serverSession.close(); +})); + +const clientSession = await connect(serverEndpoint.address, { + reuseEndpoint: false, +}); + +await Promise.all([clientSession.opened, serverReady.promise]); + +// The client receives CONNECTION_CLOSE with NO_ERROR. +// The closed promise should resolve (not reject). If the server +// failed to send CONNECTION_CLOSE (e.g., used silent close or +// stateless reset), the client would time out and closed would +// reject with ERR_QUIC_TRANSPORT_ERROR. +await clientSession.closed; + +// If we reach here, the session closed cleanly — CONNECTION_CLOSE +// was received, not an idle timeout. +assert.ok(clientSession.destroyed, 'session should be destroyed'); + +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-session-close.mjs b/test/parallel/test-quic-session-close.mjs new file mode 100644 index 00000000000000..5d63326f04c0e6 --- /dev/null +++ b/test/parallel/test-quic-session-close.mjs @@ -0,0 +1,77 @@ +// Flags: --experimental-quic --no-warnings + +// Test: session.close() lifecycle. +// session.close() with no open streams resolves the closed promise. +// Server-initiated close delivers CONNECTION_CLOSE to the client. +// Client-initiated close — server sees the session end. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +// ------------------------------------------------------------------- +// session.close() with no open streams resolves closed. +// ------------------------------------------------------------------- +{ + const serverEndpoint = await listen(mustCall(async (serverSession) => { + // Server just waits for the client to close. + await serverSession.closed; + })); + + const clientSession = await connect(serverEndpoint.address); + await clientSession.opened; + + // No streams opened. close() should resolve. + await clientSession.close(); + strictEqual(clientSession.destroyed, true); + await serverEndpoint.close(); +} + +// ------------------------------------------------------------------- +// Server-initiated close — client sees session end. +// ------------------------------------------------------------------- +{ + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.opened; + // Server initiates close. + serverSession.close(); + await serverSession.closed; + })); + + const clientSession = await connect(serverEndpoint.address); + await clientSession.opened; + + // Client's closed promise should resolve when the server closes. + await clientSession.closed; + strictEqual(clientSession.destroyed, true); + await serverEndpoint.close(); +} + +// ------------------------------------------------------------------- +// Client-initiated close — server sees session end. +// ------------------------------------------------------------------- +{ + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (serverSession) => { + // The server's closed promise should resolve when the client closes. + await serverSession.closed; + strictEqual(serverSession.destroyed, true); + serverDone.resolve(); + })); + + const clientSession = await connect(serverEndpoint.address); + await clientSession.opened; + + // Client initiates close. + await clientSession.close(); + await serverDone.promise; + await serverEndpoint.close(); +} diff --git a/test/parallel/test-quic-session-destroy-reentrant.mjs b/test/parallel/test-quic-session-destroy-reentrant.mjs new file mode 100644 index 00000000000000..15d3ca28cf4ac8 --- /dev/null +++ b/test/parallel/test-quic-session-destroy-reentrant.mjs @@ -0,0 +1,188 @@ +// Flags: --experimental-quic --no-warnings + +// Test: QuicSession.destroy and QuicStream.destroy are safely re-entrant. +// +// Calling destroy() from within an onerror callback (or from a stream +// onerror that fires during the session destroy cascade) used to run +// cleanup twice because the `if (this.destroyed)` guard checked `#handle`, +// which was only cleared at the END of destroy() — well after user-visible +// callbacks ran. +// +// The fix introduces a `#destroying` boolean flag that flips +// synchronously at the top of `destroy()`, so a re-entrant call hits +// the guard and returns immediately. The `#handle === undefined` +// invariant remains the "fully torn down" signal used by `kFinishClose` +// and only flips once teardown completes - so `session.destroyed` / +// `stream.destroyed` is still false from inside `onerror` (which runs +// during teardown), and only becomes true once `destroy()` returns. +// +// Cases covered: +// 1. session.onerror calls session.destroy() recursively. Verify the +// session is not torn down twice (no double publish on the +// diagnostics_channel, closed promise settles exactly once). +// 2. session.destroy(err) cascades to stream.destroy; the stream's +// onerror calls session.destroy() again. Verify safe. +// 3. stream.onerror calls stream.destroy() recursively. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import diagnostics_channel from 'node:diagnostics_channel'; +import { setImmediate } from 'node:timers/promises'; + +const { strictEqual, rejects } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +// Short idle timeout so the server cleans up quickly after we destroy +// the client without sending CONNECTION_CLOSE. +const transportParams = { maxIdleTimeout: 1 }; + +// ------------------------------------------------------------------- +// 1. session.onerror calls session.destroy() recursively. +// ------------------------------------------------------------------- +{ + const serverDone = Promise.withResolvers(); + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; + serverDone.resolve(); + }), { transportParams }); + + const clientSession = await connect(serverEndpoint.address, { + transportParams, + }); + await clientSession.opened; + + // Count diagnostics_channel publishes. Even though `destroy()` is + // called twice (once explicitly and once recursively from inside the + // `onerror` handler), the `#destroying` guard makes the second call + // a true no-op so each channel publishes exactly once. + const errSub = mustCall((msg) => { + strictEqual(msg.session, clientSession); + }); + const closedSub = mustCall((msg) => { + strictEqual(msg.session, clientSession); + }); + diagnostics_channel.subscribe('quic.session.error', errSub); + diagnostics_channel.subscribe('quic.session.closed', closedSub); + + const testError = new Error('reentrant destroy test'); + + clientSession.onerror = mustCall((err) => { + strictEqual(err, testError); + // Re-enter destroy synchronously from the error handler. This must + // be a no-op because `#destroying` is already set; `destroyed` is + // still false here because `#handle` is cleared at the end of + // `destroy()`. The fact that the closed promise still rejects with + // `testError` (asserted below) - and not `'should be ignored'` - + // proves the recursive call did not run a second teardown. + clientSession.destroy(new Error('should be ignored')); + }); + + clientSession.destroy(testError); + // Once `destroy()` has returned, `destroyed` flips to true. + strictEqual(clientSession.destroyed, true); + + await rejects(clientSession.closed, testError); + + // Give the diagnostics_channel a tick to deliver any deferred messages. + await setImmediate(); + + diagnostics_channel.unsubscribe('quic.session.error', errSub); + diagnostics_channel.unsubscribe('quic.session.closed', closedSub); + + await serverDone.promise; + await serverEndpoint.close(); +} + +// ------------------------------------------------------------------- +// 2. session.destroy(err) -> stream onerror -> session.destroy() again. +// The stream's onerror is invoked during the session's destroy +// cascade; if that handler calls session.destroy() again, the second +// destroy must be a no-op. +// ------------------------------------------------------------------- +{ + const serverDone = Promise.withResolvers(); + const serverEndpoint = await listen(mustCall(async (serverSession) => { + // Server-side onstream callbacks are not always invoked here because + // the client may destroy before the server processes the stream open. + // We don't make assertions about server stream activity in this case; + // the test is purely about client-side re-entrancy. + await serverSession.closed; + serverDone.resolve(); + }), { transportParams }); + + const clientSession = await connect(serverEndpoint.address, { + transportParams, + }); + await clientSession.opened; + + const stream = await clientSession.createBidirectionalStream(); + + const testError = new Error('cascade reentrant destroy test'); + + stream.onerror = mustCall((err) => { + strictEqual(err, testError); + // Re-enter session.destroy from inside the stream's onerror. This + // is happening DURING the session's stream cascade, so the session + // is mid-destroy. The second destroy() call must be a no-op. + clientSession.destroy(new Error('should be ignored')); + }); + + clientSession.onerror = mustCall((err) => { + strictEqual(err, testError); + }); + + clientSession.destroy(testError); + strictEqual(clientSession.destroyed, true); + strictEqual(stream.destroyed, true); + + await rejects(clientSession.closed, testError); + await rejects(stream.closed, testError); + + await serverDone.promise; + await serverEndpoint.close(); +} + +// ------------------------------------------------------------------- +// 3. stream.onerror calls stream.destroy() recursively. +// ------------------------------------------------------------------- +{ + const serverDone = Promise.withResolvers(); + const serverEndpoint = await listen(mustCall(async (serverSession) => { + try { await serverSession.closed; } catch { /* server cascade-close */ } + serverDone.resolve(); + }), { transportParams }); + + const clientSession = await connect(serverEndpoint.address, { + transportParams, + }); + await clientSession.opened; + + const stream = await clientSession.createBidirectionalStream(); + + const testError = new Error('stream reentrant destroy test'); + + stream.onerror = mustCall((err) => { + strictEqual(err, testError); + // Re-enter stream.destroy from inside its own onerror. The + // `#destroying` flag traps the recursive call; `destroyed` (i.e. + // `#handle === undefined`) is still false here because the handle + // is cleared inside `[kFinishClose]` later in this method. + stream.destroy(new Error('should be ignored')); + }); + + stream.destroy(testError); + // Once `destroy()` has returned, `destroyed` flips to true. + strictEqual(stream.destroyed, true); + + await rejects(stream.closed, testError); + + clientSession.close(); + await clientSession.closed; + await serverDone.promise; + await serverEndpoint.close(); +} diff --git a/test/parallel/test-quic-session-destroy-validate-options.mjs b/test/parallel/test-quic-session-destroy-validate-options.mjs new file mode 100644 index 00000000000000..d3812a7b341f16 --- /dev/null +++ b/test/parallel/test-quic-session-destroy-validate-options.mjs @@ -0,0 +1,133 @@ +// Flags: --experimental-quic --no-warnings + +// Test: QuicSession.destroy(error, options) validates `options` up front, +// before any side effects. A malformed `options` argument must throw +// without: +// * publishing on the `quic.session.error` diagnostics channel, +// * invoking the user's `onerror` callback, +// * cascading destroy to open streams, +// * clearing the session's private state, +// * destroying the underlying C++ handle. +// +// After such a throw the session is still alive and a subsequent +// destroy() with valid options must succeed: the client emits a +// CONNECTION_CLOSE frame with the supplied transport error code, and +// the local `closed` promise rejects with the original error. + +import { hasQuic, skip, mustCall, mustNotCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import diagnostics_channel from 'node:diagnostics_channel'; + +const { strictEqual, rejects, throws } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +// `maxIdleTimeout` is measured in seconds. Set short so any regression +// that prevents CONNECTION_CLOSE from being sent fails promptly via +// idle close instead of hanging the test. +const transportParams = { maxIdleTimeout: 1 }; + +// Capture the server-side session in the listen callback. Do not +// `await serverSession.closed` from inside the callback: the final +// destroy in this test sends a transport-error CONNECTION_CLOSE which +// makes that promise reject, and an unhandled rejection inside the +// listen callback would be routed by `safeCallbackInvoke` to +// `endpoint.destroy(err)` and surface as a process-level +// unhandled-rejection crash before the test body has had a chance +// to attach its own rejection handler. +const serverSessionReady = Promise.withResolvers(); +let serverSession; +const serverEndpoint = await listen(mustCall((session) => { + serverSession = session; + serverSessionReady.resolve(); +}), { transportParams }); + +const clientSession = await connect(serverEndpoint.address, { + transportParams, +}); +await clientSession.opened; +await serverSessionReady.promise; + +// Open a stream so the destroy cascade has work to do; if the +// validation hoist regresses and side effects run before the throw, +// this stream will be destroyed by the failed destroy() and the +// `mustNotCall` handler will fire. +const stream = await clientSession.createBidirectionalStream(); +stream.onerror = mustNotCall( + 'stream.onerror must not fire when destroy() throws on bad options'); + +// Subscribe to diagnostics channels so we can assert nothing is +// published before the validation throw. +const errSub = mustNotCall( + 'quic.session.error must not publish when destroy() throws on bad options'); +diagnostics_channel.subscribe('quic.session.error', errSub); + +clientSession.onerror = mustNotCall( + 'session.onerror must not fire when destroy() throws on bad options'); + +const goodError = new Error('intended teardown'); + +// 1. options is not an object -> throws ERR_INVALID_ARG_TYPE. +throws(() => clientSession.destroy(goodError, 'not an object'), { + code: 'ERR_INVALID_ARG_TYPE', +}); +strictEqual(clientSession.destroyed, false); +strictEqual(stream.destroyed, false); + +// 2. options.code is the wrong type -> throws ERR_INVALID_ARG_TYPE. +throws(() => clientSession.destroy(goodError, { code: 'oops' }), { + code: 'ERR_INVALID_ARG_TYPE', +}); +strictEqual(clientSession.destroyed, false); +strictEqual(stream.destroyed, false); + +// 3. options.type is not in the allowed set -> throws ERR_INVALID_ARG_VALUE. +throws(() => clientSession.destroy(goodError, { type: 'bogus' }), { + code: 'ERR_INVALID_ARG_VALUE', +}); +strictEqual(clientSession.destroyed, false); +strictEqual(stream.destroyed, false); + +// 4. options.reason is the wrong type -> throws ERR_INVALID_ARG_TYPE. +throws(() => clientSession.destroy(goodError, { reason: 42 }), { + code: 'ERR_INVALID_ARG_TYPE', +}); +strictEqual(clientSession.destroyed, false); +strictEqual(stream.destroyed, false); + +// Now switch the handlers to expect the real teardown so the final +// destroy with valid options can run cleanly. +diagnostics_channel.unsubscribe('quic.session.error', errSub); +clientSession.onerror = mustCall((err) => { strictEqual(err, goodError); }); +stream.onerror = mustCall((err) => { strictEqual(err, goodError); }); + +// Pre-attach rejection handlers on both sides BEFORE triggering the +// final destroy, so the rejections do not race ahead of any awaits in +// the test body. The client rejects with the original `goodError`; +// the server decodes the CONNECTION_CLOSE frame transport code into +// an `ERR_QUIC_TRANSPORT_ERROR`. +const clientClosedAssertion = rejects(clientSession.closed, goodError); +const serverClosedAssertion = rejects(serverSession.closed, mustCall((err) => { + strictEqual(err.code, 'ERR_QUIC_TRANSPORT_ERROR'); + return true; +})); + +// 5. Valid options after the failed attempts -> session destroys +// normally, the underlying handle sends CONNECTION_CLOSE with the +// supplied transport code, and the local closed promise rejects +// with the original error. +clientSession.destroy(goodError, { + code: 1n, + type: 'transport', + reason: 'after validation throw', +}); +strictEqual(clientSession.destroyed, true); +strictEqual(stream.destroyed, true); + +await clientClosedAssertion; +await serverClosedAssertion; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-session-destroy.mjs b/test/parallel/test-quic-session-destroy.mjs new file mode 100644 index 00000000000000..03468e429178c7 --- /dev/null +++ b/test/parallel/test-quic-session-destroy.mjs @@ -0,0 +1,103 @@ +// Flags: --experimental-quic --no-warnings + +// Test: session.destroy() forceful close. +// destroy() without error resolves the closed promise. +// destroy(error) rejects the closed promise with that error. +// destroy() works without a prior close() call. +// Note: destroy() is forceful and does not send CONNECTION_CLOSE. +// The server session remains alive until idle timeout unless we also +// destroy the server session explicitly. We use a short idle timeout +// to keep the tests fast, and destroy both sides in each section. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual, rejects } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +// Use a short idle timeout so the server session cleans up quickly +// after the client destroys without CONNECTION_CLOSE. +const transportParams = { maxIdleTimeout: 1 }; + +// ------------------------------------------------------------------- +// destroy() without error resolves the closed promise. +// ------------------------------------------------------------------- +{ + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; + serverDone.resolve(); + }), { transportParams }); + + const clientSession = await connect(serverEndpoint.address, { + transportParams, + }); + await clientSession.opened; + + clientSession.destroy(); + strictEqual(clientSession.destroyed, true); + + // Closed should resolve (no error). + await clientSession.closed; + + await serverDone.promise; + await serverEndpoint.close(); +} + +// ------------------------------------------------------------------- +// destroy(error) rejects closed with that error. +// ------------------------------------------------------------------- +{ + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; + serverDone.resolve(); + }), { transportParams }); + + const clientSession = await connect(serverEndpoint.address, { + transportParams, + }); + await clientSession.opened; + + const testError = new Error('intentional destroy error'); + clientSession.destroy(testError); + strictEqual(clientSession.destroyed, true); + + // Closed should reject with the same error. + await rejects(clientSession.closed, testError); + + await serverDone.promise; + await serverEndpoint.close(); +} + +// ------------------------------------------------------------------- +// destroy() works without prior close(). +// ------------------------------------------------------------------- +{ + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; + serverDone.resolve(); + }), { transportParams }); + + const clientSession = await connect(serverEndpoint.address, { + transportParams, + }); + await clientSession.opened; + + // Destroy directly without calling close() first. + clientSession.destroy(); + strictEqual(clientSession.destroyed, true); + await clientSession.closed; + + await serverDone.promise; + await serverEndpoint.close(); +} diff --git a/test/parallel/test-quic-session-idle-timeout.mjs b/test/parallel/test-quic-session-idle-timeout.mjs new file mode 100644 index 00000000000000..e55f9a0a16fda2 --- /dev/null +++ b/test/parallel/test-quic-session-idle-timeout.mjs @@ -0,0 +1,37 @@ +// Flags: --experimental-quic --no-warnings + +// Test: idle timeout closes the session. +// Both client and server are configured with a short maxIdleTimeout. +// After the handshake completes, neither side sends any data. The idle +// timeout fires and both sessions close without error. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const transportParams = { maxIdleTimeout: 1 }; // 1 second + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + // The server's closed promise should resolve when the idle timeout fires. + await serverSession.closed; + serverDone.resolve(); +}), { + transportParams, +}); + +const clientSession = await connect(serverEndpoint.address, { + transportParams, +}); + +await clientSession.opened; + +// Don't send anything. Just wait for the idle timeout to close the session. +await Promise.all([clientSession.closed, serverDone.promise]); + +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-session-opened-early-destroy.mjs b/test/parallel/test-quic-session-opened-early-destroy.mjs new file mode 100644 index 00000000000000..897f6653495884 --- /dev/null +++ b/test/parallel/test-quic-session-opened-early-destroy.mjs @@ -0,0 +1,146 @@ +// Flags: --experimental-quic --no-warnings + +// Test: session.opened rejects when the session is destroyed before the +// TLS handshake completes. +// +// Per doc/api/quic.md: "If the handshake fails or the session is destroyed +// before the handshake completes, the promise will be rejected." +// +// Cases covered: +// 1. session.destroy() (no error) before handshake -> opened rejects +// with ERR_INVALID_STATE. +// 2. session.destroy(error) before handshake -> opened rejects with +// that error. +// 3. endpoint.destroy() while a client handshake is in flight -> +// session.opened rejects (the endpoint cascades destroy to its +// sessions). +// 4. session.destroy() AFTER opened has already resolved -> opened +// stays resolved (no late rejection). + +import { hasQuic, skip, mustCall, mustNotCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { rejects, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { QuicEndpoint } = await import('node:quic'); + +// Use a short idle timeout so any leftover server-side state cleans up +// quickly when the client tears down before the handshake completes. +const transportParams = { maxIdleTimeout: 1 }; + +// ------------------------------------------------------------------- +// 1. session.destroy() (no error) before handshake -> opened rejects +// with ERR_INVALID_STATE. +// ------------------------------------------------------------------- +{ + const serverEndpoint = await listen(() => { + // The server may or may not see this session before the client + // destroys; we don't await it here. + }, { transportParams }); + + const clientSession = await connect(serverEndpoint.address, { + transportParams, + }); + + // Synchronously destroy the session before the handshake can finish. + // `connect()` returns the session as soon as the C++ handle is created; + // the handshake itself happens asynchronously over the network. + clientSession.destroy(); + + await rejects(clientSession.opened, { + code: 'ERR_INVALID_STATE', + message: /destroyed before it opened/, + }); + + await serverEndpoint.close(); +} + +// ------------------------------------------------------------------- +// 2. session.destroy(error) before handshake -> opened rejects with +// that error. Setting `onerror` registers the session-level error +// handler and marks both `opened` and `closed` as handled, so we +// only need to assert the rejection on `opened`. +// ------------------------------------------------------------------- +{ + const serverEndpoint = await listen(mustNotCall, { transportParams }); + + const clientSession = await connect(serverEndpoint.address, { + transportParams, + }); + + const testError = new Error('intentional early destroy'); + clientSession.onerror = mustCall((err) => { + assert.strictEqual(err, testError); + }); + clientSession.destroy(testError); + + await assert.rejects(clientSession.opened, testError); + + await serverEndpoint.close(); +} + +// ------------------------------------------------------------------- +// 3. endpoint.destroy() while a client handshake is in flight -> +// session.opened rejects. +// ------------------------------------------------------------------- +{ + const serverEndpoint = await listen(mustNotCall(), { transportParams }); + + // Use a dedicated client endpoint so destroying it does not affect + // the shared default endpoint used by other tests in this file. + const clientEndpoint = new QuicEndpoint(); + + const clientSession = await connect(serverEndpoint.address, { + transportParams, + endpoint: clientEndpoint, + }); + + // Synchronously destroy the endpoint while the handshake is still + // in flight. The endpoint should cascade destroy() to its in-flight + // session, which should reject session.opened. + clientEndpoint.destroy(); + + await rejects(clientSession.opened, { + code: 'ERR_INVALID_STATE', + message: /destroyed before it opened/, + }); + + await serverEndpoint.close(); +} + +// ------------------------------------------------------------------- +// 4. session.destroy() AFTER opened resolved -> opened stays resolved. +// Sanity check that the new "always reject pendingOpen" logic does +// not stomp on an already-resolved promise. +// ------------------------------------------------------------------- +{ + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; + serverDone.resolve(); + }), { transportParams }); + + const clientSession = await connect(serverEndpoint.address, { + transportParams, + }); + + const info = await clientSession.opened; + strictEqual(typeof info.protocol, 'string'); + + clientSession.destroy(); + + // Awaiting opened a second time should still resolve to the same + // info object (PromiseWithResolvers caches it; we just assert the + // promise is not rejected). + const infoAgain = await clientSession.opened; + strictEqual(infoAgain, info); + + await serverDone.promise; + await serverEndpoint.close(); +} diff --git a/test/parallel/test-quic-session-opened-info.mjs b/test/parallel/test-quic-session-opened-info.mjs new file mode 100644 index 00000000000000..e954f079452ab6 --- /dev/null +++ b/test/parallel/test-quic-session-opened-info.mjs @@ -0,0 +1,72 @@ +// Flags: --experimental-quic --no-warnings + +// Test: session.opened resolves with handshake info (INFO-05, INFO-06, +// INFO-07, INFO-08). +// local and remote SocketAddress objects are correct. +// servername matches the SNI sent by the client. +// protocol matches the negotiated ALPN. +// cipher and cipherVersion reflect the negotiated cipher suite. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { notStrictEqual, strictEqual, ok } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + const info = await serverSession.opened; + + // Server sees its own local address and the client's remote. + strictEqual(info.local.address, '127.0.0.1'); + strictEqual(info.local.family, 'ipv4'); + strictEqual(typeof info.local.port, 'number'); + strictEqual(info.remote.address, '127.0.0.1'); + strictEqual(info.remote.family, 'ipv4'); + strictEqual(typeof info.remote.port, 'number'); + + // Local and remote ports should differ. + notStrictEqual(info.local.port, info.remote.port); + + // Servername matches the SNI. + strictEqual(info.servername, 'localhost'); + + // Protocol matches ALPN. + strictEqual(info.protocol, 'quic-test'); + + // cipher info. + strictEqual(typeof info.cipher, 'string'); + ok(info.cipher.length > 0); + strictEqual(info.cipherVersion, 'TLSv1.3'); + + serverSession.close(); + serverDone.resolve(); +})); + +const clientSession = await connect(serverEndpoint.address); +const clientInfo = await clientSession.opened; + +// Client sees its own local address and the server's remote. +strictEqual(clientInfo.local.address, '127.0.0.1'); +strictEqual(clientInfo.remote.address, '127.0.0.1'); +notStrictEqual(clientInfo.local.port, clientInfo.remote.port); + +// servername matches. +strictEqual(clientInfo.servername, 'localhost'); + +// Protocol matches ALPN. +strictEqual(clientInfo.protocol, 'quic-test'); + +// cipher info. +strictEqual(typeof clientInfo.cipher, 'string'); +ok(clientInfo.cipher.length > 0); +strictEqual(clientInfo.cipherVersion, 'TLSv1.3'); + +await Promise.all([serverDone.promise, clientSession.closed]); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-session-opened-validation.mjs b/test/parallel/test-quic-session-opened-validation.mjs new file mode 100644 index 00000000000000..d9f3d758f6df04 --- /dev/null +++ b/test/parallel/test-quic-session-opened-validation.mjs @@ -0,0 +1,43 @@ +// Flags: --experimental-quic --no-warnings + +// Test: opened info includes cert validation error details. +// validationErrorReason populated on cert validation failure. +// validationErrorCode populated on cert validation failure. +// The test helper uses self-signed certs so validation always fails +// (unless rejectUnauthorized is explicitly set). + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual, ok } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + const serverInfo = await serverSession.opened; + + // Server also sees validation info about the peer. + strictEqual(typeof serverInfo.validationErrorReason, 'string'); + strictEqual(typeof serverInfo.validationErrorCode, 'string'); + + serverSession.close(); +})); + +const clientSession = await connect(serverEndpoint.address); +const clientInfo = await clientSession.opened; + +// validationErrorReason is a non-empty string describing +// why the cert failed validation (self-signed cert). +strictEqual(typeof clientInfo.validationErrorReason, 'string'); +ok(clientInfo.validationErrorReason.length > 0); + +// validationErrorCode is the OpenSSL error code string. +strictEqual(typeof clientInfo.validationErrorCode, 'string'); +ok(clientInfo.validationErrorCode.length > 0); + +await clientSession.closed; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-session-preferred-address-ignore.mjs b/test/parallel/test-quic-session-preferred-address-ignore.mjs new file mode 100644 index 00000000000000..f59f4a0dc814e4 --- /dev/null +++ b/test/parallel/test-quic-session-preferred-address-ignore.mjs @@ -0,0 +1,69 @@ +// Flags: --experimental-quic --no-warnings + +// Test: Create two listening endpoints, one secondary and one +// preferred. Initiate a connection with the secondary, with +// preferred advertised. Client should ignore the preferred +// address and continue on with the original + +import { hasQuic, skip, mustCall, mustNotCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const allStatusDone = Promise.withResolvers(); +const serverGot = Promise.withResolvers(); +let statusCount = 0; + +const handleSession = mustCall(async (serverSession) => { + await allStatusDone.promise; + await serverGot.promise; + await serverSession.close(); +}); + +const sessionOptions = { + ondatagram: mustCall((data) => { + serverGot.resolve(); + }, 4), + onpathvalidation: mustNotCall(), +}; + +const preferredEndpoint = await listen(handleSession, sessionOptions); +const serverEndpoint = await listen(handleSession, { + ...sessionOptions, + transportParams: { + preferredAddressIpv4: preferredEndpoint.address, + } +}); + +const clientSession = await connect(serverEndpoint.address, { + // We don't want this endpoint to reuse either of the two listening endpoints. + reuseEndpoint: false, + preferredAddressPolicy: 'ignore', + transportParams: { maxDatagramFrameSize: 1200 }, + ondatagramstatus: mustCall((id, status) => { + if (++statusCount >= 4) allStatusDone.resolve(); + }, 4), + onpathvalidation: mustNotCall(), +}); +await clientSession.opened; + +// Send datagrams. +await clientSession.sendDatagram(new Uint8Array([1])); +await clientSession.sendDatagram(new Uint8Array([2])); +await clientSession.sendDatagram(new Uint8Array([3])); +await clientSession.sendDatagram(new Uint8Array([4])); + +await Promise.all([serverGot.promise, allStatusDone.promise]); + +strictEqual(clientSession.stats.datagramsSent, 4n); +ok(clientSession.stats.datagramsAcknowledged >= 1n); + +await clientSession.closed; +await serverEndpoint.close(); +await preferredEndpoint.close(); diff --git a/test/parallel/test-quic-session-preferred-address-ipv6.mjs b/test/parallel/test-quic-session-preferred-address-ipv6.mjs new file mode 100644 index 00000000000000..3eda4a0b04a678 --- /dev/null +++ b/test/parallel/test-quic-session-preferred-address-ipv6.mjs @@ -0,0 +1,124 @@ +// Flags: --experimental-quic --no-warnings + +// Test: Create two listening ipv6 endpoints, one secondary and one +// preferred. Initiate a connection with the secondary, with +// preferred advertised. Client should automatically migrate +// to the preferred address without interupting data flow. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { ok, strictEqual, notStrictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { createPrivateKey } = await import('node:crypto'); + +const allStatusDone = Promise.withResolvers(); +const serverGot = Promise.withResolvers(); +const serverPathValidated = Promise.withResolvers(); +let statusCount = 0; + +const handleSession = mustCall(async (serverSession) => { + await allStatusDone.promise; + await serverGot.promise; + await serverSession.close(); +}); + +function assertEqualAddress(addr1, addr2) { + strictEqual(addr1.address, addr2.address); + strictEqual(addr1.port, addr2.port); + strictEqual(addr1.family, addr2.family); +} + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); + +const sessionOptions = { + ondatagram: mustCall((data) => { + serverGot.resolve(); + }, 4), + onpathvalidation: mustCall((result, newLocal, newRemote, oldLocal, oldRemote, preferred) => { + // The status here can be 'success' or 'aborted' depending on timing. + // The 'aborted' status only means that path validation is no longer + // necessary for a number of reasons (usually ngtcp2 received a non-probing + // packet on the new path). + notStrictEqual(result, 'failure'); + assertEqualAddress(newLocal, preferredEndpoint.address); + assertEqualAddress(oldLocal, serverEndpoint.address); + assertEqualAddress(newRemote, oldRemote); + // The preferred arg is only passed on client side + strictEqual(preferred, undefined); + serverPathValidated.resolve(); + }), + sni: { '*': { keys: [key], certs: [cert] } }, + alpn: ['quic-test'], + endpoint: { + address: { + address: '::1', + family: 'ipv6', + }, + ipv6Only: true, + }, +}; + +const preferredEndpoint = await listen(handleSession, sessionOptions); +const serverEndpoint = await listen(handleSession, { + ...sessionOptions, + transportParams: { + preferredAddressIpv6: preferredEndpoint.address, + } +}); + +console.log(preferredEndpoint.address); +console.log(serverEndpoint.address); + +const clientSession = await connect(serverEndpoint.address, { + // We don't want this endpoint to reuse either of the two listening endpoints. + reuseEndpoint: false, + transportParams: { maxDatagramFrameSize: 1200 }, + ondatagramstatus: mustCall((id, status) => { + if (++statusCount >= 4) allStatusDone.resolve(); + }, 4), + onpathvalidation: mustCall((result, newLocal, newRemote, oldLocal, oldRemote, preferred) => { + strictEqual(result, 'success'); + assertEqualAddress(newLocal, clientSession.endpoint.address); + assertEqualAddress(newRemote, preferredEndpoint.address); + strictEqual(oldLocal, null); + strictEqual(oldRemote, null); + strictEqual(preferred, true); + }), + endpoint: { + address: { + address: '::', + family: 'ipv6', + }, + }, +}); +await clientSession.opened; + +// Send two datagrams. +await clientSession.sendDatagram(new Uint8Array([1])); +await clientSession.sendDatagram(new Uint8Array([2])); + +await serverPathValidated.promise; + +// Send more datagrams after the preferred address migration completes +// To show that data is still flowing after we close the original +// endpoint. +await clientSession.sendDatagram(new Uint8Array([3])); +await clientSession.sendDatagram(new Uint8Array([4])); + +await Promise.all([serverGot.promise, allStatusDone.promise]); + +strictEqual(clientSession.stats.datagramsSent, 4n); +ok(clientSession.stats.datagramsAcknowledged >= 1n); + +await clientSession.closed; +await serverEndpoint.close(); +await preferredEndpoint.close(); diff --git a/test/parallel/test-quic-session-preferred-address.mjs b/test/parallel/test-quic-session-preferred-address.mjs new file mode 100644 index 00000000000000..59858649bec29a --- /dev/null +++ b/test/parallel/test-quic-session-preferred-address.mjs @@ -0,0 +1,102 @@ +// Flags: --experimental-quic --no-warnings + +// Test: preferred address migration. +// Two server endpoints: one initial, one preferred. The server +// advertises the preferred endpoint's address in transport params. +// After the handshake, the client migrates to the preferred address +// via path validation. Datagrams sent before migration take the +// original path; datagrams sent after take the preferred path. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok, strictEqual, notStrictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const allStatusDone = Promise.withResolvers(); +const serverGot = Promise.withResolvers(); +const serverPathValidated = Promise.withResolvers(); +let statusCount = 0; + +const handleSession = mustCall(async (serverSession) => { + await allStatusDone.promise; + await serverGot.promise; + await serverSession.close(); +}); + +function assertEqualAddress(addr1, addr2) { + strictEqual(addr1.address, addr2.address); + strictEqual(addr1.port, addr2.port); + strictEqual(addr1.family, addr2.family); +} + +const sessionOptions = { + ondatagram: mustCall((data) => { + serverGot.resolve(); + }, 4), + onpathvalidation: mustCall((result, newLocal, newRemote, oldLocal, oldRemote, preferred) => { + // The status here can be 'success' or 'aborted' depending on timing. + // The 'aborted' status only means that path validation is no longer + // necessary for a number of reasons (usually ngtcp2 received a non-probing + // packet on the new path). + notStrictEqual(result, 'failure'); + assertEqualAddress(newLocal, preferredEndpoint.address); + assertEqualAddress(oldLocal, serverEndpoint.address); + assertEqualAddress(newRemote, oldRemote); + // The preferred arg is only passed on client side + strictEqual(preferred, undefined); + serverPathValidated.resolve(); + }), +}; + +const preferredEndpoint = await listen(handleSession, sessionOptions); +const serverEndpoint = await listen(handleSession, { + ...sessionOptions, + transportParams: { + preferredAddressIpv4: preferredEndpoint.address, + } +}); + +const clientSession = await connect(serverEndpoint.address, { + // We don't want this endpoint to reuse either of the two listening endpoints. + reuseEndpoint: false, + transportParams: { maxDatagramFrameSize: 1200 }, + ondatagramstatus: mustCall((id, status) => { + if (++statusCount >= 4) allStatusDone.resolve(); + }, 4), + onpathvalidation: mustCall((result, newLocal, newRemote, oldLocal, oldRemote, preferred) => { + strictEqual(result, 'success'); + assertEqualAddress(newLocal, clientSession.endpoint.address); + assertEqualAddress(newRemote, preferredEndpoint.address); + strictEqual(oldLocal, null); + strictEqual(oldRemote, null); + strictEqual(preferred, true); + }), +}); +await clientSession.opened; + +// Send two datagrams. +await clientSession.sendDatagram(new Uint8Array([1])); +await clientSession.sendDatagram(new Uint8Array([2])); + +await serverPathValidated.promise; + +// Send more datagrams after the preferred address migration completes +// To show that data is still flowing after we close the original +// endpoint. +await clientSession.sendDatagram(new Uint8Array([3])); +await clientSession.sendDatagram(new Uint8Array([4])); + +await Promise.all([serverGot.promise, allStatusDone.promise]); + +strictEqual(clientSession.stats.datagramsSent, 4n); +ok(clientSession.stats.datagramsAcknowledged >= 1n); + +await clientSession.closed; +await serverEndpoint.close(); +await preferredEndpoint.close(); diff --git a/test/parallel/test-quic-session-properties.mjs b/test/parallel/test-quic-session-properties.mjs new file mode 100644 index 00000000000000..ced11a7bdd7244 --- /dev/null +++ b/test/parallel/test-quic-session-properties.mjs @@ -0,0 +1,88 @@ +// Flags: --experimental-quic --no-warnings + +// Test: session properties (PATH-03, PATH-06, PATH-07, PATH-08, +// CERT-01, CERT-02, CERT-03, CERT-04, CERT-05). +// PATH-03/06: session.path returns { local, remote } with addresses. +// session.path is cached (same object on second access). +// session.path returns undefined after destroy. +// session.certificate returns own cert object. +// session.peerCertificate returns peer cert. +// session.ephemeralKeyInfo returns key info on client. +// All three cached. +// All three return undefined after destroy. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.opened; + + // PATH-03/06: Server path has local and remote. + const path = serverSession.path; + ok(path); + ok(path.local); + ok(path.remote); + + // Cached. + strictEqual(serverSession.path, path); + + // Own certificate. + const cert = serverSession.certificate; + ok(cert); + + // Peer certificate (client's cert — not set in this + // test since we don't use verifyClient, so it's undefined). + strictEqual(serverSession.peerCertificate, undefined); + + // Cached. + strictEqual(serverSession.certificate, cert); + + await serverSession.close(); + serverDone.resolve(); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// PATH-03/06: Client path. +const path = clientSession.path; +ok(path); +ok(path.local); +ok(path.remote); + +// Cached. +strictEqual(clientSession.path, path); + +// Peer certificate (server's cert). +const peerCert = clientSession.peerCertificate; +ok(peerCert); + +// Ephemeral key info (client only). +const keyInfo = clientSession.ephemeralKeyInfo; +ok(keyInfo); + +// Cached. +strictEqual(clientSession.peerCertificate, peerCert); +strictEqual(clientSession.ephemeralKeyInfo, keyInfo); + +await Promise.all([clientSession.closed, serverDone.promise]); + +// Returns undefined after destroy. +strictEqual(clientSession.path, undefined); + +// Returns undefined after destroy. +strictEqual(clientSession.certificate, undefined); +strictEqual(clientSession.peerCertificate, undefined); +strictEqual(clientSession.ephemeralKeyInfo, undefined); + +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-session-stats-datagram.mjs b/test/parallel/test-quic-session-stats-datagram.mjs new file mode 100644 index 00000000000000..7749e98e6a72d7 --- /dev/null +++ b/test/parallel/test-quic-session-stats-datagram.mjs @@ -0,0 +1,58 @@ +// Flags: --experimental-quic --no-warnings + +// Test: session datagram stats counters. +// After sending datagrams, the session stats should reflect +// datagramsSent, datagramsReceived, and datagramsAcknowledged. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const allStatusDone = Promise.withResolvers(); +const serverGot = Promise.withResolvers(); +let statusCount = 0; + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + // Wait for the client to receive all status updates before closing. + // The server must stay alive long enough to ACK the datagrams. + await allStatusDone.promise; + + // Server received datagrams. + ok(serverSession.stats.datagramsReceived > 0n); + + serverSession.close(); + await serverSession.closed; +}), { + transportParams: { maxDatagramFrameSize: 1200 }, + ondatagram: mustCall((data) => { + serverGot.resolve(); + }, 2), +}); + +const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxDatagramFrameSize: 1200 }, + ondatagramstatus(id, status) { + if (++statusCount >= 2) allStatusDone.resolve(); + }, +}); +await clientSession.opened; + +// Send two datagrams. +await clientSession.sendDatagram(new Uint8Array([1])); +await clientSession.sendDatagram(new Uint8Array([2])); + +await Promise.all([serverGot.promise, allStatusDone.promise]); + +// Client sent datagrams. +strictEqual(clientSession.stats.datagramsSent, 2n); +ok(clientSession.stats.datagramsAcknowledged >= 1n); + +await clientSession.closed; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-session-stats-detailed.mjs b/test/parallel/test-quic-session-stats-detailed.mjs new file mode 100644 index 00000000000000..8908543520e494 --- /dev/null +++ b/test/parallel/test-quic-session-stats-detailed.mjs @@ -0,0 +1,65 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: detailed session stats. +// RTT fields populated after data transfer. +// cwnd, bytesInFlight populated under load. +// V2 fields (pktSent, pktReceived, etc.) populated. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + await bytes(stream); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// Send enough data to generate meaningful stats. +const data = new Uint8Array(8192); +const stream = await clientSession.createBidirectionalStream(); +stream.setBody(data); + +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars +await Promise.all([stream.closed, serverDone.promise]); + +const stats = clientSession.stats; + +// RTT fields populated. +ok(stats.smoothedRtt >= 0n, 'smoothedRtt should be >= 0'); +ok(stats.latestRtt >= 0n, 'latestRtt should be >= 0'); +ok(stats.minRtt >= 0n, 'minRtt should be >= 0'); +strictEqual(typeof stats.rttVar, 'bigint'); + +// Congestion fields. +ok(stats.cwnd > 0n, 'cwnd should be > 0'); +strictEqual(typeof stats.bytesInFlight, 'bigint'); +strictEqual(typeof stats.ssthresh, 'bigint'); + +// V2 packet/byte fields. +ok(stats.pktSent > 0n, 'pktSent should be > 0'); +ok(stats.pktRecv > 0n, 'pktRecv should be > 0'); +strictEqual(typeof stats.pktLost, 'bigint'); +ok(stats.bytesSent > 0n, 'bytesSent should be > 0'); +ok(stats.bytesRecv > 0n, 'bytesRecv should be > 0'); +strictEqual(typeof stats.bytesLost, 'bigint'); + +await clientSession.closed; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-session-stats.mjs b/test/parallel/test-quic-session-stats.mjs new file mode 100644 index 00000000000000..cf65da46641fd0 --- /dev/null +++ b/test/parallel/test-quic-session-stats.mjs @@ -0,0 +1,72 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: session stats increment with data transfer and track streams +// bytesReceived/bytesSent increment after data transfer. +// bidiInStreamCount/bidiOutStreamCount track streams. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const encoder = new TextEncoder(); +const payload = encoder.encode('hello stats world'); +const payloadLength = payload.byteLength; +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const data = await bytes(stream); + strictEqual(data.byteLength, payloadLength); + stream.writer.endSync(); + await stream.closed; + + // Server sees one inbound bidi stream. + strictEqual(serverSession.stats.bidiInStreamCount, 1n); + strictEqual(serverSession.stats.bidiOutStreamCount, 0n); + + // Server received data bytes. + ok(serverSession.stats.bytesReceived > 0n); + ok(serverSession.stats.bytesSent > 0n); + + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// Before sending, bytes should be from handshake only. +const bytesSentBefore = clientSession.stats.bytesSent; +ok(bytesSentBefore > 0n, 'handshake bytes should be counted'); + +const stream = await clientSession.createBidirectionalStream({ + body: payload, +}); + +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars +await stream.closed; +await serverDone.promise; + +// After sending, bytesSent should have increased. +ok(clientSession.stats.bytesSent > bytesSentBefore, + 'bytesSent should increase after data transfer'); +ok(clientSession.stats.bytesReceived > 0n); + +// Client opened one outbound bidi stream. +strictEqual(clientSession.stats.bidiOutStreamCount, 1n); +strictEqual(clientSession.stats.bidiInStreamCount, 0n); + +// Verify RTT fields are populated (connection was active). +ok(clientSession.stats.smoothedRtt > 0n); + +await clientSession.closed; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-session-stream-lifecycle.mjs b/test/parallel/test-quic-session-stream-lifecycle.mjs index dcd9fa9987eae6..f18f82994f26dd 100644 --- a/test/parallel/test-quic-session-stream-lifecycle.mjs +++ b/test/parallel/test-quic-session-stream-lifecycle.mjs @@ -3,6 +3,9 @@ import { hasQuic, skip, mustCall } from '../common/index.mjs'; import assert from 'node:assert'; import * as fixtures from '../common/fixtures.mjs'; +const { readKey } = fixtures; + +const { ok, strictEqual } = assert; if (!hasQuic) { skip('QUIC is not enabled'); @@ -12,87 +15,83 @@ if (!hasQuic) { const quic = await import('node:quic'); const { createPrivateKey } = await import('node:crypto'); -const keys = createPrivateKey(fixtures.readKey('agent1-key.pem')); -const certs = fixtures.readKey('agent1-cert.pem'); +const keys = createPrivateKey(readKey('agent1-key.pem')); +const certs = readKey('agent1-cert.pem'); const serverDone = Promise.withResolvers(); -const clientDone = Promise.withResolvers(); // Create a server endpoint -const serverEndpoint = await quic.listen(mustCall((serverSession) => { - serverSession.opened.then((info) => { - assert.ok(serverSession.endpoint !== null); - assert.strictEqual(serverSession.destroyed, false); - - const stats = serverSession.stats; - assert.strictEqual(stats.isConnected, true); - assert.ok(stats.handshakeCompletedAt > 0n); - assert.ok(stats.handshakeConfirmedAt > 0n); - assert.strictEqual(stats.closingAt, 0n); - - serverDone.resolve(); - serverSession.close(); - }).then(mustCall()); +const serverEndpoint = await quic.listen(mustCall(async (serverSession) => { + await serverSession.opened; + ok(serverSession.endpoint !== null); + strictEqual(serverSession.destroyed, false); + + const stats = serverSession.stats; + strictEqual(stats.isConnected, true); + ok(stats.handshakeCompletedAt > 0n); + ok(stats.handshakeConfirmedAt > 0n); + strictEqual(stats.closingAt, 0n); + + serverDone.resolve(); + serverSession.close(); }), { sni: { '*': { keys, certs } } }); -assert.strictEqual(serverEndpoint.busy, false); -assert.strictEqual(serverEndpoint.closing, false); -assert.strictEqual(serverEndpoint.destroyed, false); -assert.strictEqual(serverEndpoint.listening, true); +strictEqual(serverEndpoint.busy, false); +strictEqual(serverEndpoint.closing, false); +strictEqual(serverEndpoint.destroyed, false); +strictEqual(serverEndpoint.listening, true); -assert.ok(serverEndpoint.address !== undefined); -assert.strictEqual(serverEndpoint.address.family, 'ipv4'); -assert.strictEqual(serverEndpoint.address.address, '127.0.0.1'); -assert.ok(typeof serverEndpoint.address.port === 'number'); -assert.ok(serverEndpoint.address.port > 0); +ok(serverEndpoint.address !== undefined); +strictEqual(serverEndpoint.address.family, 'ipv4'); +strictEqual(serverEndpoint.address.address, '127.0.0.1'); +ok(typeof serverEndpoint.address.port === 'number'); +ok(serverEndpoint.address.port > 0); const epStats = serverEndpoint.stats; -assert.strictEqual(epStats.isConnected, true); -assert.ok(epStats.createdAt > 0n); +strictEqual(epStats.isConnected, true); +ok(epStats.createdAt > 0n); // Connect with a client const clientSession = await quic.connect(serverEndpoint.address); -assert.strictEqual(clientSession.destroyed, false); -assert.ok(clientSession.endpoint !== null); -assert.strictEqual(clientSession.stats.isConnected, true); - -clientSession.opened.then((clientInfo) => { - assert.strictEqual(clientInfo.servername, 'localhost'); - assert.strictEqual(clientInfo.protocol, 'h3'); - assert.strictEqual(clientInfo.cipherVersion, 'TLSv1.3'); - assert.ok(clientInfo.local !== undefined); - assert.ok(clientInfo.remote !== undefined); +strictEqual(clientSession.destroyed, false); +ok(clientSession.endpoint !== null); +strictEqual(clientSession.stats.isConnected, true); - const cStats = clientSession.stats; - assert.strictEqual(cStats.isConnected, true); - assert.ok(cStats.handshakeCompletedAt > 0n); - assert.ok(cStats.bytesSent > 0n, 'Expected bytesSent > 0 after handshake'); +const clientInfo = await clientSession.opened; +strictEqual(clientInfo.servername, 'localhost'); +strictEqual(clientInfo.protocol, 'h3'); +strictEqual(clientInfo.cipherVersion, 'TLSv1.3'); +ok(clientInfo.local !== undefined); +ok(clientInfo.remote !== undefined); - clientDone.resolve(); -}).then(mustCall()); +const cStats = clientSession.stats; +strictEqual(cStats.isConnected, true); +ok(cStats.handshakeCompletedAt > 0n); +ok(cStats.bytesSent > 0n, 'Expected bytesSent > 0 after handshake'); -await Promise.all([serverDone.promise, clientDone.promise]); +await serverDone.promise; // Open a bidirectional stream. const stream = await clientSession.createBidirectionalStream(); -assert.strictEqual(stream.destroyed, false); -assert.strictEqual(stream.direction, 'bidi'); -assert.strictEqual(stream.session, clientSession); -assert.ok(stream.id !== null, 'Non-pending stream should have an id'); -assert.strictEqual(typeof stream.id, 'bigint'); -assert.strictEqual(stream.pending, false); -assert.strictEqual(stream.stats.isConnected, true); -assert.ok(stream.readable instanceof ReadableStream); +strictEqual(stream.destroyed, false); +strictEqual(stream.direction, 'bidi'); +strictEqual(stream.session, clientSession); +ok(stream.id !== null, 'Non-pending stream should have an id'); +strictEqual(typeof stream.id, 'bigint'); +strictEqual(stream.pending, false); +strictEqual(stream.stats.isConnected, true); // Destroying the session should destroy it and the stream, and clear its properties. clientSession.destroy(); -assert.strictEqual(clientSession.destroyed, true); -assert.strictEqual(clientSession.endpoint, null); -assert.strictEqual(clientSession.stats.isConnected, false); - -assert.strictEqual(stream.destroyed, true); -assert.strictEqual(stream.session, null); -assert.strictEqual(stream.id, null); -assert.strictEqual(stream.direction, null); +strictEqual(clientSession.destroyed, true); +strictEqual(clientSession.endpoint, null); +strictEqual(clientSession.stats.isConnected, false); + +strictEqual(stream.destroyed, true); +strictEqual(stream.session, null); +strictEqual(stream.id, null); +strictEqual(stream.direction, null); + +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-shared-endpoint-stream-close.mjs b/test/parallel/test-quic-shared-endpoint-stream-close.mjs new file mode 100644 index 00000000000000..1a76decd4e2937 --- /dev/null +++ b/test/parallel/test-quic-shared-endpoint-stream-close.mjs @@ -0,0 +1,92 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Regression test: when a client QuicEndpoint has a session terminated +// by a stateless reset, subsequent sessions on the same endpoint must +// be able to complete their stream close handshake. +// Without the fix, the server-side stream.closed for session 2 never +// resolves and the test hangs. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); +const { QuicEndpoint } = await import('node:quic'); + +const encoder = new TextEncoder(); + +let sessionCount = 0; +const serverDone1 = Promise.withResolvers(); +const serverDone2 = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + sessionCount++; + const which = sessionCount; + + serverSession.onstream = mustCall(async (stream) => { + const data = await bytes(stream); + assert.ok(data.byteLength > 0); + stream.writer.endSync(); + // For session 2 this hangs when the bug is present — the server + // never receives the client's ACK for its FIN. + await stream.closed; + + if (which === 1) serverSession.destroy(); + (which === 1 ? serverDone1 : serverDone2).resolve(); + }); +}, 2), { + onerror(err) { /* marks promises as handled */ }, +}); + +// Both sessions share one endpoint — same source UDP address. +const clientEndpoint = new QuicEndpoint(); + +// Session 1: complete a full round-trip, then the server destroys +// without sending CONNECTION_CLOSE. The client sends a packet to the +// now-unknown DCID, which causes the server to send a stateless reset. +// The client receives the stateless reset and closes session 1. +const client1 = await connect(serverEndpoint.address, { + endpoint: clientEndpoint, + onerror: mustCall((err) => { assert.ok(err); }), +}); +await client1.opened; + +const s1 = await client1.createBidirectionalStream({ + body: encoder.encode('session1'), +}); +for await (const _ of s1) { /* drain */ } // eslint-disable-line no-unused-vars +await s1.closed; + +await serverDone1.promise; + +// Trigger the stateless reset. +// eslint-disable-next-line no-unused-vars +const s1b = await client1.createBidirectionalStream({ + body: encoder.encode('trigger'), +}); +await assert.rejects(client1.closed, { code: 'ERR_QUIC_TRANSPORT_ERROR' }); + +// Session 2: uses the same endpoint as session 1. The bug manifests +// as serverDone2 never resolving because the server's stream.closed +// for session 2 hangs. +const client2 = await connect(serverEndpoint.address, { + endpoint: clientEndpoint, + onerror(err) { /* marks promises as handled */ }, +}); +await client2.opened; + +const s2 = await client2.createBidirectionalStream({ + body: encoder.encode('session2'), +}); +for await (const _ of s2) { /* drain */ } // eslint-disable-line no-unused-vars +await s2.closed; + +// If the bug is present, this never resolves and the test hangs. +await serverDone2.promise; + +await serverEndpoint.close(); +await clientEndpoint.close(); diff --git a/test/parallel/test-quic-sni-mismatch.mjs b/test/parallel/test-quic-sni-mismatch.mjs new file mode 100644 index 00000000000000..ea77672101355a --- /dev/null +++ b/test/parallel/test-quic-sni-mismatch.mjs @@ -0,0 +1,61 @@ +// Flags: --experimental-quic --no-warnings + +// Test: SNI mismatch. +// Client connects with a servername that doesn't match any SNI entry +// and no wildcard is configured. The handshake should fail with a +// TLS alert (unrecognized_name). + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { rejects, strictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); + +// Server only has an entry for 'specific.example.com', no wildcard. +// Connections to any other hostname will be rejected at the TLS level. +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await rejects(serverSession.opened, { + code: 'ERR_QUIC_TRANSPORT_ERROR', + }); + await rejects(serverSession.closed, { + code: 'ERR_QUIC_TRANSPORT_ERROR', + }); +}), { + sni: { 'specific.example.com': { keys: [key], certs: [cert] } }, + alpn: ['quic-test'], + transportParams: { maxIdleTimeout: 1 }, + onerror: mustCall((err) => { + strictEqual(err.code, 'ERR_QUIC_TRANSPORT_ERROR'); + }), +}); + +// Client connects with a different servername — no matching identity. +const clientSession = await connect(serverEndpoint.address, { + alpn: 'quic-test', + servername: 'wrong.example.com', + transportParams: { maxIdleTimeout: 1 }, + onerror: mustCall((err) => { + strictEqual(err.code, 'ERR_QUIC_TRANSPORT_ERROR'); + }), +}); + +await rejects(clientSession.opened, { + code: 'ERR_QUIC_TRANSPORT_ERROR', +}); + +await rejects(clientSession.closed, { + code: 'ERR_QUIC_TRANSPORT_ERROR', +}); + +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-sni-multi-entry.mjs b/test/parallel/test-quic-sni-multi-entry.mjs new file mode 100644 index 00000000000000..254e90e29e3211 --- /dev/null +++ b/test/parallel/test-quic-sni-multi-entry.mjs @@ -0,0 +1,81 @@ +// Flags: --experimental-quic --no-warnings + +// Test: SNI with multiple entries. +// Server has 3+ SNI entries. Different servername values should +// negotiate successfully using the correct identity. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { strictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const key1 = createPrivateKey(readKey('agent1-key.pem')); +const cert1 = readKey('agent1-cert.pem'); +const key2 = createPrivateKey(readKey('agent2-key.pem')); +const cert2 = readKey('agent2-cert.pem'); +const key3 = createPrivateKey(readKey('agent3-key.pem')); +const cert3 = readKey('agent3-cert.pem'); + +let sessionCount = 0; +const allDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + const info = await serverSession.opened; + // Each client should negotiate with the correct servername. + strictEqual(typeof info.servername, 'string'); + serverSession.close(); + await serverSession.closed; + if (++sessionCount === 3) allDone.resolve(); +}, 3), { + sni: { + 'host1.example.com': { keys: [key1], certs: [cert1] }, + 'host2.example.com': { keys: [key2], certs: [cert2] }, + '*': { keys: [key3], certs: [cert3] }, + }, + alpn: ['quic-test'], +}); + +// Client 1: connects with servername 'host1.example.com'. +{ + const cs = await connect(serverEndpoint.address, { + servername: 'host1.example.com', + alpn: 'quic-test', + }); + const info = await cs.opened; + strictEqual(info.servername, 'host1.example.com'); + await cs.closed; +} + +// Client 2: connects with servername 'host2.example.com'. +{ + const cs = await connect(serverEndpoint.address, { + servername: 'host2.example.com', + alpn: 'quic-test', + }); + const info = await cs.opened; + strictEqual(info.servername, 'host2.example.com'); + await cs.closed; +} + +// Client 3: connects with servername 'unknown.example.com' → wildcard. +{ + const cs = await connect(serverEndpoint.address, { + servername: 'unknown.example.com', + alpn: 'quic-test', + }); + const info = await cs.opened; + assert.strictEqual(info.servername, 'unknown.example.com'); + await cs.closed; +} + +await allDone.promise; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-sni-setcontexts.mjs b/test/parallel/test-quic-sni-setcontexts.mjs new file mode 100644 index 00000000000000..af0c6dc048f1d7 --- /dev/null +++ b/test/parallel/test-quic-sni-setcontexts.mjs @@ -0,0 +1,72 @@ +// Flags: --experimental-quic --no-warnings + +// Test: setSNIContexts hot-swap and options. +// setSNIContexts() updates TLS identities at runtime. +// setSNIContexts() with replace: true replaces all entries. +// setSNIContexts() with replace: false merges new entries. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { strictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect, QuicEndpoint } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const key1 = createPrivateKey(readKey('agent1-key.pem')); +const cert1 = readKey('agent1-cert.pem'); +const key2 = createPrivateKey(readKey('agent2-key.pem')); +const cert2 = readKey('agent2-cert.pem'); + +const endpoint = new QuicEndpoint(); + +// Start with agent1 cert for all hosts. +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.opened; + serverSession.close(); + await serverSession.closed; +}, 2), { + endpoint, + sni: { '*': { keys: [key1], certs: [cert1] } }, + alpn: ['quic-test'], + transportParams: { maxIdleTimeout: 2 }, +}); + +// First connection uses agent1 cert. +{ + const cs = await connect(serverEndpoint.address, { + alpn: 'quic-test', + transportParams: { maxIdleTimeout: 2 }, + }); + const info = await cs.opened; + strictEqual(info.servername, 'localhost'); + await cs.closed; +} + +endpoint.setSNIContexts( + { '*': { keys: [key2], certs: [cert2] } }, + { replace: true }, +); + +// Second connection should use agent2 cert. +{ + const cs = await connect(serverEndpoint.address, { + alpn: 'quic-test', + transportParams: { maxIdleTimeout: 2 }, + }); + const info = await cs.opened; + strictEqual(info.servername, 'localhost'); + // The cert changed — we can verify by checking the connection succeeded + // (if the old cert was still used and the new one was expected, the + // handshake would still succeed since both are self-signed and + // rejectUnauthorized defaults to false in the test helper). + await cs.closed; +} + +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-sni.mjs b/test/parallel/test-quic-sni.mjs index b2fe9968eee746..e8669380ba855e 100644 --- a/test/parallel/test-quic-sni.mjs +++ b/test/parallel/test-quic-sni.mjs @@ -4,6 +4,9 @@ import { hasQuic, skip, mustCall } from '../common/index.mjs'; import assert from 'node:assert'; import * as fixtures from '../common/fixtures.mjs'; +const { ok, strictEqual } = assert; +const { readKey } = fixtures; + if (!hasQuic) { skip('QUIC is not enabled'); } @@ -12,22 +15,17 @@ const { listen, connect } = await import('node:quic'); const { createPrivateKey } = await import('node:crypto'); // Use two different keys/certs for the default and SNI host. -const defaultKey = createPrivateKey(fixtures.readKey('agent1-key.pem')); -const defaultCert = fixtures.readKey('agent1-cert.pem'); -const sniKey = createPrivateKey(fixtures.readKey('agent2-key.pem')); -const sniCert = fixtures.readKey('agent2-cert.pem'); +const defaultKey = createPrivateKey(readKey('agent1-key.pem')); +const defaultCert = readKey('agent1-cert.pem'); +const sniKey = createPrivateKey(readKey('agent2-key.pem')); +const sniCert = readKey('agent2-cert.pem'); // Server with SNI: default ('*') uses agent1, 'localhost' uses agent2. -const serverOpened = Promise.withResolvers(); -const clientOpened = Promise.withResolvers(); - -const serverEndpoint = await listen(mustCall((serverSession) => { - serverSession.opened.then((info) => { - // The server should see the client's requested servername. - assert.strictEqual(info.servername, 'localhost'); - serverOpened.resolve(); - serverSession.close(); - }).then(mustCall()); +const serverEndpoint = await listen(mustCall(async (serverSession) => { + const info = await serverSession.opened; + // The server should see the client's requested servername. + strictEqual(info.servername, 'localhost'); + await serverSession.close(); }), { sni: { '*': { keys: [defaultKey], certs: [defaultCert] }, @@ -36,17 +34,15 @@ const serverEndpoint = await listen(mustCall((serverSession) => { alpn: ['quic-test'], }); -assert.ok(serverEndpoint.address !== undefined); +ok(serverEndpoint.address !== undefined); // Client connects with servername 'localhost' — should match the SNI entry. const clientSession = await connect(serverEndpoint.address, { servername: 'localhost', alpn: 'quic-test', }); -clientSession.opened.then((info) => { - assert.strictEqual(info.servername, 'localhost'); - clientOpened.resolve(); -}).then(mustCall()); +const clientInfo = await clientSession.opened; +strictEqual(clientInfo.servername, 'localhost'); -await Promise.all([serverOpened.promise, clientOpened.promise]); -clientSession.close(); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stateless-reset.mjs b/test/parallel/test-quic-stateless-reset.mjs new file mode 100644 index 00000000000000..b9fdb397e00c6f --- /dev/null +++ b/test/parallel/test-quic-stateless-reset.mjs @@ -0,0 +1,232 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: stateless reset. +// When the server loses session state and the client sends +// data, the server sends a stateless reset and the client +// session closes. +// When disableStatelessReset is true, the server does NOT +// send a stateless reset. +// maxStatelessResetsPerHost rate limits the number of resets +// sent to a single remote address. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok, strictEqual, rejects } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const encoder = new TextEncoder(); + +// Stateless reset received closes session. +{ + const serverDestroyed = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + // Do a complete data exchange first so both sides are + // fully at 1-RTT with all ACKs exchanged. + const data = await bytes(stream); + ok(data.byteLength > 0); + stream.writer.endSync(); + await stream.closed; + + // Now forcefully destroy the server session WITHOUT sending + // CONNECTION_CLOSE. The client doesn't know the session + // is gone. + serverSession.destroy(); + serverDestroyed.resolve(); + }); + }), { + onerror(err) { ok(err); }, + }); + + const clientSession = await connect(serverEndpoint.address, { + reuseEndpoint: false, + onerror: mustCall((err) => { + strictEqual(err.code, 'ERR_QUIC_TRANSPORT_ERROR'); + }), + }); + await clientSession.opened; + + // First exchange: complete round-trip to confirm 1-RTT. + const stream1 = await clientSession.createBidirectionalStream({ + body: encoder.encode('hello'), + }); + for await (const _ of stream1) { /* drain */ } // eslint-disable-line no-unused-vars + await stream1.closed; + + // Wait for the server to destroy. + await serverDestroyed.promise; + + // Open a second stream — this sends a short header (1-RTT) packet + // to the server. The server endpoint doesn't recognize the DCID + // and should send a stateless reset. + // eslint-disable-next-line no-unused-vars + const stream2 = await clientSession.createBidirectionalStream({ + body: encoder.encode('after destroy'), + }); + + // The client session should be closed by the stateless reset. + await rejects(clientSession.closed, { + code: 'ERR_QUIC_TRANSPORT_ERROR', + }); + + ok(serverEndpoint.stats.statelessResetCount > 0n, + 'Server should have sent a stateless reset'); + + await serverEndpoint.close(); +} + +// disableStatelessReset prevents the server from sending resets. +{ + const serverDestroyed = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const data = await bytes(stream); + ok(data.byteLength > 0); + stream.writer.endSync(); + await stream.closed; + + serverSession.destroy(); + serverDestroyed.resolve(); + }); + }), { + endpoint: { disableStatelessReset: true }, + onerror(err) { ok(err); }, + }); + + const clientSession = await connect(serverEndpoint.address, { + reuseEndpoint: false, + // Short idle timeout so the client doesn't hang waiting for + // a stateless reset that will never arrive. + transportParams: { maxIdleTimeout: 1 }, + // Onerror marks stream closed promises as handled so that the + // idle-timeout stream destruction doesn't cause unhandled rejections. + onerror(err) { ok(err); }, + }); + await clientSession.opened; + + const stream1 = await clientSession.createBidirectionalStream({ + body: encoder.encode('hello'), + }); + for await (const _ of stream1) { /* drain */ } // eslint-disable-line no-unused-vars + await stream1.closed; + + await serverDestroyed.promise; + + // Send a packet after the server session is destroyed. The server + // endpoint silently drops the packet (stateless reset disabled). + // eslint-disable-next-line no-unused-vars + const stream2 = await clientSession.createBidirectionalStream({ + body: encoder.encode('after destroy'), + }); + + // The client should NOT receive a stateless reset. It will close + // via idle timeout instead. + await clientSession.closed; + + strictEqual(serverEndpoint.stats.statelessResetCount, 0n, + 'No stateless reset should have been sent'); + + await serverEndpoint.close(); +} + +// maxStatelessResetsPerHost rate limits resets per remote address. +// The LRU tracks resets per IP+port, so both sessions must share a +// client endpoint to have the same source address. +{ + let sessionCount = 0; + const serverDestroyed1 = Promise.withResolvers(); + const serverDestroyed2 = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall((serverSession) => { + sessionCount++; + const which = sessionCount; + const deferred = which === 1 ? serverDestroyed1 : serverDestroyed2; + + serverSession.onstream = mustCall(async (stream) => { + const data = await bytes(stream); + ok(data.byteLength > 0); + stream.writer.endSync(); + await stream.closed; + + serverSession.destroy(); + deferred.resolve(); + }); + }, 2), { + endpoint: { maxStatelessResetsPerHost: 1 }, + onerror(err) { ok(err); }, + }); + + // Both clients share an endpoint so the server sees the same + // remote IP+port for both, making the rate limiter apply. + const { QuicEndpoint } = await import('node:quic'); + const clientEndpoint = new QuicEndpoint(); + + // --- First session: triggers a stateless reset --- + + const client1 = await connect(serverEndpoint.address, { + endpoint: clientEndpoint, + onerror: mustCall((err) => { + strictEqual(err.code, 'ERR_QUIC_TRANSPORT_ERROR'); + }), + }); + await client1.opened; + + // Send data so the server onstream fires and destroys the session. + await client1.createBidirectionalStream({ + body: encoder.encode('session1'), + }); + await serverDestroyed1.promise; + + // Send a packet to trigger stateless reset. + // eslint-disable-next-line no-unused-vars + const s1b = await client1.createBidirectionalStream({ + body: encoder.encode('after destroy 1'), + }); + await rejects(client1.closed, { code: 'ERR_QUIC_TRANSPORT_ERROR' }); + + strictEqual(serverEndpoint.stats.statelessResetCount, 1n, + 'First reset should have been sent'); + + // --- Second session: rate-limited, no reset sent --- + + const client2 = await connect(serverEndpoint.address, { + endpoint: clientEndpoint, + // Short idle timeout so the client closes after the server + // destroys (no stateless reset will arrive, rate-limited). + transportParams: { maxIdleTimeout: 1 }, + // Onerror marks stream closed promises as handled. + onerror(err) { ok(err); }, + }); + await client2.opened; + + // Send data so the server onstream fires and destroys the session. + await client2.createBidirectionalStream({ + body: encoder.encode('session2'), + }); + await serverDestroyed2.promise; + + // Send a packet — the server would normally send a stateless reset, + // but the rate limit (1 per host) is already exhausted. + // eslint-disable-next-line no-unused-vars + const s2b = await client2.createBidirectionalStream({ + body: encoder.encode('after destroy 2'), + }); + + // The client closes via idle timeout (no stateless reset). + await client2.closed; + + strictEqual(serverEndpoint.stats.statelessResetCount, 1n, + 'Second reset should have been rate-limited'); + + await clientEndpoint.close(); + await serverEndpoint.close(); +} diff --git a/test/parallel/test-quic-stats-tojson-inspect.mjs b/test/parallel/test-quic-stats-tojson-inspect.mjs new file mode 100644 index 00000000000000..860b02c2ed09a0 --- /dev/null +++ b/test/parallel/test-quic-stats-tojson-inspect.mjs @@ -0,0 +1,67 @@ +// Flags: --experimental-quic --no-warnings + +// Test: toJSON() and inspect() on stats objects. +// Verifies that stats objects from endpoints and sessions +// support toJSON() and util.inspect(). + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import { inspect } from 'node:util'; + +const { ok, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + // Session stats toJSON and inspect. + const sessionStatsJson = serverSession.stats.toJSON(); + ok(sessionStatsJson); + strictEqual(typeof sessionStatsJson.createdAt, 'string'); + strictEqual(typeof sessionStatsJson.bytesSent, 'string'); + + const sessionStatsInspect = inspect(serverSession.stats); + ok(sessionStatsInspect.includes('QuicSessionStats')); + + serverSession.onstream = mustCall(async (stream) => { + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +})); + +// Endpoint stats toJSON and inspect. +const endpointStatsJson = serverEndpoint.stats.toJSON(); +ok(endpointStatsJson); +strictEqual(typeof endpointStatsJson.createdAt, 'string'); + +const endpointStatsInspect = inspect(serverEndpoint.stats); +ok(endpointStatsInspect.includes('QuicEndpointStats')); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// Client session stats. +const clientStatsJson = clientSession.stats.toJSON(); +ok(clientStatsJson); +strictEqual(typeof clientStatsJson.createdAt, 'string'); + +const clientStatsInspect = inspect(clientSession.stats); +ok(clientStatsInspect.includes('QuicSessionStats')); + +const stream = await clientSession.createBidirectionalStream({ + body: new TextEncoder().encode('test'), +}); +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + +await Promise.all([stream.closed, serverDone.promise]); + +await clientSession.closed; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-bidi-basic.mjs b/test/parallel/test-quic-stream-bidi-basic.mjs new file mode 100644 index 00000000000000..de71890e888ac9 --- /dev/null +++ b/test/parallel/test-quic-stream-bidi-basic.mjs @@ -0,0 +1,60 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: basic bidirectional stream data transfer. +// The client creates a bidi stream with a fixed body. The server reads the +// data via async iteration (using stream/iter bytes()), verifies integrity, +// then closes its write side of the stream. Both sides await stream.closed +// to ensure the stream is fully acknowledged before the session is torn down. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { deepStrictEqual, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const message = 'Hello from the client'; +const encoder = new TextEncoder(); +const decoder = new TextDecoder(); +// Keep a separate copy for comparison — the body passed to +// createBidirectionalStream will have its ArrayBuffer transferred. +const body = encoder.encode(message); +const expected = encoder.encode(message); + +const done = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + + deepStrictEqual(received, expected); + strictEqual(decoder.decode(received), message); + + // Close the server's write side of the bidi stream (FIN with no data) + // so the stream is fully closed on both directions. + stream.writer.endSync(); + + // Wait for the stream to be fully closed before closing the session. + await stream.closed; + serverSession.close(); + done.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// Create a bidi stream with the message as the body. +// For DefaultApplication, the server's onstream fires when data arrives. +const stream = await clientSession.createBidirectionalStream({ + body: body, +}); + +await Promise.all([stream.closed, done.promise]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-bidi-concurrent.mjs b/test/parallel/test-quic-stream-bidi-concurrent.mjs new file mode 100644 index 00000000000000..240f377d7d5513 --- /dev/null +++ b/test/parallel/test-quic-stream-bidi-concurrent.mjs @@ -0,0 +1,65 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: multiple concurrent bidirectional streams on a single session. +// The client opens several bidi streams in parallel, each sending a +// distinct message. The server reads each stream independently and +// verifies data integrity. All streams and the session are closed +// cleanly after all transfers complete. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const encoder = new TextEncoder(); +const decoder = new TextDecoder(); +const numStreams = 5; + +const messages = Array.from({ length: numStreams }, + (_, i) => `message from stream ${i}`); + +let serverStreamsReceived = 0; +const done = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + const text = decoder.decode(received); + + // Verify it's one of the expected messages. + ok(messages.includes(text), + `Unexpected message: ${text}`); + + stream.writer.endSync(); + await stream.closed; + + serverStreamsReceived++; + if (serverStreamsReceived === numStreams) { + serverSession.close(); + done.resolve(); + } + }, numStreams); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// Open all streams concurrently. +const clientStreams = await Promise.all( + messages.map((msg) => + clientSession.createBidirectionalStream({ + body: encoder.encode(msg), + }), + ), +); + +await Promise.all([done.promise, ...clientStreams.map((s) => s.closed)]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-bidi-echo.mjs b/test/parallel/test-quic-stream-bidi-echo.mjs new file mode 100644 index 00000000000000..dbc82d16646f26 --- /dev/null +++ b/test/parallel/test-quic-stream-bidi-echo.mjs @@ -0,0 +1,54 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: bidirectional stream echo. +// The client sends a message, the server reads it and echoes it back. +// Both directions of the bidi stream carry data and are properly FIN'd. +// Verifies that both client and server can read and write on the same stream. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const message = 'ping from client'; +const encoder = new TextEncoder(); +const decoder = new TextDecoder(); + +const done = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + // Read client's data. + const received = await bytes(stream); + + // Echo it back and close the write side. + const w = stream.writer; + w.writeSync(received); + w.endSync(); + + await stream.closed; + serverSession.close(); + done.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const body = encoder.encode(message); +const stream = await clientSession.createBidirectionalStream({ body }); + +// Read the echoed response from the server. +const echoed = await bytes(stream); +strictEqual(decoder.decode(echoed), message); + +await Promise.all([stream.closed, done.promise]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-bidi-halfclose.mjs b/test/parallel/test-quic-stream-bidi-halfclose.mjs new file mode 100644 index 00000000000000..5f94d281355d2b --- /dev/null +++ b/test/parallel/test-quic-stream-bidi-halfclose.mjs @@ -0,0 +1,60 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: half-close on a bidirectional stream. +// The client sends a body and closes its write side (FIN). While the +// client's writable side is closed, the server's writable side remains +// open. The server reads all client data, then sends a response back. +// The client reads the server's response and verifies both payloads. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const encoder = new TextEncoder(); +const decoder = new TextDecoder(); +const clientMessage = 'request from client'; +const serverMessage = 'response from server'; + +const done = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + // Read the client's data (client has already sent FIN). + const received = await bytes(stream); + strictEqual(decoder.decode(received), clientMessage); + + // The server's writable side is still open. Send a response. + const w = stream.writer; + w.writeSync(encoder.encode(serverMessage)); + w.endSync(); + + await stream.closed; + serverSession.close(); + done.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// Create a stream with a body -- this sends FIN after the body. +const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode(clientMessage), +}); + +// The client's writable side is closed (FIN sent with body), but +// the readable side is still open. Read the server's response. +const response = await bytes(stream); +strictEqual(decoder.decode(response), serverMessage); + +await Promise.all([stream.closed, done.promise]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-bidi-large.mjs b/test/parallel/test-quic-stream-bidi-large.mjs new file mode 100644 index 00000000000000..329dc519bd702a --- /dev/null +++ b/test/parallel/test-quic-stream-bidi-large.mjs @@ -0,0 +1,88 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: large bidirectional data transfer with backpressure. +// The client sends >1MB of data using the writer API, exercising the +// QUIC flow control path. The server reads all data and verifies the +// total byte count and a checksum. This tests that backpressure is +// correctly applied and released across the full transfer. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes, drainableProtocol: dp } = await import('stream/iter'); + +// 1.5 MB payload — large enough to trigger flow control. +const totalSize = 1.5 * 1024 * 1024; +const chunkSize = 16 * 1024; +const numChunks = Math.ceil(totalSize / chunkSize); + +// Build a deterministic payload so we can verify integrity. +function buildChunk(index) { + const chunk = new Uint8Array(chunkSize); + // Fill with a pattern derived from the chunk index. + const val = index & 0xff; + for (let i = 0; i < chunkSize; i++) { + chunk[i] = (val + i) & 0xff; + } + return chunk; +} + +function checksum(data) { + let sum = 0; + for (let i = 0; i < data.byteLength; i++) { + sum = (sum + data[i]) | 0; + } + return sum; +} + +// Compute expected checksum. +let expectedChecksum = 0; +for (let i = 0; i < numChunks; i++) { + const chunk = buildChunk(i); + expectedChecksum = (expectedChecksum + checksum(chunk)) | 0; +} + +const done = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + strictEqual(received.byteLength, numChunks * chunkSize); + strictEqual(checksum(received), expectedChecksum); + + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + done.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream(); +const w = stream.writer; + +// Write chunks, respecting backpressure via drainableProtocol. +for (let i = 0; i < numChunks; i++) { + const chunk = buildChunk(i); + while (!w.writeSync(chunk)) { + // Flow controlled — wait for drain before retrying. + const drainable = w[dp](); + if (drainable) await drainable; + } +} + +const totalWritten = w.endSync(); +strictEqual(totalWritten, numChunks * chunkSize); + +await Promise.all([stream.closed, done.promise]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-bidi-server-initiated.mjs b/test/parallel/test-quic-stream-bidi-server-initiated.mjs new file mode 100644 index 00000000000000..30328ffde508ec --- /dev/null +++ b/test/parallel/test-quic-stream-bidi-server-initiated.mjs @@ -0,0 +1,57 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: server-initiated bidirectional stream. +// The server creates a bidi stream and sends a body to the client. +// The client receives the data via its onstream handler and verifies +// integrity. This is the reverse of test-quic-stream-bidi-basic.mjs. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { deepStrictEqual, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const message = 'Hello from the server'; +const encoder = new TextEncoder(); +const decoder = new TextDecoder(); +const expected = encoder.encode(message); + +const done = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.opened; + + const stream = await serverSession.createBidirectionalStream({ + body: encoder.encode(message), + }); + + // Drain the client's write side (client sends FIN with no data). + for await (const batch of stream) { /* drain */ } // eslint-disable-line no-unused-vars + await stream.closed; +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +clientSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + + deepStrictEqual(received, expected); + strictEqual(decoder.decode(received), message); + + // Close the client's write side so the stream fully closes. + stream.writer.endSync(); + await stream.closed; + + clientSession.close(); + done.resolve(); +}); + +await done.promise; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-bidi-setbody.mjs b/test/parallel/test-quic-stream-bidi-setbody.mjs new file mode 100644 index 00000000000000..856211fc36cda3 --- /dev/null +++ b/test/parallel/test-quic-stream-bidi-setbody.mjs @@ -0,0 +1,59 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: stream.setBody() after creation. +// Creates a bidirectional stream without an initial body, then attaches +// a body via setBody(). The server reads the data and verifies integrity. +// Also verifies that calling setBody() a second time throws. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { deepStrictEqual, strictEqual, throws } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const encoder = new TextEncoder(); +const decoder = new TextDecoder(); +const message = 'body set after creation'; +const expected = encoder.encode(message); + +const done = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + + deepStrictEqual(received, expected); + strictEqual(decoder.decode(received), message); + + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + done.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// Create a stream with no body. +const stream = await clientSession.createBidirectionalStream(); + +// Attach a body after creation. +stream.setBody(encoder.encode(message)); + +// Calling setBody() again should throw. +throws(() => { + stream.setBody(encoder.encode('second body')); +}, { + code: 'ERR_INVALID_STATE', +}); + +await Promise.all([stream.closed, done.promise]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-bidi-writer.mjs b/test/parallel/test-quic-stream-bidi-writer.mjs new file mode 100644 index 00000000000000..972c376257ec96 --- /dev/null +++ b/test/parallel/test-quic-stream-bidi-writer.mjs @@ -0,0 +1,63 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: writer API for bidirectional streams. +// Exercises writeSync, write (async), endSync, and verifies that data +// written in multiple chunks arrives intact and in order on the server. +// Also tests that the writer reports correct state after operations. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const encoder = new TextEncoder(); +const decoder = new TextDecoder(); + +const done = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + strictEqual(decoder.decode(received), 'chunk1chunk2chunk3'); + + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + done.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream(); +const w = stream.writer; + +// Writer should be open. +strictEqual(typeof w.desiredSize, 'number'); + +// Write multiple chunks synchronously. +strictEqual(w.writeSync(encoder.encode('chunk1')), true); +strictEqual(w.writeSync(encoder.encode('chunk2')), true); +strictEqual(w.writeSync(encoder.encode('chunk3')), true); + +// End the write side — returns total bytes written. +const totalWritten = w.endSync(); +strictEqual(totalWritten, 18); // 6 * 3 + +// After end, write should return false. +strictEqual(w.writeSync(encoder.encode('nope')), false); + +// desiredSize should be null after close. +strictEqual(w.desiredSize, null); + +await Promise.all([stream.closed, done.promise]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-body-async-error.mjs b/test/parallel/test-quic-stream-body-async-error.mjs new file mode 100644 index 00000000000000..b84df950a34997 --- /dev/null +++ b/test/parallel/test-quic-stream-body-async-error.mjs @@ -0,0 +1,46 @@ +// Flags: --experimental-quic --no-warnings + +// Test: async iterable source error destroys the stream. +// When the async iterable body source throws, the stream should be +// destroyed with the error and stream.closed should reject. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { rejects } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const encoder = new TextEncoder(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; +}), { transportParams: { maxIdleTimeout: 1 } }); + +const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxIdleTimeout: 1 }, +}); +await clientSession.opened; + +const testError = new Error('async source error'); + +async function* failingSource() { + yield encoder.encode('partial '); + throw testError; +} + +const stream = await clientSession.createBidirectionalStream(); + +// Attach the closed handler BEFORE setBody so the rejection from +// stream.destroy(err) is caught before it becomes unhandled. +const closedPromise = rejects(stream.closed, testError); + +stream.setBody(failingSource()); + +// The stream should be destroyed with the source error. +await Promise.all([closedPromise, clientSession.closed]); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-body-async-iterable.mjs b/test/parallel/test-quic-stream-body-async-iterable.mjs new file mode 100644 index 00000000000000..b73cfd07b67441 --- /dev/null +++ b/test/parallel/test-quic-stream-body-async-iterable.mjs @@ -0,0 +1,51 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: body from async iterable source. +// An async generator is used as the body source. The data is consumed +// via the streaming path in configureOutbound. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import * as assert from 'node:assert'; + +const { deepStrictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const encoder = new TextEncoder(); +const chunks = ['hello ', 'from ', 'async ', 'iterable']; +const expected = encoder.encode(chunks.join('')); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + deepStrictEqual(received, expected); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +async function* generateChunks() { + for (const chunk of chunks) { + yield encoder.encode(chunk); + } +} + +const stream = await clientSession.createBidirectionalStream(); +stream.setBody(generateChunks()); + +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars +await Promise.all([stream.closed, serverDone.promise]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-body-error.mjs b/test/parallel/test-quic-stream-body-error.mjs new file mode 100644 index 00000000000000..6045d8a82f4d95 --- /dev/null +++ b/test/parallel/test-quic-stream-body-error.mjs @@ -0,0 +1,51 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: stream destroyed during async source consumption. +// When the stream is destroyed while an async iterable body source is +// active, the source consumption should stop. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import * as assert from 'node:assert'; +const { setTimeout } = await import('node:timers/promises'); + +const { ok } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const encoder = new TextEncoder(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; +}), { transportParams: { maxIdleTimeout: 1 } }); + +const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxIdleTimeout: 1 }, +}); +await clientSession.opened; + +let yieldCount = 0; +async function* slowSource() { + while (true) { + yield encoder.encode(`chunk ${yieldCount++} `); + await setTimeout(50); + } +} + +const stream = await clientSession.createBidirectionalStream(); +stream.setBody(slowSource()); + +// Destroy the stream after a short delay. +await setTimeout(200); +stream.destroy(); +await stream.closed; + +// The source should have stopped. It may yield a few chunks +// but not an unbounded number. +ok(yieldCount < 50, `yieldCount too high: ${yieldCount}`); + +await clientSession.closed; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-body-filehandle.mjs b/test/parallel/test-quic-stream-body-filehandle.mjs new file mode 100644 index 00000000000000..a990f3a23ae14f --- /dev/null +++ b/test/parallel/test-quic-stream-body-filehandle.mjs @@ -0,0 +1,122 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: FileHandle as body source for QUIC streams. +// The file contents are sent via an fd-backed DataQueue. The FileHandle +// is automatically closed when the stream finishes. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import { writeFileSync } from 'node:fs'; +import { open } from 'node:fs/promises'; + +const tmpdir = await import('../common/tmpdir.js'); + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const decoder = new TextDecoder(); +const testContent = 'Hello from a file!\nLine two.\n'; + +tmpdir.refresh(); +const testFile = tmpdir.resolve('quic-fh-test.txt'); +writeFileSync(testFile, testContent); + +// FileHandle as body in createBidirectionalStream. +{ + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const body = await bytes(stream); + strictEqual(decoder.decode(body), testContent); + stream.writer.writeSync('ok'); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); + })); + + const clientSession = await connect(serverEndpoint.address); + await clientSession.opened; + + const fh = await open(testFile, 'r'); + const stream = await clientSession.createBidirectionalStream({ + body: fh, + }); + + const response = await bytes(stream); + strictEqual(decoder.decode(response), 'ok'); + await Promise.all([stream.closed, serverDone.promise, clientSession.closed]); + await serverEndpoint.close(); + // FileHandle is closed automatically when the stream finishes. +} + +// FileHandle as body in setBody. +{ + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const body = await bytes(stream); + strictEqual(decoder.decode(body), testContent); + stream.writer.writeSync('ok'); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); + })); + + const clientSession = await connect(serverEndpoint.address); + await clientSession.opened; + + const fh = await open(testFile, 'r'); + const stream = await clientSession.createBidirectionalStream(); + stream.setBody(fh); + + const response = await bytes(stream); + strictEqual(decoder.decode(response), 'ok'); + await Promise.all([stream.closed, serverDone.promise, clientSession.closed]); + await serverEndpoint.close(); + // FileHandle is closed automatically when the stream finishes. +} + +// Locked FileHandle rejects on second use. +{ + const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + // Drain the incoming data so the stream can close cleanly. + await bytes(stream); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + }); + })); + + const clientSession = await connect(serverEndpoint.address); + await clientSession.opened; + + const fh = await open(testFile, 'r'); + + // First use locks the FileHandle. + const stream1 = await clientSession.createBidirectionalStream({ + body: fh, + }); + + // Second use should reject because it's locked. + await assert.rejects( + clientSession.createBidirectionalStream({ body: fh }), + { code: 'ERR_INVALID_STATE' }, + ); + + await Promise.all([stream1.closed, clientSession.closed]); + await serverEndpoint.close(); + // FileHandle is closed automatically when the stream finishes. +} diff --git a/test/parallel/test-quic-stream-body-pooled-buffer.mjs b/test/parallel/test-quic-stream-body-pooled-buffer.mjs new file mode 100644 index 00000000000000..f716c95ac2eac1 --- /dev/null +++ b/test/parallel/test-quic-stream-body-pooled-buffer.mjs @@ -0,0 +1,51 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: pooled Buffer body copies correctly. +// Buffer.from() creates pooled buffers that share a larger ArrayBuffer. +// The QUIC body handling must copy (not transfer) partial views. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual, ok } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const message = 'pooled buffer test data'; +const expected = Buffer.from(message); + +// Verify this IS a pooled buffer (byteLength < buffer.byteLength). +ok( + expected.buffer.byteLength > expected.byteLength, + 'Buffer should be pooled for this test to be meaningful', +); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + strictEqual(Buffer.from(received).toString(), message); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// Send the pooled buffer as body via setBody. +const stream = await clientSession.createBidirectionalStream(); +stream.setBody(expected); + +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars +await Promise.all([stream.closed, serverDone.promise]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-body-promise-error.mjs b/test/parallel/test-quic-stream-body-promise-error.mjs new file mode 100644 index 00000000000000..e3cec3fe94e76d --- /dev/null +++ b/test/parallel/test-quic-stream-body-promise-error.mjs @@ -0,0 +1,38 @@ +// Flags: --experimental-quic --no-warnings + +// Test: body: Promise rejection destroys the stream. +// When the body is a Promise that rejects, the stream should be +// destroyed with the rejection error. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { rejects } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; +}), { transportParams: { maxIdleTimeout: 5 } }); + +const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxIdleTimeout: 5 }, +}); +await clientSession.opened; + +const testError = new Error('promise body rejected'); +const stream = await clientSession.createBidirectionalStream(); + +// Attach the closed handler BEFORE setBody so the rejection from +// stream.destroy(err) is caught before it becomes unhandled. +const closedPromise = rejects(stream.closed, testError); + +stream.setBody(Promise.reject(testError)); + +// The stream should be destroyed with the rejection error. +await Promise.all([closedPromise, clientSession.closed]); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-body-promise-reject.mjs b/test/parallel/test-quic-stream-body-promise-reject.mjs new file mode 100644 index 00000000000000..6cd4e1004fbeac --- /dev/null +++ b/test/parallel/test-quic-stream-body-promise-reject.mjs @@ -0,0 +1,51 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: body: nested promise resolution. +// Native promises auto-flatten, so Promise> resolves +// to the inner string value. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +// Nested promises — native promises auto-flatten, so the +// resolved value is never itself a promise. +{ + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + strictEqual( + new TextDecoder().decode(received), + 'nested promise', + ); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); + })); + + const clientSession = await connect(serverEndpoint.address); + await clientSession.opened; + + // Double-nested promise: Promise> + const stream = await clientSession.createBidirectionalStream(); + stream.setBody( + Promise.resolve(Promise.resolve('nested promise')), + ); + + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + await Promise.all([stream.closed, serverDone.promise]); + await clientSession.close(); + await serverEndpoint.close(); +} diff --git a/test/parallel/test-quic-stream-body-promise.mjs b/test/parallel/test-quic-stream-body-promise.mjs new file mode 100644 index 00000000000000..040372f2c38832 --- /dev/null +++ b/test/parallel/test-quic-stream-body-promise.mjs @@ -0,0 +1,71 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: body from Promise. +// Promise is awaited then configured as a string body. +// Promise is awaited then closes the writable side. +// BODY-13 (Promise rejection) is not tested here because the rejected +// promise calls resetStream synchronously which may or may not cause +// the server's onstream to fire depending on timing. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { text, bytes } = await import('stream/iter'); + +let streamIdx = 0; +const totalStreams = 2; +const allDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const idx = streamIdx++; + + if (idx === 0) { + // Promise resolved to string data. + const received = await text(stream); + strictEqual(received, 'resolved string'); + } else if (idx === 1) { + // Promise closes the writable side. + const received = await bytes(stream); + strictEqual(received.byteLength, 0); + } + + stream.writer.endSync(); + await stream.closed; + + if (streamIdx === totalStreams) { + serverSession.close(); + allDone.resolve(); + } + }, totalStreams); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// Promise +{ + const stream = await clientSession.createBidirectionalStream(); + stream.setBody(Promise.resolve('resolved string')); + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + await stream.closed; +} + +// Promise +{ + const stream = await clientSession.createBidirectionalStream(); + stream.setBody(Promise.resolve(null)); + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + await stream.closed; +} + +await allDone.promise; +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-body-readable-stream.mjs b/test/parallel/test-quic-stream-body-readable-stream.mjs new file mode 100644 index 00000000000000..5d23b74947d1bc --- /dev/null +++ b/test/parallel/test-quic-stream-body-readable-stream.mjs @@ -0,0 +1,66 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: body from ReadableStream and stream.Readable. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { deepStrictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); +const { Readable } = await import('node:stream'); + +const encoder = new TextEncoder(); +const message = 'readable stream body'; +const expected = encoder.encode(message); + +let serverStreamCount = 0; +const allDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + deepStrictEqual(received, expected); + stream.writer.endSync(); + await stream.closed; + if (++serverStreamCount === 2) { + serverSession.close(); + allDone.resolve(); + } + }, 2); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// Web ReadableStream as body source. +{ + const rs = new ReadableStream({ + start(controller) { + controller.enqueue(encoder.encode(message)); + controller.close(); + }, + }); + const stream = await clientSession.createBidirectionalStream(); + stream.setBody(rs); + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + await stream.closed; +} + +// Node.js stream.Readable as body source. +{ + const readable = Readable.from([encoder.encode(message)]); + const stream = await clientSession.createBidirectionalStream(); + stream.setBody(readable); + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + await stream.closed; +} + +await allDone.promise; +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-body-sources.mjs b/test/parallel/test-quic-stream-body-sources.mjs new file mode 100644 index 00000000000000..06b8cad7ec56ef --- /dev/null +++ b/test/parallel/test-quic-stream-body-sources.mjs @@ -0,0 +1,88 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: various body source types for createBidirectionalStream. +// Verifies that ArrayBuffer, ArrayBufferView (with non-zero byteOffset), +// SharedArrayBuffer, and Blob bodies all deliver data correctly. +// Covers BIDI-07, BIDI-08, BIDI-09, BIDI-10, BIDI-11, BODY-03..06. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import * as assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const encoder = new TextEncoder(); +const message = 'hello body sources'; +const expectedBytes = encoder.encode(message); + +let testIndex = 0; +const totalTests = 4; +const allDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + await bytes(stream); + stream.writer.endSync(); + await stream.closed; + + testIndex++; + if (testIndex === totalTests) { + serverSession.close(); + allDone.resolve(); + } + }, totalTests); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// Test 1: ArrayBuffer body +{ + const buf = encoder.encode(message); + const ab = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength); + const stream = await clientSession.createBidirectionalStream({ body: ab }); + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + await stream.closed; +} + +// Test 2: ArrayBufferView with non-zero byteOffset +{ + const backing = new ArrayBuffer(64); + const fullView = new Uint8Array(backing); + const offset = 10; + fullView.set(expectedBytes, offset); + const view = new Uint8Array(backing, offset, expectedBytes.byteLength); + const stream = await clientSession.createBidirectionalStream({ body: view }); + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + await stream.closed; +} + +// Test 3: SharedArrayBuffer body +{ + const sab = new SharedArrayBuffer(expectedBytes.byteLength); + const sabView = new Uint8Array(sab); + sabView.set(expectedBytes); + const stream = await clientSession.createBidirectionalStream({ body: sabView }); + // The SharedArrayBuffer should still be usable (copied, not transferred). + strictEqual(sab.byteLength, expectedBytes.byteLength); + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + await stream.closed; +} + +// Test 4: Blob body +{ + const blob = new Blob([expectedBytes]); + const stream = await clientSession.createBidirectionalStream({ body: blob }); + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + await stream.closed; +} + +await allDone.promise; +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-body-state.mjs b/test/parallel/test-quic-stream-body-state.mjs new file mode 100644 index 00000000000000..8dcf6d6c6771ef --- /dev/null +++ b/test/parallel/test-quic-stream-body-state.mjs @@ -0,0 +1,85 @@ +// Flags: --experimental-quic --no-warnings + +// Test: setBody / writer mutual exclusion. +// setBody() after writer accessed throws. +// writer after setBody() throws. +// setBody() on destroyed stream throws. +// BODY-17 (setBody twice throws) is already covered by +// test-quic-stream-bidi-setbody.mjs. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok, throws } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const encoder = new TextEncoder(); + +let streamCount = 0; +// BODY-20 destroys the stream before data is sent, so the server only sees 2. +const totalStreams = 2; +const allDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + // Close the server's write side so the stream can fully close. + stream.writer.endSync(); + await stream.closed; + if (++streamCount === totalStreams) { + serverSession.close(); + allDone.resolve(); + } + }, totalStreams); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// setBody() after writer accessed throws. +{ + const stream = await clientSession.createBidirectionalStream(); + // Access the writer — this initializes the streaming source. + const w = stream.writer; + ok(w); + throws(() => { + stream.setBody(encoder.encode('too late')); + }, { + code: 'ERR_INVALID_STATE', + }); + w.endSync(); + await stream.closed; +} + +// Writer after setBody() throws. +{ + const stream = await clientSession.createBidirectionalStream(); + stream.setBody(encoder.encode('body set')); + throws(() => { + stream.writer; // eslint-disable-line no-unused-expressions + }, { + code: 'ERR_INVALID_STATE', + }); + await stream.closed; +} + +// setBody() on destroyed stream throws. +{ + const stream = await clientSession.createBidirectionalStream(); + stream.destroy(); + throws(() => { + stream.setBody(encoder.encode('destroyed')); + }, { + code: 'ERR_INVALID_STATE', + }); + // stream.closed resolves (destroy without error). + await stream.closed; +} + +await allDone.promise; +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-body-string-shorthand.mjs b/test/parallel/test-quic-stream-body-string-shorthand.mjs new file mode 100644 index 00000000000000..04535def7568fb --- /dev/null +++ b/test/parallel/test-quic-stream-body-string-shorthand.mjs @@ -0,0 +1,106 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: string body shorthand for stream creation and setBody. +// Strings are automatically encoded as UTF-8. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const decoder = new TextDecoder(); + +// String body in createBidirectionalStream options. +{ + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const body = await bytes(stream); + strictEqual(decoder.decode(body), 'hello from string body'); + stream.writer.writeSync(new TextEncoder().encode('ok')); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); + })); + + const clientSession = await connect(serverEndpoint.address); + await clientSession.opened; + + // Body provided as a string — should be UTF-8 encoded automatically. + const stream = await clientSession.createBidirectionalStream({ + body: 'hello from string body', + }); + + const response = await bytes(stream); + strictEqual(decoder.decode(response), 'ok'); + await Promise.all([stream.closed, serverDone.promise, clientSession.closed]); + await serverEndpoint.close(); +} + +// String body with setBody. +{ + const serverDone = Promise.withResolvers(); + + const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const body = await bytes(stream); + strictEqual(decoder.decode(body), 'setBody string'); + stream.writer.writeSync(new TextEncoder().encode('ok')); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); + })); + + const clientSession = await connect(serverEndpoint.address); + await clientSession.opened; + + const stream = await clientSession.createBidirectionalStream(); + stream.setBody('setBody string'); + + const response = await bytes(stream); + strictEqual(decoder.decode(response), 'ok'); + await Promise.all([stream.closed, serverDone.promise, clientSession.closed]); + await serverEndpoint.close(); +} + +// UTF-8 multi-byte characters preserved correctly. +{ + const serverDone = Promise.withResolvers(); + const testString = 'Hello \u{1F600} world \u00E9\u00FC\u00F1'; + + const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const body = await bytes(stream); + strictEqual(decoder.decode(body), testString); + stream.writer.writeSync(new TextEncoder().encode('ok')); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); + })); + + const clientSession = await connect(serverEndpoint.address); + await clientSession.opened; + + const stream = await clientSession.createBidirectionalStream({ + body: testString, + }); + + const response = await bytes(stream); + strictEqual(decoder.decode(response), 'ok'); + await Promise.all([stream.closed, serverDone.promise, clientSession.closed]); + await serverEndpoint.close(); +} diff --git a/test/parallel/test-quic-stream-body-string.mjs b/test/parallel/test-quic-stream-body-string.mjs new file mode 100644 index 00000000000000..6b3f96ee7b0d23 --- /dev/null +++ b/test/parallel/test-quic-stream-body-string.mjs @@ -0,0 +1,43 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: body: string sends UTF-8 encoded data. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { text } = await import('stream/iter'); + +const message = 'Hello from a string body! 🎉 Unicode works.'; + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await text(stream); + strictEqual(received, message); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// setBody with a string — configureOutbound handles this via +// Buffer.from(body, 'utf8'). +const stream = await clientSession.createBidirectionalStream(); +stream.setBody(message); + +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars +await Promise.all([stream.closed, serverDone.promise]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-body-sync-iterable.mjs b/test/parallel/test-quic-stream-body-sync-iterable.mjs new file mode 100644 index 00000000000000..f022df9b5ad7dc --- /dev/null +++ b/test/parallel/test-quic-stream-body-sync-iterable.mjs @@ -0,0 +1,45 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: body from sync iterable source. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { deepStrictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const encoder = new TextEncoder(); +const chunks = ['sync ', 'iterable ', 'source']; +const expected = encoder.encode(chunks.join('')); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + deepStrictEqual(received, expected); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// Create an array of Uint8Arrays as a sync iterable body. +const bodyChunks = chunks.map((c) => encoder.encode(c)); +const stream = await clientSession.createBidirectionalStream(); +stream.setBody(bodyChunks); + +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars +await Promise.all([stream.closed, serverDone.promise]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-closed-promise.mjs b/test/parallel/test-quic-stream-closed-promise.mjs new file mode 100644 index 00000000000000..2c30a44fb70bb3 --- /dev/null +++ b/test/parallel/test-quic-stream-closed-promise.mjs @@ -0,0 +1,40 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: stream.closed promise resolves after normal completion. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const encoder = new TextEncoder(); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + await bytes(stream); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode('normal close'), +}); + +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + +// Closed should resolve (not reject). +await Promise.all([stream.closed, serverDone.promise]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-closed-rejects.mjs b/test/parallel/test-quic-stream-closed-rejects.mjs new file mode 100644 index 00000000000000..aa0f3c083b715e --- /dev/null +++ b/test/parallel/test-quic-stream-closed-rejects.mjs @@ -0,0 +1,55 @@ +// Flags: --experimental-quic --no-warnings + +// Test: stream.closed promise rejects on error. +// The server resets the stream, causing both sides' closed to reject +// with the application error code. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import * as assert from 'node:assert'; + +const { ok, rejects, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const encoder = new TextEncoder(); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + stream.resetStream(1n); + + // The server's own stream.closed should also reject with the + // reset error code. + await rejects(stream.closed, (error) => { + strictEqual(error.code, 'ERR_QUIC_APPLICATION_ERROR'); + ok(error.message.includes('1')); + return true; + }); + + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode('will error'), +}); + +// Client's closed should reject with the reset error code. +await rejects(stream.closed, (error) => { + strictEqual(error.code, 'ERR_QUIC_APPLICATION_ERROR'); + ok(error.message.includes('1')); + return true; +}); + +await serverDone.promise; +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-destroy-emits-reset.mjs b/test/parallel/test-quic-stream-destroy-emits-reset.mjs new file mode 100644 index 00000000000000..280e25bc293a2d --- /dev/null +++ b/test/parallel/test-quic-stream-destroy-emits-reset.mjs @@ -0,0 +1,69 @@ +// Flags: --experimental-quic --no-warnings + +// stream.destroy(err) emits RESET_STREAM on the wire even when the +// user never accessed `stream.writer`. Previously the wire frame was +// only emitted via the writer.fail path inside [kFinishClose], so +// streams that destroyed without ever creating a writer (e.g. used +// `setBody()` or never wrote at all) left the write side dangling on +// the wire and the peer kept the stream alive until the session-level +// idle timer fired. +// +// Verified by observing the server-side `onreset` callback. The wire +// code is the negotiated application's "internal error" code: for +// the test fixture's non-h3 ALPN (`quic-test`) the C++ +// DefaultApplication reports `1n`, which propagates to the server +// as `ERR_QUIC_APPLICATION_ERROR` carrying `1n` in its message. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual, ok, rejects } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const serverResetSeen = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall((stream) => { + // The cascade-driven destroy of the server-side stream after the + // peer reset rejects `stream.closed` with the wire error; the + // test does not assert on its specific shape, only that `onreset` + // fired with the expected code. + stream.onreset = mustCall((err) => { + strictEqual(err.code, 'ERR_QUIC_APPLICATION_ERROR'); + // The DefaultApplication's internal error code is 0x1n, which + // util.format renders as `1n` (BigInt) in the message text. + ok(err.message.includes('1n'), + `expected '1n' in message, got: ${err.message}`); + serverResetSeen.resolve(); + }); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// Bidirectional stream with a body source set up front. No JS-side +// writer is accessed -- the body is consumed and pushed by the C++ +// streaming source. Pre-B13, calling destroy() on this stream would +// not emit RESET_STREAM because the writer.fail path was the only +// emission site. +const stream = await clientSession.createBidirectionalStream({ + body: 'hello world', +}); + +const err = new Error('destroy without writer'); +// Pre-attach the rejection assertion before destroying so the +// resulting `stream.closed` rejection isn't reported as unhandled. +const clientClosedAssertion = rejects(stream.closed, err); + +stream.destroy(err); + +await Promise.all([clientClosedAssertion, serverResetSeen.promise]); + +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-destroy-emits-stop-sending.mjs b/test/parallel/test-quic-stream-destroy-emits-stop-sending.mjs new file mode 100644 index 00000000000000..dc78908af7a3b1 --- /dev/null +++ b/test/parallel/test-quic-stream-destroy-emits-stop-sending.mjs @@ -0,0 +1,83 @@ +// Flags: --experimental-quic --no-warnings + +// stream.destroy(err) emits STOP_SENDING on the wire so the peer +// stops sending data the local side is about to discard. Previously, +// destroy never sent STOP_SENDING - the readable side stayed open +// from the peer's perspective and they would keep transmitting until +// the session-level idle timer fired. +// +// Verified via the server-side writer's `desiredSize` getter, which +// returns `null` once `state.writeEnded` is set. STOP_SENDING from +// the client triggers `Stream::ReceiveStopSending -> EndWritable` on +// the server, which sets `state.writeEnded = 1`. +// +// ngtcp2 packs RESET_STREAM before STOP_SENDING in the same packet +// regardless of the order our JS code makes the calls. The server +// processes RESET_STREAM first (firing `onreset`) and then +// STOP_SENDING. The observation must therefore be deferred until +// after the `onreset` callback returns so ngtcp2 can finish +// processing the packet. Capturing `writer.desiredSize` synchronously +// inside `onreset` would always see the pre-STOP_SENDING value. +// Throwing inside `onreset` would also crash the process before +// STOP_SENDING could be processed. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const serverObservation = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall((stream) => { + const writer = stream.writer; + // Sanity: the writer is active before the peer tears the stream + // down, so desiredSize is a number reflecting the initial + // flow-control window. + if (typeof writer.desiredSize !== 'number') { + serverObservation.reject(new Error( + `expected initial writer.desiredSize to be a number, ` + + `got ${writer.desiredSize}`)); + return; + } + stream.onreset = mustCall(() => { + // Defer the writeEnded observation: ngtcp2 fires this callback + // synchronously while processing the RESET_STREAM frame, before + // it gets to the STOP_SENDING frame in the same packet. By the + // next event loop tick the rest of the packet has been + // processed and `Stream::ReceiveStopSending -> EndWritable` has + // flipped `state.writeEnded` to 1, which makes the writer's + // desiredSize getter return null. + setImmediate(() => { + serverObservation.resolve(writer.desiredSize); + }); + }); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream({ + body: 'client-data', +}); + +const err = new Error('destroy with error'); +const clientClosedAssertion = assert.rejects(stream.closed, err); + +stream.destroy(err); + +const observedDesiredSize = await serverObservation.promise; +strictEqual(observedDesiredSize, null); + +await clientClosedAssertion; + +clientSession.close(); +await clientSession.closed; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-destroy-options-code.mjs b/test/parallel/test-quic-stream-destroy-options-code.mjs new file mode 100644 index 00000000000000..bdb64329b477bb --- /dev/null +++ b/test/parallel/test-quic-stream-destroy-options-code.mjs @@ -0,0 +1,55 @@ +// Flags: --experimental-quic --no-warnings + +// stream.destroy(error, options) accepts an explicit `options.code` +// that overrides the default wire code derived from `error`. The +// caller-supplied code is sent on RESET_STREAM (and STOP_SENDING for +// the readable side) so the peer observes exactly that code. +// +// For the test fixture's non-h3 ALPN (`quic-test`), the +// DefaultApplication's `internalErrorCode` is `0x1n`. Without +// `options.code`, a plain `Error` would result in the peer seeing +// `0x1n`. With `options.code = 0x42n`, the peer must see `0x42n`. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual, ok, rejects } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const serverResetSeen = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall((stream) => { + stream.onreset = mustCall((err) => { + strictEqual(err.code, 'ERR_QUIC_APPLICATION_ERROR'); + ok(err.message.includes('66n'), + `expected '66n' in message, got: ${err.message}`); + serverResetSeen.resolve(); + }); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream({ + body: 'data', +}); + +const err = new Error('explicit code via options'); +const clientClosedAssertion = rejects(stream.closed, err); + +// `options.code` (0x42n) takes precedence over the default that +// would have been derived from `error` (which would be the session's +// internalErrorCode, 0x1n for non-h3). +stream.destroy(err, { code: 66n }); + +await Promise.all([clientClosedAssertion, serverResetSeen.promise]); + +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-destroy-options-validate.mjs b/test/parallel/test-quic-stream-destroy-options-validate.mjs new file mode 100644 index 00000000000000..ba8064121a9821 --- /dev/null +++ b/test/parallel/test-quic-stream-destroy-options-validate.mjs @@ -0,0 +1,73 @@ +// Flags: --experimental-quic --no-warnings + +// stream.destroy(error, options) validates `options` up front, before +// any side effects. A malformed `options` argument must throw without +// mutating `#destroying`, emitting wire frames, invoking `onerror`, +// or settling the `closed` promise. After the throw, the stream is +// still alive and a subsequent destroy with valid options must +// succeed. + +import { hasQuic, skip, mustCall, mustNotCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual, throws, rejects } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const serverEndpoint = await listen(mustCall(() => true)); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream(); + +stream.onerror = mustNotCall( + 'stream.onerror must not fire when destroy() throws on bad options'); + +// 1. options is not an object -> throws ERR_INVALID_ARG_TYPE. +throws(() => stream.destroy(new Error('x'), 'not an object'), { + code: 'ERR_INVALID_ARG_TYPE', +}); +strictEqual(stream.destroyed, false); + +// 2. options.code is the wrong type -> throws ERR_INVALID_ARG_TYPE. +throws(() => stream.destroy(new Error('x'), { code: 'oops' }), { + code: 'ERR_INVALID_ARG_TYPE', +}); +strictEqual(stream.destroyed, false); + +throws(() => stream.destroy(new Error('x'), { code: true }), { + code: 'ERR_INVALID_ARG_TYPE', +}); +strictEqual(stream.destroyed, false); + +// 3. options.reason is the wrong type -> throws ERR_INVALID_ARG_TYPE. +throws(() => stream.destroy(new Error('x'), { reason: 42 }), { + code: 'ERR_INVALID_ARG_TYPE', +}); +strictEqual(stream.destroyed, false); + +// Switch to the real error handler before the final destroy so the +// `mustNotCall` above does not fire on the legitimate teardown. +const finalError = new Error('final destroy'); +stream.onerror = mustCall((err) => { strictEqual(err, finalError); }); + +const clientClosedAssertion = rejects(stream.closed, finalError); + +// 4. Valid options accepted: bigint code. +stream.destroy(finalError, { code: 0x10n, reason: 'cleanup' }); +strictEqual(stream.destroyed, true); + +// 5. Re-entry with arbitrarily bad options is a no-op (the +// re-entrancy guard returns before validation runs). +stream.destroy(new Error('after-destroy'), { code: 'still-bad' }); +strictEqual(stream.destroyed, true); + +await clientClosedAssertion; + +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-error-graceful-close.mjs b/test/parallel/test-quic-stream-error-graceful-close.mjs new file mode 100644 index 00000000000000..ffd88c5026462b --- /dev/null +++ b/test/parallel/test-quic-stream-error-graceful-close.mjs @@ -0,0 +1,52 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: stream errors during graceful close are handled. +// When a session is gracefully closing and an open stream encounters +// an error, the session should still close cleanly without crashing. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok, rejects, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + // Read some data then reset the stream while the client + // is still sending — this creates a stream error. + const data = await bytes(stream); + ok(data.byteLength > 0); + stream.resetStream(99n); + serverSession.close(); + serverDone.resolve(); + }); +}), { + transportParams: { initialMaxStreamDataBidiRemote: 256 }, + onerror(err) { ok(err); }, +}); + +const clientSession = await connect(serverEndpoint.address, { + onerror(err) { ok(err); }, +}); +await clientSession.opened; + +// Send data on a stream. The server will reset it. +const stream = await clientSession.createBidirectionalStream(); +stream.setBody(new Uint8Array(4096)); + +// The stream will error due to the server's reset. +// The session should still close gracefully. +await rejects(stream.closed, (error) => { + strictEqual(error.code, 'ERR_QUIC_APPLICATION_ERROR'); + return true; +}); +await Promise.all([serverDone.promise, clientSession.closed]); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-id-ordering.mjs b/test/parallel/test-quic-stream-id-ordering.mjs new file mode 100644 index 00000000000000..ee80480fc2cd71 --- /dev/null +++ b/test/parallel/test-quic-stream-id-ordering.mjs @@ -0,0 +1,56 @@ +// Flags: --experimental-quic --no-warnings + +// Test: stream IDs are strictly increasing and unique. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const encoder = new TextEncoder(); +const serverDone = Promise.withResolvers(); +let serverStreamCount = 0; + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + stream.writer.endSync(); + await stream.closed; + if (++serverStreamCount === 10) { + serverSession.close(); + serverDone.resolve(); + } + }, 10); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const ids = []; +for (let i = 0; i < 10; i++) { + const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode(`stream ${i}`), + }); + ids.push(stream.id); + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + await stream.closed; +} + +// Verify IDs are strictly increasing. +for (let i = 1; i < ids.length; i++) { + ok(ids[i] > ids[i - 1], + `Stream ID ${ids[i]} should be > ${ids[i - 1]}`); +} + +// Verify all IDs are unique. +const uniqueIds = new Set(ids); +strictEqual(uniqueIds.size, ids.length); + +await Promise.all([serverDone.promise, clientSession.closed]); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-iteration-batching.mjs b/test/parallel/test-quic-stream-iteration-batching.mjs new file mode 100644 index 00000000000000..092f270304ff12 --- /dev/null +++ b/test/parallel/test-quic-stream-iteration-batching.mjs @@ -0,0 +1,66 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: batching — multiple chunks collected per iteration step. +// When multiple chunks are available synchronously (e.g., the server +// sends them rapidly), the async iterator should batch them into +// arrays of Uint8Array, not yield one chunk at a time. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const encoder = new TextEncoder(); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + // Send multiple small chunks rapidly — they should be batched + // on the receiving side. + const w = stream.writer; + for (let i = 0; i < 20; i++) { + w.writeSync(encoder.encode(`chunk${i} `)); + } + w.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode('request'), +}); + +// Iterate and count batches vs total chunks. +let batchCount = 0; +let totalChunks = 0; +for await (const batch of stream) { + batchCount++; + ok(Array.isArray(batch), 'Each iteration step yields an array'); + for (const chunk of batch) { + ok(chunk instanceof Uint8Array, 'Each item is a Uint8Array'); + totalChunks++; + } +} + +// There should be fewer batches than total chunks — proving batching. +// (On very slow machines, each chunk might arrive separately, so we +// can't assert batchCount < totalChunks strictly. But totalChunks +// should be > 0.) +ok(totalChunks > 0, 'Should have received chunks'); +ok(batchCount > 0, 'Should have received batches'); + +await Promise.all([stream.closed, serverDone.promise]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-iteration-break.mjs b/test/parallel/test-quic-stream-iteration-break.mjs new file mode 100644 index 00000000000000..23febf831b26d6 --- /dev/null +++ b/test/parallel/test-quic-stream-iteration-break.mjs @@ -0,0 +1,58 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: iterator cleanup on break. +// When the consumer breaks out of a for-await loop, the iterator's +// finally block should clean up (clear wakeup, release reader). +// The stream should still be usable for closing. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const encoder = new TextEncoder(); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + // Send multiple chunks so the client can break mid-stream. + const w = stream.writer; + for (let i = 0; i < 10; i++) { + w.writeSync(encoder.encode(`chunk ${i} `)); + } + w.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode('request'), +}); + +// Break out of the iterator after the first batch. +let batchCount = 0; +for await (const batch of stream) { + batchCount++; + ok(Array.isArray(batch)); + break; // Exit early — should trigger iterator cleanup. +} +strictEqual(batchCount, 1); + +// After break, the stream should still be closable. +// End the writable side (it was already ended by the body). +// The stream closed promise should resolve. +await Promise.all([stream.closed, serverDone.promise]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-iteration-destroyed.mjs b/test/parallel/test-quic-stream-iteration-destroyed.mjs new file mode 100644 index 00000000000000..0825b00c94e2d7 --- /dev/null +++ b/test/parallel/test-quic-stream-iteration-destroyed.mjs @@ -0,0 +1,39 @@ +// Flags: --experimental-quic --no-warnings + +// Test: destroyed stream returns finished iterator. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import * as assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const encoder = new TextEncoder(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode('destroy test'), +}); + +// Destroy the stream immediately. +stream.destroy(); + +// Iterating a destroyed stream should immediately finish. +const iter = stream[Symbol.asyncIterator](); +const { done } = await iter.next(); +strictEqual(done, true); + +await stream.closed; +await clientSession.close(); +await serverEndpoint.destroy(); diff --git a/test/parallel/test-quic-stream-iteration-double.mjs b/test/parallel/test-quic-stream-iteration-double.mjs new file mode 100644 index 00000000000000..76b88a529a444e --- /dev/null +++ b/test/parallel/test-quic-stream-iteration-double.mjs @@ -0,0 +1,59 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: second iterator rejects when first is active. +// Because [Symbol.asyncIterator]() is an async generator, creating the +// generator always succeeds. The lock check runs inside the body, so +// the ERR_INVALID_STATE manifests as a rejected .next() promise, not +// a synchronous throw on generator creation. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import * as assert from 'node:assert'; + +const { rejects, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const encoder = new TextEncoder(); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const iter1 = stream[Symbol.asyncIterator](); + // Advance the first iterator so the lock is set. + const first = await iter1.next(); + strictEqual(first.done, false); + + // A second iterator can be created (generator object), but + // advancing it should reject because the lock is held. + const iter2 = stream[Symbol.asyncIterator](); + await rejects(iter2.next(), { + code: 'ERR_INVALID_STATE', + }); + + // Drain the first iterator. + for (;;) { + const { done } = await iter1.next(); + if (done) break; + } + + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode('double iter test'), +}); +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars +await Promise.all([stream.closed, serverDone.promise]); +await clientSession.close(); diff --git a/test/parallel/test-quic-stream-iteration-nonreadable.mjs b/test/parallel/test-quic-stream-iteration-nonreadable.mjs new file mode 100644 index 00000000000000..e7f0ff4dc2c12a --- /dev/null +++ b/test/parallel/test-quic-stream-iteration-nonreadable.mjs @@ -0,0 +1,46 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: non-readable stream returns finished iterator. +// The sender side of a unidirectional stream is not readable, so +// iterating it should immediately return done: true. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import * as assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const encoder = new TextEncoder(); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + await bytes(stream); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createUnidirectionalStream({ + body: encoder.encode('uni data'), +}); + +// The sender side of a uni stream is not readable. +const iter = stream[Symbol.asyncIterator](); +const { done } = await iter.next(); +strictEqual(done, true); + +await Promise.all([serverDone.promise, stream.closed]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-iteration-pipeto.mjs b/test/parallel/test-quic-stream-iteration-pipeto.mjs new file mode 100644 index 00000000000000..a169f2d3af4b4f --- /dev/null +++ b/test/parallel/test-quic-stream-iteration-pipeto.mjs @@ -0,0 +1,48 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: pipeTo pipes a QUIC stream to another writable. +// The server reads from the incoming stream and pipes it to the +// outgoing writer side of the same bidi stream (echo). + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes, pipeTo } = await import('stream/iter'); + +const encoder = new TextEncoder(); +const message = 'pipeTo test data'; +const expected = encoder.encode(message); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + // Pipe the readable side of the stream to the writable side (echo). + // pipeTo(source, destination) where destination is the stream's writer. + await pipeTo(stream, stream.writer); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode(message), +}); + +// Read the echoed data. +const echoed = await bytes(stream); +assert.deepStrictEqual(echoed, expected); + +await Promise.all([stream.closed, serverDone.promise]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-iteration-pull.mjs b/test/parallel/test-quic-stream-iteration-pull.mjs new file mode 100644 index 00000000000000..69dc70f6b7d439 --- /dev/null +++ b/test/parallel/test-quic-stream-iteration-pull.mjs @@ -0,0 +1,52 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: pull applies a transform to a QUIC stream. +// Verifies that pull() can process chunks from a QUIC stream through +// a synchronous transform function. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { deepStrictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes, pull } = await import('stream/iter'); + +const encoder = new TextEncoder(); +const message = 'pull test'; +const expected = encoder.encode(message); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + // Use pull with an identity transform — pass chunks through. + const transformed = pull(stream, (chunk) => { + if (chunk === null) return null; + return chunk; + }); + const result = await bytes(transformed); + deepStrictEqual(result, expected); + + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode(message), +}); + +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars +await Promise.all([stream.closed, serverDone.promise]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-iteration-reset.mjs b/test/parallel/test-quic-stream-iteration-reset.mjs new file mode 100644 index 00000000000000..7b0d077064c563 --- /dev/null +++ b/test/parallel/test-quic-stream-iteration-reset.mjs @@ -0,0 +1,66 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: peer RESET_STREAM causes iterator to error. +// When the server resets the stream, the client's async iterator +// should throw or return early. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import * as assert from 'node:assert'; + +const { ok, rejects } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const encoder = new TextEncoder(); + +const serverReady = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + // Reset the stream from the server side. + stream.resetStream(42n); + await rejects(stream.closed, mustCall((err) => { + assert.ok(err); + return true; + })); + serverReady.resolve(); + await serverSession.closed; + }); +}), { transportParams: { maxIdleTimeout: 1 } }); + +const clientSession = await connect(serverEndpoint.address, { + transportParams: { maxIdleTimeout: 1 }, +}); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode('will be reset by server'), +}); + +// Set up the closed handler before the reset to avoid unhandled rejection. +const closedPromise = rejects(stream.closed, mustCall((err) => { + assert.ok(err); + return true; +})); + +await serverReady.promise; + +// The async iterator should either throw or return early when the +// peer resets the readable side. +try { + for await (const batch of stream) { + // May receive some data before the reset arrives. + ok(Array.isArray(batch)); + } +} catch { + // The iterator may throw when the reset arrives mid-iteration. +} + +// Either way, the stream should close. +await closedPromise; +await clientSession.closed; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-iteration.mjs b/test/parallel/test-quic-stream-iteration.mjs new file mode 100644 index 00000000000000..c33a486276c099 --- /dev/null +++ b/test/parallel/test-quic-stream-iteration.mjs @@ -0,0 +1,81 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: stream iteration basics. +// All use a single endpoint with one stream each to avoid the +// sequential endpoint bug. +// for-await yields Uint8Array[] batches. +// text() consumes stream as string. +// bytes() consumes stream as Uint8Array. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok, strictEqual, deepStrictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes, text } = await import('stream/iter'); + +const encoder = new TextEncoder(); +const message = 'iteration test data'; +const expected = encoder.encode(message); + +let streamCount = 0; +const allDone = Promise.withResolvers(); +const totalStreams = 3; + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const idx = streamCount++; + + if (idx === 0) { + // for-await yields batches. + const chunks = []; + for await (const batch of stream) { + ok(Array.isArray(batch), 'batch should be an array'); + for (const chunk of batch) { + ok(chunk instanceof Uint8Array, 'chunk should be Uint8Array'); + chunks.push(chunk); + } + } + ok(chunks.length > 0); + } else if (idx === 1) { + // text() consumes as string. + const result = await text(stream); + strictEqual(typeof result, 'string'); + strictEqual(result, message); + } else if (idx === 2) { + // bytes() consumes as Uint8Array. + const result = await bytes(stream); + ok(result instanceof Uint8Array); + deepStrictEqual(result, expected); + } + + stream.writer.endSync(); + await stream.closed; + + if (streamCount === totalStreams) { + serverSession.close(); + allDone.resolve(); + } + }, totalStreams); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// Send three streams sequentially. +for (let i = 0; i < totalStreams; i++) { + const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode(message), + }); + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + await stream.closed; +} + +await allDone.promise; +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-limits-pending.mjs b/test/parallel/test-quic-stream-limits-pending.mjs new file mode 100644 index 00000000000000..fed900696d91c5 --- /dev/null +++ b/test/parallel/test-quic-stream-limits-pending.mjs @@ -0,0 +1,71 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: stream limits and pending behavior. +// initialMaxStreamsBidi limits concurrent bidi streams. +// When the limit is reached, new streams are queued as pending +// and open when existing streams close. +// initialMaxStreamsUni limits concurrent uni streams (same behavior). + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const encoder = new TextEncoder(); +const allDone = Promise.withResolvers(); +let serverStreamCount = 0; + +// Server allows only 1 bidi stream at a time. +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + await bytes(stream); + stream.writer.endSync(); + await stream.closed; + if (++serverStreamCount === 2) { + serverSession.close(); + allDone.resolve(); + } + }, 2); +}), { + transportParams: { initialMaxStreamsBidi: 1 }, +}); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// First stream opens immediately (within the limit). +const s1 = await clientSession.createBidirectionalStream({ + body: encoder.encode('stream 1'), +}); + +// Second stream is created but queued as pending because the +// server only allows 1 concurrent bidi stream. +const s2 = await clientSession.createBidirectionalStream({ + body: encoder.encode('stream 2'), +}); + +// s2 should be pending until s1 closes and the server grants +// more stream credits. +strictEqual(s2.pending, true); + +// Drain and close the first stream. +for await (const _ of s1) { /* drain */ } // eslint-disable-line no-unused-vars +await s1.closed; + +// After s1 closes, the server sends MAX_STREAMS which opens s2. +// Wait for the server to receive both streams. +await allDone.promise; + +// s2 should no longer be pending. +for await (const _ of s2) { /* drain */ } // eslint-disable-line no-unused-vars +await s2.closed; + +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-limits-uni.mjs b/test/parallel/test-quic-stream-limits-uni.mjs new file mode 100644 index 00000000000000..4851b06a3cdffe --- /dev/null +++ b/test/parallel/test-quic-stream-limits-uni.mjs @@ -0,0 +1,56 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: uni stream limits and pending behavior. +// initialMaxStreamsUni = 1 limits concurrent uni streams. The second +// stream is queued as pending and opens after the first closes. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const encoder = new TextEncoder(); +const allDone = Promise.withResolvers(); +let serverStreamCount = 0; + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + await bytes(stream); + await stream.closed; + if (++serverStreamCount === 2) { + serverSession.close(); + allDone.resolve(); + } + }, 2); +}), { + transportParams: { initialMaxStreamsUni: 1 }, +}); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// First uni stream opens immediately. +const s1 = await clientSession.createUnidirectionalStream({ + body: encoder.encode('uni 1'), +}); + +// Second uni stream is pending (limit = 1). +const s2 = await clientSession.createUnidirectionalStream({ + body: encoder.encode('uni 2'), +}); +strictEqual(s2.pending, true); + +// Wait for both to complete. +await s1.closed; +await allDone.promise; +await s2.closed; + +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-many-rapid.mjs b/test/parallel/test-quic-stream-many-rapid.mjs new file mode 100644 index 00000000000000..77aaf0432430dc --- /dev/null +++ b/test/parallel/test-quic-stream-many-rapid.mjs @@ -0,0 +1,58 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: many streams opened and closed rapidly. +// Open 50 bidirectional streams in rapid succession, each with a +// small body. All streams should close successfully and the server +// should receive all data. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const streamCount = 50; +const encoder = new TextEncoder(); +let serverReceived = 0; +const allReceived = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const data = await bytes(stream); + strictEqual(data.byteLength, 5); + stream.writer.endSync(); + await stream.closed; + if (++serverReceived === streamCount) { + serverSession.close(); + allReceived.resolve(); + } + }, streamCount); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// Open 50 streams rapidly, each with a small body. +const streams = []; +for (let i = 0; i < streamCount; i++) { + const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode('hello'), + }); + streams.push(stream); +} + +// Wait for all client streams to close. +await Promise.all(streams.map(async (stream) => { + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + await stream.closed; +})); + +await allReceived.promise; +await clientSession.closed; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-onblocked.mjs b/test/parallel/test-quic-stream-onblocked.mjs new file mode 100644 index 00000000000000..3532d70fc5c32a --- /dev/null +++ b/test/parallel/test-quic-stream-onblocked.mjs @@ -0,0 +1,73 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: stream.onblocked fires when flow control blocks a stream. +// When the peer's stream-level receive window is exhausted, ngtcp2 returns +// NGTCP2_ERR_STREAM_DATA_BLOCKED. The stream is unscheduled and the +// onblocked callback fires. The stream resumes automatically when the peer +// sends MAX_STREAM_DATA to extend the window. +// Strategy: set the body to a buffer larger than the flow control window. +// ngtcp2 sends the initial window then blocks. onblocked fires. Flow +// control extension eventually unblocks and the full transfer completes. + +import { hasQuic, skip, mustCall, mustCallAtLeast } from '../common/index.mjs'; +import assert from 'node:assert'; +import dc from 'node:diagnostics_channel'; + +const { ok, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +// quic.stream.blocked fires when a stream is flow-control blocked. +dc.subscribe('quic.stream.blocked', mustCallAtLeast((msg) => { + ok(msg.stream, 'stream.blocked should include stream'); + ok(msg.session, 'stream.blocked should include session'); +}, 1)); + +const totalSize = 4096; +const body = new Uint8Array(totalSize); +for (let i = 0; i < totalSize; i++) body[i] = i & 0xff; + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + strictEqual(received.byteLength, totalSize); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +}), { + // Small stream window — forces stream-level flow control blocking. + transportParams: { initialMaxStreamDataBidiRemote: 256 }, +}); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream(); + +let blockedCount = 0; +stream.onblocked = mustCallAtLeast(() => { + blockedCount++; +}, 1); + +// Set the body via setBody() — larger than the flow control window. +// ngtcp2 sends the first 256 bytes then returns +// NGTCP2_ERR_STREAM_DATA_BLOCKED, triggering onblocked. +stream.setBody(body); + +for await (const _ of stream) { /* drain readable side */ } // eslint-disable-line no-unused-vars +await stream.closed; +await serverDone.promise; + +ok(blockedCount > 0, `Expected onblocked to fire, got ${blockedCount} calls`); + +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-pending.mjs b/test/parallel/test-quic-stream-pending.mjs new file mode 100644 index 00000000000000..9b847a9ae6ff00 --- /dev/null +++ b/test/parallel/test-quic-stream-pending.mjs @@ -0,0 +1,57 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: pending streams. +// Stream created before handshake completes, opens after. +// stream.pending is true before open, false after. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const encoder = new TextEncoder(); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + strictEqual(new TextDecoder().decode(received), 'pending stream'); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); + +// Create a stream BEFORE awaiting opened — the handshake may not have +// completed yet. The stream should be created in a pending state. +const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode('pending stream'), +}); + +// The stream should initially be pending (no ID assigned yet). +// On fast machines the handshake might already be done. +strictEqual(typeof stream.pending, 'boolean'); + +// The server's onstream fires only after the handshake completes AND +// the pending stream opens. By the time we get data on the server, +// the stream is definitely no longer pending. +await serverDone.promise; + +// After the server received data, the stream opened successfully. +// The data arrival proves (pending stream opens after handshake). + +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars +await stream.closed; +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-priority.mjs b/test/parallel/test-quic-stream-priority.mjs new file mode 100644 index 00000000000000..1b8128ed6cbe29 --- /dev/null +++ b/test/parallel/test-quic-stream-priority.mjs @@ -0,0 +1,95 @@ +// Flags: --experimental-quic --no-warnings + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; +const { readKey } = fixtures; + +const { rejects, strictEqual, throws } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.opened; + await serverSession.close(); +}), { + sni: { '*': { keys: [key], certs: [cert] } }, + alpn: ['quic-test'], +}); + +const clientSession = await connect(serverEndpoint.address, { + alpn: 'quic-test', +}); +await clientSession.opened; + +// Collect stream.closed promises so we can await them all at the end. +// We must not await them inline because the server's CONNECTION_CLOSE +// arrives asynchronously and would put the session into a closing state, +// preventing subsequent createBidirectionalStream calls. +const streamClosedPromises = []; + +// Test 1: Priority getter returns null for non-HTTP/3 sessions. +// setPriority throws because the session doesn't support priority. +{ + const stream = await clientSession.createBidirectionalStream(); + streamClosedPromises.push(stream.closed); + strictEqual(stream.priority, null); + + throws( + () => stream.setPriority({ level: 'high', incremental: true }), + { code: 'ERR_INVALID_STATE' }, + ); +} + +// Test 2: Validation of createStream priority/incremental options +{ + await rejects( + clientSession.createBidirectionalStream({ priority: 'urgent' }), + { code: 'ERR_INVALID_ARG_VALUE' }, + ); + await rejects( + clientSession.createBidirectionalStream({ priority: 42 }), + { code: 'ERR_INVALID_ARG_VALUE' }, + ); + await rejects( + clientSession.createBidirectionalStream({ incremental: 'yes' }), + { code: 'ERR_INVALID_ARG_TYPE' }, + ); + await rejects( + clientSession.createBidirectionalStream({ incremental: 1 }), + { code: 'ERR_INVALID_ARG_TYPE' }, + ); +} + +// Test 3: setPriority throws on non-H3 sessions regardless of arguments +{ + const stream = await clientSession.createBidirectionalStream(); + streamClosedPromises.push(stream.closed); + + throws( + () => stream.setPriority({ level: 'high' }), + { code: 'ERR_INVALID_STATE' }, + ); + throws( + () => stream.setPriority({ level: 'low', incremental: true }), + { code: 'ERR_INVALID_STATE' }, + ); + throws( + () => stream.setPriority(), + { code: 'ERR_INVALID_STATE' }, + ); +} + +// Wait for all streams to close (they close when the session closes +// in response to the server's CONNECTION_CLOSE). +await Promise.all(streamClosedPromises); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-reset-after-data.mjs b/test/parallel/test-quic-stream-reset-after-data.mjs new file mode 100644 index 00000000000000..75f3650b2c3a2a --- /dev/null +++ b/test/parallel/test-quic-stream-reset-after-data.mjs @@ -0,0 +1,67 @@ +// Flags: --experimental-quic --no-warnings + +// Test: resetStream() after all data written but before ACK. +// The stream is in the Data Sent state — all data has been sent +// including FIN, but the peer hasn't acknowledged everything yet. +// Calling resetStream() aborts the stream. The server's onreset +// callback fires with the error code. + +import { hasQuic, skip, mustCall, mustNotCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok, rejects, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const encoder = new TextEncoder(); +const serverDone = Promise.withResolvers(); +const serverReady = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall((stream) => { + rejects(stream.closed, (error) => { + strictEqual(error.code, 'ERR_QUIC_APPLICATION_ERROR'); + return true; + }).then(mustCall()); + + stream.onreset = mustCall((error) => { + strictEqual(error.code, 'ERR_QUIC_APPLICATION_ERROR'); + ok(error.message.includes('44')); + serverSession.close(); + serverDone.resolve(); + }); + serverReady.resolve(); + }); +}), { + onerror: mustNotCall(), +}); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// Send a small body — it will be sent quickly (including FIN), +// putting the stream in "Data Sent" state. +const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode('small payload'), +}); + +// Wait for the server to receive the stream before resetting. +await serverReady.promise; + +// Reset after data was written. The data and FIN have been sent +// but may not be fully acknowledged yet. +stream.resetStream(44n); + +await rejects(stream.closed, (error) => { + strictEqual(error.code, 'ERR_QUIC_APPLICATION_ERROR'); + ok(error.message.includes('44')); + return true; +}); + +await serverDone.promise; +await clientSession.closed; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-reset-before-data.mjs b/test/parallel/test-quic-stream-reset-before-data.mjs new file mode 100644 index 00000000000000..cb298aef3a7fda --- /dev/null +++ b/test/parallel/test-quic-stream-reset-before-data.mjs @@ -0,0 +1,83 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: resetStream() before any data is written. +// The stream is in the Ready state — no data has been sent by the +// client. The client calls resetStream() which sends RESET_STREAM +// to the server. The server receives the stream via onstream (the +// RESET_STREAM implicitly creates the bidi stream), and onreset +// fires. The server then sends data back on its side of the bidi +// stream, which the client reads — verifying that even when the +// client's send side is reset, the server can still use its send +// side and the client can still receive. + +import { hasQuic, skip, mustCall, mustNotCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import dc from 'node:diagnostics_channel'; + +const { ok, deepStrictEqual, strictEqual, rejects } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +// quic.stream.reset fires when a stream receives RESET_STREAM from the peer. +dc.subscribe('quic.stream.reset', mustCall((msg) => { + ok(msg.stream, 'stream.reset should include stream'); + ok(msg.session, 'stream.reset should include session'); + ok(msg.error, 'stream.reset should include error'); +})); + +const encoder = new TextEncoder(); +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + stream.onreset = mustCall((error) => { + strictEqual(error.code, 'ERR_QUIC_APPLICATION_ERROR'); + ok(error.message.includes('42')); + + // The client reset its send side, but the server can still + // send data on its side of the bidi stream. + stream.setBody(encoder.encode('response')); + }); + + // The stream's closed promise may reject because the client's + // send side was reset. Either way, clean up. + await rejects(stream.closed, { + code: 'ERR_QUIC_APPLICATION_ERROR', + }); + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address, { + onerror: mustNotCall(), +}); +await clientSession.opened; + +// Create a bidi stream but do NOT write any data. +const stream = await clientSession.createBidirectionalStream(); + +// Reset immediately — no data was ever written. This sends +// RESET_STREAM to the server which implicitly creates the bidi +// stream on the server side. +stream.resetStream(42n); + +// The client should still be able to receive data from the server +// on the readable side of this bidi stream. +const received = await bytes(stream); +deepStrictEqual(Buffer.from(received), Buffer.from('response')); + +// stream.closed rejects with the reset error (the client's send +// side was reset). Verify the error and consume the rejection. +await stream.closed.catch((error) => { + strictEqual(error.code, 'ERR_QUIC_APPLICATION_ERROR'); + ok(error.message.includes('42')); +}); +await serverDone.promise; +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-reset-mid-transfer.mjs b/test/parallel/test-quic-stream-reset-mid-transfer.mjs new file mode 100644 index 00000000000000..1c32a5ee28ea74 --- /dev/null +++ b/test/parallel/test-quic-stream-reset-mid-transfer.mjs @@ -0,0 +1,66 @@ +// Flags: --experimental-quic --no-warnings + +// Test: resetStream() mid-transfer. +// The stream is in the Send state — data is being sent. Calling +// resetStream() aborts the transfer. The server's onreset callback +// fires with the error code. The server may receive partial data +// before the reset. + +import { hasQuic, skip, mustCall, mustNotCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok, rejects, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const serverDone = Promise.withResolvers(); +const serverReady = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall((stream) => { + rejects(stream.closed, (error) => { + strictEqual(error.code, 'ERR_QUIC_APPLICATION_ERROR'); + return true; + }).then(mustCall()); + + stream.onreset = mustCall((error) => { + strictEqual(error.code, 'ERR_QUIC_APPLICATION_ERROR'); + ok(error.message.includes('43')); + serverSession.close(); + serverDone.resolve(); + }); + serverReady.resolve(); + }); +}), { + // Small flow control window to keep data in flight longer. + transportParams: { initialMaxStreamDataBidiRemote: 256 }, + onerror: mustNotCall(), +}); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// Send a large body — with the 256-byte flow control window, the +// transfer will be in progress when we reset. +const stream = await clientSession.createBidirectionalStream(); +stream.setBody(new Uint8Array(8192)); + +// Wait for the server to receive the stream (first STREAM frames). +await serverReady.promise; + +// Reset mid-transfer. +stream.resetStream(43n); + +await rejects(stream.closed, (error) => { + strictEqual(error.code, 'ERR_QUIC_APPLICATION_ERROR'); + ok(error.message.includes('43')); + return true; +}); + +await serverDone.promise; +await clientSession.closed; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-reset-stop.mjs b/test/parallel/test-quic-stream-reset-stop.mjs new file mode 100644 index 00000000000000..6741dabfef5b7b --- /dev/null +++ b/test/parallel/test-quic-stream-reset-stop.mjs @@ -0,0 +1,65 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: RESET_STREAM and STOP_SENDING. +// server's onreset fires with that code. +// NOTE: CTRL-01/CTRL-08 (stopSending with specific code) is tested +// separately because it requires a second endpoint. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import * as assert from 'node:assert'; + +const { ok, rejects, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const encoder = new TextEncoder(); + +const serverDone = Promise.withResolvers(); +const serverReady = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall((stream) => { + // The server's stream.closed will reject when the session is + // gracefully closed after the peer's reset. + rejects(stream.closed, (error) => { + strictEqual(error.code, 'ERR_QUIC_APPLICATION_ERROR'); + return true; + }).then(mustCall()); + + stream.onreset = mustCall((error) => { + // The error is the raw close tuple: [type, code, reason]. + strictEqual(error.code, 'ERR_QUIC_APPLICATION_ERROR'); + ok(error.message.includes('42')); + serverSession.close(); + serverDone.resolve(); + }); + serverReady.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode('will be reset'), +}); + +// Wait for the server to receive the stream before resetting. +await serverReady.promise; +stream.resetStream(42n); + +await serverDone.promise; +// After the server closes (sending CONNECTION_CLOSE), the client +// session enters draining and all streams are destroyed. The client's +// stream.closed rejects with the reset code. +await rejects(stream.closed, (error) => { + strictEqual(error.code, 'ERR_QUIC_APPLICATION_ERROR'); + ok(error.message.includes('42')); + return true; +}); +await clientSession.closed; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-setbody-errors.mjs b/test/parallel/test-quic-stream-setbody-errors.mjs new file mode 100644 index 00000000000000..4b41ac4cb66ea3 --- /dev/null +++ b/test/parallel/test-quic-stream-setbody-errors.mjs @@ -0,0 +1,63 @@ +// Flags: --experimental-quic --no-warnings + +// Test: setBody throws when body already configured or writer +// already accessed. +// Writer throws ERR_INVALID_STATE if body was already set. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { throws } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const encoder = new TextEncoder(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// Test 1: setBody after setBody throws. +{ + const stream = await clientSession.createBidirectionalStream(); + stream.setBody(encoder.encode('first')); + + throws(() => stream.setBody(encoder.encode('second')), { + code: 'ERR_INVALID_STATE', + message: /outbound already configured/, + }); + + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + await stream.closed; +} + +// Test 2: setBody after writer accessed throws. +{ + const stream = await clientSession.createBidirectionalStream(); + // Access the writer — this prevents setBody from being used. + const w = stream.writer; + w.endSync(); + + throws(() => stream.setBody(encoder.encode('data')), { + code: 'ERR_INVALID_STATE', + message: /writer already accessed/, + }); + + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + await stream.closed; +} + +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-slow-consumer.mjs b/test/parallel/test-quic-stream-slow-consumer.mjs new file mode 100644 index 00000000000000..98d45f7474146a --- /dev/null +++ b/test/parallel/test-quic-stream-slow-consumer.mjs @@ -0,0 +1,58 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: slow consumer applies backpressure. +// With a small flow control window and a large body, the sender +// blocks waiting for the receiver to extend the window. The transfer +// completes when the receiver reads the data. + +import { hasQuic, skip, mustCall, mustCallAtLeast } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const dataLength = 4096; +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + strictEqual(received.byteLength, dataLength); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +}), { + // Small stream window forces the sender to block repeatedly. + transportParams: { initialMaxStreamDataBidiRemote: 256 }, +}); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +let blockedCount = 0; +const stream = await clientSession.createBidirectionalStream(); + +// The actual number of blocks can vary on a range of factors. We're +// only validating that blocking occurs at least once. +stream.onblocked = mustCallAtLeast(() => { + blockedCount++; +}, 1); + +stream.setBody(new Uint8Array(dataLength)); + +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars +await Promise.all([stream.closed, serverDone.promise]); + +// The sender should have been blocked multiple times. +ok(blockedCount > 0, `Expected blocking, got ${blockedCount}`); + +await clientSession.closed; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-stats.mjs b/test/parallel/test-quic-stream-stats.mjs new file mode 100644 index 00000000000000..8d002bc7248fd9 --- /dev/null +++ b/test/parallel/test-quic-stream-stats.mjs @@ -0,0 +1,73 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: stream stats fields. +// Verify that stream stats are populated with correct types and +// that bytesReceived/bytesSent reflect actual data transfer. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const encoder = new TextEncoder(); +const payload = encoder.encode('stream stats test data'); +const payloadLength = payload.byteLength; +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const data = await bytes(stream); + strictEqual(data.byteLength, payloadLength); + + // Stream stats should reflect received bytes. + strictEqual(stream.stats.bytesReceived, BigInt(payloadLength)); + strictEqual(typeof stream.stats.createdAt, 'bigint'); + strictEqual(typeof stream.stats.receivedAt, 'bigint'); + + // Send response. + stream.setBody(encoder.encode('response')); + await stream.closed; + + // After close, bytesSent should reflect response. + strictEqual(stream.stats.bytesSent, BigInt('response'.length)); + + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream({ + body: payload, +}); + +// Stats should have correct types before transfer completes. +strictEqual(typeof stream.stats.createdAt, 'bigint'); +strictEqual(typeof stream.stats.bytesReceived, 'bigint'); +strictEqual(typeof stream.stats.bytesSent, 'bigint'); +strictEqual(typeof stream.stats.maxOffset, 'bigint'); + +// Verify toJSON works. +const json = stream.stats.toJSON(); +ok(json); +strictEqual(typeof json.createdAt, 'string'); + +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars +await stream.closed; +await serverDone.promise; + +// After transfer, bytesSent should reflect the payload. +strictEqual(stream.stats.bytesSent, BigInt(payloadLength)); +ok(stream.stats.bytesReceived > 0n); + +await clientSession.closed; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-stop-sending-interaction.mjs b/test/parallel/test-quic-stream-stop-sending-interaction.mjs new file mode 100644 index 00000000000000..c7b80402260dc6 --- /dev/null +++ b/test/parallel/test-quic-stream-stop-sending-interaction.mjs @@ -0,0 +1,78 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: STOP_SENDING / RESET_STREAM interaction. +// When the peer sends STOP_SENDING, the local sending side is +// notified — the stream closes on the sender side. +// Receiving STOP_SENDING automatically triggers RESET_STREAM +// to the peer (ngtcp2 handles this internally). Verified by +// the server's stream.closed rejecting with the error code. +// The error code from STOP_SENDING is copied to the automatic +// RESET_STREAM — the server's stream.closed rejects with the +// same code that was passed to stopSending(). + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok, strictEqual, rejects } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const encoder = new TextEncoder(); +const stopCode = 77n; + +const serverDone = Promise.withResolvers(); +const clientStreamReady = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + // Wait for the client stream to be fully set up. + await clientStreamReady.promise; + + // Send STOP_SENDING with a specific error code. + stream.stopSending(stopCode); + + // Send data from server to client (the other direction is unaffected). + const w = stream.writer; + w.writeSync(encoder.encode('server data')); + w.endSync(); + + // The server's stream.closed rejects because + // the client automatically sends RESET_STREAM in response to + // STOP_SENDING. The error code matches the STOP_SENDING code. + await rejects(stream.closed, (error) => { + strictEqual(error.code, 'ERR_QUIC_APPLICATION_ERROR'); + ok(error.message.includes(String(stopCode))); + return true; + }); + + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode('initial data'), +}); +clientStreamReady.resolve(); + +// Read the server's data. The server→client direction is unaffected +// by STOP_SENDING on the client→server direction. +const received = await bytes(stream); +strictEqual(new TextDecoder().decode(received), 'server data'); + +// The client's stream.closed resolves. The STOP_SENDING caused +// the client's write side to end (ngtcp2 sends RESET_STREAM +// automatically), but from the client's JS perspective the stream +// completed: the read side got FIN from the server, and the write +// side was handled internally by ngtcp2. stream.closed only rejects +// on the side that receives the RESET_STREAM (the server). +await Promise.all([stream.closed, serverDone.promise, clientSession.closed]); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-stop-sending.mjs b/test/parallel/test-quic-stream-stop-sending.mjs new file mode 100644 index 00000000000000..0b2b9edd75db7a --- /dev/null +++ b/test/parallel/test-quic-stream-stop-sending.mjs @@ -0,0 +1,54 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: stopSending. +// Server calls stopSending(99n) on an incoming stream from the client. +// The server's stream.closed rejects with error code 99 (the stop +// sending code). The client's stream.closed resolves normally because +// the server's write side completed (endSync sent FIN). + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import * as assert from 'node:assert'; + +const { ok, rejects, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const encoder = new TextEncoder(); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + // Tell the client to stop sending with code 99. + stream.stopSending(99n); + stream.writer.endSync(); + + // The server's stream.closed rejects with the stop-sending code + // because the inbound side was reset by the peer in response. + await rejects(stream.closed, (error) => { + strictEqual(error.code, 'ERR_QUIC_APPLICATION_ERROR'); + ok(error.message.includes('99')); + return true; + }); + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream({ + body: encoder.encode('stop me'), +}); + +// The client's stream.closed resolves because the server sent FIN +// on its write side (endSync) and the read side completed normally. + +await Promise.all([serverDone.promise, stream.closed]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-uni-basic.mjs b/test/parallel/test-quic-stream-uni-basic.mjs new file mode 100644 index 00000000000000..4ab4c31e094252 --- /dev/null +++ b/test/parallel/test-quic-stream-uni-basic.mjs @@ -0,0 +1,65 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: basic unidirectional stream data transfer. +// The client creates a unidirectional stream with a body. The server reads +// the data and verifies integrity. The unidirectional stream is write-only +// on the client side and read-only on the server side. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import * as assert from 'node:assert'; + +const { deepStrictEqual, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const message = 'unidirectional payload'; +const encoder = new TextEncoder(); +const decoder = new TextDecoder(); +const body = encoder.encode(message); +const expected = encoder.encode(message); + +const done = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + strictEqual(stream.direction, 'uni'); + + const received = await bytes(stream); + deepStrictEqual(received, expected); + strictEqual(decoder.decode(received), message); + + // The server side of a remote unidirectional stream is not writable. + // The writer should be pre-closed (desiredSize returns null). + const w = stream.writer; + strictEqual(w.desiredSize, null); + strictEqual(w.endSync(), 0); + + await stream.closed; + serverSession.close(); + done.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createUnidirectionalStream({ body }); +strictEqual(stream.direction, 'uni'); + +// The client-side uni stream is write-only — async iteration yields nothing. +const iter = stream[Symbol.asyncIterator](); +const { done: iterDone } = await iter.next(); +strictEqual(iterDone, true); + +await done.promise; +// The server closed its session, delivering CONNECTION_CLOSE to the client. +// The client session enters the draining period, after which all streams +// and the session itself close cleanly. +await stream.closed; +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-uni-server-initiated.mjs b/test/parallel/test-quic-stream-uni-server-initiated.mjs new file mode 100644 index 00000000000000..7853938626617d --- /dev/null +++ b/test/parallel/test-quic-stream-uni-server-initiated.mjs @@ -0,0 +1,58 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: server-initiated unidirectional stream. +// The server creates a uni stream and sends data to the client. +// The client receives the data via its onstream handler and verifies +// integrity. The receiving side should not have a usable writer. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import * as assert from 'node:assert'; + +const { deepStrictEqual, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const message = 'server uni stream data'; +const encoder = new TextEncoder(); +const decoder = new TextDecoder(); +const expected = encoder.encode(message); + +const done = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.opened; + + const stream = await serverSession.createUnidirectionalStream({ + body: encoder.encode(message), + }); + + // Uni stream has no readable side for the sender. + await stream.closed; +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +clientSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + + deepStrictEqual(received, expected); + strictEqual(decoder.decode(received), message); + + // The receiving side of a uni stream should not be writable. + // The writer should be pre-closed. + const w = stream.writer; + strictEqual(w.desiredSize, null); + + await stream.closed; + clientSession.close(); + done.resolve(); +}); + +await done.promise; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-write-partial-view.mjs b/test/parallel/test-quic-stream-write-partial-view.mjs new file mode 100644 index 00000000000000..fcb3db58cc84bc --- /dev/null +++ b/test/parallel/test-quic-stream-write-partial-view.mjs @@ -0,0 +1,75 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// writer.writeSync() must not detach the caller's underlying +// ArrayBuffer. The bytes from each write are copied into an internal +// buffer, so the caller's source ArrayBuffer remains live and may be +// reused, mutated, or sliced into additional views — including +// successive subarrays of the same Uint8Array. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual, ok } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +// Eight bytes split into two 4-byte halves. +const source = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]); +const sourceCopy = source.slice(); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + // Server receives the original 8 bytes in order, regardless of + // any caller-side mutation that happens after writeSync returns. + strictEqual(received.length, sourceCopy.length); + for (let i = 0; i < sourceCopy.length; i++) { + strictEqual(received[i], sourceCopy[i], + `byte ${i} mismatch: got ${received[i]}, ` + + `expected ${sourceCopy[i]}`); + } + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream(); +const writer = stream.writer; + +// First half. The underlying ArrayBuffer must stay live after the +// write so that the caller can build the next view from it. +writer.writeSync(source.subarray(0, 4)); +strictEqual(source.buffer.detached, false, + 'source ArrayBuffer must not be detached after writeSync'); +strictEqual(source.byteLength, 8, + 'source view must remain usable after writeSync'); + +// Second half — slicing into the same backing buffer must succeed. +writer.writeSync(source.subarray(4, 8)); +strictEqual(source.buffer.detached, false, + 'source ArrayBuffer must remain live after second writeSync'); + +// The C++ layer has already copied the bytes by the time writeSync +// returned. Mutating the source here must not affect the data the +// peer ultimately observes. +for (let i = 0; i < source.length; i++) source[i] = 0; +ok(source.every((b) => b === 0), 'source mutation should succeed'); + +writer.endSync(); + +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars +await Promise.all([stream.closed, serverDone.promise]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-writer-api.mjs b/test/parallel/test-quic-stream-writer-api.mjs new file mode 100644 index 00000000000000..6003473584c51d --- /dev/null +++ b/test/parallel/test-quic-stream-writer-api.mjs @@ -0,0 +1,144 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: writer API methods (WRIT-02, WRIT-03, WRIT-04, WRIT-06, +// WRIT-07, WRIT-08, WRIT-12, WRIT-15). +// Uses a single endpoint with multiple streams, one per test. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import * as assert from 'node:assert'; + +const { ok, rejects, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const encoder = new TextEncoder(); + +const totalStreams = 5; +const serverResults = []; +const allDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + serverResults.push(received); + stream.writer.endSync(); + await stream.closed; + + if (serverResults.length === totalStreams) { + serverSession.close(); + allDone.resolve(); + } + }, totalStreams); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// write() async +{ + const stream = await clientSession.createBidirectionalStream(); + const w = stream.writer; + await w.write(encoder.encode('async write')); + const n = w.endSync(); + strictEqual(n, 11); + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + await stream.closed; +} + +// writevSync() vectored write +{ + const stream = await clientSession.createBidirectionalStream(); + const w = stream.writer; + const result = w.writevSync([ + encoder.encode('hello '), + encoder.encode('writev'), + ]); + strictEqual(result, true); + const n = w.endSync(); + strictEqual(n, 12); + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + await stream.closed; +} + +// writev() async vectored write +{ + const stream = await clientSession.createBidirectionalStream(); + const w = stream.writer; + await w.writev([ + encoder.encode('async '), + encoder.encode('writev'), + ]); + const n = w.endSync(); + strictEqual(n, 12); + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + await stream.closed; +} + +// end() async close +{ + const stream = await clientSession.createBidirectionalStream(); + const w = stream.writer; + w.writeSync(encoder.encode('end async')); + const n = await w.end(); + strictEqual(n, 9); + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + await stream.closed; +} + +{ + const stream = await clientSession.createBidirectionalStream(); + const w = stream.writer; + // desiredSize should be a number (may be 0 initially before flow + // control window opens, or > 0 if the window is already open). + strictEqual(typeof w.desiredSize, 'number'); + ok(w.desiredSize >= 0, `desiredSize should be >= 0, got ${w.desiredSize}`); + // drainableProtocol should return null when desiredSize > 0 (has capacity), + // or a promise when desiredSize <= 0 (backpressured). Either way, it + // should not throw. + const { drainableProtocol: dp } = await import('stream/iter'); + const drain = w[dp](); + ok(drain === null || drain instanceof Promise); + w.writeSync(encoder.encode('capacity')); + w.endSync(); + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + await stream.closed; +} + +// Return null when errored. +{ + const stream = await clientSession.createBidirectionalStream(); + const w = stream.writer; + const testError = new Error('writer fail test'); + w.fail(testError); + // After fail, desiredSize is null. + strictEqual(w.desiredSize, null); + // drainableProtocol returns null when errored. + const { drainableProtocol: dp } = await import('stream/iter'); + strictEqual(w[dp](), null); + // endSync after fail returns -1 (errored). + strictEqual(w.endSync(), -1); + // WriteSync after fail returns false. + strictEqual(w.writeSync(encoder.encode('x')), false); + // Write after fail throws with the original error. + await rejects(w.write(encoder.encode('x')), testError); + // Don't await stream.closed here — the reset stream may not trigger + // server onstream (no data was sent before fail), so the server + // won't count it. The stream is cleaned up when the session closes. +} + +await allDone.promise; +await clientSession.close(); +await serverEndpoint.close(); + +// Verify server received the right data. +const decoder = new TextDecoder(); +strictEqual(decoder.decode(serverResults[0]), 'async write'); +strictEqual(decoder.decode(serverResults[1]), 'hello writev'); +strictEqual(decoder.decode(serverResults[2]), 'async writev'); +strictEqual(decoder.decode(serverResults[3]), 'end async'); +strictEqual(decoder.decode(serverResults[4]), 'capacity'); diff --git a/test/parallel/test-quic-stream-writer-dispose.mjs b/test/parallel/test-quic-stream-writer-dispose.mjs new file mode 100644 index 00000000000000..3899f2f2973636 --- /dev/null +++ b/test/parallel/test-quic-stream-writer-dispose.mjs @@ -0,0 +1,50 @@ +// Flags: --experimental-quic --no-warnings + +// Test: writer Symbol.dispose. +// Symbol.dispose calls fail() if the writer is not already closed/errored. +// After disposal, the writer is in an errored state. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import * as assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const encoder = new TextEncoder(); + +const transportParams = { maxIdleTimeout: 1 }; + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + // The server session will close via idle timeout because the client + // resets the stream before any data is sent. + await serverSession.closed; +}), { transportParams }); + +const clientSession = await connect(serverEndpoint.address, { + transportParams, +}); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream(); +const w = stream.writer; + +// Writer is active — desiredSize should be a number (not null). +strictEqual(typeof w.desiredSize, 'number'); + +// Symbol.dispose calls fail() if not already closed/errored. +w[Symbol.dispose](); + +// After dispose, writer should be errored. +strictEqual(w.desiredSize, null); +strictEqual(w.writeSync(encoder.encode('x')), false); + +// stream.closed resolves because fail() with default code 0 +// is treated as a clean close (no error). +// The session will close via idle timeout or CONNECTION_CLOSE. +await Promise.all([stream.closed, clientSession.closed]); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-writer-fail-error-code.mjs b/test/parallel/test-quic-stream-writer-fail-error-code.mjs new file mode 100644 index 00000000000000..75a680ec4fa8bf --- /dev/null +++ b/test/parallel/test-quic-stream-writer-fail-error-code.mjs @@ -0,0 +1,102 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: stream writer.fail() emits a RESET_STREAM with a non-zero +// application error code instead of the previously hard-coded 0n. +// +// Two cases are exercised against the test fixture's non-h3 ALPN +// (`quic-test`), which selects the C++ DefaultApplication and exposes +// `internalErrorCode === 0x1n` (NGTCP2_INTERNAL_ERROR) via session +// state: +// +// 1. `writer.fail(plainError)` — peer receives RESET_STREAM with the +// session's `internalErrorCode` (`0x1`), proving the hard-coded +// `0n` regression is gone and that the C++ -> JS state plumbing +// surfaces the application's code. +// 2. `writer.fail(new QuicError('msg', { errorCode: 0x42n }))` — +// peer receives RESET_STREAM with the explicit code, proving +// the QuicError fast path. +// +// The peer-side observation goes through `stream.onreset(err)` where +// `err` is `ERR_QUIC_APPLICATION_ERROR` carrying the wire code in its +// message string. We extract the code via regex; once +// `ERR_QUIC_APPLICATION_ERROR` exposes the numeric code as a property +// (a planned follow-up), this test can switch to direct property +// access. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { QuicError } = await import('node:quic'); + +// Extract the numeric wire code from an ERR_QUIC_APPLICATION_ERROR +// message of the form +// "A QUIC application error occurred. n []" +// where the trailing `n` on the code is the BigInt formatting from +// `util.format('%d', bigint)`. RESET_STREAM frames do not carry a +// reason string, so the bracketed value is typically `undefined`. +function wireCodeOf(err) { + strictEqual(err.code, 'ERR_QUIC_APPLICATION_ERROR'); + const match = err.message.match(/A QUIC application error occurred\. (\d+)n /); + if (!match) { + throw new Error(`Could not extract code from message: ${err.message}`); + } + return BigInt(match[1]); +} + +// Server: capture the next two streams. Each stream receives an +// onreset handler synchronously inside onstream so the C++ -> JS +// dispatch ordering (data packet -> reset packet) finds the handler +// already attached. +const expectedCodes = [0x1n, 0x42n]; +let nextStreamIndex = 0; +const allDone = Promise.withResolvers(); +const observed = []; + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall((stream) => { + const i = nextStreamIndex++; + stream.onreset = mustCall((err) => { + observed[i] = wireCodeOf(err); + if (observed.length === expectedCodes.length && + observed[0] !== undefined && observed[1] !== undefined) { + allDone.resolve(); + } + }); + }, 2); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// 1. Plain Error -> session.internalErrorCode (0x1n for non-h3). +{ + const stream = await clientSession.createBidirectionalStream(); + const writer = stream.writer; + // Write a tiny chunk to guarantee the server-side stream is + // created via onstream before the RESET_STREAM frame arrives. + writer.writeSync('x'); + writer.fail(new Error('plain error reason')); +} + +// 2. QuicError with explicit code -> peer sees that exact code. +{ + const stream = await clientSession.createBidirectionalStream(); + const writer = stream.writer; + writer.writeSync('y'); + writer.fail(new QuicError('explicit code', { errorCode: 0x42n })); +} + +await allDone.promise; + +strictEqual(observed[0], expectedCodes[0]); +strictEqual(observed[1], expectedCodes[1]); + +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-stream-zero-length.mjs b/test/parallel/test-quic-stream-zero-length.mjs new file mode 100644 index 00000000000000..0a38d4df09536a --- /dev/null +++ b/test/parallel/test-quic-stream-zero-length.mjs @@ -0,0 +1,42 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: zero-length stream via setBody(null). +// Creates a stream with no body, then calls setBody(null) which sends +// FIN immediately. The server receives zero bytes. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + strictEqual(received.byteLength, 0); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream(); +stream.setBody(null); + +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + +await Promise.all([stream.closed, serverDone.promise]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-test-client.mjs b/test/parallel/test-quic-test-client.mjs index 25918b17e8b96c..8a8ffdd67f70e4 100644 --- a/test/parallel/test-quic-test-client.mjs +++ b/test/parallel/test-quic-test-client.mjs @@ -1,6 +1,8 @@ // Flags: --experimental-quic import { hasQuic, isAIX, isIBMi, isWindows, skip } from '../common/index.mjs'; import assert from 'node:assert'; +import { existsSync } from 'node:fs'; +import { resolve } from 'node:path'; if (!hasQuic) { skip('QUIC support is not enabled'); @@ -20,6 +22,9 @@ if (isWindows) { // required by the ngtcp2 example server/client. skip('QUIC third-party tests are disabled on Windows'); } +if (!existsSync(resolve(process.execPath, '../ngtcp2_test_client'))) { + skip('ngtcp2_test_client binary not built'); +} const { default: QuicTestClient } = await import('../common/quic/test-client.mjs'); diff --git a/test/parallel/test-quic-test-server.mjs b/test/parallel/test-quic-test-server.mjs index ae70a3bc5fc64d..84dbff6b2d69a3 100644 --- a/test/parallel/test-quic-test-server.mjs +++ b/test/parallel/test-quic-test-server.mjs @@ -1,5 +1,7 @@ // Flags: --experimental-quic import { hasQuic, isAIX, isIBMi, isWindows, skip } from '../common/index.mjs'; +import { existsSync } from 'node:fs'; +import { resolve } from 'node:path'; if (!hasQuic) { skip('QUIC support is not enabled'); @@ -19,6 +21,9 @@ if (isWindows) { // required by the ngtcp2 example server/client. skip('QUIC third-party tests are disabled on Windows'); } +if (!existsSync(resolve(process.execPath, '../ngtcp2_test_server'))) { + skip('ngtcp2_test_server binary not built'); +} const { default: QuicTestServer } = await import('../common/quic/test-server.mjs'); const fixtures = await import('../common/fixtures.mjs'); diff --git a/test/parallel/test-quic-tls-ca.mjs b/test/parallel/test-quic-tls-ca.mjs new file mode 100644 index 00000000000000..dae35e975a6760 --- /dev/null +++ b/test/parallel/test-quic-tls-ca.mjs @@ -0,0 +1,49 @@ +// Flags: --experimental-quic --no-warnings + +// Test: custom CA certificate chain. +// The client provides a CA cert that matches the server's cert, +// allowing validation to succeed. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { strictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); +const ca = readKey('ca1-cert.pem'); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + const info = await serverSession.opened; + strictEqual(info.protocol, 'quic-test'); + serverSession.close(); +}), { + sni: { '*': { keys: [key], certs: [cert] } }, + alpn: ['quic-test'], +}); + +// Client provides the CA cert. The validation error should be different +// (or absent) compared to when no CA is provided. +const clientSession = await connect(serverEndpoint.address, { + alpn: 'quic-test', + servername: 'localhost', + ca, +}); + +const info = await clientSession.opened; +strictEqual(info.protocol, 'quic-test'); +// The CA option is accepted. Validation may or may not succeed +// depending on the cert chain. The important thing is the +// handshake completed and the option was used. + +await clientSession.closed; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-tls-crl.mjs b/test/parallel/test-quic-tls-crl.mjs new file mode 100644 index 00000000000000..78a854759695c8 --- /dev/null +++ b/test/parallel/test-quic-tls-crl.mjs @@ -0,0 +1,78 @@ +// Flags: --experimental-quic --no-warnings + +// Test: CRL (certificate revocation list) enforcement. +// A server using a non-revoked certificate succeeds when the client +// provides a CRL. A server using the same certificate reports +// "certificate revoked" in the validation error when the client +// provides a CRL that revokes it. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { ok, strictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const ca2Cert = readKey('ca2-cert.pem'); +const ca2Crl = readKey('ca2-crl.pem'); +const ca2CrlAgent3 = readKey('ca2-crl-agent3.pem'); +const agent3Key = createPrivateKey(readKey('agent3-key.pem')); +const agent3Cert = readKey('agent3-cert.pem'); + +// --- Non-revoked: agent3 with original CRL (doesn't list agent3) --- +{ + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.opened; + await serverSession.close(); + }), { + sni: { '*': { keys: [agent3Key], certs: [agent3Cert] } }, + alpn: ['quic-test'], + }); + + const clientSession = await connect(serverEndpoint.address, { + alpn: 'quic-test', + ca: [ca2Cert], + crl: [ca2Crl], + }); + + // Should succeed — agent3 is NOT in the original CRL. + const info = await clientSession.opened; + strictEqual(clientSession.destroyed, false); + // No revocation error. + ok(!info.validationErrorReason || + !info.validationErrorReason.includes('revoked')); + await clientSession.close(); + await serverEndpoint.close(); +} + +// --- Revoked: agent3 with CRL that revokes agent3 --- +{ + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.opened; + await serverSession.close(); + }), { + sni: { '*': { keys: [agent3Key], certs: [agent3Cert] } }, + alpn: ['quic-test'], + }); + + const clientSession = await connect(serverEndpoint.address, { + alpn: 'quic-test', + ca: [ca2Cert], + crl: [ca2CrlAgent3], + }); + + // The connection currently succeeds but the validation error + // reports "certificate revoked". This verifies the CRL is loaded + // and checked. + const info = await clientSession.opened; + strictEqual(info.validationErrorReason, 'certificate revoked'); + await clientSession.close(); + await serverEndpoint.close(); +} diff --git a/test/parallel/test-quic-tls-keylog.mjs b/test/parallel/test-quic-tls-keylog.mjs new file mode 100644 index 00000000000000..82d1b0aa8bc900 --- /dev/null +++ b/test/parallel/test-quic-tls-keylog.mjs @@ -0,0 +1,66 @@ +// Flags: --experimental-quic --no-warnings + +// Test: keylog callback. +// When keylog: true, TLS key material is delivered to the +// session.onkeylog callback during the handshake for both +// client and server sessions. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const clientLines = []; +const serverLines = []; + +const expectedLabels = [ + 'CLIENT_HANDSHAKE_TRAFFIC_SECRET', + 'SERVER_HANDSHAKE_TRAFFIC_SECRET', + 'CLIENT_TRAFFIC_SECRET_0', + 'SERVER_TRAFFIC_SECRET_0', +]; + +function assertKeylogLines(lines, side) { + ok(lines.length > 0, `Expected ${side} keylog lines, got ${lines.length}`); + + for (const line of lines) { + strictEqual(typeof line, 'string', + `Each ${side} keylog line should be a string`); + } + + const joined = lines.join(''); + for (const label of expectedLabels) { + ok(joined.includes(label), + `Expected ${side} keylog to contain ${label}`); + } +} + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.opened; + serverSession.close(); +}), { + keylog: true, + onkeylog(line) { + serverLines.push(line); + }, +}); + +const clientSession = await connect(serverEndpoint.address, { + keylog: true, + onkeylog(line) { + clientLines.push(line); + }, +}); + +await clientSession.opened; +await clientSession.closed; +await serverEndpoint.close(); + +assertKeylogLines(clientLines, 'client'); +assertKeylogLines(serverLines, 'server'); diff --git a/test/parallel/test-quic-tls-options.mjs b/test/parallel/test-quic-tls-options.mjs new file mode 100644 index 00000000000000..ccf6488b8a076c --- /dev/null +++ b/test/parallel/test-quic-tls-options.mjs @@ -0,0 +1,83 @@ +// Flags: --experimental-quic --no-warnings + +// Test: custom TLS ciphers and groups. +// Custom ciphers option on the server/client. +// Custom groups option on the server/client. +// Default ciphers/groups used when not specified. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { strictEqual, ok } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect, constants } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); + +// Custom ciphers. Use a specific TLS 1.3 cipher suite. +{ + const serverEndpoint = await listen(mustCall(async (serverSession) => { + const info = await serverSession.opened; + strictEqual(typeof info.cipher, 'string'); + ok(info.cipher.includes('AES_256_GCM')); + serverSession.close(); + }), { + sni: { '*': { keys: [key], certs: [cert] } }, + alpn: ['quic-test'], + ciphers: 'TLS_AES_256_GCM_SHA384', + }); + + const clientSession = await connect(serverEndpoint.address, { + alpn: 'quic-test', + servername: 'localhost', + ciphers: 'TLS_AES_256_GCM_SHA384', + }); + + const info = await clientSession.opened; + ok(info.cipher.includes('AES_256_GCM')); + strictEqual(info.cipherVersion, 'TLSv1.3'); + + await clientSession.closed; + await serverEndpoint.close(); +} + +// Custom groups. Use a specific key exchange group. +{ + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.opened; + serverSession.close(); + }), { + sni: { '*': { keys: [key], certs: [cert] } }, + alpn: ['quic-test'], + groups: 'P-256', + }); + + const clientSession = await connect(serverEndpoint.address, { + alpn: 'quic-test', + servername: 'localhost', + groups: 'P-256', + }); + + const info = await clientSession.opened; + // The handshake should succeed with the specified group. + assert.strictEqual(info.cipherVersion, 'TLSv1.3'); + + await clientSession.closed; + await serverEndpoint.close(); +} + +// Default ciphers/groups are non-empty strings from constants. +{ + strictEqual(typeof constants.DEFAULT_CIPHERS, 'string'); + ok(constants.DEFAULT_CIPHERS.length > 0); + strictEqual(typeof constants.DEFAULT_GROUPS, 'string'); + ok(constants.DEFAULT_GROUPS.length > 0); +} diff --git a/test/parallel/test-quic-tls-trace.mjs b/test/parallel/test-quic-tls-trace.mjs new file mode 100644 index 00000000000000..b5ebd161cd58a0 --- /dev/null +++ b/test/parallel/test-quic-tls-trace.mjs @@ -0,0 +1,33 @@ +// Flags: --experimental-quic --no-warnings + +// Test: TLS trace output. +// When tlsTrace: true is set, the session produces TLS debug +// output on stderr. Verify the option is accepted without error +// and the connection succeeds. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.opened; + await serverSession.close(); +}), { + tlsTrace: true, +}); + +const clientSession = await connect(serverEndpoint.address, { + tlsTrace: true, +}); +await clientSession.opened; +strictEqual(clientSession.destroyed, false); + +await clientSession.closed; +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-tls-verify-client.mjs b/test/parallel/test-quic-tls-verify-client.mjs new file mode 100644 index 00000000000000..ae2e89c8785f72 --- /dev/null +++ b/test/parallel/test-quic-tls-verify-client.mjs @@ -0,0 +1,87 @@ +// Flags: --experimental-quic --no-warnings + +// Test: client certificate verification. +// With verifyClient: true, a client that provides a valid +// certificate succeeds. +// With verifyClient: true, a client that does NOT provide a +// certificate fails the handshake. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { strictEqual, ok, rejects } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const serverKey = createPrivateKey(readKey('agent1-key.pem')); +const serverCert = readKey('agent1-cert.pem'); +const clientKey = createPrivateKey(readKey('agent2-key.pem')); +const clientCert = readKey('agent2-cert.pem'); + +// --- TLS-03: Client provides a certificate — handshake succeeds --- +{ + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.opened; + // The server should see the client's certificate. + ok(serverSession.peerCertificate); + await serverSession.close(); + }), { + sni: { '*': { keys: [serverKey], certs: [serverCert] } }, + alpn: ['quic-test'], + verifyClient: true, + // Trust the client's self-signed certificate. + ca: [clientCert], + }); + + const clientSession = await connect(serverEndpoint.address, { + alpn: 'quic-test', + keys: [clientKey], + certs: [clientCert], + }); + + await Promise.all([clientSession.opened, clientSession.closed]); + await serverEndpoint.close(); +} + +// --- TLS-04: Client does NOT provide a certificate — connection fails --- +// In TLS 1.3, client certificate verification happens post-handshake. +// The client's opened promise may resolve (handshake completes), but +// the server then sends a fatal alert (certificate_required) which +// closes both sides with a transport error. +{ + const serverEndpoint = await listen(mustCall(async (serverSession) => { + await rejects(serverSession.closed, { + code: 'ERR_QUIC_TRANSPORT_ERROR', + }); + }), { + sni: { '*': { keys: [serverKey], certs: [serverCert] } }, + alpn: ['quic-test'], + verifyClient: true, + onerror: mustCall((err) => { + strictEqual(err.code, 'ERR_QUIC_TRANSPORT_ERROR'); + }), + }); + + // Client connects WITHOUT providing a certificate. + const clientSession = await connect(serverEndpoint.address, { + alpn: 'quic-test', + onerror: mustCall((err) => { + strictEqual(err.code, 'ERR_QUIC_TRANSPORT_ERROR'); + }), + }); + + // The client's closed promise rejects with the transport error + // from the server's certificate_required alert. + await rejects(clientSession.closed, { + code: 'ERR_QUIC_TRANSPORT_ERROR', + }); + + await serverEndpoint.close(); +} diff --git a/test/parallel/test-quic-token-distinct.mjs b/test/parallel/test-quic-token-distinct.mjs new file mode 100644 index 00000000000000..cb830134847065 --- /dev/null +++ b/test/parallel/test-quic-token-distinct.mjs @@ -0,0 +1,50 @@ +// Flags: --experimental-quic --no-warnings + +// Test: two clients receive distinct NEW_TOKEN tokens. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok, notDeepStrictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +let token1; +let token2; +const gotToken1 = Promise.withResolvers(); +const gotToken2 = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.closed; +}, 2)); + +// Client 1. +const cs1 = await connect(serverEndpoint.address, { + onnewtoken: mustCall((token) => { + token1 = Buffer.from(token); + gotToken1.resolve(); + }), +}); +await Promise.all([cs1.opened, gotToken1.promise]); +ok(token1.length > 0); + +// Client 2. +const cs2 = await connect(serverEndpoint.address, { + onnewtoken: mustCall((token) => { + token2 = Buffer.from(token); + gotToken2.resolve(); + }), +}); +await Promise.all([cs2.opened, gotToken2.promise]); +ok(token2.length > 0); + +// Tokens should be distinct. +notDeepStrictEqual(token1, token2); + +await cs1.close(); +await cs2.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-token-expired.mjs b/test/parallel/test-quic-token-expired.mjs new file mode 100644 index 00000000000000..f0f24ac8e891a3 --- /dev/null +++ b/test/parallel/test-quic-token-expired.mjs @@ -0,0 +1,68 @@ +// Flags: --experimental-quic --no-warnings + +// Test: expired NEW_TOKEN is rejected. +// The server issues a NEW_TOKEN with a short tokenExpiration. After +// the token expires, the client provides it on reconnect. The server +// should reject it (the token is invalid) and fall back to Retry +// flow for address validation. + +import { hasQuic, skip, mustCall, mustNotCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; +import { setTimeout } from 'node:timers/promises'; + +const { ok, strictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); +const sni = { '*': { keys: [key], certs: [cert] } }; +const alpn = ['quic-test']; + +let savedToken; +const gotToken = Promise.withResolvers(); + +// Server with a very short token expiration (1 second). +const serverEndpoint = await listen((serverSession) => { + serverSession.onstream = mustNotCall(); +}, { + sni, + alpn, + endpoint: { tokenExpiration: 1 }, +}); + +// First connection: receive the token. +const cs1 = await connect(serverEndpoint.address, { + alpn: 'quic-test', + onnewtoken: mustCall((token) => { + savedToken = token; + gotToken.resolve(); + }), +}); +await Promise.all([cs1.opened, gotToken.promise]); +ok(savedToken.length > 0); +await cs1.close(); + +// Wait for the token to expire. +await setTimeout(1500); + +// Second connection with the expired token. The server should reject +// the token and fall back to Retry for address validation. The +// connection should still succeed (Retry is transparent). +const cs2 = await connect(serverEndpoint.address, { + alpn: 'quic-test', + token: savedToken, +}); +await cs2.opened; +// The connection succeeded despite the expired token. +strictEqual(cs2.destroyed, false); +await cs2.close(); + +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-token-reuse.mjs b/test/parallel/test-quic-token-reuse.mjs new file mode 100644 index 00000000000000..60ab0c29a38ceb --- /dev/null +++ b/test/parallel/test-quic-token-reuse.mjs @@ -0,0 +1,62 @@ +// Flags: --experimental-quic --no-warnings + +// Test: client reuses NEW_TOKEN on reconnect. +// The server sends a NEW_TOKEN after handshake. The client saves it +// and provides it in the token option on a subsequent connection to +// the same server. The second connection should succeed. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +let savedToken; +const gotToken = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall((stream) => { + stream.writer.endSync(); + serverSession.close(); + }); +}, 2), { + onerror() {}, +}); + +// First connection: receive the token. +const cs1 = await connect(serverEndpoint.address, { + onnewtoken: mustCall((token) => { + ok(Buffer.isBuffer(token)); + ok(token.length > 0); + savedToken = token; + gotToken.resolve(); + }), +}); +await Promise.all([cs1.opened, gotToken.promise]); + +// Signal the server to close this session. +const s1 = await cs1.createBidirectionalStream(); +s1.writer.endSync(); +for await (const _ of s1) { /* drain */ } // eslint-disable-line no-unused-vars +await Promise.all([s1.closed, cs1.closed]); + +// Second connection: reuse the token. The connection should succeed. +const cs2 = await connect(serverEndpoint.address, { + token: savedToken, +}); +await cs2.opened; + +// Verify data transfer works on the second connection. +const s2 = await cs2.createBidirectionalStream(); +s2.writer.endSync(); +for await (const _ of s2) { /* drain */ } // eslint-disable-line no-unused-vars +await s2.closed; + +// Close from the client side. +await cs2.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-token-secret.mjs b/test/parallel/test-quic-token-secret.mjs new file mode 100644 index 00000000000000..cbafd679d772b6 --- /dev/null +++ b/test/parallel/test-quic-token-secret.mjs @@ -0,0 +1,90 @@ +// Flags: --experimental-quic --no-warnings + +// Test: tokenSecret cross-endpoint token validation. +// Two server endpoints with the same tokenSecret should accept each +// other's NEW_TOKEN tokens. A token from a server with a different +// tokenSecret should be rejected (falls back to Retry). + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { ok, strictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey, randomBytes } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); +const sni = { '*': { keys: [key], certs: [cert] } }; +const alpn = ['quic-test']; + +const sharedSecret = randomBytes(16); + +let savedToken; +const gotToken = Promise.withResolvers(); + +// First server with shared tokenSecret. +const ep1 = await listen(async (serverSession) => { + await serverSession.closed; +}, { + sni, + alpn, + endpoint: { tokenSecret: sharedSecret }, +}); + +// Get a token from the first server. +const cs1 = await connect(ep1.address, { + alpn: 'quic-test', + onnewtoken: mustCall((token) => { + savedToken = token; + gotToken.resolve(); + }), +}); +await Promise.all([cs1.opened, gotToken.promise]); +ok(savedToken.length > 0); +await cs1.close(); +await ep1.close(); + +// Second server with the SAME tokenSecret. The token from ep1 +// should be accepted, allowing the connection to skip Retry. +const ep2 = await listen(async (serverSession) => { + await serverSession.closed; +}, { + sni, + alpn, + endpoint: { tokenSecret: sharedSecret }, +}); + +const cs2 = await connect(ep2.address, { + alpn: 'quic-test', + token: savedToken, +}); +await cs2.opened; +strictEqual(cs2.destroyed, false); +await cs2.close(); +await ep2.close(); + +// Third server with a DIFFERENT tokenSecret. The token from ep1 +// should be rejected. The connection still succeeds (Retry fallback). +const ep3 = await listen(async (serverSession) => { + await serverSession.closed; +}, { + sni, + alpn, + endpoint: { tokenSecret: randomBytes(16) }, +}); + +const cs3 = await connect(ep3.address, { + alpn: 'quic-test', + token: savedToken, +}); +await cs3.opened; +strictEqual(cs3.destroyed, false); +await cs3.close(); +await ep3.close(); diff --git a/test/parallel/test-quic-transport-params-validation.mjs b/test/parallel/test-quic-transport-params-validation.mjs new file mode 100644 index 00000000000000..b17f23b9bd0bb2 --- /dev/null +++ b/test/parallel/test-quic-transport-params-validation.mjs @@ -0,0 +1,76 @@ +// Flags: --experimental-quic --no-warnings + +// Test: transport parameter validation. +// Transport parameters are validated by ngtcp2 at connection time. +// Node.js validates the type (must be a number) but ngtcp2 validates +// the ranges. Verify that invalid types are rejected and valid +// values are accepted. + +import { hasQuic, skip, mustNotCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { readKey } = fixtures; + +const { rejects, ok } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen } = await import('node:quic'); +const { createPrivateKey } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); +const sni = { '*': { keys: [key], certs: [cert] } }; +const alpn = ['quic-test']; + +async function tryListen(sessionOpts) { + return listen(mustNotCall(), { sni, alpn, ...sessionOpts }); +} + +// Invalid types for transport params are rejected. +for (const param of [ + 'initialMaxStreamDataBidiLocal', + 'initialMaxStreamDataBidiRemote', + 'initialMaxStreamDataUni', + 'initialMaxData', + 'initialMaxStreamsBidi', + 'initialMaxStreamsUni', + 'maxIdleTimeout', + 'activeConnectionIDLimit', + 'ackDelayExponent', + 'maxAckDelay', +]) { + await rejects(tryListen({ + transportParams: { [param]: 'invalid' }, + }), { + code: 'ERR_INVALID_ARG_VALUE', + }, `${param} should reject string value`); + + await rejects(tryListen({ + transportParams: { [param]: -1 }, + }), { + code: 'ERR_INVALID_ARG_VALUE', + }, `${param} should reject negative value`); +} + +// Valid values are accepted. +const ep = await tryListen({ + transportParams: { + initialMaxStreamDataBidiLocal: 65536, + initialMaxStreamDataBidiRemote: 65536, + initialMaxStreamDataUni: 65536, + initialMaxData: 1048576, + initialMaxStreamsBidi: 100, + initialMaxStreamsUni: 3, + maxIdleTimeout: 30, + activeConnectionIDLimit: 4, + ackDelayExponent: 3, + maxAckDelay: 25, + maxDatagramFrameSize: 1200, + }, +}); +ok(ep); +await ep.close(); diff --git a/test/parallel/test-quic-version-negotiation.mjs b/test/parallel/test-quic-version-negotiation.mjs new file mode 100644 index 00000000000000..f255ab87c39740 --- /dev/null +++ b/test/parallel/test-quic-version-negotiation.mjs @@ -0,0 +1,79 @@ +// Flags: --experimental-quic --no-warnings + +// Test: version negotiation. +// Version mismatch triggers version negotiation. +// Client receives ERR_QUIC_VERSION_NEGOTIATION_ERROR. +// quic.session.version.negotiation diagnostics channel fires. +// The client connects with an unsupported version number. The server +// responds with a Version Negotiation packet. The client's closed +// promise rejects with ERR_QUIC_VERSION_NEGOTIATION_ERROR. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import dc from 'node:diagnostics_channel'; + +const { ok, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const bogusVersion = 0x1a1a1a1a; + +// Subscribe to the version negotiation diagnostics channel. +const channelFired = Promise.withResolvers(); +dc.subscribe('quic.session.version.negotiation', mustCall((msg) => { + ok(msg.session, 'message should have session'); + strictEqual(msg.version, bogusVersion); + ok(Array.isArray(msg.requestedVersions), + 'requestedVersions should be an array'); + ok(msg.requestedVersions.length > 0, + 'server should advertise at least one version'); + ok(Array.isArray(msg.supportedVersions), + 'supportedVersions should be an array'); + channelFired.resolve(); +})); + +const serverEndpoint = await listen(async (serverSession) => { + // The server should never create a session for an unsupported version. + assert.fail('Server session callback should not be called'); +}); + +const clientSession = await connect(serverEndpoint.address, { + reuseEndpoint: false, + // Use an unsupported version to trigger version negotiation. + version: bogusVersion, + // The onversionnegotiation callback fires with version info. + onversionnegotiation: mustCall((version, requestedVersions, + supportedVersions) => { + // The version is the bogus version we configured. + strictEqual(version, bogusVersion); + // requestedVersions are the versions the server advertised in + // the Version Negotiation packet. + ok(Array.isArray(requestedVersions), + 'requestedVersions should be an array'); + ok(requestedVersions.length > 0, + 'server should advertise at least one supported version'); + // supportedVersions is our local supported range [min, max]. + ok(Array.isArray(supportedVersions), + 'supportedVersions should be an array'); + strictEqual(supportedVersions.length, 2, + 'supportedVersions should have [min, max]'); + }), + // The onerror callback fires with the version negotiation error. + onerror: mustCall((err) => { + strictEqual(err.code, 'ERR_QUIC_VERSION_NEGOTIATION_ERROR'); + }), +}); + +// The closed promise rejects with ERR_QUIC_VERSION_NEGOTIATION_ERROR. +await assert.rejects(clientSession.closed, { + code: 'ERR_QUIC_VERSION_NEGOTIATION_ERROR', +}); + +// Wait for the diagnostics channel to fire. +await channelFired.promise; + +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-version.mjs b/test/parallel/test-quic-version.mjs new file mode 100644 index 00000000000000..1df17e3b1f163f --- /dev/null +++ b/test/parallel/test-quic-version.mjs @@ -0,0 +1,45 @@ +// Flags: --experimental-quic --no-warnings + +// Test: QUIC version selection. +// QUIC v1 handshake succeeds. +// QUIC v2 handshake succeeds. +// Both V1 and V2 are advertised in preferred/available versions. +// Version negotiation upgrades V1 → V2 when both sides support it. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + await serverSession.opened; + await serverSession.close(); + serverDone.resolve(); +})); + +// Default handshake uses v1 initial packets. +// The session should complete successfully. +const cs = await connect(serverEndpoint.address); +const info = await cs.opened; + +// The cipher and protocol should be negotiated. +strictEqual(typeof info.cipher, 'string'); +strictEqual(info.cipherVersion, 'TLSv1.3'); +strictEqual(info.protocol, 'quic-test'); + +// Both V1 and V2 are in preferred/available versions +// (configured in Session::Config). The compatible version negotiation +// (RFC 9368) should upgrade to V2 when both sides support it. +// We verify the handshake succeeded — the version negotiation +// happens transparently. + +await Promise.all([serverDone.promise, cs.closed]); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-writer-abort-signal.mjs b/test/parallel/test-quic-writer-abort-signal.mjs new file mode 100644 index 00000000000000..8d0dbb0351d931 --- /dev/null +++ b/test/parallel/test-quic-writer-abort-signal.mjs @@ -0,0 +1,52 @@ +// Flags: --experimental-quic --no-warnings + +// Test: write with aborted signal rejects immediately. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import * as assert from 'node:assert'; + +const { rejects } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const encoder = new TextEncoder(); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream(); +const w = stream.writer; + +// Create an already-aborted signal. +const ac = new AbortController(); +ac.abort(new Error('already aborted')); + +// write() with an already-aborted signal should reject immediately. +await rejects( + w.write(encoder.encode('data'), { signal: ac.signal }), + { message: 'already aborted' }, +); + +// The writer should still be usable for normal writes. +w.writeSync(encoder.encode('ok')); +w.endSync(); + +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars +await Promise.all([stream.closed, serverDone.promise]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-writer-async-dispose-ended.mjs b/test/parallel/test-quic-writer-async-dispose-ended.mjs new file mode 100644 index 00000000000000..04337343ea8735 --- /dev/null +++ b/test/parallel/test-quic-writer-async-dispose-ended.mjs @@ -0,0 +1,46 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: Symbol.asyncDispose only fails if writable side not ended. +// If the writer was already ended (via endSync/end), asyncDispose +// should not fail — it's a no-op. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const encoder = new TextEncoder(); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream(); +const w = stream.writer; + +// End the writer normally. +w.writeSync(encoder.encode('data')); +w.endSync(); + +// After end, asyncDispose should be a no-op (writer already ended). +await w[Symbol.asyncDispose](); + +// The stream should close cleanly. +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + +await Promise.all([stream.closed, serverDone.promise]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-writer-backpressure.mjs b/test/parallel/test-quic-writer-backpressure.mjs new file mode 100644 index 00000000000000..4d74f029929e53 --- /dev/null +++ b/test/parallel/test-quic-writer-backpressure.mjs @@ -0,0 +1,81 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: writer backpressure. +// writeSync returns false when highWaterMark is exceeded. +// drainableProtocol returns promise when desiredSize <= 0. +// drainableProtocol promise resolves when drain fires. +// Try-fallback pattern: writeSync false, await drain, retry. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual, ok } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes, drainableProtocol: dp } = await import('stream/iter'); + +// Total data: 8 x 1KB = 8KB. highWaterMark: 2KB. +const numChunks = 8; +const chunkSize = 1024; +const totalSize = numChunks * chunkSize; + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + strictEqual(received.byteLength, totalSize); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream({ + highWaterMark: 2048, +}); +const w = stream.writer; + +// Initial desiredSize should be the highWaterMark. +strictEqual(w.desiredSize, 2048); +strictEqual(stream.highWaterMark, 2048); + +let backpressureCount = 0; + +for (let i = 0; i < numChunks; i++) { + const chunk = new Uint8Array(chunkSize); + chunk.fill(i & 0xFF); + while (!w.writeSync(chunk)) { + // writeSync returned false. + backpressureCount++; + + // drainableProtocol returns a promise when backpressured. + const drain = w[dp](); + ok(drain instanceof Promise, 'drainableProtocol should return a Promise'); + + // The promise resolves when drain fires. + await drain; + + // After drain, desiredSize should be > 0. + ok(w.desiredSize > 0, `desiredSize after drain should be > 0, got ${w.desiredSize}`); + } +} + +w.endSync(); + +// Backpressure should have been hit with a 2KB highWaterMark +// and 1KB chunks (every 2 chunks fills the buffer). +ok(backpressureCount > 0, 'backpressure should have been hit'); + +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars +await Promise.all([stream.closed, serverDone.promise]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-writer-stop-sending.mjs b/test/parallel/test-quic-writer-stop-sending.mjs new file mode 100644 index 00000000000000..c964fa11bce5d6 --- /dev/null +++ b/test/parallel/test-quic-writer-stop-sending.mjs @@ -0,0 +1,59 @@ +// Flags: --experimental-quic --no-warnings + +// Test: peer STOP_SENDING transitions writer to errored state. +// After the server calls stopSending(), the client's writer should +// become errored — desiredSize is null, writeSync returns false. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import * as assert from 'node:assert'; +import { setTimeout } from 'node:timers/promises'; + +const { rejects, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +const encoder = new TextEncoder(); + +const serverReady = Promise.withResolvers(); +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall(async (serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + // Tell the client to stop sending. + stream.stopSending(1n); + serverReady.resolve(); + stream.writer.endSync(); + await rejects(stream.closed, mustCall((err) => { + assert.ok(err); + return true; + })); + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream(); +const w = stream.writer; +w.writeSync(encoder.encode('initial data')); + +// Wait for the server to send STOP_SENDING. +await serverReady.promise; + +// Give a moment for the STOP_SENDING to propagate. +await setTimeout(100); + +// After STOP_SENDING, the writer should be in an errored state. +// writeSync returns false (refuses to accept data). +strictEqual(w.writeSync(encoder.encode('rejected')), false); + +// The stream closes after the server sends FIN. +await Promise.all([serverDone.promise, stream.closed]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-writer-write-rejects.mjs b/test/parallel/test-quic-writer-write-rejects.mjs new file mode 100644 index 00000000000000..864246b9e80e70 --- /dev/null +++ b/test/parallel/test-quic-writer-write-rejects.mjs @@ -0,0 +1,65 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: write() rejects when flow-controlled. +// The async write() method rejects with ERR_INVALID_STATE when the +// chunk exceeds desiredSize. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { rejects, strictEqual, ok } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes, drainableProtocol: dp } = await import('stream/iter'); + +const serverDone = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + await bytes(stream); + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + serverDone.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +// Use a small highWaterMark to trigger backpressure easily. +const stream = await clientSession.createBidirectionalStream({ + highWaterMark: 1024, +}); +const w = stream.writer; + +// Fill the buffer. +strictEqual(w.writeSync(new Uint8Array(1024)), true); + +// desiredSize should now be 0 or very small. +strictEqual(w.desiredSize, 0); + +// Async write() should reject when buffer is full. +await rejects( + w.write(new Uint8Array(512)), + { code: 'ERR_INVALID_STATE' }, +); + +// Wait for drain, then write should succeed. +const drain = w[dp](); +ok(drain instanceof Promise); +await drain; +ok(w.desiredSize > 0); + +// Now write succeeds. +await w.write(new Uint8Array(100)); + +w.endSync(); +for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars +await Promise.all([stream.closed, serverDone.promise]); +await clientSession.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-zero-rtt-datagram.mjs b/test/parallel/test-quic-zero-rtt-datagram.mjs new file mode 100644 index 00000000000000..5cfd776e51a205 --- /dev/null +++ b/test/parallel/test-quic-zero-rtt-datagram.mjs @@ -0,0 +1,81 @@ +// Flags: --experimental-quic --no-warnings + +// Test: 0-RTT with datagrams. +// The client sends a datagram as 0-RTT data in the first flight. +// The server receives it with the early flag set on the ondatagram +// callback. The datagram's early parameter should be true. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok, strictEqual, deepStrictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +let savedTicket; +let savedToken; +const gotTicket = Promise.withResolvers(); +const gotToken = Promise.withResolvers(); + +let earlyDatagramReceived = false; +let receivedDatagramData; +const serverGotDatagram = Promise.withResolvers(); + +let serverSessionCount = 0; +const serverEndpoint = await listen((serverSession) => { + const sessionNum = ++serverSessionCount; + if (sessionNum === 2) { + serverSession.ondatagram = (data, early) => { + receivedDatagramData = Buffer.from(data); + earlyDatagramReceived = early; + serverGotDatagram.resolve(); + }; + } +}, { + transportParams: { maxDatagramFrameSize: 1200 }, +}); + +// --- First connection: receive session ticket and token --- +const cs1 = await connect(serverEndpoint.address, { + transportParams: { maxDatagramFrameSize: 1200 }, + onsessionticket: mustCall((ticket) => { + ok(Buffer.isBuffer(ticket)); + savedTicket = ticket; + gotTicket.resolve(); + }), + onnewtoken: mustCall((token) => { + ok(Buffer.isBuffer(token)); + savedToken = token; + gotToken.resolve(); + }), +}); + +await cs1.opened; +await Promise.all([gotTicket.promise, gotToken.promise]); +await cs1.close(); + +// --- Second connection: send datagram as 0-RTT --- +const cs2 = await connect(serverEndpoint.address, { + transportParams: { maxDatagramFrameSize: 1200 }, + sessionTicket: savedTicket, + token: savedToken, +}); + +// Send datagram BEFORE the handshake completes — true 0-RTT. +await cs2.sendDatagram(new Uint8Array([0xCA, 0xFE])); + +const info2 = await cs2.opened; +strictEqual(info2.earlyDataAttempted, true); +strictEqual(info2.earlyDataAccepted, true); + +// Verify the server received the datagram as early data. +await serverGotDatagram.promise; +deepStrictEqual(receivedDatagramData, Buffer.from([0xCA, 0xFE])); +strictEqual(earlyDatagramReceived, true); + +await cs2.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-zero-rtt-disabled-client.mjs b/test/parallel/test-quic-zero-rtt-disabled-client.mjs new file mode 100644 index 00000000000000..1c7f8cebd9fdac --- /dev/null +++ b/test/parallel/test-quic-zero-rtt-disabled-client.mjs @@ -0,0 +1,60 @@ +// Flags: --experimental-quic --no-warnings + +// Test: 0-RTT not attempted when client sets enableEarlyData: false +// Even with a valid session ticket and token, the client should not +// attempt 0-RTT when enableEarlyData is false. The opened info +// should show earlyDataAttempted: false. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); + +let savedTicket; +let savedToken; +const gotTicket = Promise.withResolvers(); +const gotToken = Promise.withResolvers(); + +const serverEndpoint = await listen((serverSession) => { + serverSession.onstream = async (stream) => { + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + }; +}); + +// First connection: get ticket and token. +const cs1 = await connect(serverEndpoint.address, { + onsessionticket: mustCall((ticket) => { + savedTicket = ticket; + gotTicket.resolve(); + }), + onnewtoken: mustCall((token) => { + savedToken = token; + gotToken.resolve(); + }), +}); +await Promise.all([cs1.opened, gotTicket.promise, gotToken.promise]); +await cs1.close(); + +// Second connection: provide ticket and token but disable early data. +const cs2 = await connect(serverEndpoint.address, { + sessionTicket: savedTicket, + token: savedToken, + enableEarlyData: false, +}); + +const info2 = await cs2.opened; +// 0-RTT should NOT be attempted. +strictEqual(info2.earlyDataAttempted, false); +strictEqual(info2.earlyDataAccepted, false); + +await cs2.close(); +await serverEndpoint.close(); diff --git a/test/parallel/test-quic-zero-rtt-disabled-server.mjs b/test/parallel/test-quic-zero-rtt-disabled-server.mjs new file mode 100644 index 00000000000000..0dffb304c68818 --- /dev/null +++ b/test/parallel/test-quic-zero-rtt-disabled-server.mjs @@ -0,0 +1,93 @@ +// Flags: --experimental-quic --no-warnings + +// Test: Server rejects 0-RTT when enableEarlyData: false. +// The client has a valid session ticket and token, and attempts 0-RTT. +// The server has enableEarlyData: false, so it rejects the early data. +// The connection should still succeed (fallback to 1-RTT), and +// earlyDataAccepted should be false. + +import { hasQuic, skip, mustNotCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import * as fixtures from '../common/fixtures.mjs'; + +const { strictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey, randomBytes } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); +const sni = { '*': { keys: [key], certs: [cert] } }; +const alpn = ['quic-test']; + +// Use the same tokenSecret for both servers so the token is valid. +const tokenSecret = randomBytes(16); + +let savedTicket; +let savedToken; +const gotTicket = Promise.withResolvers(); +const gotToken = Promise.withResolvers(); + +// First server: enableEarlyData: true (default) to generate a valid ticket. +const serverEndpoint1 = await listen((serverSession) => { + serverSession.onstream = async (stream) => { + for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + }; +}, { + sni, + alpn, + endpoint: { tokenSecret }, +}); + +const cs1 = await connect(serverEndpoint1.address, { + alpn: 'quic-test', + onsessionticket(ticket) { + savedTicket = ticket; + gotTicket.resolve(); + }, + onnewtoken(token) { + savedToken = token; + gotToken.resolve(); + }, +}); +await Promise.all([cs1.opened, gotTicket.promise, gotToken.promise]); +await cs1.close(); +await serverEndpoint1.close(); + +// Second server: enableEarlyData: false — rejects 0-RTT. +const serverEndpoint2 = await listen(async (serverSession) => { + await serverSession.opened; + serverSession.close(); + await serverSession.closed; +}, { + sni, + alpn, + enableEarlyData: false, + endpoint: { tokenSecret }, + onerror: mustNotCall(), +}); + +const cs2 = await connect(serverEndpoint2.address, { + alpn: 'quic-test', + sessionTicket: savedTicket, + token: savedToken, +}); + +// The deferred handshake needs a send to trigger. Use sendDatagram +// since it's simpler than a stream for this test. +await cs2.sendDatagram(new Uint8Array([1])); + +const info2 = await cs2.opened; +strictEqual(info2.earlyDataAttempted, true); +strictEqual(info2.earlyDataAccepted, false); + +await cs2.closed; +await serverEndpoint2.close(); diff --git a/test/parallel/test-quic-zero-rtt-rejected-settings.mjs b/test/parallel/test-quic-zero-rtt-rejected-settings.mjs new file mode 100644 index 00000000000000..f29eaec8b6d478 --- /dev/null +++ b/test/parallel/test-quic-zero-rtt-rejected-settings.mjs @@ -0,0 +1,111 @@ +// Flags: --experimental-quic --no-warnings + +// Test: 0-RTT rejected when server settings change. +// The client has a session ticket from a server with generous +// transport params. The server restarts with reduced params +// (smaller initialMaxStreamsBidi). The 0-RTT should be rejected +// because the stored transport params are more permissive than +// the current ones. The connection falls back to 1-RTT. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; +import dc from 'node:diagnostics_channel'; +import * as fixtures from '../common/fixtures.mjs'; + +const { ok, strictEqual } = assert; +const { readKey } = fixtures; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('node:quic'); +const { createPrivateKey, randomBytes } = await import('node:crypto'); + +const key = createPrivateKey(readKey('agent1-key.pem')); +const cert = readKey('agent1-cert.pem'); +const sni = { '*': { keys: [key], certs: [cert] } }; +const alpn = ['quic-test']; +const tokenSecret = randomBytes(16); + +// quic.session.early.rejected fires when 0-RTT is rejected. +dc.subscribe('quic.session.early.rejected', mustCall((msg) => { + ok(msg.session, 'early.rejected should include session'); +})); + +let savedTicket; +let savedToken; +const gotTicket = Promise.withResolvers(); +const gotToken = Promise.withResolvers(); + +// First server: generous transport params. +const ep1 = await listen(async (serverSession) => { + await serverSession.closed; +}, { + sni, + alpn, + endpoint: { tokenSecret }, + transportParams: { + initialMaxStreamsBidi: 100, + initialMaxData: 1048576, + }, +}); + +const cs1 = await connect(ep1.address, { + alpn: 'quic-test', + onsessionticket: mustCall((ticket) => { + savedTicket = ticket; + gotTicket.resolve(); + }), + onnewtoken: mustCall((token) => { + savedToken = token; + gotToken.resolve(); + }), +}); +await Promise.all([cs1.opened, gotTicket.promise, gotToken.promise]); +await cs1.close(); +await ep1.close(); + +// Second server: reduced transport params. +// initialMaxStreamsBidi reduced from 100 to 10. +const serverStreamSeen = Promise.withResolvers(); +const ep2 = await listen((serverSession) => { + serverSession.onstream = (stream) => { + // The stream may be destroyed by EarlyDataRejected before + // we can process it. Just record that we saw it. + serverStreamSeen.resolve(true); + }; +}, { + sni, + alpn, + endpoint: { tokenSecret }, + transportParams: { + initialMaxStreamsBidi: 10, + initialMaxData: 1048576, + }, + onerror(err) { ok(err); }, +}); + +const cs2 = await connect(ep2.address, { + alpn: 'quic-test', + sessionTicket: savedTicket, + token: savedToken, + onerror(err) { ok(err); }, + onearlyrejected() {}, +}); + +// Trigger the deferred handshake. +const encoder = new TextEncoder(); +await cs2.createBidirectionalStream({ + body: encoder.encode('test'), +}); + +const info2 = await cs2.opened; +// 0-RTT was attempted but rejected due to changed transport params. +strictEqual(info2.earlyDataAttempted, true); +strictEqual(info2.earlyDataAccepted, false); + +// The 0-RTT stream may have been destroyed by EarlyDataRejected. +// Close from the client side. +await cs2.close(); +await ep2.close(); diff --git a/test/parallel/test-quic-zero-rtt.mjs b/test/parallel/test-quic-zero-rtt.mjs new file mode 100644 index 00000000000000..ef1a345541045b --- /dev/null +++ b/test/parallel/test-quic-zero-rtt.mjs @@ -0,0 +1,111 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: 0-RTT session resumption. +// First connection receives a session ticket and NEW_TOKEN. +// Second connection uses both the session ticket and token. +// The token skips address validation (Retry), the session +// ticket enables 0-RTT encryption. The client sends data +// BEFORE the handshake completes (true 0-RTT). The server's +// onstream fires and the stream's early flag is true. + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { ok, strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes } = await import('stream/iter'); + +const encoder = new TextEncoder(); + +let savedTicket; +let savedToken; +const gotTicket = Promise.withResolvers(); +const gotToken = Promise.withResolvers(); + +let firstStreamEarly; +let secondStreamEarly; +const secondStreamDone = Promise.withResolvers(); + +let serverSessionCount = 0; +const serverEndpoint = await listen((serverSession) => { + const sessionNum = ++serverSessionCount; + serverSession.onstream = async (stream) => { + const data = await bytes(stream); + ok(data.byteLength > 0); + + if (sessionNum === 1) { + firstStreamEarly = stream.early; + } else { + secondStreamEarly = stream.early; + secondStreamDone.resolve(); + } + + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + }; +}); + +// --- ZRTT-01: First connection — receive the session ticket and token --- +const cs1 = await connect(serverEndpoint.address, { + onsessionticket: mustCall((ticket) => { + ok(Buffer.isBuffer(ticket)); + ok(ticket.length > 0); + savedTicket = ticket; + gotTicket.resolve(); + }, 2), + onnewtoken: mustCall((token) => { + ok(Buffer.isBuffer(token)); + ok(token.length > 0); + savedToken = token; + gotToken.resolve(); + }), +}); + +const info1 = await cs1.opened; +strictEqual(info1.earlyDataAttempted, false); +strictEqual(info1.earlyDataAccepted, false); + +await Promise.all([gotTicket.promise, gotToken.promise]); + +// Send data to verify the connection works. +const s1 = await cs1.createBidirectionalStream({ + body: encoder.encode('first'), +}); +for await (const _ of s1) { /* drain */ } // eslint-disable-line no-unused-vars +await Promise.all([s1.closed, cs1.closed]); + +// --- ZRTT-02: Second connection — 0-RTT with ticket + token --- +// The token skips Retry (address validation), the session ticket +// enables 0-RTT encryption. With the deferred handshake, the +// stream data is included in the first flight as 0-RTT. +const cs2 = await connect(serverEndpoint.address, { + sessionTicket: savedTicket, + token: savedToken, +}); + +// Send data BEFORE the handshake completes — true 0-RTT. +const s2 = await cs2.createBidirectionalStream({ + body: encoder.encode('early data'), +}); + +// Now wait for handshake completion. +const info2 = await cs2.opened; +strictEqual(info2.earlyDataAttempted, true); +strictEqual(info2.earlyDataAccepted, true); + +for await (const _ of s2) { /* drain */ } // eslint-disable-line no-unused-vars +await s2.closed; + +// Verify the server saw the early data flag. +await secondStreamDone.promise; +strictEqual(firstStreamEarly, false); +strictEqual(secondStreamEarly, true); + +await cs2.closed; +await serverEndpoint.close(); From 1aebbdef06065cef6566525ca4a042ffb8fb5308 Mon Sep 17 00:00:00 2001 From: Felipe Coelho Date: Thu, 19 Mar 2026 09:46:51 -0300 Subject: [PATCH 072/168] src: skip JS callback for settled Promise.race losers MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit When Promise.race() or Promise.any() settles, V8 fires kPromiseResolveAfterResolved / kPromiseRejectAfterResolved for each "losing" promise. The PromiseRejectCallback in node_task_queue.cc was crossing into JS for these events, but since the multipleResolves event reached EOL in v25 (PR #58707), the JS handler does nothing. The unnecessary C++-to-JS boundary crossings accumulate references in a tight loop, causing OOM when using Promise.race() with immediately-resolving promises. Return early in PromiseRejectCallback() for these two events, skipping the JS callback entirely. Also remove the dead case branches and unused constant imports from the JS side. Move early returns for kPromiseResolveAfterResolved and kPromiseRejectAfterResolved before Number::New and CHECK(!callback), avoiding unnecessary work. Remove dead NODE_DEFINE_CONSTANT exports and fix comment placement in the JS switch statement. Bump test --max-old-space-size from 20 to 64 for safety on instrumented builds. Fixes: https://github.com/nodejs/node/issues/51452 Refs: https://github.com/nodejs/node/pull/60184 Refs: https://github.com/nodejs/node/pull/61960 PR-URL: https://github.com/nodejs/node/pull/62336 Refs: https://github.com/nodejs/node/issues/51452 Reviewed-By: Jordan Harband Reviewed-By: Benjamin Gruenbaum Reviewed-By: James M Snell Reviewed-By: Gürgün Dayıoğlu --- lib/internal/process/promises.js | 12 ++-------- src/node_task_queue.cc | 12 ++++------ .../parallel/test-promise-race-memory-leak.js | 24 +++++++++++++++++++ 3 files changed, 31 insertions(+), 17 deletions(-) create mode 100644 test/parallel/test-promise-race-memory-leak.js diff --git a/lib/internal/process/promises.js b/lib/internal/process/promises.js index 0ccea4d05a87f5..8bb2062b3a9f0f 100644 --- a/lib/internal/process/promises.js +++ b/lib/internal/process/promises.js @@ -14,8 +14,6 @@ const { promiseRejectEvents: { kPromiseRejectWithNoHandler, kPromiseHandlerAddedAfterReject, - kPromiseRejectAfterResolved, - kPromiseResolveAfterResolved, }, setPromiseRejectCallback, } = internalBinding('task_queue'); @@ -161,6 +159,8 @@ function promiseRejectHandler(type, promise, reason) { if (unhandledRejectionsMode === undefined) { unhandledRejectionsMode = getUnhandledRejectionsMode(); } + // kPromiseRejectAfterResolved and kPromiseResolveAfterResolved are + // filtered out in C++ (src/node_task_queue.cc) and never reach JS. switch (type) { case kPromiseRejectWithNoHandler: // 0 unhandledRejection(promise, reason); @@ -168,14 +168,6 @@ function promiseRejectHandler(type, promise, reason) { case kPromiseHandlerAddedAfterReject: // 1 handledRejection(promise); break; - case kPromiseRejectAfterResolved: // 2 - // Do nothing in this case. Previous we would emit a multipleResolves - // event but that was deprecated then later removed. - break; - case kPromiseResolveAfterResolved: // 3 - // Do nothing in this case. Previous we would emit a multipleResolves - // event but that was deprecated then later removed. - break; } } diff --git a/src/node_task_queue.cc b/src/node_task_queue.cc index f1c53c44f201b2..82a706c1edd6a6 100644 --- a/src/node_task_queue.cc +++ b/src/node_task_queue.cc @@ -53,7 +53,11 @@ void PromiseRejectCallback(PromiseRejectMessage message) { Environment* env = Environment::GetCurrent(isolate); - if (env == nullptr || !env->can_call_into_js()) return; + if (env == nullptr || !env->can_call_into_js() || + event != kPromiseRejectWithNoHandler && + event != kPromiseHandlerAddedAfterReject) { + return; + } Local callback = env->promise_reject_callback(); // The promise is rejected before JS land calls SetPromiseRejectCallback @@ -77,10 +81,6 @@ void PromiseRejectCallback(PromiseRejectMessage message) { "rejections", "unhandled", unhandledRejections, "handledAfter", rejectionsHandledAfter); - } else if (event == kPromiseResolveAfterResolved) { - value = message.GetValue(); - } else if (event == kPromiseRejectAfterResolved) { - value = message.GetValue(); } else { return; } @@ -173,8 +173,6 @@ static void Initialize(Local target, Local events = Object::New(isolate); NODE_DEFINE_CONSTANT(events, kPromiseRejectWithNoHandler); NODE_DEFINE_CONSTANT(events, kPromiseHandlerAddedAfterReject); - NODE_DEFINE_CONSTANT(events, kPromiseResolveAfterResolved); - NODE_DEFINE_CONSTANT(events, kPromiseRejectAfterResolved); target->Set(env->context(), FIXED_ONE_BYTE_STRING(isolate, "promiseRejectEvents"), diff --git a/test/parallel/test-promise-race-memory-leak.js b/test/parallel/test-promise-race-memory-leak.js new file mode 100644 index 00000000000000..db00af4e4ef5f9 --- /dev/null +++ b/test/parallel/test-promise-race-memory-leak.js @@ -0,0 +1,24 @@ +// Flags: --max-old-space-size=64 +'use strict'; + +// Regression test for https://github.com/nodejs/node/issues/51452 +// When Promise.race() settles, V8 fires kPromiseResolveAfterResolved / +// kPromiseRejectAfterResolved for each "losing" promise. Before this fix, +// the C++ PromiseRejectCallback crossed into JS for these no-op events, +// accumulating references and causing OOM in tight async loops. +// With --max-old-space-size=64, this test would crash before completing +// if the leak is present. + +const common = require('../common'); + +async function main() { + for (let i = 0; i < 100_000; i++) { + await Promise.race([ + Promise.resolve(1), + Promise.resolve(2), + Promise.resolve(3), + ]); + } +} + +main().then(common.mustCall()); From e80b5d2ab2115013ab9963b3becfc739fa0e45fa Mon Sep 17 00:00:00 2001 From: Mert Can Altin Date: Wed, 6 May 2026 11:32:35 +0300 Subject: [PATCH 073/168] src: remove unused using declarations in node_task_queue MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mert Can Altin PR-URL: https://github.com/nodejs/node/pull/63144 Reviewed-By: Filip Skokan Reviewed-By: Michaël Zasso Reviewed-By: Chemi Atlow --- src/node_task_queue.cc | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/src/node_task_queue.cc b/src/node_task_queue.cc index 82a706c1edd6a6..0d40f3914b101e 100644 --- a/src/node_task_queue.cc +++ b/src/node_task_queue.cc @@ -19,9 +19,7 @@ using v8::FunctionCallbackInfo; using v8::Isolate; using v8::Just; using v8::kPromiseHandlerAddedAfterReject; -using v8::kPromiseRejectAfterResolved; using v8::kPromiseRejectWithNoHandler; -using v8::kPromiseResolveAfterResolved; using v8::Local; using v8::Maybe; using v8::Number; @@ -54,8 +52,8 @@ void PromiseRejectCallback(PromiseRejectMessage message) { Environment* env = Environment::GetCurrent(isolate); if (env == nullptr || !env->can_call_into_js() || - event != kPromiseRejectWithNoHandler && - event != kPromiseHandlerAddedAfterReject) { + (event != kPromiseRejectWithNoHandler && + event != kPromiseHandlerAddedAfterReject)) { return; } From e46e0d1679de2d527d949213c21c0dff749872bc Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Wed, 15 Apr 2026 12:37:21 +0200 Subject: [PATCH 074/168] crypto: optimize normalizeAlgorithm dispatch hot path Replace the O(n) case-insensitive algorithm-name scan with an O(1) SafeMap lookup. The map is pre-built at module init alongside kSupportedAlgorithms. Hoist the opts object literal used in normalizeAlgorithm to module level to avoid allocating identical { prefix, context } objects on every call. Pre-compute ObjectKeys() for simpleAlgorithmDictionaries entries at module init to avoid allocating a new keys array on every normalizeAlgorithm call. Signed-off-by: Filip Skokan PR-URL: https://github.com/nodejs/node/pull/62756 Reviewed-By: Yagiz Nizipli --- lib/internal/crypto/util.js | 106 +++++++++++++++++++----------------- 1 file changed, 57 insertions(+), 49 deletions(-) diff --git a/lib/internal/crypto/util.js b/lib/internal/crypto/util.js index b743f3f93a149e..67b5f66e4c3320 100644 --- a/lib/internal/crypto/util.js +++ b/lib/internal/crypto/util.js @@ -16,6 +16,7 @@ const { ObjectKeys, ObjectPrototypeHasOwnProperty, PromiseWithResolvers, + SafeMap, SafeSet, StringPrototypeToUpperCase, Symbol, @@ -453,8 +454,11 @@ const experimentalAlgorithms = [ ]; // Transform the algorithm definitions into the operation-keyed structure +// Also builds a parallel Map per operation +// for O(1) case-insensitive algorithm name lookup in normalizeAlgorithm. function createSupportedAlgorithms(algorithmDefs) { const result = {}; + const nameMap = {}; for (const { 0: algorithmName, 1: operations } of ObjectEntries(algorithmDefs)) { // Skip algorithms that are conditionally not supported @@ -465,6 +469,8 @@ function createSupportedAlgorithms(algorithmDefs) { for (const { 0: operation, 1: dict } of ObjectEntries(operations)) { result[operation] ||= {}; + nameMap[operation] ||= new SafeMap(); + nameMap[operation].set(StringPrototypeToUpperCase(algorithmName), algorithmName); // Add experimental warnings for experimental algorithms if (ArrayPrototypeIncludes(experimentalAlgorithms, algorithmName)) { @@ -482,10 +488,11 @@ function createSupportedAlgorithms(algorithmDefs) { } } - return result; + return { algorithms: result, nameMap }; } -const kSupportedAlgorithms = createSupportedAlgorithms(kAlgorithmDefinitions); +const { algorithms: kSupportedAlgorithms, nameMap: kAlgorithmNameMap } = + createSupportedAlgorithms(kAlgorithmDefinitions); const simpleAlgorithmDictionaries = { AesCbcParams: { iv: 'BufferSource' }, @@ -527,6 +534,12 @@ const simpleAlgorithmDictionaries = { TurboShakeParams: {}, }; +// Pre-compute ObjectKeys() for each dictionary entry at module init +// to avoid allocating a new keys array on every normalizeAlgorithm call. +for (const { 0: name, 1: types } of ObjectEntries(simpleAlgorithmDictionaries)) { + simpleAlgorithmDictionaries[name] = { keys: ObjectKeys(types), types }; +} + function validateMaxBufferLength(data, name, max = kMaxBufferLength) { if (data.byteLength > max) { throw lazyDOMException( @@ -537,6 +550,14 @@ function validateMaxBufferLength(data, name, max = kMaxBufferLength) { let webidl; +// Keep this as a regular object. The WebIDL converters read and spread these +// options on the normalizeAlgorithm hot path, and a null-prototype object +// measurably regresses benchmark/misc/webcrypto-webidl normalizeAlgorithm-*. +const kNormalizeAlgorithmOpts = { + prefix: 'Failed to normalize algorithm', + context: 'passed algorithm', +}; + // https://w3c.github.io/webcrypto/#algorithm-normalization-normalize-an-algorithm // adapted for Node.js from Deno's implementation // https://github.com/denoland/deno/blob/v1.29.1/ext/crypto/00_crypto.js#L195 @@ -549,29 +570,20 @@ function normalizeAlgorithm(algorithm, op) { // 1. const registeredAlgorithms = kSupportedAlgorithms[op]; // 2. 3. - const initialAlg = webidl.converters.Algorithm(algorithm, { - prefix: 'Failed to normalize algorithm', - context: 'passed algorithm', - }); + const initialAlg = webidl.converters.Algorithm(algorithm, + kNormalizeAlgorithmOpts); // 4. let algName = initialAlg.name; - // 5. - let desiredType; - for (const key in registeredAlgorithms) { - if (!ObjectPrototypeHasOwnProperty(registeredAlgorithms, key)) { - continue; - } - if ( - StringPrototypeToUpperCase(key) === StringPrototypeToUpperCase(algName) - ) { - algName = key; - desiredType = registeredAlgorithms[key]; - } - } - if (desiredType === undefined) + // 5. Case-insensitive lookup via pre-built Map (O(1) instead of O(n)). + const canonicalName = kAlgorithmNameMap[op]?.get( + StringPrototypeToUpperCase(algName)); + if (canonicalName === undefined) throw lazyDOMException('Unrecognized algorithm name', 'NotSupportedError'); + algName = canonicalName; + const desiredType = registeredAlgorithms[algName]; + // Fast path everything below if the registered dictionary is null if (desiredType === null) return { name: algName }; @@ -579,39 +591,35 @@ function normalizeAlgorithm(algorithm, op) { // 6. const normalizedAlgorithm = webidl.converters[desiredType]( { __proto__: algorithm, name: algName }, - { - prefix: 'Failed to normalize algorithm', - context: 'passed algorithm', - }, + kNormalizeAlgorithmOpts, ); // 7. normalizedAlgorithm.name = algName; - // 9. - const dict = simpleAlgorithmDictionaries[desiredType]; - // 10. - const dictKeys = dict ? ObjectKeys(dict) : []; - for (let i = 0; i < dictKeys.length; i++) { - const member = dictKeys[i]; - if (!ObjectPrototypeHasOwnProperty(dict, member)) - continue; - const idlType = dict[member]; - const idlValue = normalizedAlgorithm[member]; - // 3. - if (idlType === 'BufferSource' && idlValue) { - const isView = ArrayBufferIsView(idlValue); - normalizedAlgorithm[member] = TypedArrayPrototypeSlice( - new Uint8Array( - isView ? getDataViewOrTypedArrayBuffer(idlValue) : idlValue, - isView ? getDataViewOrTypedArrayByteOffset(idlValue) : 0, - isView ? getDataViewOrTypedArrayByteLength(idlValue) : ArrayBufferPrototypeGetByteLength(idlValue), - ), - ); - } else if (idlType === 'HashAlgorithmIdentifier') { - normalizedAlgorithm[member] = normalizeAlgorithm(idlValue, 'digest'); - } else if (idlType === 'AlgorithmIdentifier') { - // This extension point is not used by any supported algorithm (yet?) - throw lazyDOMException('Not implemented.', 'NotSupportedError'); + // 9. 10. Pre-computed keys and types from simpleAlgorithmDictionaries. + const dictMeta = simpleAlgorithmDictionaries[desiredType]; + if (dictMeta) { + const { keys: dictKeys, types: dictTypes } = dictMeta; + for (let i = 0; i < dictKeys.length; i++) { + const member = dictKeys[i]; + const idlType = dictTypes[member]; + const idlValue = normalizedAlgorithm[member]; + // 3. + if (idlType === 'BufferSource' && idlValue) { + const isView = ArrayBufferIsView(idlValue); + normalizedAlgorithm[member] = TypedArrayPrototypeSlice( + new Uint8Array( + isView ? getDataViewOrTypedArrayBuffer(idlValue) : idlValue, + isView ? getDataViewOrTypedArrayByteOffset(idlValue) : 0, + isView ? getDataViewOrTypedArrayByteLength(idlValue) : ArrayBufferPrototypeGetByteLength(idlValue), + ), + ); + } else if (idlType === 'HashAlgorithmIdentifier') { + normalizedAlgorithm[member] = normalizeAlgorithm(idlValue, 'digest'); + } else if (idlType === 'AlgorithmIdentifier') { + // This extension point is not used by any supported algorithm (yet?) + throw lazyDOMException('Not implemented.', 'NotSupportedError'); + } } } From fa17dc2f40464a84db86390789e75592f4e7e7f6 Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Mon, 4 May 2026 18:58:05 +0200 Subject: [PATCH 075/168] lib: optimize webidl conversion options Replace object spread in nested WebIDL conversion options with stable-shape ordinary objects. This keeps hot dictionary and sequence conversion paths from allocating null-prototype spread results. Apply the same pattern to Web Crypto converter wrappers that override allowResizable or enable [EnforceRange]. Signed-off-by: Filip Skokan PR-URL: https://github.com/nodejs/node/pull/62756 Reviewed-By: Yagiz Nizipli --- lib/internal/crypto/webidl.js | 63 +++++++++++++++++++++++------------ lib/internal/webidl.js | 47 +++++++++++++++++--------- 2 files changed, 73 insertions(+), 37 deletions(-) diff --git a/lib/internal/crypto/webidl.js b/lib/internal/crypto/webidl.js index a87edcb411d08e..18bea7df03880d 100644 --- a/lib/internal/crypto/webidl.js +++ b/lib/internal/crypto/webidl.js @@ -106,6 +106,22 @@ converters['sequence'] = createSequenceConverter(converters.KeyUsage); converters.HashAlgorithmIdentifier = converters.AlgorithmIdentifier; +/** + * Builds conversion options for Web Crypto integer members that use Web IDL + * [EnforceRange]. Keep this helper instead of spreading opts in each member + * converter so the hot dictionary paths allocate stable-shape objects. + * @param {object} opts Parent conversion options. + * @returns {object} + */ +function enforceRangeOptions(opts) { + return { + prefix: opts.prefix, + context: opts.context, + code: opts.code, + enforceRange: true, + }; +} + const dictAlgorithm = [ { key: 'name', @@ -121,8 +137,9 @@ converters.Algorithm = createDictionaryConverter( // converters.BigInteger = webidl.Uint8Array; converters.BigInteger = (V, opts = kEmptyObject) => { return webidl.Uint8Array(V, { - __proto__: null, - ...opts, + prefix: opts.prefix, + context: opts.context, + code: opts.code, allowResizable: true, allowShared: false, }); @@ -132,10 +149,12 @@ converters.BigInteger = (V, opts = kEmptyObject) => { // removing this altogether. converters.BufferSource = (V, opts = kEmptyObject) => { return webidl.BufferSource(V, { - __proto__: null, - ...opts, + prefix: opts.prefix, + context: opts.context, + code: opts.code, allowResizable: opts.allowResizable === undefined ? true : opts.allowResizable, + allowShared: opts.allowShared, }); }; @@ -143,7 +162,7 @@ const dictRsaKeyGenParams = [ { key: 'modulusLength', converter: (V, opts) => - converters['unsigned long'](V, { ...opts, enforceRange: true }), + converters['unsigned long'](V, enforceRangeOptions(opts)), required: true, }, { @@ -221,7 +240,7 @@ converters.AesKeyGenParams = createDictionaryConverter( { key: 'length', converter: (V, opts) => - converters['unsigned short'](V, { ...opts, enforceRange: true }), + converters['unsigned short'](V, enforceRangeOptions(opts)), validator: AESLengthValidator, required: true, }, @@ -244,7 +263,7 @@ converters.RsaPssParams = createDictionaryConverter( { key: 'saltLength', converter: (V, opts) => - converters['unsigned long'](V, { ...opts, enforceRange: true }), + converters['unsigned long'](V, enforceRangeOptions(opts)), required: true, }, ], @@ -288,7 +307,7 @@ for (const { 0: name, 1: zeroError } of [['HmacKeyGenParams', 'OperationError'], { key: 'length', converter: (V, opts) => - converters['unsigned long'](V, { ...opts, enforceRange: true }), + converters['unsigned long'](V, enforceRangeOptions(opts)), validator: validateMacKeyLength(`${name}.length`, zeroError), }, ], @@ -370,7 +389,7 @@ converters.CShakeParams = createDictionaryConverter( { key: 'outputLength', converter: (V, opts) => - converters['unsigned long'](V, { ...opts, enforceRange: true }), + converters['unsigned long'](V, enforceRangeOptions(opts)), validator: (V, opts) => { // The Web Crypto spec allows for SHAKE output length that are not multiples of // 8. We don't. @@ -404,7 +423,7 @@ converters.Pbkdf2Params = createDictionaryConverter( { key: 'iterations', converter: (V, opts) => - converters['unsigned long'](V, { ...opts, enforceRange: true }), + converters['unsigned long'](V, enforceRangeOptions(opts)), validator: (V, dict) => { if (V === 0) throw lazyDOMException('iterations cannot be zero', 'OperationError'); @@ -427,7 +446,7 @@ converters.AesDerivedKeyParams = createDictionaryConverter( { key: 'length', converter: (V, opts) => - converters['unsigned short'](V, { ...opts, enforceRange: true }), + converters['unsigned short'](V, enforceRangeOptions(opts)), validator: AESLengthValidator, required: true, }, @@ -481,7 +500,7 @@ converters.AeadParams = createDictionaryConverter( { key: 'tagLength', converter: (V, opts) => - converters.octet(V, { ...opts, enforceRange: true }), + converters.octet(V, enforceRangeOptions(opts)), validator: (V, dict) => { switch (StringPrototypeToLowerCase(dict.name)) { case 'chacha20-poly1305': @@ -524,7 +543,7 @@ converters.AesCtrParams = createDictionaryConverter( { key: 'length', converter: (V, opts) => - converters.octet(V, { ...opts, enforceRange: true }), + converters.octet(V, enforceRangeOptions(opts)), validator: (V, dict) => { if (V === 0 || V > 128) throw lazyDOMException( @@ -600,7 +619,7 @@ converters.Argon2Params = createDictionaryConverter( { key: 'parallelism', converter: (V, opts) => - converters['unsigned long'](V, { ...opts, enforceRange: true }), + converters['unsigned long'](V, enforceRangeOptions(opts)), validator: (V, dict) => { if (V === 0 || V > MathPow(2, 24) - 1) { throw lazyDOMException( @@ -613,7 +632,7 @@ converters.Argon2Params = createDictionaryConverter( { key: 'memory', converter: (V, opts) => - converters['unsigned long'](V, { ...opts, enforceRange: true }), + converters['unsigned long'](V, enforceRangeOptions(opts)), validator: (V, dict) => { if (V < 8 * dict.parallelism) { throw lazyDOMException( @@ -626,7 +645,7 @@ converters.Argon2Params = createDictionaryConverter( { key: 'passes', converter: (V, opts) => - converters['unsigned long'](V, { ...opts, enforceRange: true }), + converters['unsigned long'](V, enforceRangeOptions(opts)), validator: (V) => { if (V === 0) { throw lazyDOMException('passes must be > 0', 'OperationError'); @@ -637,7 +656,7 @@ converters.Argon2Params = createDictionaryConverter( { key: 'version', converter: (V, opts) => - converters.octet(V, { ...opts, enforceRange: true }), + converters.octet(V, enforceRangeOptions(opts)), validator: (V, dict) => { if (V !== 0x13) { throw lazyDOMException( @@ -676,7 +695,7 @@ for (const { 0: name, 1: zeroError } of [['KmacKeyGenParams', 'OperationError'], { key: 'length', converter: (V, opts) => - converters['unsigned long'](V, { ...opts, enforceRange: true }), + converters['unsigned long'](V, enforceRangeOptions(opts)), validator: validateMacKeyLength(`${name}.length`, zeroError), }, ], @@ -690,7 +709,7 @@ converters.KmacParams = createDictionaryConverter( { key: 'outputLength', converter: (V, opts) => - converters['unsigned long'](V, { ...opts, enforceRange: true }), + converters['unsigned long'](V, enforceRangeOptions(opts)), validator: (V, opts) => { // The Web Crypto spec allows for KMAC output length that are not multiples of 8. We don't. if (V % 8) @@ -712,7 +731,7 @@ converters.KangarooTwelveParams = createDictionaryConverter( { key: 'outputLength', converter: (V, opts) => - converters['unsigned long'](V, { ...opts, enforceRange: true }), + converters['unsigned long'](V, enforceRangeOptions(opts)), validator: (V, opts) => { if (V === 0 || V % 8) throw lazyDOMException('Invalid KangarooTwelveParams outputLength', 'OperationError'); @@ -733,7 +752,7 @@ converters.TurboShakeParams = createDictionaryConverter( { key: 'outputLength', converter: (V, opts) => - converters['unsigned long'](V, { ...opts, enforceRange: true }), + converters['unsigned long'](V, enforceRangeOptions(opts)), validator: (V, opts) => { if (V === 0 || V % 8) throw lazyDOMException('Invalid TurboShakeParams outputLength', 'OperationError'); @@ -743,7 +762,7 @@ converters.TurboShakeParams = createDictionaryConverter( { key: 'domainSeparation', converter: (V, opts) => - converters.octet(V, { ...opts, enforceRange: true }), + converters.octet(V, enforceRangeOptions(opts)), validator: (V) => { if (V < 0x01 || V > 0x7F) { throw lazyDOMException( diff --git a/lib/internal/webidl.js b/lib/internal/webidl.js index f727ea84a40535..13575d4f730df7 100644 --- a/lib/internal/webidl.js +++ b/lib/internal/webidl.js @@ -109,6 +109,28 @@ function makeException(message, options = kEmptyObject) { ); } +/** + * Builds derived conversion options for nested converter calls and adjusted + * error codes. These objects are allocated on dictionary/sequence conversion + * hot paths, so keep their shape stable and avoid object spread and + * null-prototype objects. + * @param {ConversionOptions} options Parent conversion options. + * @param {string} [context] Replacement context. + * @param {string} [code] Replacement error code. + * @returns {ConversionOptions} + */ +function makeOptions(options, context = options.context, code = options.code) { + return { + prefix: options.prefix, + context, + code, + enforceRange: options.enforceRange, + clamp: options.clamp, + allowShared: options.allowShared, + allowResizable: options.allowResizable, + }; +} + /** * Returns the ECMAScript specification type of a JavaScript value. * @see https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values @@ -376,7 +398,7 @@ function convertToInt( if (integer < lowerBound || integer > upperBound) { throw makeException( `is outside the expected range of ${lowerBound} to ${upperBound}.`, - { __proto__: null, ...options, code: 'ERR_OUT_OF_RANGE' }); + makeOptions(options, options.context, 'ERR_OUT_OF_RANGE')); } return integer; @@ -416,7 +438,7 @@ function convertToInt( if (x < lowerBound || x > upperBound) { throw makeException( `is outside the expected range of ${lowerBound} to ${upperBound}.`, - { __proto__: null, ...options, code: 'ERR_OUT_OF_RANGE' }); + makeOptions(options, options.context, 'ERR_OUT_OF_RANGE')); } return x; @@ -593,7 +615,7 @@ function requiredArguments(length, required, options = kEmptyObject) { `${required} argument${ required === 1 ? '' : 's' } required, but only ${length} present.`, - { __proto__: null, ...options, context: '', code: 'ERR_MISSING_ARGS' }); + makeOptions(options, '', 'ERR_MISSING_ARGS')); } } @@ -615,7 +637,7 @@ function createEnumConverter(name, values) { if (!E.has(S)) { throw makeException( `'${S}' is not a valid enum value of type ${name}.`, - { __proto__: null, ...options, code: 'ERR_INVALID_ARG_VALUE' }); + makeOptions(options, options.context, 'ERR_INVALID_ARG_VALUE')); } // Step 3: return the matching enumeration value. @@ -715,11 +737,7 @@ function createDictionaryConverter( // Step 4.1.4.1: convert the JavaScript value to IDL. const idlMemberValue = converter( jsMemberValue, - { - __proto__: null, - ...options, - context: dictionaryMemberContext(key, options), - }, + makeOptions(options, dictionaryMemberContext(key, options)), ); // Validators are a Node.js extension after conversion. They let // consumers reject known unsupported values while dictionary @@ -736,7 +754,7 @@ function createDictionaryConverter( // Step 4.1.6: required missing members throw. throw makeException( missingDictionaryMemberMessage(dictionaryName, key), - { __proto__: null, ...options, code: 'ERR_MISSING_OPTION' }); + makeOptions(options, options.context, 'ERR_MISSING_OPTION')); } } } @@ -794,11 +812,10 @@ function createSequenceConverter(converter) { break; } // Step 3.3: convert next to an IDL value of type T. - const idlValue = converter(next.value, { - __proto__: null, - ...options, - context: sequenceElementContext(idlSequence.length, options), - }); + const idlValue = converter( + next.value, + makeOptions(options, sequenceElementContext(idlSequence.length, options)), + ); // Step 3.4: store the value and advance i. ArrayPrototypePush(idlSequence, idlValue); } From e690df38e72e39c45e490e046f13c7d020d818ad Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Wed, 6 May 2026 14:59:08 +0200 Subject: [PATCH 076/168] doc: remove list of versions in `BUILDING.md` MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/63113 Reviewed-By: Filip Skokan Reviewed-By: René Reviewed-By: Michaël Zasso Reviewed-By: Marco Ippolito Reviewed-By: James M Snell Reviewed-By: Rafael Gonzaga Reviewed-By: Trivikram Kamat Reviewed-By: Luigi Pinca Reviewed-By: Paolo Insogna --- BUILDING.md | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/BUILDING.md b/BUILDING.md index 632833c2a66697..eb7538f03fed86 100644 --- a/BUILDING.md +++ b/BUILDING.md @@ -226,12 +226,11 @@ If compiling without one of the above, use `configure` with the ### Previous versions of this document Supported platforms and toolchains change with each major version of Node.js. -This document is only valid for the current major version of Node.js. -Consult previous versions of this document for older versions of Node.js: +This document is only valid for the current version of Node.js, and is expected +to be valid for the entire lifetime of this release line. -* [Node.js 24](https://github.com/nodejs/node/blob/v24.x/BUILDING.md) -* [Node.js 22](https://github.com/nodejs/node/blob/v22.x/BUILDING.md) -* [Node.js 20](https://github.com/nodejs/node/blob/v20.x/BUILDING.md) +To consult the version of this document for another version, download its source +tarball and/or browse the git repository checked out at the relevant tag. ## Building Node.js on supported platforms From 0bd46c151be7cc50369180e70b0745755077ea03 Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Wed, 6 May 2026 15:49:06 +0200 Subject: [PATCH 077/168] crypto: improve accuracy of SubtleCrypto.supports Signed-off-by: Filip Skokan PR-URL: https://github.com/nodejs/node/pull/63104 Reviewed-By: James M Snell Reviewed-By: Yagiz Nizipli --- lib/internal/crypto/webcrypto.js | 42 +++-- test/fixtures/webcrypto/supports-level-2.mjs | 30 ++- .../webcrypto/supports-secure-curves.mjs | 10 +- test/fixtures/wpt/README.md | 2 +- .../supports-modern.tentative.https.any.js | 159 ++++++++++++++++ .../supports.tentative.https.any.js | 176 ++++++++++++++++++ test/fixtures/wpt/versions.json | 2 +- test/wpt/status/WebCryptoAPI.cjs | 34 +++- 8 files changed, 432 insertions(+), 23 deletions(-) create mode 100644 test/fixtures/wpt/WebCryptoAPI/supports-modern.tentative.https.any.js diff --git a/lib/internal/crypto/webcrypto.js b/lib/internal/crypto/webcrypto.js index 150f489c541b8c..1d351ab90bc7c4 100644 --- a/lib/internal/crypto/webcrypto.js +++ b/lib/internal/crypto/webcrypto.js @@ -1658,7 +1658,11 @@ class SubtleCrypto { } } - return check(operation, algorithm, length); + try { + return check(operation, algorithm, length); + } catch { + return false; + } } } @@ -1701,25 +1705,35 @@ function check(op, alg, length) { return true; case 'deriveBits': { if (normalizedAlgorithm.name === 'HKDF') { - try { - require('internal/crypto/hkdf').validateHkdfDeriveBitsLength(length); - } catch { - return false; - } + require('internal/crypto/hkdf').validateHkdfDeriveBitsLength(length); } if (normalizedAlgorithm.name === 'PBKDF2') { - try { - require('internal/crypto/pbkdf2').validatePbkdf2DeriveBitsLength(length); - } catch { - return false; - } + require('internal/crypto/pbkdf2').validatePbkdf2DeriveBitsLength(length); } if (StringPrototypeStartsWith(normalizedAlgorithm.name, 'Argon2')) { - try { - require('internal/crypto/argon2').validateArgon2DeriveBitsLength(length); - } catch { + require('internal/crypto/argon2').validateArgon2DeriveBitsLength(length); + } + + if (normalizedAlgorithm.name === 'X25519' && length > 256) { + return false; + } + + if (normalizedAlgorithm.name === 'X448' && length > 448) { + return false; + } + + if (normalizedAlgorithm.name === 'ECDH') { + const namedCurve = getCryptoKeyAlgorithm(normalizedAlgorithm.public).namedCurve; + const maxLength = { + '__proto__': null, + 'P-256': 256, + 'P-384': 384, + 'P-521': 528, + }[namedCurve]; + + if (length > maxLength) { return false; } } diff --git a/test/fixtures/webcrypto/supports-level-2.mjs b/test/fixtures/webcrypto/supports-level-2.mjs index 196f4588188b48..931be98a824032 100644 --- a/test/fixtures/webcrypto/supports-level-2.mjs +++ b/test/fixtures/webcrypto/supports-level-2.mjs @@ -103,18 +103,36 @@ export const vectors = { [true, { name: 'X25519', public: X25519.publicKey }, { name: 'AES-CBC', length: 128 }], - [true, + [false, { name: 'X25519', public: X25519.publicKey }, { name: 'HMAC', hash: 'SHA-256' }], + [true, + { name: 'X25519', public: X25519.publicKey }, + { name: 'HMAC', hash: 'SHA-256', length: 256 }], + [false, + { name: 'X25519', public: X25519.publicKey }, + { name: 'HMAC', hash: 'SHA-256', length: 257 }], [true, { name: 'X25519', public: X25519.publicKey }, 'HKDF'], [true, { name: 'ECDH', public: ECDH.publicKey }, { name: 'AES-CBC', length: 128 }], - [true, + [false, { name: 'ECDH', public: ECDH.publicKey }, { name: 'HMAC', hash: 'SHA-256' }], + [false, + { name: 'ECDH', public: ECDH.publicKey }, + { name: 'HMAC', hash: 'SHA-256', length: 255 }], + [true, + { name: 'ECDH', public: ECDH.publicKey }, + { name: 'HMAC', hash: 'SHA-256', length: 256 }], + [false, + { name: 'ECDH', public: ECDH.publicKey }, + { name: 'HMAC', hash: 'SHA-256', length: 257 }], + [false, + { name: 'ECDH', public: ECDH.publicKey }, + { name: 'HMAC', hash: 'SHA-256', length: 264 }], [true, { name: 'ECDH', public: ECDH.publicKey }, 'HKDF'], @@ -143,10 +161,18 @@ export const vectors = { [true, { name: 'ECDH', public: ECDH.publicKey }], + [true, + { name: 'ECDH', public: ECDH.publicKey }, 256], + [false, + { name: 'ECDH', public: ECDH.publicKey }, 257], + [false, + { name: 'ECDH', public: ECDH.publicKey }, 264], [false, { name: 'ECDH', public: ECDH.privateKey }], [false, 'ECDH'], [true, { name: 'X25519', public: X25519.publicKey }], + [true, { name: 'X25519', public: X25519.publicKey }, 256], + [false, { name: 'X25519', public: X25519.publicKey }, 257], [false, { name: 'X25519', public: X25519.privateKey }], [false, 'X25519'], ], diff --git a/test/fixtures/webcrypto/supports-secure-curves.mjs b/test/fixtures/webcrypto/supports-secure-curves.mjs index e2799b5baf40fc..56bb89c28afaae 100644 --- a/test/fixtures/webcrypto/supports-secure-curves.mjs +++ b/test/fixtures/webcrypto/supports-secure-curves.mjs @@ -28,15 +28,23 @@ export const vectors = { [!boringSSL, { name: 'X448', public: X448?.publicKey }, { name: 'AES-CBC', length: 128 }], - [!boringSSL, + [false, { name: 'X448', public: X448?.publicKey }, { name: 'HMAC', hash: 'SHA-256' }], + [!boringSSL, + { name: 'X448', public: X448?.publicKey }, + { name: 'HMAC', hash: 'SHA-256', length: 448 }], + [false, + { name: 'X448', public: X448?.publicKey }, + { name: 'HMAC', hash: 'SHA-256', length: 449 }], [!boringSSL, { name: 'X448', public: X448?.publicKey }, 'HKDF'], ], 'deriveBits': [ [!boringSSL, { name: 'X448', public: X448?.publicKey }], + [!boringSSL, { name: 'X448', public: X448?.publicKey }, 448], + [false, { name: 'X448', public: X448?.publicKey }, 449], [false, { name: 'X448', public: X25519.publicKey }], [false, { name: 'X448', public: X448?.privateKey }], [false, 'X448'], diff --git a/test/fixtures/wpt/README.md b/test/fixtures/wpt/README.md index ebbffd5e53fe3b..c3fc541fcd4741 100644 --- a/test/fixtures/wpt/README.md +++ b/test/fixtures/wpt/README.md @@ -34,7 +34,7 @@ Last update: - wasm/jsapi: https://github.com/web-platform-tests/wpt/tree/65a2134d50/wasm/jsapi - wasm/webapi: https://github.com/web-platform-tests/wpt/tree/fd1b23eeaa/wasm/webapi - web-locks: https://github.com/web-platform-tests/wpt/tree/10a122a6bc/web-locks -- WebCryptoAPI: https://github.com/web-platform-tests/wpt/tree/2cb332d710/WebCryptoAPI +- WebCryptoAPI: https://github.com/web-platform-tests/wpt/tree/8b5cd267b4/WebCryptoAPI - webidl: https://github.com/web-platform-tests/wpt/tree/63ca529a02/webidl - webidl/ecmascript-binding/es-exceptions: https://github.com/web-platform-tests/wpt/tree/2f96fa1996/webidl/ecmascript-binding/es-exceptions - webmessaging/broadcastchannel: https://github.com/web-platform-tests/wpt/tree/6495c91853/webmessaging/broadcastchannel diff --git a/test/fixtures/wpt/WebCryptoAPI/supports-modern.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/supports-modern.tentative.https.any.js new file mode 100644 index 00000000000000..709ffcd43e2962 --- /dev/null +++ b/test/fixtures/wpt/WebCryptoAPI/supports-modern.tentative.https.any.js @@ -0,0 +1,159 @@ +// META: title=WebCrypto API: supports method tests for algorithms in https://wicg.github.io/webcrypto-modern-algos/ +// META: script=util/helpers.js + +'use strict'; + +const modernAlgorithms = { + // Asymmetric algorithms + 'ML-DSA-44': { + operations: ['generateKey', 'importKey', 'sign', 'verify'], + }, + 'ML-DSA-65': { + operations: ['generateKey', 'importKey', 'sign', 'verify'], + }, + 'ML-DSA-87': { + operations: ['generateKey', 'importKey', 'sign', 'verify'], + }, + 'ML-KEM-512': { + operations: [ + 'generateKey', 'importKey', 'encapsulateKey', 'encapsulateBits', + 'decapsulateKey', 'decapsulateBits' + ], + }, + 'ML-KEM-768': { + operations: [ + 'generateKey', 'importKey', 'encapsulateKey', 'encapsulateBits', + 'decapsulateKey', 'decapsulateBits' + ], + }, + 'ML-KEM-1024': { + operations: [ + 'generateKey', 'importKey', 'encapsulateKey', 'encapsulateBits', + 'decapsulateKey', 'decapsulateBits' + ], + }, + + // Symmetric algorithms + 'ChaCha20-Poly1305': { + operations: ['generateKey', 'importKey', 'encrypt', 'decrypt'], + encryptParams: {name: 'ChaCha20-Poly1305', iv: new Uint8Array(12)}, + }, + +}; + +const operations = [ + 'generateKey', + 'importKey', + 'sign', + 'verify', + 'encrypt', + 'decrypt', + 'deriveBits', + 'digest', + 'encapsulateKey', + 'encapsulateBits', + 'decapsulateKey', + 'decapsulateBits', +]; + +// Test that supports method exists and is a static method +test(() => { + assert_true( + typeof SubtleCrypto.supports === 'function', + 'SubtleCrypto.supports should be a function'); +}, 'SubtleCrypto.supports method exists'); + + +// Test standard WebCrypto algorithms for requested operations +for (const [algorithmName, algorithmInfo] of Object.entries(modernAlgorithms)) { + for (const operation of operations) { + promise_test(async (t) => { + const isSupported = algorithmInfo.operations.includes(operation); + + // Use appropriate algorithm parameters for each operation + let algorithm; + let lengthOrAdditionalAlgorithm; + switch (operation) { + case 'generateKey': + algorithm = algorithmInfo.keyGenParams || algorithmName; + break; + case 'importKey': + algorithm = algorithmInfo.importParams || algorithmName; + break; + case 'sign': + case 'verify': + algorithm = algorithmInfo.signParams || algorithmName; + break; + case 'encrypt': + case 'decrypt': + algorithm = algorithmInfo.encryptParams || algorithmName; + break; + case 'deriveBits': + algorithm = algorithmInfo.deriveBitsParams || algorithmName; + if (algorithm?.public instanceof Promise) { + algorithm.public = (await algorithm.public).publicKey; + } + if (algorithmName === 'PBKDF2' || algorithmName === 'HKDF') { + lengthOrAdditionalAlgorithm = 256; + } + break; + case 'digest': + algorithm = algorithmName; + break; + case 'encapsulateKey': + case 'encapsulateBits': + case 'decapsulateKey': + case 'decapsulateBits': + algorithm = algorithmName; + if (operation === 'encapsulateKey' || operation === 'decapsulateKey') { + lengthOrAdditionalAlgorithm = { name: 'AES-GCM', length: 256 }; + } + break; + default: + algorithm = algorithmName; + } + + const result = SubtleCrypto.supports(operation, algorithm, lengthOrAdditionalAlgorithm); + + if (isSupported) { + assert_true(result, `${algorithmName} should support ${operation}`); + } else { + assert_false( + result, `${algorithmName} should not support ${operation}`); + } + }, `supports(${operation}, ${algorithmName})`); + } +} + +// Test some algorithm objects with valid parameters +test(() => { + assert_true( + SubtleCrypto.supports('encrypt', { + name: 'ChaCha20-Poly1305', + iv: new Uint8Array(12), + tagLength: 128, + }), + 'ChaCha20-Poly1305 encrypt with valid tagLength'); +}, 'supports returns true for algorithm objects with valid parameters'); + +// Test some algorithm objects with invalid parameters +test(() => { + assert_false( + SubtleCrypto.supports('encrypt', { + name: 'ChaCha20-Poly1305', + iv: new Uint8Array(12), + tagLength: 100, + }), + 'ChaCha20-Poly1305 encrypt with invalid tagLength'); + + assert_false( + SubtleCrypto.supports('encrypt', { + name: 'ChaCha20-Poly1305', + iv: new Uint8Array(10), + tagLength: 128, + }), + 'ChaCha20-Poly1305 encrypt with invalid iv'); +}, 'supports returns false for algorithm objects with invalid parameters'); + + +done(); diff --git a/test/fixtures/wpt/WebCryptoAPI/supports.tentative.https.any.js b/test/fixtures/wpt/WebCryptoAPI/supports.tentative.https.any.js index dd39273e4b918b..921212a0c21dfa 100644 --- a/test/fixtures/wpt/WebCryptoAPI/supports.tentative.https.any.js +++ b/test/fixtures/wpt/WebCryptoAPI/supports.tentative.https.any.js @@ -268,6 +268,137 @@ test(() => { }), 'Invalid hash parameter should return false' ); + assert_false( + SubtleCrypto.supports( + 'encrypt', {name: 'AES-CBC', iv: new Uint8Array(10)}), + 'Invalid IV for AES-CBC should return false'); + assert_false( + SubtleCrypto.supports('encrypt', { + name: 'AES-CTR', + counter: new Uint8Array(10), + length: 128, + }), + 'Invalid IV for AES-CTR should return false'); + assert_false( + SubtleCrypto.supports('encrypt', { + name: 'AES-CTR', + counter: new Uint8Array(16), + length: 0, + }), + 'Invalid length=0 for AES-CTR should return false'); + assert_false( + SubtleCrypto.supports('encrypt', { + name: 'AES-CTR', + counter: new Uint8Array(16), + length: 129, + }), + 'Invalid length=129 for AES-CTR should return false'); + assert_false( + SubtleCrypto.supports('encrypt', { + name: 'AES-GCM', + iv: new Uint8Array(16), + tagLength: 100, + }), + 'Invalid tag length for AES-GCM should return false'); + assert_false( + SubtleCrypto.supports('generateKey', {name: 'ECDH', namedCurve: 'P-51'}), + 'Invalid curve for ECDH should return false'); + assert_false( + SubtleCrypto.supports( + 'deriveBits', { + name: 'HKDF', + hash: 'SHA-25', + salt: new Uint8Array(16), + info: new Uint8Array(0), + }, + 8), + 'Invalid hash for HKDF should return false'); + assert_false( + SubtleCrypto.supports( + 'deriveBits', { + name: 'HKDF', + hash: 'SHA-256', + salt: new Uint8Array(16), + info: new Uint8Array(0), + }, + 11), + 'Invalid length for HKDF should return false'); + assert_false( + SubtleCrypto.supports( + 'deriveBits', { + name: 'HKDF', + hash: 'SHA-256', + salt: new Uint8Array(16), + info: new Uint8Array(0), + }), + 'null length for HKDF should return false'); + assert_false( + SubtleCrypto.supports('generateKey', { + name: 'HMAC', + hash: 'SHA-25', + }), + 'Invalid hash for HMAC should return false'); + assert_false( + SubtleCrypto.supports('generateKey', { + name: 'HMAC', + hash: 'SHA-256', + length: 0, + }), + 'Invalid length for HMAC should return false'); + assert_false( + SubtleCrypto.supports( + 'deriveBits', { + name: 'PBKDF2', + hash: 'SHA-25', + salt: new Uint8Array(16), + iterations: 100000, + }, + 8), + 'Invalid hash for PBKDF2 should return false'); + assert_false( + SubtleCrypto.supports( + 'deriveBits', { + name: 'PBKDF2', + hash: 'SHA-256', + salt: new Uint8Array(16), + iterations: 100000, + }, + 11), + 'Invalid length for PBKDF2 should return false'); + assert_false( + SubtleCrypto.supports( + 'deriveBits', { + name: 'PBKDF2', + hash: 'SHA-256', + salt: new Uint8Array(16), + iterations: 100000, + }), + 'null length for PBKDF2 should return false'); + assert_false( + SubtleCrypto.supports('generateKey', { + name: 'RSASSA-PKCS1-v1_5', + modulusLength: 2048, + publicExponent: new Uint8Array([1, 0, 1]), + hash: 'SHA-56', + }), + 'Invalid hash for RSA PKCS1 should return false'); + assert_false( + SubtleCrypto.supports('generateKey', { + name: 'RSA-PSS', + modulusLength: 2048, + publicExponent: new Uint8Array([1, 0, 1]), + hash: 'SHA-56', + }), + 'Invalid hash for RSA PSS should return false'); + assert_false( + SubtleCrypto.supports('generateKey', { + name: 'RSA-OAEP', + modulusLength: 2048, + publicExponent: new Uint8Array([1, 0, 1]), + hash: 'SHA-26', + }), + 'Invalid hash for RSA OAEP should return false'); + }, 'supports returns false for algorithm objects with invalid parameters'); // Test some specific combinations that should work @@ -394,4 +525,49 @@ test(() => { ); }, 'Invalid algorithm and operation combinations fail'); +// Test supports for deriveKey op +test(() => { + assert_true( + SubtleCrypto.supports( + 'deriveKey', { + name: 'HKDF', + hash: 'SHA-256', + salt: new Uint8Array(16), + info: new Uint8Array(0), + }, + {name: 'HMAC', hash: 'SHA-256'}), + + 'deriveKey HKDF-HMAC should pass'); +}, 'deriveKey tests'); + +promise_test(async (t) => { + let keypair = await crypto.subtle.generateKey( + { + name: 'X25519', + }, + false, ['deriveKey', 'deriveBits']); + + assert_true( + SubtleCrypto.supports( + 'deriveKey', { + name: 'X25519', + public: keypair.publicKey, + }, + {name: 'AES-GCM', length: 256}), + + 'deriveKey X25519-AES-GCM-256 should pass'); + + assert_false( + SubtleCrypto.supports( + 'deriveKey', { + name: 'X25519', + public: keypair.publicKey, + }, + {name: 'HMAC', hash: 'SHA-256'}), + + 'deriveKey X25519-HMAC-SHA-256 should fail'); +}, 'deriveKey promise tests'); + + + done(); diff --git a/test/fixtures/wpt/versions.json b/test/fixtures/wpt/versions.json index e3c707ac35cc28..3bc78cb9889a82 100644 --- a/test/fixtures/wpt/versions.json +++ b/test/fixtures/wpt/versions.json @@ -96,7 +96,7 @@ "path": "web-locks" }, "WebCryptoAPI": { - "commit": "2cb332d71030ba0200610d72b94bb1badf447418", + "commit": "8b5cd267b480d75bce41aa306bebbd07ce414fa5", "path": "WebCryptoAPI" }, "webidl": { diff --git a/test/wpt/status/WebCryptoAPI.cjs b/test/wpt/status/WebCryptoAPI.cjs index 722a0b38398e1d..253877f1a970e0 100644 --- a/test/wpt/status/WebCryptoAPI.cjs +++ b/test/wpt/status/WebCryptoAPI.cjs @@ -6,16 +6,27 @@ const { hasOpenSSL } = require('../../common/crypto.js'); const s390x = os.arch() === 's390x'; -const conditionalSkips = {}; +const conditionalFileSkips = {}; +const conditionalSubtestSkips = {}; function skip(...files) { for (const file of files) { - conditionalSkips[file] = { - 'skip': `Unsupported in OpenSSL ${process.versions.openssl}`, + conditionalFileSkips[file] = { + 'skip': 'Unsupported in ' + (process.features.openssl_is_boringssl ? 'BoringSSL' : `OpenSSL ${process.versions.openssl}`), }; } } +function skipSubtests(...entries) { + for (const [file, regexp] of entries) { + conditionalSubtestSkips[file] ||= { + 'skipTests': [], + }; + + conditionalSubtestSkips[file].skipTests.push(regexp); + } +} + if (!hasOpenSSL(3, 0)) { skip( 'encrypt_decrypt/aes_ocb.tentative.https.any.js', @@ -45,10 +56,25 @@ if (!hasOpenSSL(3, 5)) { 'import_export/ML-DSA_importKey.tentative.https.any.js', 'import_export/ML-KEM_importKey.tentative.https.any.js', 'sign_verify/mldsa.tentative.https.any.js'); + + skipSubtests( + ['supports-modern.tentative.https.any.js', /ml-(?:kem|dsa)/i]); } +function assertNoOverlap(fileSkips, subtestSkips) { + const subtestSkipFiles = new Set(Object.keys(subtestSkips)); + const overlap = Object.keys(fileSkips).filter((file) => subtestSkipFiles.has(file)); + + if (overlap.length !== 0) { + throw new Error(`conditionalFileSkips and conditionalSubtestSkips overlap: ${overlap.join(', ')}`); + } +} + +assertNoOverlap(conditionalFileSkips, conditionalSubtestSkips); + module.exports = { - ...conditionalSkips, + ...conditionalFileSkips, + ...conditionalSubtestSkips, 'algorithm-discards-context.https.window.js': { 'skip': 'Not relevant in Node.js context', }, From c52fad331f15e9909f467ee25e4c19e0430899bf Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Wed, 6 May 2026 16:35:31 +0200 Subject: [PATCH 078/168] doc: downgrade macOS x64 to Tier 2 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/63055 Refs: https://developer.apple.com/documentation/apple-silicon/about-the-rosetta-translation-environment/ Reviewed-By: Richard Lau Reviewed-By: Marco Ippolito Reviewed-By: Stewart X Addison Reviewed-By: Paolo Insogna Reviewed-By: Luigi Pinca Reviewed-By: Gürgün Dayıoğlu Reviewed-By: Yagiz Nizipli Reviewed-By: Matteo Collina Reviewed-By: Chengzhong Wu Reviewed-By: Michaël Zasso Reviewed-By: Ulises Gascón Reviewed-By: Filip Skokan Reviewed-By: Rafael Gonzaga --- BUILDING.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/BUILDING.md b/BUILDING.md index eb7538f03fed86..27c651469b6958 100644 --- a/BUILDING.md +++ b/BUILDING.md @@ -117,7 +117,7 @@ platforms. This is true regardless of entries in the table below. | GNU/Linux | riscv64 | kernel >= 5.19, glibc >= 2.36 | Experimental | GCC >= 14 or Clang >= 19 for native builds[^7] | | Windows | x64 | >= Windows 10/Server 2016 | Tier 1 | [^2],[^3] | | Windows | arm64 | >= Windows 10 | Tier 2 | | -| macOS | x64 | >= 13.5 | Tier 1 | For notes about compilation see [^4] | +| macOS | x64 | >= 13.5 | Tier 2 | For notes about compilation see [^4] | | macOS | arm64 | >= 13.5 | Tier 1 | | | SmartOS | x64 | >= 18 | Tier 2 | | | AIX | ppc64be >=power9 | >= 7.2 TL04 | Tier 2 | | From 400285363201536f79f5f31f350d0e7b618afb22 Mon Sep 17 00:00:00 2001 From: Marco Ippolito Date: Wed, 29 Apr 2026 11:59:55 +0200 Subject: [PATCH 079/168] src: support multiple versions in node.config.json Signed-off-by: Marco Ippolito PR-URL: https://github.com/nodejs/node/pull/63033 Reviewed-By: Pietro Marchini Reviewed-By: James M Snell --- doc/api/cli.md | 38 + doc/node-config-schema.json | 2074 +++++++++++++++-------------- lib/internal/options.js | 60 +- src/node_config_file.cc | 243 +++- src/node_config_file.h | 8 + test/parallel/test-config-file.js | 227 ++++ 6 files changed, 1610 insertions(+), 1040 deletions(-) diff --git a/doc/api/cli.md b/doc/api/cli.md index 12c3e3b4151250..8933fc67baedc8 100644 --- a/doc/api/cli.md +++ b/doc/api/cli.md @@ -1091,6 +1091,44 @@ The configuration file supports namespace-specific options: * Namespace fields like `test`, `watch`, and `permission` contain configuration specific to that subsystem. +The configuration file can target a specific Node.js major version with +`nodeVersion`: + +```json +{ + "nodeVersion": 25, + "nodeOptions": { + "watch-path": "src" + } +} +``` + +To keep multiple version-specific configurations in the same file, use the +`configs` array. Node.js will use the first entry whose `nodeVersion` matches +the current Node.js major version: + +```json +{ + "$schema": "https://nodejs.org/dist/latest-v26.x/docs/node-config-schema.json", + "configs": [ + { + "nodeVersion": 25, + "config": { + "$schema": "https://nodejs.org/dist/latest-v25.x/docs/node-config-schema.json", + "nodeOptions": { + "watch-path": "src" + } + } + } + ] +} +``` + +When `configs` is used, the top level may only contain `$schema` and +`configs`. Each `configs` item must define an integer `nodeVersion` and an +object `config`. A single top-level config does not require `nodeVersion`, but +if present it must match the current Node.js major version. + When a namespace is present in the configuration file, Node.js automatically enables the corresponding flag (e.g., `--test`, `--watch`, `--permission`). This allows you to configure diff --git a/doc/node-config-schema.json b/doc/node-config-schema.json index d33c73e9b4c556..a78031061dca87 100644 --- a/doc/node-config-schema.json +++ b/doc/node-config-schema.json @@ -1,1036 +1,1088 @@ { "$schema": "https://json-schema.org/draft/2020-12/schema", - "additionalProperties": false, - "required": [], - "properties": { - "$schema": { - "type": "string" + "oneOf": [ + { + "$ref": "#/$defs/config" }, - "nodeOptions": { - "additionalProperties": false, - "required": [], - "properties": { - "addons": { - "type": "boolean", - "description": "disable loading native addons" - }, - "allow-addons": { - "type": "boolean", - "description": "allow use of addons when any permissions are set" - }, - "allow-child-process": { - "type": "boolean", - "description": "allow use of child process when any permissions are set" - }, - "allow-ffi": { - "type": "boolean", - "description": "allow use of FFI when any permissions are set (only in builds with FFI support)" - }, - "allow-fs-read": { - "oneOf": [ - { - "type": "string" - }, - { - "type": "array", - "minItems": 1, - "items": { - "type": "string" - } - } - ], - "description": "allow permissions to read the filesystem" - }, - "allow-fs-write": { - "oneOf": [ - { - "type": "string" - }, - { - "type": "array", - "minItems": 1, - "items": { - "type": "string" - } - } - ], - "description": "allow permissions to write in the filesystem" - }, - "allow-inspector": { - "type": "boolean", - "description": "allow use of inspector when any permissions are set" - }, - "allow-net": { - "type": "boolean", - "description": "allow use of network when any permissions are set" - }, - "allow-wasi": { - "type": "boolean", - "description": "allow wasi when any permissions are set" - }, - "allow-worker": { - "type": "boolean", - "description": "allow worker threads when any permissions are set" - }, - "async-context-frame": { - "type": "boolean", - "description": "Improve AsyncLocalStorage performance with AsyncContextFrame" - }, - "conditions": { - "oneOf": [ - { - "type": "string" - }, - { - "type": "array", - "minItems": 1, - "items": { - "type": "string" - } - } - ], - "description": "additional user conditions for conditional exports and imports" - }, - "cpu-prof": { - "type": "boolean", - "description": "Start the V8 CPU profiler on start up, and write the CPU profile to disk before exit. If --cpu-prof-dir is not specified, write the profile to the current working directory." - }, - "cpu-prof-dir": { - "type": "string", - "description": "Directory where the V8 profiles generated by --cpu-prof will be placed. Does not affect --prof." - }, - "cpu-prof-interval": { - "type": "number", - "description": "specified sampling interval in microseconds for the V8 CPU profile generated with --cpu-prof. (default: 1000)" - }, - "cpu-prof-name": { - "type": "string", - "description": "specified file name of the V8 CPU profile generated with --cpu-prof" - }, - "debug-arraybuffer-allocations": { - "type": "boolean", - "description": "" - }, - "deprecation": { - "type": "boolean", - "description": "silence deprecation warnings" - }, - "diagnostic-dir": { - "type": "string", - "description": "set dir for all output files (default: current working directory)" - }, - "disable-proto": { - "type": "string", - "description": "disable Object.prototype.__proto__" - }, - "disable-sigusr1": { - "type": "boolean", - "description": "Disable inspector thread to be listening for SIGUSR1 signal" - }, - "disable-warning": { - "oneOf": [ - { - "type": "string" - }, - { - "type": "array", - "minItems": 1, - "items": { - "type": "string" - } - } - ], - "description": "silence specific process warnings" - }, - "disable-wasm-trap-handler": { - "type": "boolean", - "description": "Disable trap-handler-based WebAssembly bound checks. V8 will insert inline bound checks when compiling WebAssembly which may slow down performance." - }, - "dns-result-order": { - "type": "string", - "description": "set default value of verbatim in dns.lookup. Options are 'ipv4first' (IPv4 addresses are placed before IPv6 addresses) 'ipv6first' (IPv6 addresses are placed before IPv4 addresses) 'verbatim' (addresses are in the order the DNS resolver returned)" - }, - "enable-fips": { - "type": "boolean", - "description": "enable FIPS crypto at startup" - }, - "enable-source-maps": { - "type": "boolean", - "description": "Source Map V3 support for stack traces" - }, - "entry-url": { - "type": "boolean", - "description": "Treat the entrypoint as a URL" - }, - "experimental-addon-modules": { - "type": "boolean", - "description": "experimental import support for addons" - }, - "experimental-detect-module": { - "type": "boolean", - "description": "when ambiguous modules fail to evaluate because they contain ES module syntax, try again to evaluate them as ES modules" - }, - "experimental-eventsource": { - "type": "boolean", - "description": "experimental EventSource API" - }, - "experimental-ffi": { - "type": "boolean", - "description": "experimental node:ffi module (only in builds with FFI support)" - }, - "experimental-global-navigator": { - "type": "boolean", - "description": "expose experimental Navigator API on the global scope" - }, - "experimental-import-meta-resolve": { - "type": "boolean", - "description": "experimental ES Module import.meta.resolve() parentURL support" - }, - "experimental-loader": { - "oneOf": [ - { - "type": "string" - }, - { - "type": "array", - "minItems": 1, - "items": { - "type": "string" - } - } - ], - "description": "use the specified module as a custom loader" - }, - "experimental-print-required-tla": { - "type": "boolean", - "description": "Print pending top-level await. If --require-module is true, evaluate asynchronous graphs loaded by `require()` but do not run the microtasks, in order to to find and print top-level await in the graph" - }, - "experimental-repl-await": { - "type": "boolean", - "description": "experimental await keyword support in REPL" - }, - "experimental-require-module": { - "type": "boolean", - "description": "Legacy alias for --require-module" - }, - "experimental-shadow-realm": { - "type": "boolean", - "description": "" - }, - "experimental-sqlite": { - "type": "boolean", - "description": "experimental node:sqlite module" - }, - "experimental-vm-modules": { - "type": "boolean", - "description": "experimental ES Module support in vm module" - }, - "experimental-websocket": { - "type": "boolean", - "description": "experimental WebSocket API" - }, - "experimental-webstorage": { - "type": "boolean", - "description": "experimental Web Storage API" - }, - "extra-info-on-fatal-exception": { - "type": "boolean", - "description": "hide extra information on fatal exception that causes exit" - }, - "force-async-hooks-checks": { - "type": "boolean", - "description": "disable checks for async_hooks" - }, - "force-context-aware": { - "type": "boolean", - "description": "disable loading non-context-aware addons" - }, - "force-fips": { - "type": "boolean", - "description": "force FIPS crypto (cannot be disabled)" - }, - "force-node-api-uncaught-exceptions-policy": { - "type": "boolean", - "description": "enforces 'uncaughtException' event on Node API asynchronous callbacks" - }, - "frozen-intrinsics": { - "type": "boolean", - "description": "experimental frozen intrinsics support" - }, - "global-search-paths": { - "type": "boolean", - "description": "disable global module search paths" - }, - "heap-prof": { - "type": "boolean", - "description": "Start the V8 heap profiler on start up, and write the heap profile to disk before exit. If --heap-prof-dir is not specified, write the profile to the current working directory." - }, - "heap-prof-dir": { - "type": "string", - "description": "Directory where the V8 heap profiles generated by --heap-prof will be placed." - }, - "heap-prof-interval": { - "type": "number", - "description": "specified sampling interval in bytes for the V8 heap profile generated with --heap-prof. (default: 512 * 1024)" - }, - "heap-prof-name": { - "type": "string", - "description": "specified file name of the V8 heap profile generated with --heap-prof" - }, - "heapsnapshot-near-heap-limit": { - "type": "number", - "description": "Generate heap snapshots whenever V8 is approaching the heap limit. No more than the specified number of heap snapshots will be generated." - }, - "heapsnapshot-signal": { - "type": "string", - "description": "Generate heap snapshot on specified signal" - }, - "icu-data-dir": { - "type": "string", - "description": "set ICU data load path to dir (overrides NODE_ICU_DATA) (note: linked-in ICU data is present)" - }, - "import": { - "oneOf": [ - { - "type": "string" - }, - { - "type": "array", - "minItems": 1, - "items": { - "type": "string" - } - } - ], - "description": "ES module to preload (option can be repeated)" - }, - "input-type": { - "type": "string", - "description": "set module type for string input" - }, - "insecure-http-parser": { - "type": "boolean", - "description": "use an insecure HTTP parser that accepts invalid HTTP headers" - }, - "inspect": { - "type": "boolean", - "description": "activate inspector on host:port (default: 127.0.0.1:9229)" - }, - "inspect-brk": { - "type": "boolean", - "description": "activate inspector on host:port and break at start of user script" - }, - "inspect-port": { - "type": "number", - "description": "set host:port for inspector" - }, - "inspect-publish-uid": { - "type": "string", - "description": "comma separated list of destinations for inspector uid(default: stderr,http)" - }, - "inspect-wait": { - "type": "boolean", - "description": "activate inspector on host:port and wait for debugger to be attached" - }, - "localstorage-file": { - "type": "string", - "description": "file used to persist localStorage data" - }, - "max-http-header-size": { - "type": "number", - "description": "set the maximum size of HTTP headers (default: 16384 (16KB))" - }, - "max-old-space-size-percentage": { - "type": "string", - "description": "set V8's max old space size as a percentage of available memory (e.g., '50%'). Takes precedence over --max-old-space-size." - }, - "network-family-autoselection": { - "type": "boolean", - "description": "Disable network address family autodetection algorithm" - }, - "network-family-autoselection-attempt-timeout": { - "type": "number", - "description": "Sets the default value for the network family autoselection attempt timeout." - }, - "node-snapshot": { - "type": "boolean", - "description": "" - }, - "openssl-config": { - "type": "string", - "description": "load OpenSSL configuration from the specified file (overrides OPENSSL_CONF)" - }, - "openssl-legacy-provider": { - "type": "boolean", - "description": "enable OpenSSL 3.0 legacy provider" - }, - "openssl-shared-config": { - "type": "boolean", - "description": "enable OpenSSL shared configuration" - }, - "pending-deprecation": { - "type": "boolean", - "description": "emit pending deprecation warnings" - }, - "permission": { - "type": "boolean", - "description": "enable the permission system" - }, - "preserve-symlinks": { - "type": "boolean", - "description": "preserve symbolic links when resolving" - }, - "preserve-symlinks-main": { - "type": "boolean", - "description": "preserve symbolic links when resolving the main module" - }, - "redirect-warnings": { - "type": "string", - "description": "write warnings to file instead of stderr" - }, - "report-compact": { - "type": "boolean", - "description": "output compact single-line JSON" - }, - "report-dir": { - "type": "string", - "description": "define custom report pathname. (default: current working directory)" - }, - "report-exclude-env": { - "type": "boolean", - "description": "Exclude environment variables when generating report (default: false)" - }, - "report-exclude-network": { - "type": "boolean", - "description": "exclude network interface diagnostics. (default: false)" - }, - "report-filename": { - "type": "string", - "description": "define custom report file name. (default: YYYYMMDD.HHMMSS.PID.SEQUENCE#.txt)" - }, - "report-on-fatalerror": { - "type": "boolean", - "description": "generate diagnostic report on fatal (internal) errors" - }, - "report-on-signal": { - "type": "boolean", - "description": "generate diagnostic report upon receiving signals" - }, - "report-signal": { - "type": "string", - "description": "causes diagnostic report to be produced on provided signal, unsupported in Windows. (default: SIGUSR2)" - }, - "report-uncaught-exception": { - "type": "boolean", - "description": "generate diagnostic report on uncaught exceptions" - }, - "require": { - "oneOf": [ - { - "type": "string" - }, - { - "type": "array", - "minItems": 1, - "items": { - "type": "string" - } - } - ], - "description": "CommonJS module to preload (option can be repeated)" - }, - "require-module": { - "type": "boolean", - "description": "Allow loading synchronous ES Modules in require()." - }, - "secure-heap": { - "type": "number", - "description": "total size of the OpenSSL secure heap" - }, - "secure-heap-min": { - "type": "number", - "description": "minimum allocation size from the OpenSSL secure heap" - }, - "snapshot-blob": { - "type": "string", - "description": "Path to the snapshot blob that's either the result of snapshotbuilding, or the blob that is used to restore the application state" - }, - "stack-trace-limit": { - "type": "number", - "description": "" - }, - "strip-types": { - "type": "boolean", - "description": "Type-stripping for TypeScript files." - }, - "test-coverage-branches": { - "type": "number", - "description": "the branch coverage minimum threshold" - }, - "test-coverage-exclude": { - "oneOf": [ - { - "type": "string" - }, - { - "type": "array", - "minItems": 1, - "items": { - "type": "string" - } - } - ], - "description": "exclude files from coverage report that match this glob pattern" - }, - "test-coverage-functions": { - "type": "number", - "description": "the function coverage minimum threshold" - }, - "test-coverage-include": { - "oneOf": [ - { - "type": "string" - }, - { - "type": "array", - "minItems": 1, - "items": { - "type": "string" - } - } - ], - "description": "include files in coverage report that match this glob pattern" - }, - "test-coverage-lines": { - "type": "number", - "description": "the line coverage minimum threshold" - }, - "test-global-setup": { - "type": "string", - "description": "specifies the path to the global setup file" - }, - "test-isolation": { - "type": "string", - "description": "configures the type of test isolation used in the test runner" - }, - "test-name-pattern": { - "oneOf": [ - { - "type": "string" - }, - { - "type": "array", - "minItems": 1, - "items": { - "type": "string" - } - } - ], - "description": "run tests whose name matches this regular expression" - }, - "test-only": { - "type": "boolean", - "description": "run tests with 'only' option set" - }, - "test-random-seed": { - "type": "number", - "description": "seed used to randomize test execution order" - }, - "test-randomize": { - "type": "boolean", - "description": "run tests in a random order" - }, - "test-reporter": { - "oneOf": [ - { - "type": "string" - }, - { - "type": "array", - "minItems": 1, - "items": { - "type": "string" - } - } - ], - "description": "report test output using the given reporter" - }, - "test-reporter-destination": { - "oneOf": [ - { - "type": "string" - }, - { - "type": "array", - "minItems": 1, - "items": { - "type": "string" - } - } - ], - "description": "report given reporter to the given destination" - }, - "test-rerun-failures": { - "type": "string", - "description": "specifies the path to the rerun state file" - }, - "test-shard": { - "type": "string", - "description": "run test at specific shard" - }, - "test-skip-pattern": { - "oneOf": [ - { - "type": "string" - }, - { - "type": "array", - "minItems": 1, - "items": { - "type": "string" - } - } - ], - "description": "run tests whose name do not match this regular expression" - }, - "throw-deprecation": { - "type": "boolean", - "description": "throw an exception on deprecations" - }, - "title": { - "type": "string", - "description": "the process title to use on startup" - }, - "tls-cipher-list": { - "type": "string", - "description": "use an alternative default TLS cipher list" - }, - "tls-keylog": { - "type": "string", - "description": "log TLS decryption keys to named file for traffic analysis" - }, - "tls-max-v1.2": { - "type": "boolean", - "description": "set default TLS maximum to TLSv1.2 (default: TLSv1.3)" - }, - "tls-max-v1.3": { - "type": "boolean", - "description": "set default TLS maximum to TLSv1.3 (default: TLSv1.3)" - }, - "tls-min-v1.0": { - "type": "boolean", - "description": "set default TLS minimum to TLSv1.0 (default: TLSv1.2)" - }, - "tls-min-v1.1": { - "type": "boolean", - "description": "set default TLS minimum to TLSv1.1 (default: TLSv1.2)" - }, - "tls-min-v1.2": { - "type": "boolean", - "description": "set default TLS minimum to TLSv1.2 (default: TLSv1.2)" - }, - "tls-min-v1.3": { - "type": "boolean", - "description": "set default TLS minimum to TLSv1.3 (default: TLSv1.2)" - }, - "trace-deprecation": { - "type": "boolean", - "description": "show stack traces on deprecations" - }, - "trace-env": { - "type": "boolean", - "description": "Print accesses to the environment variables" - }, - "trace-env-js-stack": { - "type": "boolean", - "description": "Print accesses to the environment variables and the JavaScript stack trace" - }, - "trace-env-native-stack": { - "type": "boolean", - "description": "Print accesses to the environment variables and the native stack trace" - }, - "trace-event-categories": { - "type": "string", - "description": "comma separated list of trace event categories to record" - }, - "trace-event-file-pattern": { - "type": "string", - "description": "Template string specifying the filepath for the trace-events data, it supports ${rotation} and ${pid}." - }, - "trace-exit": { - "type": "boolean", - "description": "show stack trace when an environment exits" - }, - "trace-promises": { - "type": "boolean", - "description": "show stack traces on promise initialization and resolution" - }, - "trace-require-module": { - "type": "string", - "description": "Print access to require(esm). Options are 'all' (print all usage) and 'no-node-modules' (excluding usage from the node_modules folder)" - }, - "trace-sigint": { - "type": "boolean", - "description": "enable printing JavaScript stacktrace on SIGINT" - }, - "trace-sync-io": { - "type": "boolean", - "description": "show stack trace when use of sync IO is detected after the first tick" - }, - "trace-tls": { - "type": "boolean", - "description": "prints TLS packet trace information to stderr" - }, - "trace-uncaught": { - "type": "boolean", - "description": "show stack traces for the `throw` behind uncaught exceptions" - }, - "trace-warnings": { - "type": "boolean", - "description": "show stack traces on process warnings" - }, - "track-heap-objects": { - "type": "boolean", - "description": "track heap object allocations for heap snapshots" - }, - "unhandled-rejections": { - "type": "string", - "description": "define unhandled rejections behavior. Options are 'strict' (always raise an error), 'throw' (raise an error unless 'unhandledRejection' hook is set), 'warn' (log a warning), 'none' (silence warnings), 'warn-with-error-code' (log a warning and set exit code 1 unless 'unhandledRejection' hook is set). (default: throw)" - }, - "use-bundled-ca": { - "type": "boolean", - "description": "use bundled CA store (default)" - }, - "use-env-proxy": { - "type": "boolean", - "description": "parse proxy settings from HTTP_PROXY/HTTPS_PROXY/NO_PROXYenvironment variables and apply the setting in global HTTP/HTTPS clients" - }, - "use-largepages": { - "type": "string", - "description": "Map the Node.js static code to large pages. Options are 'off' (the default value, meaning do not map), 'on' (map and ignore failure, reporting it to stderr), or 'silent' (map and silently ignore failure)" - }, - "use-openssl-ca": { - "type": "boolean", - "description": "use OpenSSL's default CA store" - }, - "use-system-ca": { - "type": "boolean", - "description": "use system's CA store" - }, - "v8-pool-size": { - "type": "number", - "description": "set V8's thread pool size" - }, - "verify-base-objects": { - "type": "boolean", - "description": "" - }, - "warnings": { - "type": "boolean", - "description": "silence all process warnings" - }, - "watch": { - "type": "boolean", - "description": "run in watch mode" - }, - "watch-kill-signal": { - "type": "string", - "description": "kill signal to send to the process on watch mode restarts(default: SIGTERM)" - }, - "watch-path": { - "oneOf": [ - { - "type": "string" - }, - { - "type": "array", - "minItems": 1, - "items": { - "type": "string" - } - } - ], - "description": "path to watch" - }, - "watch-preserve-output": { - "type": "boolean", - "description": "preserve outputs on watch mode restart" - }, - "zero-fill-buffers": { - "type": "boolean", - "description": "automatically zero-fill all newly allocated Buffer instances" - } - }, - "type": "object" - }, - "permission": { + { "type": "object", "additionalProperties": false, - "required": [], + "required": [ + "configs" + ], "properties": { - "allow-addons": { - "type": "boolean", - "description": "allow use of addons when any permissions are set" - }, - "allow-ffi": { - "type": "boolean", - "description": "allow use of FFI when any permissions are set (only in builds with FFI support)" - }, - "allow-child-process": { - "type": "boolean", - "description": "allow use of child process when any permissions are set" - }, - "allow-fs-read": { - "oneOf": [ - { - "type": "string" - }, - { - "type": "array", - "minItems": 1, - "items": { - "type": "string" + "$schema": { + "type": "string" + }, + "configs": { + "type": "array", + "minItems": 1, + "items": { + "type": "object", + "additionalProperties": false, + "required": [ + "nodeVersion", + "config" + ], + "properties": { + "nodeVersion": { + "type": "integer" + }, + "config": { + "$ref": "#/$defs/config" } } - ], - "description": "allow permissions to read the filesystem" - }, - "allow-fs-write": { - "oneOf": [ - { - "type": "string" - }, - { - "type": "array", - "minItems": 1, - "items": { - "type": "string" - } - } - ], - "description": "allow permissions to write in the filesystem" - }, - "allow-inspector": { - "type": "boolean", - "description": "allow use of inspector when any permissions are set" - }, - "allow-net": { - "type": "boolean", - "description": "allow use of network when any permissions are set" - }, - "allow-wasi": { - "type": "boolean", - "description": "allow wasi when any permissions are set" - }, - "allow-worker": { - "type": "boolean", - "description": "allow worker threads when any permissions are set" - }, - "permission": { - "type": "boolean", - "description": "enable the permission system" + } } } - }, - "test": { - "type": "object", + } + ], + "$defs": { + "config": { "additionalProperties": false, "required": [], "properties": { - "experimental-test-coverage": { - "type": "boolean", - "description": "enable code coverage in the test runner" - }, - "experimental-test-module-mocks": { - "type": "boolean", - "description": "enable module mocking in the test runner" - }, - "test": { - "type": "boolean", - "description": "launch test runner on startup" - }, - "test-concurrency": { - "type": "number", - "description": "specify test runner concurrency" - }, - "test-coverage-branches": { - "type": "number", - "description": "the branch coverage minimum threshold" - }, - "test-coverage-exclude": { - "oneOf": [ - { - "type": "string" - }, - { - "type": "array", - "minItems": 1, - "items": { - "type": "string" - } - } - ], - "description": "exclude files from coverage report that match this glob pattern" - }, - "test-coverage-functions": { - "type": "number", - "description": "the function coverage minimum threshold" - }, - "test-coverage-include": { - "oneOf": [ - { - "type": "string" - }, - { - "type": "array", - "minItems": 1, - "items": { - "type": "string" - } - } - ], - "description": "include files in coverage report that match this glob pattern" - }, - "test-coverage-lines": { - "type": "number", - "description": "the line coverage minimum threshold" - }, - "test-force-exit": { - "type": "boolean", - "description": "force test runner to exit upon completion" - }, - "test-global-setup": { - "type": "string", - "description": "specifies the path to the global setup file" - }, - "test-isolation": { - "type": "string", - "description": "configures the type of test isolation used in the test runner" - }, - "test-name-pattern": { - "oneOf": [ - { - "type": "string" - }, - { - "type": "array", - "minItems": 1, - "items": { - "type": "string" - } + "$schema": { + "type": "string" + }, + "nodeOptions": { + "additionalProperties": false, + "required": [], + "properties": { + "addons": { + "type": "boolean", + "description": "disable loading native addons" + }, + "allow-addons": { + "type": "boolean", + "description": "allow use of addons when any permissions are set" + }, + "allow-child-process": { + "type": "boolean", + "description": "allow use of child process when any permissions are set" + }, + "allow-ffi": { + "type": "boolean", + "description": "allow use of FFI when any permissions are set" + }, + "allow-fs-read": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "array", + "minItems": 1, + "items": { + "type": "string" + } + } + ], + "description": "allow permissions to read the filesystem" + }, + "allow-fs-write": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "array", + "minItems": 1, + "items": { + "type": "string" + } + } + ], + "description": "allow permissions to write in the filesystem" + }, + "allow-inspector": { + "type": "boolean", + "description": "allow use of inspector when any permissions are set" + }, + "allow-net": { + "type": "boolean", + "description": "allow use of network when any permissions are set" + }, + "allow-wasi": { + "type": "boolean", + "description": "allow wasi when any permissions are set" + }, + "allow-worker": { + "type": "boolean", + "description": "allow worker threads when any permissions are set" + }, + "async-context-frame": { + "type": "boolean", + "description": "Improve AsyncLocalStorage performance with AsyncContextFrame" + }, + "conditions": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "array", + "minItems": 1, + "items": { + "type": "string" + } + } + ], + "description": "additional user conditions for conditional exports and imports" + }, + "cpu-prof": { + "type": "boolean", + "description": "Start the V8 CPU profiler on start up, and write the CPU profile to disk before exit. If --cpu-prof-dir is not specified, write the profile to the current working directory." + }, + "cpu-prof-dir": { + "type": "string", + "description": "Directory where the V8 profiles generated by --cpu-prof will be placed. Does not affect --prof." + }, + "cpu-prof-interval": { + "type": "number", + "description": "specified sampling interval in microseconds for the V8 CPU profile generated with --cpu-prof. (default: 1000)" + }, + "cpu-prof-name": { + "type": "string", + "description": "specified file name of the V8 CPU profile generated with --cpu-prof" + }, + "debug-arraybuffer-allocations": { + "type": "boolean", + "description": "" + }, + "deprecation": { + "type": "boolean", + "description": "silence deprecation warnings" + }, + "diagnostic-dir": { + "type": "string", + "description": "set dir for all output files (default: current working directory)" + }, + "disable-proto": { + "type": "string", + "description": "disable Object.prototype.__proto__" + }, + "disable-sigusr1": { + "type": "boolean", + "description": "Disable inspector thread to be listening for SIGUSR1 signal" + }, + "disable-warning": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "array", + "minItems": 1, + "items": { + "type": "string" + } + } + ], + "description": "silence specific process warnings" + }, + "disable-wasm-trap-handler": { + "type": "boolean", + "description": "Disable trap-handler-based WebAssembly bound checks. V8 will insert inline bound checks when compiling WebAssembly which may slow down performance." + }, + "dns-result-order": { + "type": "string", + "description": "set default value of verbatim in dns.lookup. Options are 'ipv4first' (IPv4 addresses are placed before IPv6 addresses) 'ipv6first' (IPv6 addresses are placed before IPv4 addresses) 'verbatim' (addresses are in the order the DNS resolver returned)" + }, + "enable-fips": { + "type": "boolean", + "description": "enable FIPS crypto at startup" + }, + "enable-source-maps": { + "type": "boolean", + "description": "Source Map V3 support for stack traces" + }, + "entry-url": { + "type": "boolean", + "description": "Treat the entrypoint as a URL" + }, + "experimental-addon-modules": { + "type": "boolean", + "description": "experimental import support for addons" + }, + "experimental-detect-module": { + "type": "boolean", + "description": "when ambiguous modules fail to evaluate because they contain ES module syntax, try again to evaluate them as ES modules" + }, + "experimental-eventsource": { + "type": "boolean", + "description": "experimental EventSource API" + }, + "experimental-ffi": { + "type": "boolean", + "description": "experimental node:ffi module" + }, + "experimental-global-navigator": { + "type": "boolean", + "description": "expose experimental Navigator API on the global scope" + }, + "experimental-import-meta-resolve": { + "type": "boolean", + "description": "experimental ES Module import.meta.resolve() parentURL support" + }, + "experimental-loader": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "array", + "minItems": 1, + "items": { + "type": "string" + } + } + ], + "description": "use the specified module as a custom loader" + }, + "experimental-print-required-tla": { + "type": "boolean", + "description": "Print pending top-level await. If --require-module is true, evaluate asynchronous graphs loaded by `require()` but do not run the microtasks, in order to to find and print top-level await in the graph" + }, + "experimental-repl-await": { + "type": "boolean", + "description": "experimental await keyword support in REPL" + }, + "experimental-require-module": { + "type": "boolean", + "description": "Legacy alias for --require-module" + }, + "experimental-shadow-realm": { + "type": "boolean", + "description": "" + }, + "experimental-sqlite": { + "type": "boolean", + "description": "experimental node:sqlite module" + }, + "experimental-stream-iter": { + "type": "boolean", + "description": "experimental iterable streams API (node:stream/iter)" + }, + "experimental-vm-modules": { + "type": "boolean", + "description": "experimental ES Module support in vm module" + }, + "experimental-websocket": { + "type": "boolean", + "description": "experimental WebSocket API" + }, + "experimental-webstorage": { + "type": "boolean", + "description": "experimental Web Storage API" + }, + "extra-info-on-fatal-exception": { + "type": "boolean", + "description": "hide extra information on fatal exception that causes exit" + }, + "force-async-hooks-checks": { + "type": "boolean", + "description": "disable checks for async_hooks" + }, + "force-context-aware": { + "type": "boolean", + "description": "disable loading non-context-aware addons" + }, + "force-fips": { + "type": "boolean", + "description": "force FIPS crypto (cannot be disabled)" + }, + "force-node-api-uncaught-exceptions-policy": { + "type": "boolean", + "description": "enforces 'uncaughtException' event on Node API asynchronous callbacks" + }, + "frozen-intrinsics": { + "type": "boolean", + "description": "experimental frozen intrinsics support" + }, + "global-search-paths": { + "type": "boolean", + "description": "disable global module search paths" + }, + "heap-prof": { + "type": "boolean", + "description": "Start the V8 heap profiler on start up, and write the heap profile to disk before exit. If --heap-prof-dir is not specified, write the profile to the current working directory." + }, + "heap-prof-dir": { + "type": "string", + "description": "Directory where the V8 heap profiles generated by --heap-prof will be placed." + }, + "heap-prof-interval": { + "type": "number", + "description": "specified sampling interval in bytes for the V8 heap profile generated with --heap-prof. (default: 512 * 1024)" + }, + "heap-prof-name": { + "type": "string", + "description": "specified file name of the V8 heap profile generated with --heap-prof" + }, + "heapsnapshot-near-heap-limit": { + "type": "number", + "description": "Generate heap snapshots whenever V8 is approaching the heap limit. No more than the specified number of heap snapshots will be generated." + }, + "heapsnapshot-signal": { + "type": "string", + "description": "Generate heap snapshot on specified signal" + }, + "icu-data-dir": { + "type": "string", + "description": "set ICU data load path to dir (overrides NODE_ICU_DATA) (note: linked-in ICU data is present)" + }, + "import": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "array", + "minItems": 1, + "items": { + "type": "string" + } + } + ], + "description": "ES module to preload (option can be repeated)" + }, + "input-type": { + "type": "string", + "description": "set module type for string input" + }, + "insecure-http-parser": { + "type": "boolean", + "description": "use an insecure HTTP parser that accepts invalid HTTP headers" + }, + "inspect": { + "type": "boolean", + "description": "activate inspector on host:port (default: 127.0.0.1:9229)" + }, + "inspect-brk": { + "type": "boolean", + "description": "activate inspector on host:port and break at start of user script" + }, + "inspect-port": { + "type": "number", + "description": "set host:port for inspector" + }, + "inspect-publish-uid": { + "type": "string", + "description": "comma separated list of destinations for inspector uid(default: stderr,http)" + }, + "inspect-wait": { + "type": "boolean", + "description": "activate inspector on host:port and wait for debugger to be attached" + }, + "localstorage-file": { + "type": "string", + "description": "file used to persist localStorage data" + }, + "max-http-header-size": { + "type": "number", + "description": "set the maximum size of HTTP headers (default: 16384 (16KB))" + }, + "max-old-space-size-percentage": { + "type": "string", + "description": "set V8's max old space size as a percentage of available memory (e.g., '50%'). Takes precedence over --max-old-space-size." + }, + "network-family-autoselection": { + "type": "boolean", + "description": "Disable network address family autodetection algorithm" + }, + "network-family-autoselection-attempt-timeout": { + "type": "number", + "description": "Sets the default value for the network family autoselection attempt timeout." + }, + "node-snapshot": { + "type": "boolean", + "description": "" + }, + "openssl-config": { + "type": "string", + "description": "load OpenSSL configuration from the specified file (overrides OPENSSL_CONF)" + }, + "openssl-legacy-provider": { + "type": "boolean", + "description": "enable OpenSSL 3.0 legacy provider" + }, + "openssl-shared-config": { + "type": "boolean", + "description": "enable OpenSSL shared configuration" + }, + "pending-deprecation": { + "type": "boolean", + "description": "emit pending deprecation warnings" + }, + "permission": { + "type": "boolean", + "description": "enable the permission system" + }, + "permission-audit": { + "type": "boolean", + "description": "enable audit only for the permission system" + }, + "preserve-symlinks": { + "type": "boolean", + "description": "preserve symbolic links when resolving" + }, + "preserve-symlinks-main": { + "type": "boolean", + "description": "preserve symbolic links when resolving the main module" + }, + "redirect-warnings": { + "type": "string", + "description": "write warnings to file instead of stderr" + }, + "report-compact": { + "type": "boolean", + "description": "output compact single-line JSON" + }, + "report-dir": { + "type": "string", + "description": "define custom report pathname. (default: current working directory)" + }, + "report-exclude-env": { + "type": "boolean", + "description": "Exclude environment variables when generating report (default: false)" + }, + "report-exclude-network": { + "type": "boolean", + "description": "exclude network interface diagnostics. (default: false)" + }, + "report-filename": { + "type": "string", + "description": "define custom report file name. (default: YYYYMMDD.HHMMSS.PID.SEQUENCE#.txt)" + }, + "report-on-fatalerror": { + "type": "boolean", + "description": "generate diagnostic report on fatal (internal) errors" + }, + "report-on-signal": { + "type": "boolean", + "description": "generate diagnostic report upon receiving signals" + }, + "report-signal": { + "type": "string", + "description": "causes diagnostic report to be produced on provided signal, unsupported in Windows. (default: SIGUSR2)" + }, + "report-uncaught-exception": { + "type": "boolean", + "description": "generate diagnostic report on uncaught exceptions" + }, + "require": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "array", + "minItems": 1, + "items": { + "type": "string" + } + } + ], + "description": "CommonJS module to preload (option can be repeated)" + }, + "require-module": { + "type": "boolean", + "description": "Allow loading synchronous ES Modules in require()." + }, + "secure-heap": { + "type": "number", + "description": "total size of the OpenSSL secure heap" + }, + "secure-heap-min": { + "type": "number", + "description": "minimum allocation size from the OpenSSL secure heap" + }, + "snapshot-blob": { + "type": "string", + "description": "Path to the snapshot blob that's either the result of snapshotbuilding, or the blob that is used to restore the application state" + }, + "stack-trace-limit": { + "type": "number", + "description": "" + }, + "strip-types": { + "type": "boolean", + "description": "Type-stripping for TypeScript files." + }, + "test-coverage-branches": { + "type": "number", + "description": "the branch coverage minimum threshold" + }, + "test-coverage-exclude": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "array", + "minItems": 1, + "items": { + "type": "string" + } + } + ], + "description": "exclude files from coverage report that match this glob pattern" + }, + "test-coverage-functions": { + "type": "number", + "description": "the function coverage minimum threshold" + }, + "test-coverage-include": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "array", + "minItems": 1, + "items": { + "type": "string" + } + } + ], + "description": "include files in coverage report that match this glob pattern" + }, + "test-coverage-lines": { + "type": "number", + "description": "the line coverage minimum threshold" + }, + "test-global-setup": { + "type": "string", + "description": "specifies the path to the global setup file" + }, + "test-isolation": { + "type": "string", + "description": "configures the type of test isolation used in the test runner" + }, + "test-name-pattern": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "array", + "minItems": 1, + "items": { + "type": "string" + } + } + ], + "description": "run tests whose name matches this regular expression" + }, + "test-only": { + "type": "boolean", + "description": "run tests with 'only' option set" + }, + "test-random-seed": { + "type": "number", + "description": "seed used to randomize test execution order" + }, + "test-randomize": { + "type": "boolean", + "description": "run tests in a random order" + }, + "test-reporter": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "array", + "minItems": 1, + "items": { + "type": "string" + } + } + ], + "description": "report test output using the given reporter" + }, + "test-reporter-destination": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "array", + "minItems": 1, + "items": { + "type": "string" + } + } + ], + "description": "report given reporter to the given destination" + }, + "test-rerun-failures": { + "type": "string", + "description": "specifies the path to the rerun state file" + }, + "test-shard": { + "type": "string", + "description": "run test at specific shard" + }, + "test-skip-pattern": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "array", + "minItems": 1, + "items": { + "type": "string" + } + } + ], + "description": "run tests whose name do not match this regular expression" + }, + "throw-deprecation": { + "type": "boolean", + "description": "throw an exception on deprecations" + }, + "title": { + "type": "string", + "description": "the process title to use on startup" + }, + "tls-cipher-list": { + "type": "string", + "description": "use an alternative default TLS cipher list" + }, + "tls-keylog": { + "type": "string", + "description": "log TLS decryption keys to named file for traffic analysis" + }, + "tls-max-v1.2": { + "type": "boolean", + "description": "set default TLS maximum to TLSv1.2 (default: TLSv1.3)" + }, + "tls-max-v1.3": { + "type": "boolean", + "description": "set default TLS maximum to TLSv1.3 (default: TLSv1.3)" + }, + "tls-min-v1.0": { + "type": "boolean", + "description": "set default TLS minimum to TLSv1.0 (default: TLSv1.2)" + }, + "tls-min-v1.1": { + "type": "boolean", + "description": "set default TLS minimum to TLSv1.1 (default: TLSv1.2)" + }, + "tls-min-v1.2": { + "type": "boolean", + "description": "set default TLS minimum to TLSv1.2 (default: TLSv1.2)" + }, + "tls-min-v1.3": { + "type": "boolean", + "description": "set default TLS minimum to TLSv1.3 (default: TLSv1.2)" + }, + "trace-deprecation": { + "type": "boolean", + "description": "show stack traces on deprecations" + }, + "trace-env": { + "type": "boolean", + "description": "Print accesses to the environment variables" + }, + "trace-env-js-stack": { + "type": "boolean", + "description": "Print accesses to the environment variables and the JavaScript stack trace" + }, + "trace-env-native-stack": { + "type": "boolean", + "description": "Print accesses to the environment variables and the native stack trace" + }, + "trace-event-categories": { + "type": "string", + "description": "comma separated list of trace event categories to record" + }, + "trace-event-file-pattern": { + "type": "string", + "description": "Template string specifying the filepath for the trace-events data, it supports ${rotation} and ${pid}." + }, + "trace-exit": { + "type": "boolean", + "description": "show stack trace when an environment exits" + }, + "trace-promises": { + "type": "boolean", + "description": "show stack traces on promise initialization and resolution" + }, + "trace-require-module": { + "type": "string", + "description": "Print access to require(esm). Options are 'all' (print all usage) and 'no-node-modules' (excluding usage from the node_modules folder)" + }, + "trace-sigint": { + "type": "boolean", + "description": "enable printing JavaScript stacktrace on SIGINT" + }, + "trace-sync-io": { + "type": "boolean", + "description": "show stack trace when use of sync IO is detected after the first tick" + }, + "trace-tls": { + "type": "boolean", + "description": "prints TLS packet trace information to stderr" + }, + "trace-uncaught": { + "type": "boolean", + "description": "show stack traces for the `throw` behind uncaught exceptions" + }, + "trace-warnings": { + "type": "boolean", + "description": "show stack traces on process warnings" + }, + "track-heap-objects": { + "type": "boolean", + "description": "track heap object allocations for heap snapshots" + }, + "unhandled-rejections": { + "type": "string", + "description": "define unhandled rejections behavior. Options are 'strict' (always raise an error), 'throw' (raise an error unless 'unhandledRejection' hook is set), 'warn' (log a warning), 'none' (silence warnings), 'warn-with-error-code' (log a warning and set exit code 1 unless 'unhandledRejection' hook is set). (default: throw)" + }, + "use-bundled-ca": { + "type": "boolean", + "description": "use bundled CA store (default)" + }, + "use-env-proxy": { + "type": "boolean", + "description": "parse proxy settings from HTTP_PROXY/HTTPS_PROXY/NO_PROXYenvironment variables and apply the setting in global HTTP/HTTPS clients" + }, + "use-largepages": { + "type": "string", + "description": "Map the Node.js static code to large pages. Options are 'off' (the default value, meaning do not map), 'on' (map and ignore failure, reporting it to stderr), or 'silent' (map and silently ignore failure)" + }, + "use-openssl-ca": { + "type": "boolean", + "description": "use OpenSSL's default CA store" + }, + "use-system-ca": { + "type": "boolean", + "description": "use system's CA store" + }, + "v8-pool-size": { + "type": "number", + "description": "set V8's thread pool size" + }, + "verify-base-objects": { + "type": "boolean", + "description": "" + }, + "warnings": { + "type": "boolean", + "description": "silence all process warnings" + }, + "watch": { + "type": "boolean", + "description": "run in watch mode" + }, + "watch-kill-signal": { + "type": "string", + "description": "kill signal to send to the process on watch mode restarts(default: SIGTERM)" + }, + "watch-path": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "array", + "minItems": 1, + "items": { + "type": "string" + } + } + ], + "description": "path to watch" + }, + "watch-preserve-output": { + "type": "boolean", + "description": "preserve outputs on watch mode restart" + }, + "zero-fill-buffers": { + "type": "boolean", + "description": "automatically zero-fill all newly allocated Buffer instances" } - ], - "description": "run tests whose name matches this regular expression" - }, - "test-only": { - "type": "boolean", - "description": "run tests with 'only' option set" + }, + "type": "object" }, - "test-random-seed": { - "type": "number", - "description": "seed used to randomize test execution order" + "nodeVersion": { + "type": "integer" }, - "test-randomize": { - "type": "boolean", - "description": "run tests in a random order" - }, - "test-reporter": { - "oneOf": [ - { - "type": "string" - }, - { - "type": "array", - "minItems": 1, - "items": { - "type": "string" - } - } - ], - "description": "report test output using the given reporter" - }, - "test-reporter-destination": { - "oneOf": [ - { - "type": "string" - }, - { - "type": "array", - "minItems": 1, - "items": { - "type": "string" - } + "permission": { + "type": "object", + "additionalProperties": false, + "required": [], + "properties": { + "allow-addons": { + "type": "boolean", + "description": "allow use of addons when any permissions are set" + }, + "allow-child-process": { + "type": "boolean", + "description": "allow use of child process when any permissions are set" + }, + "allow-ffi": { + "type": "boolean", + "description": "allow use of FFI when any permissions are set" + }, + "allow-fs-read": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "array", + "minItems": 1, + "items": { + "type": "string" + } + } + ], + "description": "allow permissions to read the filesystem" + }, + "allow-fs-write": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "array", + "minItems": 1, + "items": { + "type": "string" + } + } + ], + "description": "allow permissions to write in the filesystem" + }, + "allow-inspector": { + "type": "boolean", + "description": "allow use of inspector when any permissions are set" + }, + "allow-net": { + "type": "boolean", + "description": "allow use of network when any permissions are set" + }, + "allow-wasi": { + "type": "boolean", + "description": "allow wasi when any permissions are set" + }, + "allow-worker": { + "type": "boolean", + "description": "allow worker threads when any permissions are set" + }, + "permission": { + "type": "boolean", + "description": "enable the permission system" } - ], - "description": "report given reporter to the given destination" - }, - "test-rerun-failures": { - "type": "string", - "description": "specifies the path to the rerun state file" - }, - "test-shard": { - "type": "string", - "description": "run test at specific shard" + } }, - "test-skip-pattern": { - "oneOf": [ - { - "type": "string" - }, - { - "type": "array", - "minItems": 1, - "items": { - "type": "string" - } + "test": { + "type": "object", + "additionalProperties": false, + "required": [], + "properties": { + "experimental-test-coverage": { + "type": "boolean", + "description": "enable code coverage in the test runner" + }, + "experimental-test-module-mocks": { + "type": "boolean", + "description": "enable module mocking in the test runner" + }, + "test": { + "type": "boolean", + "description": "launch test runner on startup" + }, + "test-concurrency": { + "type": "number", + "description": "specify test runner concurrency" + }, + "test-coverage-branches": { + "type": "number", + "description": "the branch coverage minimum threshold" + }, + "test-coverage-exclude": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "array", + "minItems": 1, + "items": { + "type": "string" + } + } + ], + "description": "exclude files from coverage report that match this glob pattern" + }, + "test-coverage-functions": { + "type": "number", + "description": "the function coverage minimum threshold" + }, + "test-coverage-include": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "array", + "minItems": 1, + "items": { + "type": "string" + } + } + ], + "description": "include files in coverage report that match this glob pattern" + }, + "test-coverage-lines": { + "type": "number", + "description": "the line coverage minimum threshold" + }, + "test-force-exit": { + "type": "boolean", + "description": "force test runner to exit upon completion" + }, + "test-global-setup": { + "type": "string", + "description": "specifies the path to the global setup file" + }, + "test-isolation": { + "type": "string", + "description": "configures the type of test isolation used in the test runner" + }, + "test-name-pattern": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "array", + "minItems": 1, + "items": { + "type": "string" + } + } + ], + "description": "run tests whose name matches this regular expression" + }, + "test-only": { + "type": "boolean", + "description": "run tests with 'only' option set" + }, + "test-random-seed": { + "type": "number", + "description": "seed used to randomize test execution order" + }, + "test-randomize": { + "type": "boolean", + "description": "run tests in a random order" + }, + "test-reporter": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "array", + "minItems": 1, + "items": { + "type": "string" + } + } + ], + "description": "report test output using the given reporter" + }, + "test-reporter-destination": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "array", + "minItems": 1, + "items": { + "type": "string" + } + } + ], + "description": "report given reporter to the given destination" + }, + "test-rerun-failures": { + "type": "string", + "description": "specifies the path to the rerun state file" + }, + "test-shard": { + "type": "string", + "description": "run test at specific shard" + }, + "test-skip-pattern": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "array", + "minItems": 1, + "items": { + "type": "string" + } + } + ], + "description": "run tests whose name do not match this regular expression" + }, + "test-timeout": { + "type": "number", + "description": "specify test runner timeout" + }, + "test-update-snapshots": { + "type": "boolean", + "description": "regenerate test snapshots" } - ], - "description": "run tests whose name do not match this regular expression" - }, - "test-timeout": { - "type": "number", - "description": "specify test runner timeout" + } }, - "test-update-snapshots": { - "type": "boolean", - "description": "regenerate test snapshots" - } - } - }, - "watch": { - "type": "object", - "additionalProperties": false, - "required": [], - "properties": { "watch": { - "type": "boolean", - "description": "run in watch mode" - }, - "watch-kill-signal": { - "type": "string", - "description": "kill signal to send to the process on watch mode restarts(default: SIGTERM)" - }, - "watch-path": { - "oneOf": [ - { - "type": "string" - }, - { - "type": "array", - "minItems": 1, - "items": { - "type": "string" - } + "type": "object", + "additionalProperties": false, + "required": [], + "properties": { + "watch": { + "type": "boolean", + "description": "run in watch mode" + }, + "watch-kill-signal": { + "type": "string", + "description": "kill signal to send to the process on watch mode restarts(default: SIGTERM)" + }, + "watch-path": { + "oneOf": [ + { + "type": "string" + }, + { + "type": "array", + "minItems": 1, + "items": { + "type": "string" + } + } + ], + "description": "path to watch" + }, + "watch-preserve-output": { + "type": "boolean", + "description": "preserve outputs on watch mode restart" } - ], - "description": "path to watch" - }, - "watch-preserve-output": { - "type": "boolean", - "description": "preserve outputs on watch mode restart" + } } - } + }, + "type": "object" } - }, - "type": "object" + } } diff --git a/lib/internal/options.js b/lib/internal/options.js index 92993d037fb653..3480f5794b76cc 100644 --- a/lib/internal/options.js +++ b/lib/internal/options.js @@ -65,9 +65,8 @@ function generateConfigJsonSchema() { return { __proto__: null, type, description }; } - const schema = { + const configSchema = { __proto__: null, - $schema: 'https://json-schema.org/draft/2020-12/schema', additionalProperties: false, required: [], properties: { @@ -82,13 +81,17 @@ function generateConfigJsonSchema() { properties: { __proto__: null }, type: 'object', }, + nodeVersion: { + __proto__: null, + type: 'integer', + }, __proto__: null, }, type: 'object', }; // Get the root properties object for adding namespaces - const rootProperties = schema.properties; + const rootProperties = configSchema.properties; const nodeOptions = rootProperties.nodeOptions.properties; // Add env options to nodeOptions (backward compatibility) @@ -130,7 +133,7 @@ function generateConfigJsonSchema() { ArrayPrototypeMap(sortedKeys, (key) => [key, nodeOptions[key]]), ); - schema.properties.nodeOptions.properties = sortedProperties; + configSchema.properties.nodeOptions.properties = sortedProperties; // Also sort the root level properties const sortedRootKeys = ArrayPrototypeSort(ObjectKeys(rootProperties)); @@ -138,7 +141,54 @@ function generateConfigJsonSchema() { ArrayPrototypeMap(sortedRootKeys, (key) => [key, rootProperties[key]]), ); - schema.properties = sortedRootProperties; + configSchema.properties = sortedRootProperties; + + const schema = { + __proto__: null, + $schema: 'https://json-schema.org/draft/2020-12/schema', + oneOf: [ + { __proto__: null, $ref: '#/$defs/config' }, + { + __proto__: null, + type: 'object', + additionalProperties: false, + required: ['configs'], + properties: { + __proto__: null, + $schema: { + __proto__: null, + type: 'string', + }, + configs: { + __proto__: null, + type: 'array', + minItems: 1, + items: { + __proto__: null, + type: 'object', + additionalProperties: false, + required: ['nodeVersion', 'config'], + properties: { + __proto__: null, + nodeVersion: { + __proto__: null, + type: 'integer', + }, + config: { + __proto__: null, + $ref: '#/$defs/config', + }, + }, + }, + }, + }, + }, + ], + $defs: { + __proto__: null, + config: configSchema, + }, + }; return schema; } diff --git a/src/node_config_file.cc b/src/node_config_file.cc index b2c87970b6ebc1..68c13ad881fc9f 100644 --- a/src/node_config_file.cc +++ b/src/node_config_file.cc @@ -1,7 +1,10 @@ #include "node_config_file.h" #include "debug_utils-inl.h" +#include "node_version.h" #include "simdjson.h" +#include + namespace node { constexpr std::string_view kConfigFileFlag = "--experimental-config-file"; @@ -224,39 +227,115 @@ ParseResult ConfigReader::ParseOptions( return ParseResult::Valid; } -ParseResult ConfigReader::ParseConfig(const std::string_view& config_path) { - std::string file_content; - // Read the configuration file - int r = ReadFileSync(&file_content, config_path.data()); - if (r != 0) { - const char* err = uv_strerror(r); - FPrintF( - stderr, "Cannot read configuration from %s: %s\n", config_path, err); - return ParseResult::FileError; +ParseResult ConfigReader::ParseNodeVersion( + simdjson::ondemand::value* version_value, + const std::string_view& config_path) { + int64_t version; + if (version_value->get_int64().get(version)) { + FPrintF(stderr, + "\"nodeVersion\" value unexpected for %s " + "(should be an integer)\n", + config_path.data()); + return ParseResult::InvalidContent; } - // Parse the configuration file - simdjson::ondemand::parser json_parser; - simdjson::ondemand::document document; - if (json_parser.iterate(file_content).get(document)) { - FPrintF(stderr, "Can't parse %s\n", config_path.data()); + if (version != NODE_MAJOR_VERSION) { + FPrintF(stderr, + "\"nodeVersion\" %" PRId64 + " does not match current Node.js version %d " + "for %s\n", + version, + NODE_MAJOR_VERSION, + config_path.data()); return ParseResult::InvalidContent; } - // Validate config is an object - simdjson::ondemand::object main_object; - auto root_error = document.get_object().get(main_object); - if (root_error) { - if (root_error == simdjson::error_code::INCORRECT_TYPE) { + return ParseResult::Valid; +} + +ParseResult ConfigReader::ParseConfigs(simdjson::ondemand::array* configs, + const std::string_view& config_path) { + size_t index = 0; + + for (auto raw_config : *configs) { + simdjson::ondemand::object config_wrapper; + if (raw_config.get_object().get(config_wrapper)) { FPrintF(stderr, - "Root value unexpected not an object for %s\n\n", + "\"configs[%zu]\" value unexpected for %s " + "(should be an object)\n", + index, config_path.data()); - } else { - FPrintF(stderr, "Can't parse %s\n", config_path.data()); + return ParseResult::InvalidContent; } - return ParseResult::InvalidContent; + + simdjson::ondemand::value version_value; + auto version_error = + config_wrapper.find_field_unordered("nodeVersion").get(version_value); + if (version_error == simdjson::NO_SUCH_FIELD) { + FPrintF(stderr, + "\"configs[%zu].nodeVersion\" is required for %s\n", + index, + config_path.data()); + return ParseResult::InvalidContent; + } + if (version_error) { + return ParseResult::InvalidContent; + } + + int64_t version; + if (version_value.get_int64().get(version)) { + FPrintF(stderr, + "\"configs[%zu].nodeVersion\" value unexpected for %s " + "(should be an integer)\n", + index, + config_path.data()); + return ParseResult::InvalidContent; + } + + if (version != NODE_MAJOR_VERSION) { + index++; + continue; + } + + simdjson::ondemand::value config_value; + auto config_error = + config_wrapper.find_field_unordered("config").get(config_value); + if (config_error == simdjson::NO_SUCH_FIELD) { + FPrintF(stderr, + "\"configs[%zu].config\" is required for %s\n", + index, + config_path.data()); + return ParseResult::InvalidContent; + } + if (config_error) { + return ParseResult::InvalidContent; + } + + simdjson::ondemand::object selected_config; + if (config_value.get_object().get(selected_config)) { + FPrintF(stderr, + "\"configs[%zu].config\" value unexpected for %s " + "(should be an object)\n", + index, + config_path.data()); + return ParseResult::InvalidContent; + } + + return ParseConfigObject(&selected_config, config_path, false); } + FPrintF(stderr, + "No config found for current Node.js version %d in " + "\"configs\" for %s\n", + NODE_MAJOR_VERSION, + config_path.data()); + return ParseResult::InvalidContent; +} + +ParseResult ConfigReader::ParseConfigObject( + simdjson::ondemand::object* config_object, + const std::string_view& config_path, + bool allow_version_selection) { // Get all available namespaces for validation std::vector available_namespaces = options_parser::MapAvailableNamespaces(); @@ -272,7 +351,7 @@ ParseResult ConfigReader::ParseConfig(const std::string_view& config_path) { std::unordered_set namespaces_with_implicit_flags; // Iterate through the main object to find all namespaces - for (auto field : main_object) { + for (auto field : *config_object) { std::string_view field_name; if (field.unescaped_key().get(field_name)) { return ParseResult::InvalidContent; @@ -280,6 +359,47 @@ ParseResult ConfigReader::ParseConfig(const std::string_view& config_path) { std::string namespace_name(field_name); + if (namespace_name == "$schema") { + continue; + } + + if (namespace_name == "nodeVersion") { + simdjson::ondemand::value version_value; + if (field.value().get(version_value)) { + return ParseResult::InvalidContent; + } + ParseResult result = ParseNodeVersion(&version_value, config_path); + if (result != ParseResult::Valid) { + return result; + } + continue; + } + + if (namespace_name == "configs") { + if (!allow_version_selection) { + FPrintF(stderr, + "\"configs\" is not allowed inside a versioned config " + "for %s\n", + config_path.data()); + return ParseResult::InvalidContent; + } + + simdjson::ondemand::array configs; + auto field_error = field.value().get_array().get(configs); + if (field_error) { + FPrintF(stderr, + "\"configs\" value unexpected for %s " + "(should be an array)\n", + config_path.data()); + return ParseResult::InvalidContent; + } + ParseResult result = ParseConfigs(&configs, config_path); + if (result != ParseResult::Valid) { + return result; + } + continue; + } + // TODO(@marco-ippolito): Remove warning for testRunner namespace if (namespace_name == "testRunner") { FPrintF(stderr, @@ -345,6 +465,81 @@ ParseResult ConfigReader::ParseConfig(const std::string_view& config_path) { return ParseResult::Valid; } +ParseResult ConfigReader::ParseConfig(const std::string_view& config_path) { + std::string file_content; + // Read the configuration file + int r = ReadFileSync(&file_content, config_path.data()); + if (r != 0) { + const char* err = uv_strerror(r); + FPrintF( + stderr, "Cannot read configuration from %s: %s\n", config_path, err); + return ParseResult::FileError; + } + + // Parse the configuration file + simdjson::ondemand::parser json_parser; + simdjson::ondemand::document document; + if (json_parser.iterate(file_content).get(document)) { + FPrintF(stderr, "Can't parse %s\n", config_path.data()); + return ParseResult::InvalidContent; + } + + // Validate config is an object + simdjson::ondemand::object main_object; + auto root_error = document.get_object().get(main_object); + if (root_error) { + if (root_error == simdjson::error_code::INCORRECT_TYPE) { + FPrintF(stderr, + "Root value unexpected not an object for %s\n\n", + config_path.data()); + } else { + FPrintF(stderr, "Can't parse %s\n", config_path.data()); + } + return ParseResult::InvalidContent; + } + + bool has_configs = false; + bool has_other_fields = false; + for (auto field : main_object) { + std::string_view field_name; + if (field.unescaped_key().get(field_name)) { + return ParseResult::InvalidContent; + } + + if (field_name == "$schema") { + continue; + } + + if (field_name == "configs") { + has_configs = true; + } else { + has_other_fields = true; + } + } + + if (has_configs && has_other_fields) { + FPrintF(stderr, + "\"configs\" cannot be mixed with other configuration fields " + "for %s\n", + config_path.data()); + return ParseResult::InvalidContent; + } + + simdjson::ondemand::parser config_parser; + simdjson::ondemand::document config_document; + if (config_parser.iterate(file_content).get(config_document)) { + FPrintF(stderr, "Can't parse %s\n", config_path.data()); + return ParseResult::InvalidContent; + } + + simdjson::ondemand::object config_object; + if (config_document.get_object().get(config_object)) { + return ParseResult::InvalidContent; + } + + return ParseConfigObject(&config_object, config_path, true); +} + std::string ConfigReader::GetNodeOptions() { std::string acc = ""; const size_t total_options = node_options_.size(); diff --git a/src/node_config_file.h b/src/node_config_file.h index afe0e84765b8cb..cc8d8e4c4c235e 100644 --- a/src/node_config_file.h +++ b/src/node_config_file.h @@ -39,6 +39,14 @@ class ConfigReader { size_t GetFlagsSize(); private: + ParseResult ParseConfigObject(simdjson::ondemand::object* config_object, + const std::string_view& config_path, + bool allow_version_selection); + ParseResult ParseNodeVersion(simdjson::ondemand::value* version_value, + const std::string_view& config_path); + ParseResult ParseConfigs(simdjson::ondemand::array* configs, + const std::string_view& config_path); + // Parse options for a specific namespace (including nodeOptions for backward // compatibility) ParseResult ParseOptions(simdjson::ondemand::object* options_object, diff --git a/test/parallel/test-config-file.js b/test/parallel/test-config-file.js index 3c88c16395d53b..104853cdcbe8b0 100644 --- a/test/parallel/test-config-file.js +++ b/test/parallel/test-config-file.js @@ -55,6 +55,233 @@ test('should handle empty object json', async () => { assert.strictEqual(result.code, 0); }); +describe('runtime version checks', () => { + const currentMajor = Number(process.versions.node.split('.')[0]); + + async function runConfig(config, filename = 'version-config.json') { + tmpdir.refresh(); + const configPath = join(tmpdir.path, filename); + writeFileSync(configPath, JSON.stringify(config)); + + return spawnPromisified(process.execPath, [ + '--no-warnings', + `--experimental-config-file=${configPath}`, + '-p', 'http.maxHeaderSize', + ]); + } + + it('should accept a top-level config without nodeVersion', async () => { + const result = await runConfig({ + nodeOptions: { 'max-http-header-size': 10 }, + }, 'top-level-without-version.json'); + assert.strictEqual(result.stderr, ''); + assert.strictEqual(result.stdout, '10\n'); + assert.strictEqual(result.code, 0); + }); + + it('should accept a config file matching the current Node.js version', async () => { + const result = await runConfig({ + nodeVersion: currentMajor, + nodeOptions: { 'max-http-header-size': 10 }, + }, 'matching-version.json'); + assert.strictEqual(result.stderr, ''); + assert.strictEqual(result.stdout, '10\n'); + assert.strictEqual(result.code, 0); + }); + + it('should reject a config file targeting another Node.js version', async () => { + const result = await runConfig({ + nodeVersion: currentMajor + 1, + nodeOptions: { 'max-http-header-size': 10 }, + }, 'mismatching-version.json'); + assert.match(result.stderr, /"nodeVersion" \d+ does not match current Node\.js version \d+/); + assert.strictEqual(result.stdout, ''); + assert.strictEqual(result.code, 9); + }); + + it('should select a matching config from configs', async () => { + const result = await runConfig({ + configs: [ + { + nodeVersion: currentMajor + 1, + config: { + nodeOptions: { 'max-http-header-size': 20 }, + }, + }, + { + nodeVersion: currentMajor, + config: { + nodeOptions: { 'max-http-header-size': 10 }, + }, + }, + ], + }, 'versioned-configs.json'); + assert.strictEqual(result.stderr, ''); + assert.strictEqual(result.stdout, '10\n'); + assert.strictEqual(result.code, 0); + }); + + it('should reject configs without an entry for the current version', async () => { + const result = await runConfig({ + configs: [ + { + nodeVersion: currentMajor + 1, + config: { + nodeOptions: { 'max-http-header-size': 10 }, + }, + }, + ], + }, 'missing-versioned-config.json'); + assert.match(result.stderr, /No config found for current Node\.js version \d+ in "configs"/); + assert.strictEqual(result.stdout, ''); + assert.strictEqual(result.code, 9); + }); + + it('should ignore invalid config payloads for non-matching versions', async () => { + const result = await runConfig({ + configs: [ + { + nodeVersion: currentMajor + 1, + config: false, + }, + { + nodeVersion: currentMajor, + config: { + nodeOptions: { 'max-http-header-size': 10 }, + }, + }, + ], + }, 'ignored-non-matching-config.json'); + assert.strictEqual(result.stderr, ''); + assert.strictEqual(result.stdout, '10\n'); + assert.strictEqual(result.code, 0); + }); + + it('should use the first matching config from configs', async () => { + const result = await runConfig({ + configs: [ + { + nodeVersion: currentMajor, + config: { + nodeOptions: { 'max-http-header-size': 10 }, + }, + }, + { + nodeVersion: currentMajor, + config: { + nodeOptions: { 'max-http-header-size': 20 }, + }, + }, + ], + }, 'first-matching-versioned-config.json'); + assert.strictEqual(result.stderr, ''); + assert.strictEqual(result.stdout, '10\n'); + assert.strictEqual(result.code, 0); + }); + + it('should allow $schema with configs', async () => { + const result = await runConfig({ + $schema: 'https://nodejs.org/dist/vX.Y.Z/docs/node-config-schema.json', + configs: [ + { + nodeVersion: currentMajor, + config: { + $schema: 'https://nodejs.org/dist/vX.Y.Z/docs/node-config-schema.json', + nodeOptions: { 'max-http-header-size': 10 }, + }, + }, + ], + }, 'schema-with-versioned-config.json'); + assert.strictEqual(result.stderr, ''); + assert.strictEqual(result.stdout, '10\n'); + assert.strictEqual(result.code, 0); + }); + + for (const { name, config, error } of [ + { + name: 'configs is empty', + config: { configs: [] }, + error: /No config found for current Node\.js version \d+ in "configs"/, + }, + { + name: 'configs is not an array', + config: { configs: {} }, + error: /"configs" value unexpected .* \(should be an array\)/, + }, + { + name: 'configs contains a non-object entry', + config: { configs: [false] }, + error: /"configs\[0\]" value unexpected .* \(should be an object\)/, + }, + { + name: 'configs entry is missing nodeVersion', + config: { configs: [{ config: {} }] }, + error: /"configs\[0\]\.nodeVersion" is required/, + }, + { + name: 'configs entry has a non-integer nodeVersion', + config: { configs: [{ nodeVersion: `${currentMajor}`, config: {} }] }, + error: /"configs\[0\]\.nodeVersion" value unexpected .* \(should be an integer\)/, + }, + { + name: 'matching configs entry is missing config', + config: { configs: [{ nodeVersion: currentMajor }] }, + error: /"configs\[0\]\.config" is required/, + }, + { + name: 'matching configs entry has a non-object config', + config: { configs: [{ nodeVersion: currentMajor, config: false }] }, + error: /"configs\[0\]\.config" value unexpected .* \(should be an object\)/, + }, + { + name: 'configs is mixed with preceding config fields', + config: { + nodeOptions: { 'max-http-header-size': 10 }, + configs: [{ nodeVersion: currentMajor, config: {} }], + }, + error: /"configs" cannot be mixed with other configuration fields/, + }, + { + name: 'configs is mixed with following config fields', + config: { + configs: [{ nodeVersion: currentMajor, config: {} }], + nodeOptions: { 'max-http-header-size': 10 }, + }, + error: /"configs" cannot be mixed with other configuration fields/, + }, + { + name: 'configs is nested inside a selected config', + config: { + configs: [{ + nodeVersion: currentMajor, + config: { configs: [] }, + }], + }, + error: /"configs" is not allowed inside a versioned config/, + }, + { + name: 'selected config targets another version', + config: { + configs: [{ + nodeVersion: currentMajor, + config: { + nodeVersion: currentMajor + 1, + nodeOptions: { 'max-http-header-size': 10 }, + }, + }], + }, + error: /"nodeVersion" \d+ does not match current Node\.js version \d+/, + }, + ]) { + it(`should reject when ${name}`, async () => { + const result = await runConfig(config); + assert.match(result.stderr, error); + assert.strictEqual(result.stdout, ''); + assert.strictEqual(result.code, 9); + }); + } +}); + test('should parse boolean flag', onlyWithAmaroAndNodeOptions, async () => { const result = await spawnPromisified(process.execPath, [ `--experimental-config-file=${fixtures.path('rc/strip-types.json')}`, From 18000498dad36557e6bdf01ee608cd6268ac765a Mon Sep 17 00:00:00 2001 From: Marco Ippolito Date: Wed, 29 Apr 2026 12:18:20 +0200 Subject: [PATCH 080/168] doc: document the latest-vX.x schema Signed-off-by: Marco Ippolito PR-URL: https://github.com/nodejs/node/pull/63033 Reviewed-By: Pietro Marchini Reviewed-By: James M Snell --- doc/api/cli.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/doc/api/cli.md b/doc/api/cli.md index 8933fc67baedc8..03498339ec5e70 100644 --- a/doc/api/cli.md +++ b/doc/api/cli.md @@ -1064,7 +1064,8 @@ The alias `--experimental-default-config-file` is equivalent to `--experimental-config-file` without an argument. Node.js will read the configuration file and apply the settings. The configuration file should be a JSON file with the following structure. `vX.Y.Z` -in the `$schema` must be replaced with the version of Node.js you are using. +in the `$schema` must be replaced with the version of Node.js you are using or +`latest-vX.x` for the latest version of that major release line. ```json { From 3c2d2e3221a942fb84b8cad9e5707330caa172d3 Mon Sep 17 00:00:00 2001 From: James M Snell Date: Wed, 6 May 2026 04:27:24 -0700 Subject: [PATCH 081/168] quic: ignore coverage for quic files Since they aren't built by default Signed-off-by: James M Snell PR-URL: https://github.com/nodejs/node/pull/63149 Reviewed-By: Matteo Collina Reviewed-By: Filip Skokan Reviewed-By: Moshe Atlow Reviewed-By: Tim Perry --- lib/internal/quic/diagnostics.js | 6 ++++++ lib/internal/quic/state.js | 6 ++++++ lib/internal/quic/stats.js | 6 ++++++ lib/internal/quic/symbols.js | 6 ++++++ 4 files changed, 24 insertions(+) diff --git a/lib/internal/quic/diagnostics.js b/lib/internal/quic/diagnostics.js index 7e11de4ef36ae1..68ff078af3955b 100644 --- a/lib/internal/quic/diagnostics.js +++ b/lib/internal/quic/diagnostics.js @@ -1,5 +1,9 @@ 'use strict'; +// TODO(@jasnell) Temporarily ignoring c8 covrerage for this file while tests +// are still being developed. +/* c8 ignore start */ + const dc = require('diagnostics_channel'); const onEndpointCreatedChannel = dc.channel('quic.endpoint.created'); @@ -69,3 +73,5 @@ module.exports = { onSessionErrorChannel, onEndpointConnectChannel, }; + +/* c8 ignore stop */ diff --git a/lib/internal/quic/state.js b/lib/internal/quic/state.js index 1bca0b6619bc3e..efaccb4aa00527 100644 --- a/lib/internal/quic/state.js +++ b/lib/internal/quic/state.js @@ -1,5 +1,9 @@ 'use strict'; +// TODO(@jasnell) Temporarily ignoring c8 covrerage for this file while tests +// are still being developed. +/* c8 ignore start */ + const { ArrayBuffer, DataView, @@ -806,3 +810,5 @@ module.exports = { QuicSessionState, QuicStreamState, }; + +/* c8 ignore stop */ diff --git a/lib/internal/quic/stats.js b/lib/internal/quic/stats.js index 1c64b7c8227f68..280cf5a26f419b 100644 --- a/lib/internal/quic/stats.js +++ b/lib/internal/quic/stats.js @@ -1,5 +1,9 @@ 'use strict'; +// TODO(@jasnell) Temporarily ignoring c8 covrerage for this file while tests +// are still being developed. +/* c8 ignore start */ + const { BigUint64Array, JSONStringify, @@ -743,3 +747,5 @@ module.exports = { QuicSessionStats, QuicStreamStats, }; + +/* c8 ignore stop */ diff --git a/lib/internal/quic/symbols.js b/lib/internal/quic/symbols.js index 973db27bc7cae9..9a8e9155f0b636 100644 --- a/lib/internal/quic/symbols.js +++ b/lib/internal/quic/symbols.js @@ -1,5 +1,9 @@ 'use strict'; +// TODO(@jasnell) Temporarily ignoring c8 covrerage for this file while tests +// are still being developed. +/* c8 ignore start */ + const { Symbol, } = primordials; @@ -92,3 +96,5 @@ module.exports = { kWantsHeaders, kWantsTrailers, }; + +/* c8 ignore stop */ From 1b04f162f40b7de2f4ca862d4aa4141c1ca3f729 Mon Sep 17 00:00:00 2001 From: Anshika Jain Date: Thu, 7 May 2026 00:19:27 +0530 Subject: [PATCH 082/168] doc: add Hmac.digest() documentation-only deprecation (DEP0206) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: anshikakalpana PR-URL: https://github.com/nodejs/node/pull/63121 Refs: https://github.com/nodejs/node/issues/62838 Reviewed-By: René Reviewed-By: Filip Skokan Reviewed-By: James M Snell --- doc/api/deprecations.md | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/doc/api/deprecations.md b/doc/api/deprecations.md index c9b286120b4448..68dd5a4a36561c 100644 --- a/doc/api/deprecations.md +++ b/doc/api/deprecations.md @@ -4558,6 +4558,22 @@ that have proven unresolveable. See [caveats of asynchronous customization hooks `module.registerHooks()` as soon as possible as `module.register()` will be removed in a future version of Node.js. +### DEP0206: Calling `digest()` on an already-finalized `Hmac` instance + + + +Type: Documentation-only + +Calling `hmac.digest()` more than once returns an empty buffer instead of +throwing an error. This behavior is inconsistent with `hash.digest()` and +may lead to subtle bugs. Calling `hmac.digest()` on a finalized `Hmac` instance +will throw an error in a future version. + [DEP0142]: #dep0142-repl_builtinlibs [NIST SP 800-38D]: https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf [RFC 6066]: https://tools.ietf.org/html/rfc6066#section-3 From dc99d18597a21a205692e7ff39e53ba55005b9e8 Mon Sep 17 00:00:00 2001 From: Rafael Gonzaga Date: Wed, 6 May 2026 16:21:11 -0300 Subject: [PATCH 083/168] lib: handle --permission-audit when propagating flags Signed-off-by: RafaelGSS PR-URL: https://github.com/nodejs/node/pull/63047 Reviewed-By: Paolo Insogna Reviewed-By: James M Snell --- lib/child_process.js | 3 +- lib/ffi.js | 6 +- lib/internal/process/permission.js | 10 +- ...ssion-audit-child-process-inherit-flags.js | 93 +++++++++++++++++++ 4 files changed, 109 insertions(+), 3 deletions(-) create mode 100644 test/parallel/test-permission-audit-child-process-inherit-flags.js diff --git a/lib/child_process.js b/lib/child_process.js index bba860a78fe20e..824af65556e32b 100644 --- a/lib/child_process.js +++ b/lib/child_process.js @@ -549,7 +549,8 @@ function getPermissionModelFlagsToCopy() { function copyPermissionModelFlagsToEnv(env, key, args) { // Do not override if permission was already passed to file - if (args.includes('--permission') || (env[key] && env[key].indexOf('--permission') !== -1)) { + if (args.includes('--permission') || args.includes('--permission-audit') || + (env[key] && env[key].indexOf('--permission') !== -1)) { return; } diff --git a/lib/ffi.js b/lib/ffi.js index 98af095e0cb01c..b3a1563b520dcc 100644 --- a/lib/ffi.js +++ b/lib/ffi.js @@ -61,7 +61,11 @@ DynamicLibrary.prototype[SymbolDispose] = function() { }; function checkFFIPermission() { - if (!permission.isEnabled() || permission.has('ffi')) { + if (!permission.isEnabled()) { + return; + } + + if (permission.has('ffi') || permission.isAuditMode()) { return; } diff --git a/lib/internal/process/permission.js b/lib/internal/process/permission.js index 97ea0265fa15d9..b5da69d08c455e 100644 --- a/lib/internal/process/permission.js +++ b/lib/internal/process/permission.js @@ -11,6 +11,7 @@ const { Buffer } = require('buffer'); const { isBuffer } = Buffer; let _permission; +let _audit; let _ffi; module.exports = ObjectFreeze({ @@ -18,10 +19,17 @@ module.exports = ObjectFreeze({ isEnabled() { if (_permission === undefined) { const { getOptionValue } = require('internal/options'); - _permission = getOptionValue('--permission'); + _permission = getOptionValue('--permission') || getOptionValue('--permission-audit'); } return _permission; }, + isAuditMode() { + if (_audit === undefined) { + const { getOptionValue } = require('internal/options'); + _audit = getOptionValue('--permission-audit'); + } + return _audit; + }, has(scope, reference) { validateString(scope, 'scope'); if (reference != null) { diff --git a/test/parallel/test-permission-audit-child-process-inherit-flags.js b/test/parallel/test-permission-audit-child-process-inherit-flags.js new file mode 100644 index 00000000000000..ec22220c4b2660 --- /dev/null +++ b/test/parallel/test-permission-audit-child-process-inherit-flags.js @@ -0,0 +1,93 @@ +// Flags: --permission-audit --allow-child-process --allow-fs-read=* --allow-fs-write=* +'use strict'; + +const common = require('../common'); +const { isMainThread } = require('worker_threads'); + +if (!isMainThread) { + common.skip('This test only works on a main thread'); +} +if (process.config.variables.node_without_node_options) { + common.skip('missing NODE_OPTIONS support'); +} + +const assert = require('assert'); +const childProcess = require('child_process'); + +// Verify that the parent is running in audit mode +assert.strictEqual(typeof process.permission.has, 'function'); + +{ + assert.strictEqual(process.env.NODE_OPTIONS, undefined); +} + +// Child should inherit --permission-audit and the allow-flags via NODE_OPTIONS +{ + const { status, stdout } = childProcess.spawnSync(process.execPath, + [ + '-e', + ` + console.log(typeof process.permission); + console.log(process.permission.has("fs.write")); + console.log(process.permission.has("fs.read")); + console.log(process.permission.has("child")); + `, + ] + ); + assert.strictEqual(status, 0); + const [permType, fsWrite, fsRead, child] = stdout.toString().split('\n'); + assert.strictEqual(permType, 'object'); + assert.strictEqual(fsWrite, 'true'); + assert.strictEqual(fsRead, 'true'); + assert.strictEqual(child, 'true'); +} + +// Child spawned with explicit --permission should use its own flags, not inherit parent's +{ + const { status, stdout } = childProcess.spawnSync( + process.execPath, + [ + '--permission', + '--allow-fs-write=*', + '-e', + ` + console.log(typeof process.permission); + console.log(process.permission.has("fs.write")); + console.log(process.permission.has("fs.read")); + console.log(process.permission.has("child")); + `, + ] + ); + assert.strictEqual(status, 0); + const [permType, fsWrite, fsRead, child] = stdout.toString().split('\n'); + assert.strictEqual(permType, 'object'); + assert.strictEqual(fsWrite, 'true'); + assert.strictEqual(fsRead, 'false'); + assert.strictEqual(child, 'false'); +} + +// Child spawned with explicit --permission-audit should use its own flags +{ + const { status, stdout } = childProcess.spawnSync( + process.execPath, + [ + '--permission-audit', + '--allow-fs-write=*', + '-e', + ` + console.log(typeof process.permission); + console.log(process.permission.has("fs.write")); + console.log(process.permission.has("fs.read")); + `, + ] + ); + assert.strictEqual(status, 0); + const [permType, fsWrite, fsRead] = stdout.toString().split('\n'); + assert.strictEqual(permType, 'object'); + assert.strictEqual(fsWrite, 'true'); + assert.strictEqual(fsRead, 'false'); +} + +{ + assert.strictEqual(process.env.NODE_OPTIONS, undefined); +} From 2f5d7e77def6f501cc230f40f993d4d3446f177e Mon Sep 17 00:00:00 2001 From: Jordan Harband Date: Wed, 6 May 2026 15:47:41 -0700 Subject: [PATCH 084/168] module: exclude `node:ffi` from `builtinModules` when not enabled MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `Module.builtinModules` is supposed to only list modules that are accessible to user code. `node:ffi` requires `--experimental-ffi` to be required, so filter it out when the flag is not set, mirroring the existing handling for `--experimental-quic`. Refs: https://github.com/nodejs/node/pull/63137#issuecomment-4390371187 Signed-off-by: Jordan Harband PR-URL: https://github.com/nodejs/node/pull/63158 Reviewed-By: Antoine du Hamel Reviewed-By: Michaël Zasso Reviewed-By: Filip Skokan Reviewed-By: Jacob Smith Reviewed-By: Luigi Pinca Reviewed-By: Bryan English Reviewed-By: Matteo Collina --- lib/internal/modules/cjs/loader.js | 3 +++ test/ffi/test-ffi-module.js | 22 +++++++++++----------- 2 files changed, 14 insertions(+), 11 deletions(-) diff --git a/lib/internal/modules/cjs/loader.js b/lib/internal/modules/cjs/loader.js index 0b59d7e7a0f911..c9cf6a0f82bb86 100644 --- a/lib/internal/modules/cjs/loader.js +++ b/lib/internal/modules/cjs/loader.js @@ -490,6 +490,9 @@ function initializeCJS() { if (!getOptionValue('--experimental-quic')) { modules = modules.filter((i) => i !== 'node:quic'); } + if (!getOptionValue('--experimental-ffi')) { + modules = modules.filter((i) => i !== 'node:ffi'); + } Module.builtinModules = ObjectFreeze(modules); initializeCjsConditions(); diff --git a/test/ffi/test-ffi-module.js b/test/ffi/test-ffi-module.js index 1cd2b840097d6b..573c5e7ce5947b 100644 --- a/test/ffi/test-ffi-module.js +++ b/test/ffi/test-ffi-module.js @@ -1,6 +1,7 @@ // Flags: --experimental-ffi 'use strict'; const common = require('../common'); +const { spawnSyncAndAssert } = require('../common/child_process'); const assert = require('node:assert'); const { spawnSync } = require('node:child_process'); const { test } = require('node:test'); @@ -32,17 +33,16 @@ test('ffi builtin is unavailable when disabled', () => { }); test('ffi builtin is listed', () => { - const { stdout, stderr, status, signal } = spawnSync(process.execPath, [ - '-p', - 'require("node:module").builtinModules.includes("node:ffi")', - ], { - encoding: 'utf8', - }); - - assert.strictEqual(stdout.trim(), 'true'); - assert.strictEqual(stderr, ''); - assert.strictEqual(status, 0); - assert.strictEqual(signal, null); + for (const [flag, stdout] of Object.entries({ + '--experimental-ffi': 'true\n', + '--no-experimental-ffi': 'false\n', + })) { + spawnSyncAndAssert(process.execPath, [ + flag, + '-p', + 'require("node:module").builtinModules.includes("node:ffi")', + ], { stdout }); + } }); test('ffi can be imported from ESM', () => { From b5da7515f9d9b8d3daf561b9b5beba78055db194 Mon Sep 17 00:00:00 2001 From: Matteo Collina Date: Thu, 7 May 2026 01:09:55 +0200 Subject: [PATCH 085/168] sqlite: keep source database alive during backup MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Matteo Collina PR-URL: https://github.com/nodejs/node/pull/62673 Reviewed-By: Daniel Lemire Reviewed-By: Tobias Nießen Reviewed-By: Edy Silva Reviewed-By: James M Snell --- src/node_sqlite.cc | 16 +++++++++-- test/parallel/test-sqlite-backup.mjs | 41 ++++++++++++++++++++++++++++ 2 files changed, 54 insertions(+), 3 deletions(-) diff --git a/src/node_sqlite.cc b/src/node_sqlite.cc index d9f979c36b3ce5..35dbe1ffc50772 100644 --- a/src/node_sqlite.cc +++ b/src/node_sqlite.cc @@ -565,8 +565,10 @@ class BackupJob : public ThreadPoolWork { TryCatch try_catch(env()->isolate()); USE(fn->Call(env()->context(), Null(env()->isolate()), 1, argv)); if (try_catch.HasCaught()) { + Local exception = try_catch.Exception(); Finalize(); - resolver->Reject(env()->context(), try_catch.Exception()).ToChecked(); + resolver->Reject(env()->context(), exception).ToChecked(); + delete this; return; } } @@ -585,11 +587,15 @@ class BackupJob : public ThreadPoolWork { resolver ->Resolve(env()->context(), Integer::New(env()->isolate(), total_pages)) .ToChecked(); + delete this; } void Finalize() { Cleanup(); - source_->RemoveBackup(this); + if (source_) { + source_->RemoveBackup(this); + source_.reset(); + } } void Cleanup() { @@ -610,28 +616,32 @@ class BackupJob : public ThreadPoolWork { Local e; if (!CreateSQLiteError(env()->isolate(), dest_).ToLocal(&e)) { Finalize(); + delete this; return; } Finalize(); resolver->Reject(env()->context(), e).ToChecked(); + delete this; } void HandleBackupError(Local resolver, int errcode) { Local e; if (!CreateSQLiteError(env()->isolate(), errcode).ToLocal(&e)) { Finalize(); + delete this; return; } Finalize(); resolver->Reject(env()->context(), e).ToChecked(); + delete this; } Environment* env() const { return env_; } Environment* env_; - DatabaseSync* source_; + BaseObjectPtr source_; Global resolver_; Global progressFunc_; sqlite3* dest_ = nullptr; diff --git a/test/parallel/test-sqlite-backup.mjs b/test/parallel/test-sqlite-backup.mjs index 519555479642e0..80061ee6601d72 100644 --- a/test/parallel/test-sqlite-backup.mjs +++ b/test/parallel/test-sqlite-backup.mjs @@ -1,3 +1,4 @@ +// Flags: --expose-gc import { isWindows, skipIfSQLiteMissing } from '../common/index.mjs'; import tmpdir from '../common/tmpdir.js'; import { join } from 'node:path'; @@ -314,3 +315,43 @@ test('backup has correct name and length', (t) => { t.assert.strictEqual(backup.name, 'backup'); t.assert.strictEqual(backup.length, 2); }); + +test('source database is kept alive while a backup is in flight', async (t) => { + // Regression test: previously, BackupJob stored a raw DatabaseSync* and the + // source could be garbage-collected while the backup was still running, + // leading to a use-after-free when BackupJob::Finalize() dereferenced the + // stale pointer via source_->RemoveBackup(this). + const destDb = nextDb(); + + let database = makeSourceDb(); + // Insert enough rows to ensure the backup takes multiple steps. + const insert = database.prepare('INSERT INTO data (key, value) VALUES (?, ?)'); + for (let i = 3; i <= 500; i++) { + insert.run(i, 'A'.repeat(1024) + i); + } + + const p = backup(database, destDb, { + rate: 1, + progress() {}, + }); + // Drop the last strong JS reference to the source database. With the bug, + // the DatabaseSync could be collected here and the in-flight backup would + // later crash while accessing the freed source. + database = null; + + // Nudge the GC aggressively, but the backup must keep the source alive + // regardless. Without the fix, the source DatabaseSync would be collected + // and BackupJob::Finalize() would crash the process. + for (let i = 0; i < 5; i++) { + global.gc(); + await new Promise((resolve) => setImmediate(resolve)); + } + + const totalPages = await p; + t.assert.ok(totalPages > 0); + + const backupDb = new DatabaseSync(destDb); + t.after(() => { backupDb.close(); }); + const rows = backupDb.prepare('SELECT COUNT(*) AS n FROM data').get(); + t.assert.strictEqual(rows.n, 500); +}); From a725fe138900d927f7cb6467f7d2a74c801bb1da Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Thu, 7 May 2026 00:56:44 +0200 Subject: [PATCH 086/168] 2026-05-07, Version 26.1.0 (Current) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Notable changes: buffer: * (SEMVER-MINOR) add `end` parameter (Robert Nagy) https://github.com/nodejs/node/pull/62390 crypto: * (SEMVER-MINOR) accept key data in `crypto.diffieHellman()` and cleanup DH jobs (Filip Skokan) https://github.com/nodejs/node/pull/62527 * (SEMVER-MINOR) implement `randomUUIDv7()` (nabeel378) https://github.com/nodejs/node/pull/62553 debugger: * (SEMVER-MINOR) add edit-free runtime expression probes to `node inspect` (Joyee Cheung) https://github.com/nodejs/node/pull/62713 fs: * (SEMVER-MINOR) add `signal` option to `fs.stat()` (Mert Can Altin) https://github.com/nodejs/node/pull/57775 * (SEMVER-MINOR) expose frsize field in statfs (Jinho Jang) https://github.com/nodejs/node/pull/62277 http: * (SEMVER-MINOR) harden `ClientRequest` options merge (Matteo Collina) https://github.com/nodejs/node/pull/63082 * (SEMVER-MINOR) add `req.signal` to `IncomingMessage` (Akshat) https://github.com/nodejs/node/pull/62541 lib,src,test,doc: * (SEMVER-MINOR) add `node:ffi` module (Colin Ihrig) https://github.com/nodejs/node/pull/62072 process: * (SEMVER-MINOR) throw on `execve(2)` failure instead of aborting (Bryan English) https://github.com/nodejs/node/pull/62878 src: * (SEMVER-MINOR) allow empty `--experimental-config-file` (Marco Ippolito) https://github.com/nodejs/node/pull/61610 stream: * (SEMVER-MINOR) propagate destruction in `duplexPair` (Ahmed Elhor) https://github.com/nodejs/node/pull/61098 test_runner: * (SEMVER-MINOR) align mock timeout api (sangwook) https://github.com/nodejs/node/pull/62820 * (SEMVER-MINOR) add mock-timers support for `AbortSignal.timeout` (DeveloperViraj) https://github.com/nodejs/node/pull/60751 * (SEMVER-MINOR) support test order randomization (Pietro Marchini) https://github.com/nodejs/node/pull/61747 util: * (SEMVER-MINOR) colorize text with hex colors (Guilherme Araújo) https://github.com/nodejs/node/pull/61556 PR-URL: https://github.com/nodejs/node/pull/63137 --- CHANGELOG.md | 3 +- doc/api/async_context.md | 3 - doc/api/buffer.md | 6 +- doc/api/cli.md | 9 +- doc/api/crypto.md | 10 +- doc/api/debugger.md | 2 +- doc/api/diagnostics_channel.md | 21 +-- doc/api/errors.md | 2 +- doc/api/ffi.md | 32 ++-- doc/api/fs.md | 15 +- doc/api/http.md | 2 +- doc/api/module.md | 5 - doc/api/n-api.md | 2 +- doc/api/process.md | 4 +- doc/api/quic.md | 7 +- doc/api/repl.md | 1 - doc/api/sqlite.md | 4 +- doc/api/stream.md | 2 +- doc/api/stream_iter.md | 36 +--- doc/api/test.md | 12 +- doc/api/util.md | 2 +- doc/api/v8.md | 8 +- doc/api/webcrypto.md | 18 +- doc/changelogs/CHANGELOG_V26.md | 324 ++++++++++++++++++++++++++++++++ 24 files changed, 399 insertions(+), 131 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index a6f69fa6f6b1ec..d3752d6414964f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -43,7 +43,8 @@ release. -26.0.0
+26.1.0
+26.0.0
25.9.0
diff --git a/doc/api/async_context.md b/doc/api/async_context.md index 5b18c8efdc0513..372bf9231e869c 100644 --- a/doc/api/async_context.md +++ b/doc/api/async_context.md @@ -390,7 +390,6 @@ try { @@ -530,7 +529,6 @@ probably responsible for the context loss. @@ -548,7 +546,6 @@ exits, whether through normal completion or by throwing an error. diff --git a/doc/api/buffer.md b/doc/api/buffer.md index c5639e1bdf3737..9e6eabb77caa1e 100644 --- a/doc/api/buffer.md +++ b/doc/api/buffer.md @@ -2074,7 +2074,7 @@ console.log(buf.fill('zz', 'hex')); > Stability: 1.1 - Active development @@ -1225,7 +1225,7 @@ Enable exposition of [EventSource Web API][] on the global scope. ### `--experimental-ffi` > Stability: 1 - Experimental @@ -1365,7 +1365,6 @@ Enable experimental support for storage inspection @@ -2877,7 +2876,7 @@ option set. This flag is not necessary when test isolation is disabled. ### `--test-random-seed` Set the seed used to randomize test execution order. This applies to both test @@ -2891,7 +2890,7 @@ This flag cannot be used with `--watch` or `--test-rerun-failures`. ### `--test-randomize` Randomize test execution order. This applies to both test file execution order diff --git a/doc/api/crypto.md b/doc/api/crypto.md index 1d0f081834318f..e8583803e768b1 100644 --- a/doc/api/crypto.md +++ b/doc/api/crypto.md @@ -2399,7 +2399,7 @@ type, value, and parameters. This method is not * `options` {Object} diff --git a/doc/api/debugger.md b/doc/api/debugger.md index a8a0d7b06332a2..691b025c1d9929 100644 --- a/doc/api/debugger.md +++ b/doc/api/debugger.md @@ -94,7 +94,7 @@ command. > Stability: 1 - Experimental diff --git a/doc/api/diagnostics_channel.md b/doc/api/diagnostics_channel.md index 661866bb261720..fb1bf6e93f2948 100644 --- a/doc/api/diagnostics_channel.md +++ b/doc/api/diagnostics_channel.md @@ -285,7 +285,7 @@ const channelsByCollection = diagnostics_channel.tracingChannel({ #### `diagnostics_channel.boundedChannel(nameOrChannels)` > Stability: 1 - Experimental @@ -670,7 +670,7 @@ channel.runStores({ some: 'message' }, () => { #### `channel.withStoreScope(data)` > Stability: 1 - Experimental @@ -727,7 +727,7 @@ ch.bindStore(store, (message) => { ### Class: `RunStoresScope` > Stability: 1 - Experimental @@ -1147,7 +1147,7 @@ if (channels.hasSubscribers) { ### Class: `BoundedChannel` > Stability: 1 - Experimental @@ -1165,7 +1165,7 @@ dynamically. #### `boundedChannel.hasSubscribers` * Returns: {boolean} `true` if any of the individual channels has a subscriber, @@ -1196,7 +1196,7 @@ if (wc.hasSubscribers) { #### `boundedChannel.subscribe(handlers)` * `handlers` {Object} Set of channel subscribers @@ -1239,7 +1239,7 @@ wc.subscribe({ #### `boundedChannel.unsubscribe(handlers)` * `handlers` {Object} Set of channel subscribers @@ -1282,7 +1282,7 @@ wc.unsubscribe(handlers); #### `boundedChannel.run(context, fn[, thisArg[, ...args]])` * `context` {Object} Shared object to correlate events through @@ -1321,7 +1321,7 @@ const result = wc.run({ operationId: '123' }, () => { #### `boundedChannel.withScope([context])` * `context` {Object} Shared object to correlate events through @@ -1366,7 +1366,7 @@ const context = { operationId: '123' }; ### Class: `BoundedChannelScope` > Stability: 1 - Experimental @@ -1859,7 +1859,6 @@ Emitted when [`process.execve()`][] is invoked. diff --git a/doc/api/errors.md b/doc/api/errors.md index cc7c668267fd6b..2275835e40b26e 100644 --- a/doc/api/errors.md +++ b/doc/api/errors.md @@ -2756,7 +2756,7 @@ ES modules. When `require()` encounters an ES module that contains top-level ### `ERR_REQUIRE_ESM_RACE_CONDITION` > Stability: 1 - Experimental. diff --git a/doc/api/ffi.md b/doc/api/ffi.md index 930ad70afc0155..382b95fa07c3e3 100644 --- a/doc/api/ffi.md +++ b/doc/api/ffi.md @@ -1,9 +1,9 @@ # FFI - + > Stability: 1 - Experimental @@ -140,7 +140,7 @@ const signature = { ## `ffi.suffix` * {string} @@ -162,7 +162,7 @@ const path = `libsqlite3.${suffix}`; ## `ffi.dlopen(path[, definitions])` * `path` {string|null} Path to a dynamic library, or `null` to resolve symbols @@ -222,7 +222,7 @@ console.log(functions.add_i32(20, 22)); ## `ffi.dlclose(handle)` * `handle` {DynamicLibrary} @@ -234,7 +234,7 @@ This is equivalent to calling `handle.close()`. ## `ffi.dlsym(handle, symbol)` * `handle` {DynamicLibrary} @@ -248,7 +248,7 @@ This is equivalent to calling `handle.getSymbol(symbol)`. ## Class: `DynamicLibrary` Represents a loaded dynamic library. @@ -328,7 +328,7 @@ closed. ### `library[Symbol.dispose]()` Calls `library.close()`. This allows `DynamicLibrary` instances to be used with @@ -532,7 +532,7 @@ process. ## `ffi.toString(pointer)` * `pointer` {bigint} @@ -557,7 +557,7 @@ const value = toString(ptr); ## `ffi.toBuffer(pointer, length[, copy])` * `pointer` {bigint} @@ -588,7 +588,7 @@ memory or crash the process. ## `ffi.toArrayBuffer(pointer, length[, copy])` * `pointer` {bigint} @@ -612,7 +612,7 @@ entire exposed range. ## `ffi.exportString(string, pointer, length[, encoding])` * `string` {string} @@ -635,7 +635,7 @@ available storage. This function does not allocate memory on its own. ## `ffi.exportBuffer(buffer, pointer, length)` * `buffer` {Buffer} @@ -654,7 +654,7 @@ available storage. This function does not allocate memory on its own. ## `ffi.exportArrayBuffer(arrayBuffer, pointer, length)` * `arrayBuffer` {ArrayBuffer} @@ -671,7 +671,7 @@ available storage. This function does not allocate memory on its own. ## `ffi.exportArrayBufferView(arrayBufferView, pointer, length)` * `arrayBufferView` {ArrayBufferView} @@ -688,7 +688,7 @@ available storage. This function does not allocate memory on its own. ## `ffi.getRawPointer(source)` * `source` {Buffer|ArrayBuffer|ArrayBufferView} diff --git a/doc/api/fs.md b/doc/api/fs.md index 03f4a77989c9af..c5e908aaa39f6c 100644 --- a/doc/api/fs.md +++ b/doc/api/fs.md @@ -381,7 +381,6 @@ added: v10.0.0 @@ -460,7 +459,6 @@ run().catch(console.error); @@ -782,7 +780,7 @@ Read from a file and write to an array of {ArrayBufferView}s @@ -1357,7 +1354,7 @@ behavior is similar to `cp dir1/ dir2/`. * Type: {number|bigint} diff --git a/doc/api/http.md b/doc/api/http.md index 0c7cfa5a858977..95674770153bf4 100644 --- a/doc/api/http.md +++ b/doc/api/http.md @@ -3003,7 +3003,7 @@ Calls `message.socket.setTimeout(msecs, callback)`. ### `message.signal` * Type: {AbortSignal} diff --git a/doc/api/module.md b/doc/api/module.md index 902b8dc0672265..79d6c816cae23d 100644 --- a/doc/api/module.md +++ b/doc/api/module.md @@ -179,17 +179,12 @@ added: - v20.6.0 - v18.19.0 deprecated: - - v26.0.0 - v25.9.0 - v24.15.0 changes: - version: v26.0.0 pr-url: https://github.com/nodejs/node/pull/62401 description: Runtime deprecation (DEP0205). - - version: v25.9.0 - pr-url: https://github.com/nodejs/node/pull/62395 - description: Documentation-only deprecation (DEP0205). Use - `module.registerHooks()` instead. - version: - v23.6.1 - v22.13.1 diff --git a/doc/api/n-api.md b/doc/api/n-api.md index 18cfa7dc8ab7ba..f3374909bee20c 100644 --- a/doc/api/n-api.md +++ b/doc/api/n-api.md @@ -2578,7 +2578,7 @@ JavaScript `ArrayBuffer`s are described in #### `node_api_create_external_sharedarraybuffer` ```c diff --git a/doc/api/process.md b/doc/api/process.md index 616dcbd933cdb3..d8d022799a7016 100644 --- a/doc/api/process.md +++ b/doc/api/process.md @@ -740,7 +740,6 @@ This feature is not available in [`Worker`][] threads. @@ -1738,7 +1737,7 @@ added: - v23.11.0 - v22.15.0 changes: - - version: REPLACEME + - version: v26.1.0 pr-url: https://github.com/nodejs/node/pull/62878 description: A failed `execve(2)` system call now throws an exception instead of aborting the process. Native `AtExit` @@ -4080,7 +4079,6 @@ This implies calling `module.setSourceMapsSupport()` with an option added: v9.3.0 changes: - version: - - v26.0.0 - v25.9.0 pr-url: https://github.com/nodejs/node/pull/61227 description: Use `process.addUncaughtExceptionCaptureCallback()` to diff --git a/doc/api/quic.md b/doc/api/quic.md index ddf0c9331ef533..f7f915fa321657 100644 --- a/doc/api/quic.md +++ b/doc/api/quic.md @@ -239,7 +239,7 @@ The valid range is `0` to `65535`. ### `endpoint.setSNIContexts(entries[, options])` * `entries` {object} An object mapping host names to TLS identity options. @@ -2024,7 +2024,7 @@ added: v23.8.0 #### `sessionOptions.alpn` * Type: {string} (client) | {string\[]} (server) @@ -2187,7 +2187,6 @@ can be used with tools such as Wireshark to decrypt captured QUIC traffic. added: v23.8.0 changes: - version: - - v26.0.0 - v25.9.0 - v24.15.0 pr-url: https://github.com/nodejs/node/pull/62335 @@ -2354,7 +2353,7 @@ The peer server name to target (SNI). Defaults to `'localhost'`. #### `sessionOptions.sni` (server only) * Type: {Object} diff --git a/doc/api/repl.md b/doc/api/repl.md index 67d4b8fe538fd8..eceea9a4615ec3 100644 --- a/doc/api/repl.md +++ b/doc/api/repl.md @@ -710,7 +710,6 @@ npx codemod@latest @nodejs/repl-builtin-modules added: v0.1.91 changes: - version: - - v26.0.0 - v25.9.0 pr-url: https://github.com/nodejs/node/pull/62188 description: The `handleError` parameter has been added. diff --git a/doc/api/sqlite.md b/doc/api/sqlite.md index 835784987f1f63..ec9c1ad4e8828f 100644 --- a/doc/api/sqlite.md +++ b/doc/api/sqlite.md @@ -538,7 +538,7 @@ the constructor. An exception is thrown if the database is already open. ### `database.serialize([dbName])` * `dbName` {string} Name of the database to serialize. This can be `'main'` @@ -573,7 +573,7 @@ console.log(buffer.length); // Prints the byte length of the database ### `database.deserialize(buffer[, options])` * `buffer` {Uint8Array} A binary representation of a database, such as the diff --git a/doc/api/stream.md b/doc/api/stream.md index 2a4b168b922dfe..1c661ce44b383e 100644 --- a/doc/api/stream.md +++ b/doc/api/stream.md @@ -2001,7 +2001,7 @@ has less then 64 KiB of data because no `highWaterMark` option is provided to ##### `readable[Symbol.for('Stream.toAsyncStreamable')]()` > Stability: 1 - Experimental diff --git a/doc/api/stream_iter.md b/doc/api/stream_iter.md index a9916c287b9ef3..04d416e5b1b855 100644 --- a/doc/api/stream_iter.md +++ b/doc/api/stream_iter.md @@ -522,7 +522,6 @@ Including the `node:` prefix on the module specifier is optional. @@ -564,7 +563,6 @@ run().catch(console.error); @@ -596,7 +594,6 @@ console.log(textSync(fromSync('hello'))); // 'hello' @@ -655,7 +652,6 @@ run().catch(console.error); @@ -677,7 +673,6 @@ The `writer` must have the `*Sync` methods (`writeSync`, `writevSync`, @@ -750,7 +745,6 @@ ac.abort(); // Pipeline throws AbortError on next iteration @@ -766,7 +760,6 @@ Synchronous version of [`pull()`][]. All transforms must be synchronous. @@ -832,7 +825,6 @@ The writer returned by `push()` conforms to the \[Writer interface]\[]. @@ -912,7 +904,6 @@ run().catch(console.error); @@ -929,7 +920,6 @@ Collect all chunks as an array of `Uint8Array` values (without concatenating). @@ -946,7 +936,6 @@ Collect all bytes into an `ArrayBuffer`. @@ -962,7 +951,6 @@ Synchronous version of [`arrayBuffer()`][]. @@ -978,7 +966,6 @@ Synchronous version of [`array()`][]. @@ -1013,7 +1000,6 @@ run().catch(console.error); @@ -1029,7 +1015,6 @@ Synchronous version of [`bytes()`][]. @@ -1063,7 +1048,6 @@ run().catch(console.error); @@ -1082,7 +1066,6 @@ Synchronous version of [`text()`][]. @@ -1139,7 +1122,6 @@ run().catch(console.error); @@ -1174,7 +1156,6 @@ run().catch(console.error); @@ -1215,7 +1196,6 @@ chunks by the tapping callback; but return values are ignored. @@ -1230,7 +1210,6 @@ Synchronous version of [`tap()`][]. @@ -1333,7 +1312,6 @@ Alias for `broadcast.cancel()`. @@ -1348,7 +1326,6 @@ automatically and pushed to all subscribers. @@ -1431,7 +1408,6 @@ Alias for `share.cancel()`. @@ -1445,7 +1421,6 @@ Create a {Share} from an existing source. @@ -1462,7 +1437,6 @@ Synchronous version of [`share()`][]. @@ -1489,7 +1463,7 @@ directly. The minimum contract is described below for each function. ### `fromReadable(readable)` > Stability: 1 - Experimental @@ -1543,7 +1517,7 @@ run(); ### `fromWritable(writable[, options])` > Stability: 1 - Experimental @@ -1607,7 +1581,7 @@ run(); ### `toReadable(source[, options])` > Stability: 1 - Experimental @@ -1649,7 +1623,7 @@ readable.pipe(createWriteStream('output.gz')); ### `toReadableSync(source[, options])` > Stability: 1 - Experimental @@ -1686,7 +1660,7 @@ console.log(readable.read().toString()); // 'hello world' ### `toWritable(writer)` > Stability: 1 - Experimental diff --git a/doc/api/test.md b/doc/api/test.md index 4654e6c1504938..e961c13899d668 100644 --- a/doc/api/test.md +++ b/doc/api/test.md @@ -630,7 +630,7 @@ node --test "**/*.test.js" "**/*.spec.js" ### Randomizing tests execution order > Stability: 1.0 - Early development @@ -3686,7 +3686,7 @@ Emitted when one or more tests are restarted due to a file change in watch mode. ## `getTestContext()` * Returns: {TestContext|SuiteContext|undefined} @@ -3724,7 +3724,7 @@ with. ## Test instrumentation and OpenTelemetry The test runner publishes test execution events through the Node.js @@ -4480,7 +4480,7 @@ Can be used to abort test subtasks when the test has been aborted. ### `context.passed` * Type: {boolean} @@ -4490,7 +4490,7 @@ Indicates whether the suite and all of its subtests have passed. ### `context.attempt` * Type: {number} @@ -4502,7 +4502,7 @@ the second attempt is `1`, and so on. This property is useful in conjunction wit ### `context.diagnostic(message)` * `message` {string} A diagnostic message to output. diff --git a/doc/api/util.md b/doc/api/util.md index 4c2a8b3e5fd889..770322b29d5e07 100644 --- a/doc/api/util.md +++ b/doc/api/util.md @@ -2548,7 +2548,7 @@ added: - v21.7.0 - v20.12.0 changes: - - version: REPLACEME + - version: v26.1.0 pr-url: https://github.com/nodejs/node/pull/61556 description: Add support for hexadecimal colors. - version: diff --git a/doc/api/v8.md b/doc/api/v8.md index da225a333ddcac..f025b03ec495dc 100644 --- a/doc/api/v8.md +++ b/doc/api/v8.md @@ -1620,7 +1620,7 @@ Stopping collecting the profile and the profile will be discarded. ## Class: `SyncHeapProfileHandle` > Stability: 1 - Experimental @@ -1628,7 +1628,7 @@ added: REPLACEME ### `syncHeapProfileHandle.stop()` * Returns: {string} @@ -1638,7 +1638,7 @@ Stopping collecting the profile and return the profile data. ### `syncHeapProfileHandle[Symbol.dispose]()` Stopping collecting the profile and the profile will be discarded. @@ -1797,7 +1797,7 @@ console.log(profile); ## `v8.startHeapProfile([options])` * `options` {Object} diff --git a/doc/api/webcrypto.md b/doc/api/webcrypto.md index 3645e0f263328c..f357ebb6ae0282 100644 --- a/doc/api/webcrypto.md +++ b/doc/api/webcrypto.md @@ -3,7 +3,6 @@ @@ -2358,7 +2354,6 @@ added: v15.0.0 @@ -2366,7 +2361,6 @@ added: @@ -2378,7 +2372,6 @@ The optional customization string for KangarooTwelve. @@ -2388,7 +2381,6 @@ added: @@ -2475,7 +2467,6 @@ added: v24.8.0 added: v24.8.0 changes: - version: - - v26.0.0 - v25.9.0 - v24.15.0 pr-url: https://github.com/nodejs/node/pull/61875 @@ -2494,7 +2485,6 @@ added: v24.8.0 @@ -2774,7 +2764,6 @@ The length (in bytes) of the random salt to use. @@ -2782,7 +2771,6 @@ added: @@ -2794,7 +2782,6 @@ The optional domain separation byte (0x01-0x7f). Defaults to `0x1f`. @@ -2804,7 +2791,6 @@ added: diff --git a/doc/changelogs/CHANGELOG_V26.md b/doc/changelogs/CHANGELOG_V26.md index 28571fcd6f73a9..408f7a06f58ca5 100644 --- a/doc/changelogs/CHANGELOG_V26.md +++ b/doc/changelogs/CHANGELOG_V26.md @@ -8,6 +8,7 @@ +26.1.0
26.0.0
@@ -41,6 +42,329 @@ * [io.js](CHANGELOG_IOJS.md) * [Archive](CHANGELOG_ARCHIVE.md) + + +## 2026-05-07, Version 26.1.0 (Current), @aduh95 + +### Notable Changes + +#### Experimental `node:ffi` module + +Node.js now includes an experimental `node:ffi` module for loading dynamic +libraries and calling native symbols from JavaScript. + +The API is gated behind the `--experimental-ffi` flag and, when the Permission +Model is enabled, requires `--allow-ffi`. + +This API is inherently unsafe. Invalid pointers, incorrect signatures, or accessing memory +after it has been freed can crash the process or corrupt memory. + +Contributed by Paolo Insogna in [#62072](https://github.com/nodejs/node/pull/62072). + +#### Other Notable Changes + +* \[[`34a6454fe3`](https://github.com/nodejs/node/commit/34a6454fe3)] - **(SEMVER-MINOR)** **buffer**: add `end` parameter (Robert Nagy) [#62390](https://github.com/nodejs/node/pull/62390) +* \[[`073e84d7fe`](https://github.com/nodejs/node/commit/073e84d7fe)] - **(SEMVER-MINOR)** **crypto**: accept key data in `crypto.diffieHellman()` and cleanup DH jobs (Filip Skokan) [#62527](https://github.com/nodejs/node/pull/62527) +* \[[`5b9cb10a5f`](https://github.com/nodejs/node/commit/5b9cb10a5f)] - **(SEMVER-MINOR)** **crypto**: implement `randomUUIDv7()` (nabeel378) [#62553](https://github.com/nodejs/node/pull/62553) +* \[[`98f9becd16`](https://github.com/nodejs/node/commit/98f9becd16)] - **(SEMVER-MINOR)** **debugger**: add edit-free runtime expression probes to `node inspect` (Joyee Cheung) [#62713](https://github.com/nodejs/node/pull/62713) +* \[[`06defaa2ea`](https://github.com/nodejs/node/commit/06defaa2ea)] - **(SEMVER-MINOR)** **fs**: add `signal` option to `fs.stat()` (Mert Can Altin) [#57775](https://github.com/nodejs/node/pull/57775) +* \[[`db66a963bf`](https://github.com/nodejs/node/commit/db66a963bf)] - **(SEMVER-MINOR)** **fs**: expose `frsize` field in `statfs` (Jinho Jang) [#62277](https://github.com/nodejs/node/pull/62277) +* \[[`87adb3472b`](https://github.com/nodejs/node/commit/87adb3472b)] - **(SEMVER-MINOR)** **http**: harden `ClientRequest` options merge (Matteo Collina) [#63082](https://github.com/nodejs/node/pull/63082) +* \[[`9047ec12ce`](https://github.com/nodejs/node/commit/9047ec12ce)] - **(SEMVER-MINOR)** **http**: add `req.signal` to `IncomingMessage` (Akshat) [#62541](https://github.com/nodejs/node/pull/62541) +* \[[`ab66de8eaa`](https://github.com/nodejs/node/commit/ab66de8eaa)] - **(SEMVER-MINOR)** **process**: throw on `execve(2)` failure instead of aborting (Bryan English) [#62878](https://github.com/nodejs/node/pull/62878) +* \[[`8273682c87`](https://github.com/nodejs/node/commit/8273682c87)] - **(SEMVER-MINOR)** **src**: allow empty `--experimental-config-file` (Marco Ippolito) [#61610](https://github.com/nodejs/node/pull/61610) +* \[[`fbff28f7e6`](https://github.com/nodejs/node/commit/fbff28f7e6)] - **(SEMVER-MINOR)** **stream**: propagate destruction in `duplexPair` (Ahmed Elhor) [#61098](https://github.com/nodejs/node/pull/61098) +* \[[`a8c773a0c7`](https://github.com/nodejs/node/commit/a8c773a0c7)] - **(SEMVER-MINOR)** **test\_runner**: align mock timeout api (sangwook) [#62820](https://github.com/nodejs/node/pull/62820) +* \[[`b883a5eaea`](https://github.com/nodejs/node/commit/b883a5eaea)] - **(SEMVER-MINOR)** **test\_runner**: add mock-timers support for `AbortSignal.timeout` (DeveloperViraj) [#60751](https://github.com/nodejs/node/pull/60751) +* \[[`a21ae1771e`](https://github.com/nodejs/node/commit/a21ae1771e)] - **(SEMVER-MINOR)** **test\_runner**: support test order randomization (Pietro Marchini) [#61747](https://github.com/nodejs/node/pull/61747) +* \[[`b85c73ff10`](https://github.com/nodejs/node/commit/b85c73ff10)] - **(SEMVER-MINOR)** **util**: colorize text with hex colors (Guilherme Araújo) [#61556](https://github.com/nodejs/node/pull/61556) + +### Commits + +* \[[`1b959d02c2`](https://github.com/nodejs/node/commit/1b959d02c2)] - **assert,util**: fix stale nested cycle memo entries (Ruben Bridgewater) [#62509](https://github.com/nodejs/node/pull/62509) +* \[[`bbeb38d210`](https://github.com/nodejs/node/commit/bbeb38d210)] - **buffer**: fix end parameter bugs in indexOf/lastIndexOf (Robert Nagy) [#62711](https://github.com/nodejs/node/pull/62711) +* \[[`34a6454fe3`](https://github.com/nodejs/node/commit/34a6454fe3)] - **(SEMVER-MINOR)** **buffer**: add end parameter (Robert Nagy) [#62390](https://github.com/nodejs/node/pull/62390) +* \[[`8b91526cd5`](https://github.com/nodejs/node/commit/8b91526cd5)] - **build**: track PDL files as inputs in inspector GN build (Robo) [#62888](https://github.com/nodejs/node/pull/62888) +* \[[`da40ed7842`](https://github.com/nodejs/node/commit/da40ed7842)] - **build**: remove armv6 from experimental platforms (René) [#63063](https://github.com/nodejs/node/pull/63063) +* \[[`b36e55a23e`](https://github.com/nodejs/node/commit/b36e55a23e)] - **build**: make test-addons dependency-free (Joyee Cheung) [#62388](https://github.com/nodejs/node/pull/62388) +* \[[`c27f3cf8f2`](https://github.com/nodejs/node/commit/c27f3cf8f2)] - **build**: add --enable-all-experimentals build flag (Paolo Insogna) [#62755](https://github.com/nodejs/node/pull/62755) +* \[[`0d73b63a76`](https://github.com/nodejs/node/commit/0d73b63a76)] - **build**: fix cargo check when Temporal is disabled (Antoine du Hamel) [#62730](https://github.com/nodejs/node/pull/62730) +* \[[`d8f97e6f7b`](https://github.com/nodejs/node/commit/d8f97e6f7b)] - **build**: fix ffi dependency compilation (Paolo Insogna) [#62731](https://github.com/nodejs/node/pull/62731) +* \[[`d1eb7b340f`](https://github.com/nodejs/node/commit/d1eb7b340f)] - **build**: fix stray debug string in LIEF defines (Om Ghante) [#62683](https://github.com/nodejs/node/pull/62683) +* \[[`845283009d`](https://github.com/nodejs/node/commit/845283009d)] - **build**: remove redundant -fuse-linker-plugin from GCC LTO flags (Daniel Lando) [#62667](https://github.com/nodejs/node/pull/62667) +* \[[`a6e99879f4`](https://github.com/nodejs/node/commit/a6e99879f4)] - **build,win**: enable x64 PGO (Stefan Stojanovic) [#62761](https://github.com/nodejs/node/pull/62761) +* \[[`38befee0fb`](https://github.com/nodejs/node/commit/38befee0fb)] - **crypto**: add JWK support for ML-KEM and SLH-DSA key types (Filip Skokan) [#62706](https://github.com/nodejs/node/pull/62706) +* \[[`b10653ad87`](https://github.com/nodejs/node/commit/b10653ad87)] - **crypto**: add guards and adjust tests for BoringSSL (Filip Skokan) [#62883](https://github.com/nodejs/node/pull/62883) +* \[[`2a7a69c6b0`](https://github.com/nodejs/node/commit/2a7a69c6b0)] - **crypto**: reject unintended raw key format string input (Filip Skokan) [#62974](https://github.com/nodejs/node/pull/62974) +* \[[`bad1e2fe6a`](https://github.com/nodejs/node/commit/bad1e2fe6a)] - **crypto**: fix unsigned conversion of 4-byte RSA publicExponent (DeepView Autofix) [#62839](https://github.com/nodejs/node/pull/62839) +* \[[`c9d5bae598`](https://github.com/nodejs/node/commit/c9d5bae598)] - **crypto**: remove Argon2 KDF derivation from its job setup (Filip Skokan) [#62863](https://github.com/nodejs/node/pull/62863) +* \[[`6eea52426f`](https://github.com/nodejs/node/commit/6eea52426f)] - **crypto**: reject duplicate ML-KEM JWK key\_ops (Filip Skokan) [#62905](https://github.com/nodejs/node/pull/62905) +* \[[`80d4836616`](https://github.com/nodejs/node/commit/80d4836616)] - **crypto**: deduplicate and canonicalize CryptoKey usages (Filip Skokan) [#62902](https://github.com/nodejs/node/pull/62902) +* \[[`8950247027`](https://github.com/nodejs/node/commit/8950247027)] - **crypto**: reject inherited key type names (Jonathan Lopes) [#62875](https://github.com/nodejs/node/pull/62875) +* \[[`3f42f9615a`](https://github.com/nodejs/node/commit/3f42f9615a)] - **crypto**: strengthen argument CHECKs in TurboSHAKE (Tobias Nießen) [#62763](https://github.com/nodejs/node/pull/62763) +* \[[`28346d999b`](https://github.com/nodejs/node/commit/28346d999b)] - **crypto**: guard against size\_t overflow on experimental 32-bit arch (Filip Skokan) [#62626](https://github.com/nodejs/node/pull/62626) +* \[[`d4cec263c4`](https://github.com/nodejs/node/commit/d4cec263c4)] - **(SEMVER-MINOR)** **crypto**: align key argument names in docs and error messages (Filip Skokan) [#62527](https://github.com/nodejs/node/pull/62527) +* \[[`073e84d7fe`](https://github.com/nodejs/node/commit/073e84d7fe)] - **(SEMVER-MINOR)** **crypto**: accept key data in crypto.diffieHellman() and cleanup DH jobs (Filip Skokan) [#62527](https://github.com/nodejs/node/pull/62527) +* \[[`518b578fe7`](https://github.com/nodejs/node/commit/518b578fe7)] - **crypto**: add memory tracking for secureContext openssl objects (Mert Can Altin) [#59051](https://github.com/nodejs/node/pull/59051) +* \[[`5b9cb10a5f`](https://github.com/nodejs/node/commit/5b9cb10a5f)] - **(SEMVER-MINOR)** **crypto**: implement randomUUIDv7() (nabeel378) [#62553](https://github.com/nodejs/node/pull/62553) +* \[[`7133826053`](https://github.com/nodejs/node/commit/7133826053)] - **debugger**: move ProbeInspectorSession and helpers to separate files (Joyee Cheung) [#63013](https://github.com/nodejs/node/pull/63013) +* \[[`98f9becd16`](https://github.com/nodejs/node/commit/98f9becd16)] - **(SEMVER-MINOR)** **debugger**: add edit-free runtime expression probes to `node inspect` (Joyee Cheung) [#62713](https://github.com/nodejs/node/pull/62713) +* \[[`94ac62a2d1`](https://github.com/nodejs/node/commit/94ac62a2d1)] - **deps**: update undici to 8.2.0 (Node.js GitHub Bot) [#63092](https://github.com/nodejs/node/pull/63092) +* \[[`ef71de87e6`](https://github.com/nodejs/node/commit/ef71de87e6)] - **deps**: update amaro to 1.1.9 (Node.js GitHub Bot) [#63090](https://github.com/nodejs/node/pull/63090) +* \[[`c4f0ef881a`](https://github.com/nodejs/node/commit/c4f0ef881a)] - **deps**: update llhttp to 9.4.1 (Node.js GitHub Bot) [#63045](https://github.com/nodejs/node/pull/63045) +* \[[`d29fbc0029`](https://github.com/nodejs/node/commit/d29fbc0029)] - **deps**: fix integration issues with the latest nghttp2 (Tim Perry) [#62891](https://github.com/nodejs/node/pull/62891) +* \[[`537825acee`](https://github.com/nodejs/node/commit/537825acee)] - **deps**: update nghttp2 to 1.69.0 (Node.js GitHub Bot) [#62891](https://github.com/nodejs/node/pull/62891) +* \[[`4446bf694d`](https://github.com/nodejs/node/commit/4446bf694d)] - **deps**: update corepack to 0.34.7 (Node.js GitHub Bot) [#62810](https://github.com/nodejs/node/pull/62810) +* \[[`8f55327f1c`](https://github.com/nodejs/node/commit/8f55327f1c)] - **deps**: fix libffi macos build (Paolo Insogna) [#63006](https://github.com/nodejs/node/pull/63006) +* \[[`3dee18f72f`](https://github.com/nodejs/node/commit/3dee18f72f)] - **deps**: patch V8 to 14.6.202.34 (Node.js GitHub Bot) [#62964](https://github.com/nodejs/node/pull/62964) +* \[[`e281b247e6`](https://github.com/nodejs/node/commit/e281b247e6)] - **deps**: update timezone to 2026b (Node.js GitHub Bot) [#62962](https://github.com/nodejs/node/pull/62962) +* \[[`4dd982df13`](https://github.com/nodejs/node/commit/4dd982df13)] - **deps**: upgrade npm to 11.13.0 (npm team) [#62898](https://github.com/nodejs/node/pull/62898) +* \[[`61c0ff4a13`](https://github.com/nodejs/node/commit/61c0ff4a13)] - **deps**: cherry-pick libuv/libuv\@439a54b (skooch) [#62881](https://github.com/nodejs/node/pull/62881) +* \[[`d26ca462ae`](https://github.com/nodejs/node/commit/d26ca462ae)] - **deps**: update undici to 8.1.0 (Node.js GitHub Bot) [#62728](https://github.com/nodejs/node/pull/62728) +* \[[`6f08489ac9`](https://github.com/nodejs/node/commit/6f08489ac9)] - **deps**: update sqlite to 3.53.0 (Node.js GitHub Bot) [#62699](https://github.com/nodejs/node/pull/62699) +* \[[`713601e8bd`](https://github.com/nodejs/node/commit/713601e8bd)] - **deps**: update nbytes to 0.1.4 (Node.js GitHub Bot) [#62698](https://github.com/nodejs/node/pull/62698) +* \[[`578cf1c0c1`](https://github.com/nodejs/node/commit/578cf1c0c1)] - **deps**: update archs files for openssl-3.5.6 (Node.js GitHub Bot) [#62629](https://github.com/nodejs/node/pull/62629) +* \[[`4a4ef13c67`](https://github.com/nodejs/node/commit/4a4ef13c67)] - **deps**: upgrade openssl sources to openssl-3.5.6 (Node.js GitHub Bot) [#62629](https://github.com/nodejs/node/pull/62629) +* \[[`2f3eca8c1e`](https://github.com/nodejs/node/commit/2f3eca8c1e)] - **deps**: update perfetto to 54.0 (Chengzhong Wu) [#62397](https://github.com/nodejs/node/pull/62397) +* \[[`944ed9b739`](https://github.com/nodejs/node/commit/944ed9b739)] - **deps**: add perfetto build files (Chengzhong Wu) [#62397](https://github.com/nodejs/node/pull/62397) +* \[[`15530a7484`](https://github.com/nodejs/node/commit/15530a7484)] - **deps**: update ngtcp2 to 1.22.0 (Node.js GitHub Bot) [#62595](https://github.com/nodejs/node/pull/62595) +* \[[`b813b4c4b5`](https://github.com/nodejs/node/commit/b813b4c4b5)] - **deps**: update minimatch to 10.2.5 (Node.js GitHub Bot) [#62594](https://github.com/nodejs/node/pull/62594) +* \[[`38e7ce58c5`](https://github.com/nodejs/node/commit/38e7ce58c5)] - **deps**: update googletest to d72f9c8aea6817cdf1ca0ac10887f328de7f3da2 (Node.js GitHub Bot) [#62593](https://github.com/nodejs/node/pull/62593) +* \[[`b5c573ed14`](https://github.com/nodejs/node/commit/b5c573ed14)] - **deps**: update simdjson to 4.6.1 (Node.js GitHub Bot) [#62592](https://github.com/nodejs/node/pull/62592) +* \[[`318e2c7cd3`](https://github.com/nodejs/node/commit/318e2c7cd3)] - **deps**: libuv: cherry-pick aabb7651de (Santiago Gimeno) [#62561](https://github.com/nodejs/node/pull/62561) +* \[[`c6ccbd742a`](https://github.com/nodejs/node/commit/c6ccbd742a)] - **deps**: libuv: reapply 3a9a6e3e6b (Andy Pan) [#62561](https://github.com/nodejs/node/pull/62561) +* \[[`4ad07de7ae`](https://github.com/nodejs/node/commit/4ad07de7ae)] - **diagnostics\_channel**: add BoundedChannel and scopes (Stephen Belanger) [#61680](https://github.com/nodejs/node/pull/61680) +* \[[`44416ea3fd`](https://github.com/nodejs/node/commit/44416ea3fd)] - **doc**: fix documentation history missing 25.9.0 (Antoine du Hamel) [#63151](https://github.com/nodejs/node/pull/63151) +* \[[`5f6dfbf68e`](https://github.com/nodejs/node/commit/5f6dfbf68e)] - **doc**: fix changelog for chromium numbering (Rafael Gonzaga) [#63133](https://github.com/nodejs/node/pull/63133) +* \[[`30c4b3658c`](https://github.com/nodejs/node/commit/30c4b3658c)] - **doc**: fix the TypeScript Execute (tsx) project link (David Thornton) [#63093](https://github.com/nodejs/node/pull/63093) +* \[[`ca3c3097f1`](https://github.com/nodejs/node/commit/ca3c3097f1)] - **doc**: minor structural stream/iter edits (René) [#63089](https://github.com/nodejs/node/pull/63089) +* \[[`92324aab6f`](https://github.com/nodejs/node/commit/92324aab6f)] - **doc**: remove typo comma from man page (Vas Sudanagunta) [#63080](https://github.com/nodejs/node/pull/63080) +* \[[`712a15da73`](https://github.com/nodejs/node/commit/712a15da73)] - **doc**: correct diagnostics\_channel built-in channel names (Bryan English) [#62995](https://github.com/nodejs/node/pull/62995) +* \[[`c92cb6fe0d`](https://github.com/nodejs/node/commit/c92cb6fe0d)] - **doc**: use mjs/cjs blocks for callbackify null reason example (Daijiro Wachi) [#62884](https://github.com/nodejs/node/pull/62884) +* \[[`020776d4d6`](https://github.com/nodejs/node/commit/020776d4d6)] - **doc**: fix typo in test.md (Rich Trott) [#62960](https://github.com/nodejs/node/pull/62960) +* \[[`7d52f2061e`](https://github.com/nodejs/node/commit/7d52f2061e)] - **doc**: correct typo in PR contribution instructions (Mike McCready) [#62738](https://github.com/nodejs/node/pull/62738) +* \[[`70e8944676`](https://github.com/nodejs/node/commit/70e8944676)] - **doc**: fix duplicate word "of of" in postMessageToThread (Daijiro Wachi) [#62917](https://github.com/nodejs/node/pull/62917) +* \[[`11c6c29284`](https://github.com/nodejs/node/commit/11c6c29284)] - **doc**: fix duplicate word "to to" in util.styleText (Daijiro Wachi) [#62917](https://github.com/nodejs/node/pull/62917) +* \[[`242adab671`](https://github.com/nodejs/node/commit/242adab671)] - **doc**: fix duplicate word "for for" in compile cache (Daijiro Wachi) [#62917](https://github.com/nodejs/node/pull/62917) +* \[[`b9f3abd63e`](https://github.com/nodejs/node/commit/b9f3abd63e)] - **doc**: fix doubled word typo in stream\_iter.md (Daijiro Wachi) [#62916](https://github.com/nodejs/node/pull/62916) +* \[[`7a52fd0448`](https://github.com/nodejs/node/commit/7a52fd0448)] - **doc**: fix typo in dns.lookup options description (Daijiro Wachi) [#62882](https://github.com/nodejs/node/pull/62882) +* \[[`acd7e18a8c`](https://github.com/nodejs/node/commit/acd7e18a8c)] - **doc**: fix Argon2 parameter bounds (Tobias Nießen) [#62868](https://github.com/nodejs/node/pull/62868) +* \[[`b43ecf40bb`](https://github.com/nodejs/node/commit/b43ecf40bb)] - **doc**: trust FFI in the threat model (Paolo Insogna) [#62852](https://github.com/nodejs/node/pull/62852) +* \[[`981ce96b03`](https://github.com/nodejs/node/commit/981ce96b03)] - **doc**: fix typos and inconsistencies in crypto.md and webcrypto.md (Filip Skokan) [#62828](https://github.com/nodejs/node/pull/62828) +* \[[`acc52ef257`](https://github.com/nodejs/node/commit/acc52ef257)] - **doc**: clarify diffieHellman.generateKeys recomputes same key (Kit Dallege) [#62205](https://github.com/nodejs/node/pull/62205) +* \[[`ae87597c07`](https://github.com/nodejs/node/commit/ae87597c07)] - **doc**: remove Ayase-252 and meixg from triagger team (Antoine du Hamel) [#62841](https://github.com/nodejs/node/pull/62841) +* \[[`1cd3694a5f`](https://github.com/nodejs/node/commit/1cd3694a5f)] - **doc**: clarify dns.lookup() callback signature when all is true (eungi) [#62800](https://github.com/nodejs/node/pull/62800) +* \[[`40a4337d65`](https://github.com/nodejs/node/commit/40a4337d65)] - **doc**: add experimental modules lifetime policy (Paolo Insogna) [#62753](https://github.com/nodejs/node/pull/62753) +* \[[`46f48222f8`](https://github.com/nodejs/node/commit/46f48222f8)] - **doc**: clarify process.\_debugProcess() in Permission Model (Fahad Khan) [#62537](https://github.com/nodejs/node/pull/62537) +* \[[`6eb9917497`](https://github.com/nodejs/node/commit/6eb9917497)] - **doc**: fix typo in devcontainer guide (Rohan Santhosh Kumar) [#62687](https://github.com/nodejs/node/pull/62687) +* \[[`3826c5ed7e`](https://github.com/nodejs/node/commit/3826c5ed7e)] - **doc**: clarify Backport-PR-URL metadata added automatically (Mike McCready) [#62668](https://github.com/nodejs/node/pull/62668) +* \[[`5d7e0dbbd8`](https://github.com/nodejs/node/commit/5d7e0dbbd8)] - **doc**: update WPT test runner README.md (Filip Skokan) [#62680](https://github.com/nodejs/node/pull/62680) +* \[[`e9d76b2a75`](https://github.com/nodejs/node/commit/e9d76b2a75)] - **doc**: fix spelling in release announcement guidance (Rohan Santhosh Kumar) [#62663](https://github.com/nodejs/node/pull/62663) +* \[[`1ae41cebb0`](https://github.com/nodejs/node/commit/1ae41cebb0)] - **doc**: note GCC >= 14 requirement for native riscv64 builds (Jamie Magee) [#62607](https://github.com/nodejs/node/pull/62607) +* \[[`9b29be6a28`](https://github.com/nodejs/node/commit/9b29be6a28)] - **doc**: note non-monotonic clock in crypto.randomUUIDv7 (nabeel378) [#62600](https://github.com/nodejs/node/pull/62600) +* \[[`5ae59553f6`](https://github.com/nodejs/node/commit/5ae59553f6)] - **doc**: update bug bounty program (Rafael Gonzaga) [#62590](https://github.com/nodejs/node/pull/62590) +* \[[`ce3f4c85dd`](https://github.com/nodejs/node/commit/ce3f4c85dd)] - **doc**: document TransformStream transformer.cancel option (Tom Pereira) [#62566](https://github.com/nodejs/node/pull/62566) +* \[[`08a9ba73e4`](https://github.com/nodejs/node/commit/08a9ba73e4)] - **doc**: mention test runner retry attemp is zero based (Moshe Atlow) [#62504](https://github.com/nodejs/node/pull/62504) +* \[[`32f2169ede`](https://github.com/nodejs/node/commit/32f2169ede)] - **doc,src,test**: fix dead inspector help URL (semimikoh) [#62745](https://github.com/nodejs/node/pull/62745) +* \[[`870c1cd3f4`](https://github.com/nodejs/node/commit/870c1cd3f4)] - **doc,test**: mem protection must be observed in ffi (Bryan English) [#62818](https://github.com/nodejs/node/pull/62818) +* \[[`3d5cf171dc`](https://github.com/nodejs/node/commit/3d5cf171dc)] - **esm**: add `ERR_REQUIRE_ESM_RACE_CONDITION` (Antoine du Hamel) [#62462](https://github.com/nodejs/node/pull/62462) +* \[[`2004d8d6db`](https://github.com/nodejs/node/commit/2004d8d6db)] - **ffi**: make `FFIFunctionInfo` a `BaseObject` subclass (Anna Henningsen) [#63071](https://github.com/nodejs/node/pull/63071) +* \[[`53eb7abeba`](https://github.com/nodejs/node/commit/53eb7abeba)] - **ffi**: prevent premature GC of DynamicLibrary (semimikoh) [#63024](https://github.com/nodejs/node/pull/63024) +* \[[`58dc92f502`](https://github.com/nodejs/node/commit/58dc92f502)] - **ffi**: support Symbol.dispose on DynamicLibrary (Matteo Collina) [#62925](https://github.com/nodejs/node/pull/62925) +* \[[`528f8b2bae`](https://github.com/nodejs/node/commit/528f8b2bae)] - **ffi**: add shared-buffer fast path for numeric and pointer signatures (Bryan English) [#62918](https://github.com/nodejs/node/pull/62918) +* \[[`42ac8b9ae7`](https://github.com/nodejs/node/commit/42ac8b9ae7)] - **fs**: add followSymlinks option to glob (Matteo Collina) [#62695](https://github.com/nodejs/node/pull/62695) +* \[[`873c2bca70`](https://github.com/nodejs/node/commit/873c2bca70)] - **fs**: restore fs patchability in ESM loader (Joyee Cheung) [#62835](https://github.com/nodejs/node/pull/62835) +* \[[`349c7502c3`](https://github.com/nodejs/node/commit/349c7502c3)] - **fs**: validate position argument before length === 0 early return (Edy Silva) [#62674](https://github.com/nodejs/node/pull/62674) +* \[[`06defaa2ea`](https://github.com/nodejs/node/commit/06defaa2ea)] - **(SEMVER-MINOR)** **fs**: add signal option to fs.stat() (Mert Can Altin) [#57775](https://github.com/nodejs/node/pull/57775) +* \[[`db66a963bf`](https://github.com/nodejs/node/commit/db66a963bf)] - **(SEMVER-MINOR)** **fs**: expose frsize field in statfs (Jinho Jang) [#62277](https://github.com/nodejs/node/pull/62277) +* \[[`3191d2936a`](https://github.com/nodejs/node/commit/3191d2936a)] - **http**: emit 'drain' on OutgoingMessage only after buffers drain (Robert Nagy) [#62936](https://github.com/nodejs/node/pull/62936) +* \[[`87adb3472b`](https://github.com/nodejs/node/commit/87adb3472b)] - **(SEMVER-MINOR)** **http**: harden ClientRequest options merge (Matteo Collina) [#63082](https://github.com/nodejs/node/pull/63082) +* \[[`e0b79633f6`](https://github.com/nodejs/node/commit/e0b79633f6)] - **http**: fix leaked error listener on sync HTTP req create + destroy (Tim Perry) [#62872](https://github.com/nodejs/node/pull/62872) +* \[[`70c5491f53`](https://github.com/nodejs/node/commit/70c5491f53)] - **http**: fix no\_proxy leading-dot suffix matching (Daijiro Wachi) [#62333](https://github.com/nodejs/node/pull/62333) +* \[[`60a585e68a`](https://github.com/nodejs/node/commit/60a585e68a)] - **http**: cleanup pipeline queue (Robert Nagy) [#62534](https://github.com/nodejs/node/pull/62534) +* \[[`9047ec12ce`](https://github.com/nodejs/node/commit/9047ec12ce)] - **(SEMVER-MINOR)** **http**: add req.signal to IncomingMessage (Akshat) [#62541](https://github.com/nodejs/node/pull/62541) +* \[[`01eed5901b`](https://github.com/nodejs/node/commit/01eed5901b)] - **http2**: expose writable stream state on compat response (T) [#63003](https://github.com/nodejs/node/pull/63003) +* \[[`19b7adf3ba`](https://github.com/nodejs/node/commit/19b7adf3ba)] - **inspector**: fix absolute URLs in network http (bugyaluwang) [#62955](https://github.com/nodejs/node/pull/62955) +* \[[`4d10823fbb`](https://github.com/nodejs/node/commit/4d10823fbb)] - **inspector**: coerce key and value to string in webstorage events (Ali Hassan) [#62616](https://github.com/nodejs/node/pull/62616) +* \[[`9a3ac66cc5`](https://github.com/nodejs/node/commit/9a3ac66cc5)] - **inspector**: return errors when CDP protocol event emission fails (Ryuhei Shima) [#62162](https://github.com/nodejs/node/pull/62162) +* \[[`c89501c6e5`](https://github.com/nodejs/node/commit/c89501c6e5)] - **inspector**: auto collect webstorage data (Ryuhei Shima) [#62145](https://github.com/nodejs/node/pull/62145) +* \[[`ef08c5016a`](https://github.com/nodejs/node/commit/ef08c5016a)] - **lib**: refactor internal webidl converters (Filip Skokan) [#62979](https://github.com/nodejs/node/pull/62979) +* \[[`d0744c6a99`](https://github.com/nodejs/node/commit/d0744c6a99)] - **lib**: add Temporal to frozen intrinsics (René) [#63029](https://github.com/nodejs/node/pull/63029) +* \[[`6d81cb17b3`](https://github.com/nodejs/node/commit/6d81cb17b3)] - **lib**: avoid quadratic shift() in startup snapshot callback (Daijiro Wachi) [#62914](https://github.com/nodejs/node/pull/62914) +* \[[`3491f73051`](https://github.com/nodejs/node/commit/3491f73051)] - **lib**: fix FLOAT\_32 and FLOAT\_64 type constants in ffi (Daijiro Wachi) [#62892](https://github.com/nodejs/node/pull/62892) +* \[[`c4ca303b36`](https://github.com/nodejs/node/commit/c4ca303b36)] - **lib**: harden kKeyOps lookup with null prototype (Filip Skokan) [#62877](https://github.com/nodejs/node/pull/62877) +* \[[`2e612fe070`](https://github.com/nodejs/node/commit/2e612fe070)] - **lib**: short-circuit WebIDL BufferSource SAB check (Filip Skokan) [#62833](https://github.com/nodejs/node/pull/62833) +* \[[`e850ee9c69`](https://github.com/nodejs/node/commit/e850ee9c69)] - **lib**: add new methods and error codes (Paolo Insogna) [#62762](https://github.com/nodejs/node/pull/62762) +* \[[`e21b873589`](https://github.com/nodejs/node/commit/e21b873589)] - **lib**: use js-only implementation of `isDataView()` (René) [#62780](https://github.com/nodejs/node/pull/62780) +* \[[`f454d1719d`](https://github.com/nodejs/node/commit/f454d1719d)] - **lib**: fix lint in internal/webstreams/util.js (Filip Skokan) [#62806](https://github.com/nodejs/node/pull/62806) +* \[[`fbd8ededba`](https://github.com/nodejs/node/commit/fbd8ededba)] - **lib**: fix sequence argument handling in Blob constructor (Ms2ger) [#62179](https://github.com/nodejs/node/pull/62179) +* \[[`16860e6abd`](https://github.com/nodejs/node/commit/16860e6abd)] - **lib**: improve Web Cryptography key validation ordering (Filip Skokan) [#62749](https://github.com/nodejs/node/pull/62749) +* \[[`ba3f3e1753`](https://github.com/nodejs/node/commit/ba3f3e1753)] - **lib**: reject SharedArrayBuffer in web APIs per spec (Ali Hassan) [#62632](https://github.com/nodejs/node/pull/62632) +* \[[`d065e996bb`](https://github.com/nodejs/node/commit/d065e996bb)] - **lib**: defer AbortSignal.any() following (sangwook) [#62367](https://github.com/nodejs/node/pull/62367) +* \[[`2a711f4b0c`](https://github.com/nodejs/node/commit/2a711f4b0c)] - **(SEMVER-MINOR)** **lib,src,test,doc**: add node:ffi module (Colin Ihrig) [#62072](https://github.com/nodejs/node/pull/62072) +* \[[`d578343582`](https://github.com/nodejs/node/commit/d578343582)] - **meta**: bump github/codeql-action from 4.35.1 to 4.35.3 (dependabot\[bot]) [#63074](https://github.com/nodejs/node/pull/63074) +* \[[`1b4b90d544`](https://github.com/nodejs/node/commit/1b4b90d544)] - **meta**: bump Mozilla-Actions/sccache-action from 0.0.9 to 0.0.10 (dependabot\[bot]) [#63073](https://github.com/nodejs/node/pull/63073) +* \[[`1477349e47`](https://github.com/nodejs/node/commit/1477349e47)] - **meta**: bump actions/upload-artifact from 7.0.0 to 7.0.1 (dependabot\[bot]) [#63072](https://github.com/nodejs/node/pull/63072) +* \[[`ecb7de271a`](https://github.com/nodejs/node/commit/ecb7de271a)] - **meta**: bump cachix/install-nix-action from 31.10.3 to 31.10.5 (dependabot\[bot]) [#62846](https://github.com/nodejs/node/pull/62846) +* \[[`fb91408312`](https://github.com/nodejs/node/commit/fb91408312)] - **meta**: bump actions/upload-artifact from 7.0.0 to 7.0.1 (dependabot\[bot]) [#62850](https://github.com/nodejs/node/pull/62850) +* \[[`7eb9a6be68`](https://github.com/nodejs/node/commit/7eb9a6be68)] - **meta**: add automation policy (Chengzhong Wu) [#62871](https://github.com/nodejs/node/pull/62871) +* \[[`6f053a4cb8`](https://github.com/nodejs/node/commit/6f053a4cb8)] - **meta**: update CODEOWNERS for FFI (Paolo Insogna) [#62853](https://github.com/nodejs/node/pull/62853) +* \[[`88fe50a725`](https://github.com/nodejs/node/commit/88fe50a725)] - **meta**: move VoltrexKeyva to emeritus (Matteo Collina) [#62895](https://github.com/nodejs/node/pull/62895) +* \[[`42e770bdd0`](https://github.com/nodejs/node/commit/42e770bdd0)] - **meta**: bump peter-evans/create-pull-request from 8.1.0 to 8.1.1 (dependabot\[bot]) [#62845](https://github.com/nodejs/node/pull/62845) +* \[[`952d005233`](https://github.com/nodejs/node/commit/952d005233)] - **meta**: bump step-security/harden-runner from 2.16.1 to 2.19.0 (dependabot\[bot]) [#62844](https://github.com/nodejs/node/pull/62844) +* \[[`1bd19d9768`](https://github.com/nodejs/node/commit/1bd19d9768)] - **meta**: bump actions/github-script from 8.0.0 to 9.0.0 (dependabot\[bot]) [#62843](https://github.com/nodejs/node/pull/62843) +* \[[`386244a7dd`](https://github.com/nodejs/node/commit/386244a7dd)] - **meta**: bump actions/setup-node from 6.3.0 to 6.4.0 (dependabot\[bot]) [#62842](https://github.com/nodejs/node/pull/62842) +* \[[`16b2c41f70`](https://github.com/nodejs/node/commit/16b2c41f70)] - **meta**: broaden stale bot (Aviv Keller) [#62658](https://github.com/nodejs/node/pull/62658) +* \[[`41e7a4ba82`](https://github.com/nodejs/node/commit/41e7a4ba82)] - **meta**: pass release version to release worker (flakey5) [#62777](https://github.com/nodejs/node/pull/62777) +* \[[`632821db85`](https://github.com/nodejs/node/commit/632821db85)] - **meta**: add QUIC to CODEOWNERS (Tim Perry) [#62652](https://github.com/nodejs/node/pull/62652) +* \[[`4a7ad93ed8`](https://github.com/nodejs/node/commit/4a7ad93ed8)] - **meta**: move Michael to emeritus (Michael Dawson) [#62536](https://github.com/nodejs/node/pull/62536) +* \[[`44d5a33efb`](https://github.com/nodejs/node/commit/44d5a33efb)] - **meta**: populate apt list for slim runner in update-openssl workflow (René) [#62628](https://github.com/nodejs/node/pull/62628) +* \[[`d874596aa3`](https://github.com/nodejs/node/commit/d874596aa3)] - **meta**: bump cachix/install-nix-action from 31.9.1 to 31.10.3 (dependabot\[bot]) [#62551](https://github.com/nodejs/node/pull/62551) +* \[[`1631b27e2b`](https://github.com/nodejs/node/commit/1631b27e2b)] - **meta**: bump step-security/harden-runner from 2.15.0 to 2.16.1 (dependabot\[bot]) [#62550](https://github.com/nodejs/node/pull/62550) +* \[[`4de376894d`](https://github.com/nodejs/node/commit/4de376894d)] - **meta**: bump actions/download-artifact from 8.0.0 to 8.0.1 (dependabot\[bot]) [#62549](https://github.com/nodejs/node/pull/62549) +* \[[`39da4d7bd6`](https://github.com/nodejs/node/commit/39da4d7bd6)] - **meta**: bump actions/setup-node from 6.2.0 to 6.3.0 (dependabot\[bot]) [#62548](https://github.com/nodejs/node/pull/62548) +* \[[`62e3aa55ad`](https://github.com/nodejs/node/commit/62e3aa55ad)] - **meta**: bump github/codeql-action from 4.32.4 to 4.35.1 (dependabot\[bot]) [#62547](https://github.com/nodejs/node/pull/62547) +* \[[`83986de8a2`](https://github.com/nodejs/node/commit/83986de8a2)] - **meta**: bump codecov/codecov-action from 5.5.2 to 6.0.0 (dependabot\[bot]) [#62545](https://github.com/nodejs/node/pull/62545) +* \[[`18e56861dc`](https://github.com/nodejs/node/commit/18e56861dc)] - **meta**: bump cachix/cachix-action from 16 to 17 (dependabot\[bot]) [#62544](https://github.com/nodejs/node/pull/62544) +* \[[`d4e49d567a`](https://github.com/nodejs/node/commit/d4e49d567a)] - **meta**: bump actions/cache from 5.0.3 to 5.0.4 (dependabot\[bot]) [#62543](https://github.com/nodejs/node/pull/62543) +* \[[`2c5a914af4`](https://github.com/nodejs/node/commit/2c5a914af4)] - **meta**: require DCO signoff in commit message guidelines (James M Snell) [#62510](https://github.com/nodejs/node/pull/62510) +* \[[`f21039ce59`](https://github.com/nodejs/node/commit/f21039ce59)] - **meta**: expand memory leak DoS criteria to all DoS (Joyee Cheung) [#62505](https://github.com/nodejs/node/pull/62505) +* \[[`824ac6b5bf`](https://github.com/nodejs/node/commit/824ac6b5bf)] - **module**: exclude `node:ffi` from `builtinModules` when not enabled (Jordan Harband) [#63158](https://github.com/nodejs/node/pull/63158) +* \[[`bb6293ab7c`](https://github.com/nodejs/node/commit/bb6293ab7c)] - **module**: remove duplicated checks from `_resolveFilename` (Antoine du Hamel) [#62729](https://github.com/nodejs/node/pull/62729) +* \[[`34ec8c9f5c`](https://github.com/nodejs/node/commit/34ec8c9f5c)] - **module,win**: fix long subpath import (Stefan Stojanovic) [#62101](https://github.com/nodejs/node/pull/62101) +* \[[`de46e68918`](https://github.com/nodejs/node/commit/de46e68918)] - **node-api**: update libuv ABI stability note (Chengzhong Wu) [#62789](https://github.com/nodejs/node/pull/62789) +* \[[`78c7d77bbf`](https://github.com/nodejs/node/commit/78c7d77bbf)] - **node-api**: add napi\_create\_external\_sharedarraybuffer (Ben Noordhuis) [#62623](https://github.com/nodejs/node/pull/62623) +* \[[`a0ccf94f61`](https://github.com/nodejs/node/commit/a0ccf94f61)] - **node-api**: execute tsfn finalizer after queue drains when aborted (Kevin Eady) [#61956](https://github.com/nodejs/node/pull/61956) +* \[[`ab66de8eaa`](https://github.com/nodejs/node/commit/ab66de8eaa)] - **(SEMVER-MINOR)** **process**: throw on execve(2) failure instead of aborting (Bryan English) [#62878](https://github.com/nodejs/node/pull/62878) +* \[[`20151be8cb`](https://github.com/nodejs/node/commit/20151be8cb)] - **process**: handle rejections only when needed (Gürgün Dayıoğlu) [#62919](https://github.com/nodejs/node/pull/62919) +* \[[`9b24a815a2`](https://github.com/nodejs/node/commit/9b24a815a2)] - **quic**: add QuicEndpoint.listening & QuicStream.destroy() and tests (Tim Perry) [#62648](https://github.com/nodejs/node/pull/62648) +* \[[`761a96740c`](https://github.com/nodejs/node/commit/761a96740c)] - **quic**: fixup token verification to handle zero expiration (James M Snell) [#62620](https://github.com/nodejs/node/pull/62620) +* \[[`4ade02ac85`](https://github.com/nodejs/node/commit/4ade02ac85)] - **quic**: support multiple ALPN negotiation (James M Snell) [#62620](https://github.com/nodejs/node/pull/62620) +* \[[`b2e2e648e4`](https://github.com/nodejs/node/commit/b2e2e648e4)] - **quic**: apply multiple TLS context improvements and SNI support (James M Snell) [#62620](https://github.com/nodejs/node/pull/62620) +* \[[`56b941af4a`](https://github.com/nodejs/node/commit/56b941af4a)] - **quic**: implement rapidhash for hashing improvements (James M Snell) [#62620](https://github.com/nodejs/node/pull/62620) +* \[[`7cda4300b8`](https://github.com/nodejs/node/commit/7cda4300b8)] - **quic**: use arena allocation for packets (James M Snell) [#62589](https://github.com/nodejs/node/pull/62589) +* \[[`1e8fa2f1bd`](https://github.com/nodejs/node/commit/1e8fa2f1bd)] - **sqlite**: use OneByte for ASCII text and internalize col names (Ali Hassan) [#61954](https://github.com/nodejs/node/pull/61954) +* \[[`3af44ee508`](https://github.com/nodejs/node/commit/3af44ee508)] - **sqlite**: add serialize() and deserialize() (Ali Hassan) [#62579](https://github.com/nodejs/node/pull/62579) +* \[[`6386914b4b`](https://github.com/nodejs/node/commit/6386914b4b)] - **src**: decouple KeyObject and CryptoKey and move CryptoKey to src (Filip Skokan) [#62924](https://github.com/nodejs/node/pull/62924) +* \[[`2dc1d205ee`](https://github.com/nodejs/node/commit/2dc1d205ee)] - **src**: replace uses of deprecated v8::External APIs (gahaas) [#61898](https://github.com/nodejs/node/pull/61898) +* \[[`cb33a794a5`](https://github.com/nodejs/node/commit/cb33a794a5)] - **src**: remove license headers for new node\_profiling files (Chengzhong Wu) [#63066](https://github.com/nodejs/node/pull/63066) +* \[[`59860eb798`](https://github.com/nodejs/node/commit/59860eb798)] - **src**: swap dotenv and config file parsing order (Marco Ippolito) [#63035](https://github.com/nodejs/node/pull/63035) +* \[[`fda439cb58`](https://github.com/nodejs/node/commit/fda439cb58)] - **src**: use `unique_ptr` for ffi memory management (Anna Henningsen) [#63071](https://github.com/nodejs/node/pull/63071) +* \[[`56917afc57`](https://github.com/nodejs/node/commit/56917afc57)] - **src**: split profiling helpers from util (Ilyas Shabi) [#63008](https://github.com/nodejs/node/pull/63008) +* \[[`fca56a409d`](https://github.com/nodejs/node/commit/fca56a409d)] - **src**: add missing \ for abort() declaration (Charles Kerr) [#63001](https://github.com/nodejs/node/pull/63001) +* \[[`d49c89e915`](https://github.com/nodejs/node/commit/d49c89e915)] - **src**: make node.config.json throw at unknown fields (Marco Ippolito) [#62992](https://github.com/nodejs/node/pull/62992) +* \[[`e89c8e9b68`](https://github.com/nodejs/node/commit/e89c8e9b68)] - **src**: fix crash in GetErrorSource() for invalid using syntax (semimikoh) [#62770](https://github.com/nodejs/node/pull/62770) +* \[[`d89f719ce0`](https://github.com/nodejs/node/commit/d89f719ce0)] - **src**: remove outdated comments in contextify (Chengzhong Wu) [#62932](https://github.com/nodejs/node/pull/62932) +* \[[`5117a3e52b`](https://github.com/nodejs/node/commit/5117a3e52b)] - **src**: simplify `TCPWrap::Connect` signature (Anna Henningsen) [#62929](https://github.com/nodejs/node/pull/62929) +* \[[`41bd288ec7`](https://github.com/nodejs/node/commit/41bd288ec7)] - **src**: align FFI error handling with Node.js source (Anna Henningsen) [#62858](https://github.com/nodejs/node/pull/62858) +* \[[`faaccfb9df`](https://github.com/nodejs/node/commit/faaccfb9df)] - **src**: simplify and fix FFI ArrayBuffer accesses (Anna Henningsen) [#62857](https://github.com/nodejs/node/pull/62857) +* \[[`43bf39c350`](https://github.com/nodejs/node/commit/43bf39c350)] - **src**: use DCHECK in AsyncWrap::MakeCallback instead emiting a warning (Gerhard Stöbich) [#62795](https://github.com/nodejs/node/pull/62795) +* \[[`da52b09859`](https://github.com/nodejs/node/commit/da52b09859)] - **src**: fix MaybeStackBuffer char\_traits deprecation warning (om-ghante) [#62507](https://github.com/nodejs/node/pull/62507) +* \[[`2b12bca317`](https://github.com/nodejs/node/commit/2b12bca317)] - **src**: use context-free V8 message column getters (René) [#62778](https://github.com/nodejs/node/pull/62778) +* \[[`7efc2ce7b3`](https://github.com/nodejs/node/commit/7efc2ce7b3)] - **src**: clean up experimental flag variables (Antoine du Hamel) [#62759](https://github.com/nodejs/node/pull/62759) +* \[[`8273682c87`](https://github.com/nodejs/node/commit/8273682c87)] - **(SEMVER-MINOR)** **src**: allow empty --experimental-config-file (Marco Ippolito) [#61610](https://github.com/nodejs/node/pull/61610) +* \[[`b844c24395`](https://github.com/nodejs/node/commit/b844c24395)] - **src**: coerce `spawnSync` args to string once (Antoine du Hamel) [#62633](https://github.com/nodejs/node/pull/62633) +* \[[`28679d76c4`](https://github.com/nodejs/node/commit/28679d76c4)] - **src**: use stack allocation for small string encoding (Ali Hassan) [#62431](https://github.com/nodejs/node/pull/62431) +* \[[`144ef93735`](https://github.com/nodejs/node/commit/144ef93735)] - **src**: add contextify interceptor debug logs (Chengzhong Wu) [#62460](https://github.com/nodejs/node/pull/62460) +* \[[`d34cfb512e`](https://github.com/nodejs/node/commit/d34cfb512e)] - **stream**: remove redundant method check from iter.pipeToSync (René) [#63099](https://github.com/nodejs/node/pull/63099) +* \[[`a95830b72a`](https://github.com/nodejs/node/commit/a95830b72a)] - **stream**: copyedit `webstreams/adapter.js` (Antoine du Hamel) [#63034](https://github.com/nodejs/node/pull/63034) +* \[[`4bf3e1e084`](https://github.com/nodejs/node/commit/4bf3e1e084)] - **stream**: remove duplicated utility (Antoine du Hamel) [#63031](https://github.com/nodejs/node/pull/63031) +* \[[`214a8c197b`](https://github.com/nodejs/node/commit/214a8c197b)] - **stream**: simplify `setPromiseHandled` utility (Antoine du Hamel) [#63032](https://github.com/nodejs/node/pull/63032) +* \[[`c12a767ff2`](https://github.com/nodejs/node/commit/c12a767ff2)] - **stream**: validate ReadableStream.from iterator objects (Daeyeon Jeong) [#62911](https://github.com/nodejs/node/pull/62911) +* \[[`b09953d2d4`](https://github.com/nodejs/node/commit/b09953d2d4)] - **stream**: reject duplicate nested transferables (Daeyeon Jeong) [#62831](https://github.com/nodejs/node/pull/62831) +* \[[`b9929622f3`](https://github.com/nodejs/node/commit/b9929622f3)] - **stream**: ensuring cross-destruction in \_duplexify to prevent leaks (Daijiro Wachi) [#62824](https://github.com/nodejs/node/pull/62824) +* \[[`c51a39b3ec`](https://github.com/nodejs/node/commit/c51a39b3ec)] - **stream**: simplify `readableStreamFromIterable` (Antoine du Hamel) [#62651](https://github.com/nodejs/node/pull/62651) +* \[[`36078574b9`](https://github.com/nodejs/node/commit/36078574b9)] - **stream**: fix nested compose error propagation (Matteo Collina) [#62556](https://github.com/nodejs/node/pull/62556) +* \[[`e1928cd481`](https://github.com/nodejs/node/commit/e1928cd481)] - **stream**: allow shared array buffer sources in writable webstream adapter (René) [#62163](https://github.com/nodejs/node/pull/62163) +* \[[`450e0519d9`](https://github.com/nodejs/node/commit/450e0519d9)] - **stream**: simplify `createPromiseCallback` (Antoine du Hamel) [#62650](https://github.com/nodejs/node/pull/62650) +* \[[`57e59ea070`](https://github.com/nodejs/node/commit/57e59ea070)] - **stream**: fix writev unhandled rejection in fromWeb (sangwook) [#62297](https://github.com/nodejs/node/pull/62297) +* \[[`958373413c`](https://github.com/nodejs/node/commit/958373413c)] - **stream**: noop pause/resume on destroyed streams (Robert Nagy) [#62557](https://github.com/nodejs/node/pull/62557) +* \[[`ee38d2c43d`](https://github.com/nodejs/node/commit/ee38d2c43d)] - **stream**: refactor duplexify to be less suceptible to prototype pollution (Antoine du Hamel) [#62559](https://github.com/nodejs/node/pull/62559) +* \[[`fbff28f7e6`](https://github.com/nodejs/node/commit/fbff28f7e6)] - **(SEMVER-MINOR)** **stream**: propagate destruction in duplexPair (Ahmed Elhor) [#61098](https://github.com/nodejs/node/pull/61098) +* \[[`d7317f4f90`](https://github.com/nodejs/node/commit/d7317f4f90)] - **stream**: add stream/iter to classic stream adapters (James M Snell) [#62469](https://github.com/nodejs/node/pull/62469) +* \[[`55298c443f`](https://github.com/nodejs/node/commit/55298c443f)] - **test**: accept OpenSSL 4 generic internal error for DH key-type mismatches (Filip Skokan) [#62805](https://github.com/nodejs/node/pull/62805) +* \[[`96581bccc7`](https://github.com/nodejs/node/commit/96581bccc7)] - **test**: update WPT for url to 258f285de0 (Node.js GitHub Bot) [#63087](https://github.com/nodejs/node/pull/63087) +* \[[`c73aba07fb`](https://github.com/nodejs/node/commit/c73aba07fb)] - **test**: run Temporal presence checks without V8 flag (René) [#63028](https://github.com/nodejs/node/pull/63028) +* \[[`9c94dce55b`](https://github.com/nodejs/node/commit/9c94dce55b)] - **test**: export isRiscv64 from common module (Jamie Magee) [#62609](https://github.com/nodejs/node/pull/62609) +* \[[`33c5f7fdbf`](https://github.com/nodejs/node/commit/33c5f7fdbf)] - **test**: normalize known inspector crash as completion (Joyee Cheung) [#62851](https://github.com/nodejs/node/pull/62851) +* \[[`8146a97bc3`](https://github.com/nodejs/node/commit/8146a97bc3)] - **test**: update WPT for streams to f8f26a372f (Node.js GitHub Bot) [#62864](https://github.com/nodejs/node/pull/62864) +* \[[`7c77c301c9`](https://github.com/nodejs/node/commit/7c77c301c9)] - **test**: account for RFC 7919 FFDHE negotiation in OpenSSL 4.0 (Filip Skokan) [#62805](https://github.com/nodejs/node/pull/62805) +* \[[`9bf7604eb6`](https://github.com/nodejs/node/commit/9bf7604eb6)] - **test**: skip tls-deprecated secp256k1 on OpenSSL 4.0 (Filip Skokan) [#62805](https://github.com/nodejs/node/pull/62805) +* \[[`d173604b53`](https://github.com/nodejs/node/commit/d173604b53)] - **test**: use an always invalid cipher and cover OpenSSL 4.0 behaviours (Filip Skokan) [#62805](https://github.com/nodejs/node/pull/62805) +* \[[`72f52163b4`](https://github.com/nodejs/node/commit/72f52163b4)] - **test**: use valid DER OCSP responses (Filip Skokan) [#62805](https://github.com/nodejs/node/pull/62805) +* \[[`e242394ad9`](https://github.com/nodejs/node/commit/e242394ad9)] - **test**: skip test-tls-error-stack when engines are unsupported (Filip Skokan) [#62805](https://github.com/nodejs/node/pull/62805) +* \[[`9bff52ebf8`](https://github.com/nodejs/node/commit/9bff52ebf8)] - **test**: accept renamed OpenSSL 4.0 error code and reason (Filip Skokan) [#62805](https://github.com/nodejs/node/pull/62805) +* \[[`d9b8cc1b68`](https://github.com/nodejs/node/commit/d9b8cc1b68)] - **test**: update test/addons/openssl-binding for OpenSSL 4.0 (Filip Skokan) [#62805](https://github.com/nodejs/node/pull/62805) +* \[[`960fb16287`](https://github.com/nodejs/node/commit/960fb16287)] - **test**: mark test-snapshot-reproducible flaky (Filip Skokan) [#62808](https://github.com/nodejs/node/pull/62808) +* \[[`7a12dd58cf`](https://github.com/nodejs/node/commit/7a12dd58cf)] - **test**: check contextify contextual store behavior in strict mode (René) [#62571](https://github.com/nodejs/node/pull/62571) +* \[[`c73c8e603f`](https://github.com/nodejs/node/commit/c73c8e603f)] - **test**: skip `test-temporal-with-zoneinfo` on system-icu builds (Antoine du Hamel) [#62754](https://github.com/nodejs/node/pull/62754) +* \[[`48a3ca303e`](https://github.com/nodejs/node/commit/48a3ca303e)] - **test**: generate `localstorage.db` in a temp dir (Chengzhong Wu) [#62660](https://github.com/nodejs/node/pull/62660) +* \[[`1a41c2c5db`](https://github.com/nodejs/node/commit/1a41c2c5db)] - **test**: update tls junk data error expectations (Filip Skokan) [#62629](https://github.com/nodejs/node/pull/62629) +* \[[`115e8c2052`](https://github.com/nodejs/node/commit/115e8c2052)] - **test**: ensure WPT report is in out/wpt (Filip Skokan) [#62637](https://github.com/nodejs/node/pull/62637) +* \[[`cb07b918bd`](https://github.com/nodejs/node/commit/cb07b918bd)] - **test**: improve WPT runner summary (Filip Skokan) [#62636](https://github.com/nodejs/node/pull/62636) +* \[[`7f48438380`](https://github.com/nodejs/node/commit/7f48438380)] - **test**: skip url WPT subtests instead of modifying test script (Filip Skokan) [#62635](https://github.com/nodejs/node/pull/62635) +* \[[`4097fb95d7`](https://github.com/nodejs/node/commit/4097fb95d7)] - **test**: capture negative utimes mtime at call time (Yuya Inoue) [#62490](https://github.com/nodejs/node/pull/62490) +* \[[`e29f46df81`](https://github.com/nodejs/node/commit/e29f46df81)] - **test**: allow skipping individual WPT subtests (Filip Skokan) [#62517](https://github.com/nodejs/node/pull/62517) +* \[[`4d546886c3`](https://github.com/nodejs/node/commit/4d546886c3)] - **test**: use on-disk fixture for test-npm-install (Joyee Cheung) [#62584](https://github.com/nodejs/node/pull/62584) +* \[[`5b35eb02ec`](https://github.com/nodejs/node/commit/5b35eb02ec)] - **test**: update WPT for url to 7a3645b79a (Node.js GitHub Bot) [#62591](https://github.com/nodejs/node/pull/62591) +* \[[`7a8610835d`](https://github.com/nodejs/node/commit/7a8610835d)] - **test\_runner**: fix failing suite hooks when marked with `todo` (Moshe Atlow) [#63097](https://github.com/nodejs/node/pull/63097) +* \[[`a8c773a0c7`](https://github.com/nodejs/node/commit/a8c773a0c7)] - **(SEMVER-MINOR)** **test\_runner**: align mock timeout api (sangwook) [#62820](https://github.com/nodejs/node/pull/62820) +* \[[`dc0d757c8a`](https://github.com/nodejs/node/commit/dc0d757c8a)] - **test\_runner**: fix suite rerun edge case (Moshe Atlow) [#62860](https://github.com/nodejs/node/pull/62860) +* \[[`b883a5eaea`](https://github.com/nodejs/node/commit/b883a5eaea)] - **(SEMVER-MINOR)** **test\_runner**: add mock-timers support for AbortSignal.timeout (DeveloperViraj) [#60751](https://github.com/nodejs/node/pull/60751) +* \[[`6fa62b7d58`](https://github.com/nodejs/node/commit/6fa62b7d58)] - **test\_runner**: add `testId` to test events (Moshe Atlow) [#62772](https://github.com/nodejs/node/pull/62772) +* \[[`39e08340ff`](https://github.com/nodejs/node/commit/39e08340ff)] - **test\_runner**: publish to TracingChannel for OTel instrumentation (Moshe Atlow) [#62502](https://github.com/nodejs/node/pull/62502) +* \[[`a21ae1771e`](https://github.com/nodejs/node/commit/a21ae1771e)] - **(SEMVER-MINOR)** **test\_runner**: support test order randomization (Pietro Marchini) [#61747](https://github.com/nodejs/node/pull/61747) +* \[[`cf0edeb65d`](https://github.com/nodejs/node/commit/cf0edeb65d)] - **test\_runner**: add passed, attempt, and diagnostic to SuiteContext (Moshe Atlow) [#62504](https://github.com/nodejs/node/pull/62504) +* \[[`644e2399d6`](https://github.com/nodejs/node/commit/644e2399d6)] - **test\_runner**: add `getTestContext()` (Moshe Atlow) [#62501](https://github.com/nodejs/node/pull/62501) +* \[[`480d538830`](https://github.com/nodejs/node/commit/480d538830)] - **tools**: use `npm ci` in Undici update script (Antoine du Hamel) [#63098](https://github.com/nodejs/node/pull/63098) +* \[[`9afb013edd`](https://github.com/nodejs/node/commit/9afb013edd)] - **tools**: update nixpkgs-unstable to c6d65881c5624c9cae5ea6cedef24699b0c (Node.js GitHub Bot) [#63091](https://github.com/nodejs/node/pull/63091) +* \[[`b9f2f5a90a`](https://github.com/nodejs/node/commit/b9f2f5a90a)] - **tools**: bump postcss from 8.5.8 to 8.5.10 in /tools/doc (dependabot\[bot]) [#62966](https://github.com/nodejs/node/pull/62966) +* \[[`09e4f4caca`](https://github.com/nodejs/node/commit/09e4f4caca)] - **tools**: use LTS Node.js in notify-on-push workflow (Nenad Spasenic) [#63084](https://github.com/nodejs/node/pull/63084) +* \[[`2af4c89774`](https://github.com/nodejs/node/commit/2af4c89774)] - **tools**: implements a few nits on `build-aarch64-linux-v8` (Antoine du Hamel) [#63048](https://github.com/nodejs/node/pull/63048) +* \[[`cf9c1849ca`](https://github.com/nodejs/node/commit/cf9c1849ca)] - **tools**: update gr2m/create-or-update-pull-request-action to v1.10.1 (Mike McCready) [#63065](https://github.com/nodejs/node/pull/63065) +* \[[`96370a57ed`](https://github.com/nodejs/node/commit/96370a57ed)] - **tools**: simplify `update-undici.sh` (Antoine du Hamel) [#63044](https://github.com/nodejs/node/pull/63044) +* \[[`b90486edd8`](https://github.com/nodejs/node/commit/b90486edd8)] - **tools**: do not run `test-linux` on unrelated tools changes (Antoine du Hamel) [#63037](https://github.com/nodejs/node/pull/63037) +* \[[`ac49e7c9fc`](https://github.com/nodejs/node/commit/ac49e7c9fc)] - **tools**: migrate from `openssl-matrix.json` to `openssl-matrix.nix` (Antoine du Hamel) [#63036](https://github.com/nodejs/node/pull/63036) +* \[[`a9df3e37fd`](https://github.com/nodejs/node/commit/a9df3e37fd)] - **tools**: update labels for nixpkgs pin bumps (Antoine du Hamel) [#62994](https://github.com/nodejs/node/pull/62994) +* \[[`cee0154af8`](https://github.com/nodejs/node/commit/cee0154af8)] - **tools**: reuse V8 builds even without Cachix on test-shared (Antoine du Hamel) [#62980](https://github.com/nodejs/node/pull/62980) +* \[[`78c183da6b`](https://github.com/nodejs/node/commit/78c183da6b)] - **tools**: do not include HTML docs in slim tarball (Antoine du Hamel) [#62989](https://github.com/nodejs/node/pull/62989) +* \[[`04ce9df084`](https://github.com/nodejs/node/commit/04ce9df084)] - **tools**: bump the eslint group in /tools/eslint with 4 updates (dependabot\[bot]) [#62848](https://github.com/nodejs/node/pull/62848) +* \[[`4d2952c00a`](https://github.com/nodejs/node/commit/4d2952c00a)] - **tools**: update nixpkgs-unstable to 01fbdeef22b76df85ea168fbfe1bfd9e636 (Node.js GitHub Bot) [#62963](https://github.com/nodejs/node/pull/62963) +* \[[`555ad12f27`](https://github.com/nodejs/node/commit/555ad12f27)] - **tools**: update gyp-next to 0.22.1 (Node.js GitHub Bot) [#62961](https://github.com/nodejs/node/pull/62961) +* \[[`f92cbc2c81`](https://github.com/nodejs/node/commit/f92cbc2c81)] - **tools**: fix commit linter for semver-major release proposals (Antoine du Hamel) [#62993](https://github.com/nodejs/node/pull/62993) +* \[[`3b5bb4d758`](https://github.com/nodejs/node/commit/3b5bb4d758)] - **tools**: consolidate and simplify .editorconfig deps section (Daijiro Wachi) [#62887](https://github.com/nodejs/node/pull/62887) +* \[[`027bef4f3e`](https://github.com/nodejs/node/commit/027bef4f3e)] - **tools**: add non-default OpenSSL versions to the test-shared workflow (Filip Skokan) [#62862](https://github.com/nodejs/node/pull/62862) +* \[[`fdcd7752de`](https://github.com/nodejs/node/commit/fdcd7752de)] - **tools**: set bot as author of tools-deps-update PRs (Antoine du Hamel) [#62856](https://github.com/nodejs/node/pull/62856) +* \[[`ab7be6d987`](https://github.com/nodejs/node/commit/ab7be6d987)] - **tools**: bump brace-expansion from 5.0.4 to 5.0.5 in /tools/eslint (dependabot\[bot]) [#62458](https://github.com/nodejs/node/pull/62458) +* \[[`82281ffd59`](https://github.com/nodejs/node/commit/82281ffd59)] - **tools**: bump brace-expansion in /tools/clang-format (dependabot\[bot]) [#62467](https://github.com/nodejs/node/pull/62467) +* \[[`48bb51b3d7`](https://github.com/nodejs/node/commit/48bb51b3d7)] - **tools**: update nixpkgs-unstable to ab72be9733b41190ea34f1422a3e4e243ed (Node.js GitHub Bot) [#62821](https://github.com/nodejs/node/pull/62821) +* \[[`67baa3254b`](https://github.com/nodejs/node/commit/67baa3254b)] - **tools**: bump @node-core/doc-kit in /tools/doc in the doc group (dependabot\[bot]) [#62512](https://github.com/nodejs/node/pull/62512) +* \[[`bdee0a859d`](https://github.com/nodejs/node/commit/bdee0a859d)] - **tools**: exclude @node-core/doc-kit from dependabot cooldown (Levi Zim) [#62775](https://github.com/nodejs/node/pull/62775) +* \[[`9e19f55214`](https://github.com/nodejs/node/commit/9e19f55214)] - **tools**: re-enable undici WPTs in daily wpt.fyi job (Filip Skokan) [#62677](https://github.com/nodejs/node/pull/62677) +* \[[`1eedbdded9`](https://github.com/nodejs/node/commit/1eedbdded9)] - **tools**: use upstream version of OpenSSL in `test-shared` (Antoine du Hamel) [#62679](https://github.com/nodejs/node/pull/62679) +* \[[`3490c1fba1`](https://github.com/nodejs/node/commit/3490c1fba1)] - **tools**: pass the Temporal disable flag when disabled in `shell.nix` (Antoine du Hamel) [#62733](https://github.com/nodejs/node/pull/62733) +* \[[`3a29dafd2d`](https://github.com/nodejs/node/commit/3a29dafd2d)] - **tools**: fix `--shared-ffi` compilation on macOS (Antoine du Hamel) [#62737](https://github.com/nodejs/node/pull/62737) +* \[[`5cb9108b9c`](https://github.com/nodejs/node/commit/5cb9108b9c)] - **tools**: update nixpkgs-unstable to 13043924aaa7375ce482ebe2494338e0582 (Node.js GitHub Bot) [#62700](https://github.com/nodejs/node/pull/62700) +* \[[`757cd21ea0`](https://github.com/nodejs/node/commit/757cd21ea0)] - **tools**: update gyp-next to 0.22.0 (Node.js GitHub Bot) [#62697](https://github.com/nodejs/node/pull/62697) +* \[[`fad51c2f03`](https://github.com/nodejs/node/commit/fad51c2f03)] - **tools**: add a check for clean git tree after tests (Antoine du Hamel) [#62661](https://github.com/nodejs/node/pull/62661) +* \[[`d1c517fd61`](https://github.com/nodejs/node/commit/d1c517fd61)] - **tools**: improve backport review script (Antoine du Hamel) [#62573](https://github.com/nodejs/node/pull/62573) +* \[[`6d169c75f7`](https://github.com/nodejs/node/commit/6d169c75f7)] - **tools**: make `v8.nix` more stable (Antoine du Hamel) [#62508](https://github.com/nodejs/node/pull/62508) +* \[[`1587a60bf8`](https://github.com/nodejs/node/commit/1587a60bf8)] - **tools**: add perfetto updater (Chengzhong Wu) [#62397](https://github.com/nodejs/node/pull/62397) +* \[[`f54d74a5e7`](https://github.com/nodejs/node/commit/f54d74a5e7)] - **tools**: improve output for unexpected passes in WTP tests (Antoine du Hamel) [#62587](https://github.com/nodejs/node/pull/62587) +* \[[`a86c96333c`](https://github.com/nodejs/node/commit/a86c96333c)] - **tools**: revert OpenSSL update workflow to ubuntu-latest (Richard Lau) [#62627](https://github.com/nodejs/node/pull/62627) +* \[[`c9860f5800`](https://github.com/nodejs/node/commit/c9860f5800)] - **tools**: update nixpkgs-unstable to a6522db5b947cd7026a40d02acc3ca26136 (Node.js GitHub Bot) [#62596](https://github.com/nodejs/node/pull/62596) +* \[[`ae41e2a141`](https://github.com/nodejs/node/commit/ae41e2a141)] - **tools**: bump the eslint group in /tools/eslint with 2 updates (dependabot\[bot]) [#62552](https://github.com/nodejs/node/pull/62552) +* \[[`e2ba824407`](https://github.com/nodejs/node/commit/e2ba824407)] - **tools**: allow triagers to queue a PR for CI until it's reviewed (Antoine du Hamel) [#62524](https://github.com/nodejs/node/pull/62524) +* \[[`899d780f15`](https://github.com/nodejs/node/commit/899d780f15)] - **tools**: do not run `commit-lint` on release proposals (Antoine du Hamel) [#62523](https://github.com/nodejs/node/pull/62523) +* \[[`102da27b4e`](https://github.com/nodejs/node/commit/102da27b4e)] - **url**: process crash via malformed UNC hostname in pathToFileURL() (Nicola Del Gobbo) [#62574](https://github.com/nodejs/node/pull/62574) +* \[[`3abd78c3e5`](https://github.com/nodejs/node/commit/3abd78c3e5)] - **url**: optimize URLSearchParams set/delete duplicate handling (Gürgün Dayıoğlu) [#62266](https://github.com/nodejs/node/pull/62266) +* \[[`fd3bf3830b`](https://github.com/nodejs/node/commit/fd3bf3830b)] - **url**: align default argument handling for URLPattern with webidl (Filip Skokan) [#62719](https://github.com/nodejs/node/pull/62719) +* \[[`b85c73ff10`](https://github.com/nodejs/node/commit/b85c73ff10)] - **(SEMVER-MINOR)** **util**: colorize text with hex colors (Guilherme Araújo) [#61556](https://github.com/nodejs/node/pull/61556) +* \[[`c1d6b3db73`](https://github.com/nodejs/node/commit/c1d6b3db73)] - **v8**: add cpu profile options (Ilyas Shabi) [#62684](https://github.com/nodejs/node/pull/62684) +* \[[`717d9a7fda`](https://github.com/nodejs/node/commit/717d9a7fda)] - **v8**: add heap profile API (Ilyas Shabi) [#62273](https://github.com/nodejs/node/pull/62273) +* \[[`2b885667a9`](https://github.com/nodejs/node/commit/2b885667a9)] - **watch**: track worker entry files in watch mode (SudhansuBandha) [#62368](https://github.com/nodejs/node/pull/62368) +* \[[`457fb55193`](https://github.com/nodejs/node/commit/457fb55193)] - **watch**: fix --env-file-if-exists crashing on linux if the file is missing (Efe) [#61870](https://github.com/nodejs/node/pull/61870) + ## 2026-05-05, Version 26.0.0 (Current), @RafaelGSS From 4f44c6f5fe03a174cbb4b5fbbbbe30ab9b29086f Mon Sep 17 00:00:00 2001 From: Joyee Cheung Date: Thu, 7 May 2026 16:44:56 +0200 Subject: [PATCH 087/168] module: fix sync hook short-circuit in require() in imported CJS MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - For imported CJS, if it's not customized by asynchronous hooks, make sure it won't use the quirky re-invented require in all cases. - When the imported CJS module is customized by synchronous hooks, in the synthetic module evalutation step, avoid calling the respective default step again. - Make the branching of loadCJSModuleWithModuleLoad() and loadCJSModuleWithSpecialRequire() more explicit, and fold the tentative fs read in the 'commonjs' translator into the share createCJSModuleWrap() helper instead of checking it twice in the same path. Signed-off-by: Joyee Cheung PR-URL: https://github.com/nodejs/node/pull/62920 Fixes: https://github.com/nodejs/node/issues/63060 Reviewed-By: Paolo Insogna Reviewed-By: Matteo Collina Reviewed-By: Gürgün Dayıoğlu --- lib/internal/modules/cjs/loader.js | 35 +++-- lib/internal/modules/esm/load.js | 6 - lib/internal/modules/esm/loader.js | 133 +++++++++++++----- lib/internal/modules/esm/translators.js | 113 ++++++++++----- lib/internal/test_runner/mock/mock.js | 26 +++- ...ule-hooks-load-import-cjs-custom-source.js | 41 ++++++ 6 files changed, 265 insertions(+), 89 deletions(-) create mode 100644 test/module-hooks/test-module-hooks-load-import-cjs-custom-source.js diff --git a/lib/internal/modules/cjs/loader.js b/lib/internal/modules/cjs/loader.js index c9cf6a0f82bb86..65a35299eb6552 100644 --- a/lib/internal/modules/cjs/loader.js +++ b/lib/internal/modules/cjs/loader.js @@ -1097,20 +1097,26 @@ function defaultResolveImplForCJSLoading(specifier, parent, isMain, options) { return wrapResolveFilename(specifier, parent, isMain, options); } +/** + * @typedef {{ + * resolved?: {url?: string, format?: string, filename: string}, + * shouldSkipModuleHooks?: boolean, + * source?: string|ArrayBufferView|ArrayBuffer, + * requireResolveOptions?: ResolveFilenameOptions, + * }} CJSModuleLoadInternalOptions + */ + /** * Resolve a module request for CommonJS, invoking hooks from module.registerHooks() * if necessary. * @param {string} specifier * @param {Module|undefined} parent * @param {boolean} isMain - * @param {object} internalResolveOptions - * @param {boolean} internalResolveOptions.shouldSkipModuleHooks Whether to skip module hooks. - * @param {ResolveFilenameOptions} internalResolveOptions.requireResolveOptions Options from require.resolve(). - * Only used when it comes from require.resolve(). + * @param {CJSModuleLoadInternalOptions} internalOptions * @returns {{url?: string, format?: string, parentURL?: string, filename: string}} */ -function resolveForCJSWithHooks(specifier, parent, isMain, internalResolveOptions) { - const { requireResolveOptions, shouldSkipModuleHooks } = internalResolveOptions; +function resolveForCJSWithHooks(specifier, parent, isMain, internalOptions) { + const { requireResolveOptions, shouldSkipModuleHooks } = internalOptions; const defaultResolveImpl = requireResolveOptions ? wrapResolveFilename : defaultResolveImplForCJSLoading; // Fast path: no hooks, just return simple results. @@ -1257,10 +1263,10 @@ function loadBuiltinWithHooks(id, url, format) { * @param {string} request Specifier of module to load via `require` * @param {Module} parent Absolute path of the module importing the child * @param {boolean} isMain Whether the module is the main entry point - * @param {object|undefined} internalResolveOptions Additional options for loading the module + * @param {CJSModuleLoadInternalOptions|undefined} internalOptions Additional options for loading the module * @returns {object} */ -Module._load = function(request, parent, isMain, internalResolveOptions = kEmptyObject) { +Module._load = function(request, parent, isMain, internalOptions = kEmptyObject) { let relResolveCacheIdentifier; if (parent) { debug('Module._load REQUEST %s parent: %s', request, parent.id); @@ -1284,7 +1290,10 @@ Module._load = function(request, parent, isMain, internalResolveOptions = kEmpty } } - const resolveResult = resolveForCJSWithHooks(request, parent, isMain, internalResolveOptions); + // If the module has been resolved by a short-circuiting synchronous resolve hook, + // avoid running the default resolution from disk again. + const resolveResult = internalOptions.resolved ?? + resolveForCJSWithHooks(request, parent, isMain, internalOptions); let { format } = resolveResult; const { url, filename } = resolveResult; @@ -1372,6 +1381,14 @@ Module._load = function(request, parent, isMain, internalResolveOptions = kEmpty module[kLastModuleParent] = parent; } + // The module source was provided by a short-circuiting synchronous hook, + // assign them into the module to avoid triggering the default load step again. + if (internalOptions.source !== undefined) { + module[kModuleSource] ??= internalOptions.source; + module[kURL] ??= url; + module[kFormat] ??= format; + } + if (parent !== undefined) { relativeResolveCache[relResolveCacheIdentifier] = filename; } diff --git a/lib/internal/modules/esm/load.js b/lib/internal/modules/esm/load.js index e8658716f881a9..94879761553e02 100644 --- a/lib/internal/modules/esm/load.js +++ b/lib/internal/modules/esm/load.js @@ -145,7 +145,6 @@ function defaultLoadSync(url, context = kEmptyObject) { throwIfUnsupportedURLScheme(urlInstance, false); - let shouldBeReloadedByCJSLoader = false; if (urlInstance.protocol === 'node:') { source = null; format ??= 'builtin'; @@ -160,10 +159,6 @@ function defaultLoadSync(url, context = kEmptyObject) { // Now that we have the source for the module, run `defaultGetFormat` to detect its format. format ??= defaultGetFormat(urlInstance, context); - - // For backward compatibility reasons, we need to let go through Module._load - // again. - shouldBeReloadedByCJSLoader = (format === 'commonjs'); } validateAttributes(url, format, importAttributes); @@ -172,7 +167,6 @@ function defaultLoadSync(url, context = kEmptyObject) { format, responseURL, source, - shouldBeReloadedByCJSLoader, }; } diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js index e12cb7f01baa7d..34a9393ac18f01 100644 --- a/lib/internal/modules/esm/loader.js +++ b/lib/internal/modules/esm/loader.js @@ -124,7 +124,19 @@ const { defaultLoadSync, throwUnknownModuleFormat } = require('internal/modules/ */ /** - * @typedef {{ format: ModuleFormat, source: ModuleSource, translatorKey: string }} TranslateContext + * @typedef {{format: string, url: string, isResolvedBySyncHooks: boolean}} ResolveResult + */ + +/** + * @typedef {{ + * url: string, + * format: ModuleFormat, + * source: ModuleSource, + * responseURL?: string, + * translatorKey: string, + * isResolvedBySyncHooks: boolean, + * isSourceLoadedSynchronously: boolean, + * }} TranslateContext */ /** @@ -385,19 +397,25 @@ class ModuleLoader { /** * Load a module and translate it into a ModuleWrap for require(esm). * This is run synchronously, and the translator always return a ModuleWrap synchronously. - * @param {string} url URL of the module to be translated. + * @param {ResolveResult} resolveResult Result from the resolve step. * @param {object} loadContext See {@link load} * @param {string|undefined} parentURL URL of the parent module. Undefined if it's the entry point. * @param {ModuleRequest} request Module request. * @returns {ModuleWrap} */ - loadAndTranslateForImportInRequiredESM(url, loadContext, parentURL, request) { + loadAndTranslateForImportInRequiredESM(resolveResult, loadContext, parentURL, request) { + const { url } = resolveResult; const loadResult = this.#loadSync(url, loadContext); // Use the synchronous commonjs translator which can deal with cycles. const formatFromLoad = loadResult.format; const translatorKey = (formatFromLoad === 'commonjs' || formatFromLoad === 'commonjs-typescript') ? 'commonjs-sync' : formatFromLoad; - const translateContext = { ...loadResult, translatorKey, __proto__: null }; + const translateContext = { + ...resolveResult, + ...loadResult, + translatorKey, + __proto__: null, + }; const wrap = this.#translate(url, translateContext, parentURL); assert(wrap instanceof ModuleWrap, `Translator used for require(${url}) should not be async`); @@ -446,12 +464,13 @@ class ModuleLoader { /** * Load a module and translate it into a ModuleWrap for require() in imported CJS. * This is run synchronously, and the translator always return a ModuleWrap synchronously. - * @param {string} url URL of the module to be translated. + * @param {ResolveResult} resolveResult Result from the resolve step. * @param {object} loadContext See {@link load} * @param {string|undefined} parentURL URL of the parent module. Undefined if it's the entry point. * @returns {ModuleWrap} */ - loadAndTranslateForRequireInImportedCJS(url, loadContext, parentURL) { + loadAndTranslateForRequireInImportedCJS(resolveResult, loadContext, parentURL) { + const { url } = resolveResult; const loadResult = this.#loadSync(url, loadContext); const formatFromLoad = loadResult.format; @@ -473,7 +492,12 @@ class ModuleLoader { translatorKey = 'require-commonjs-typescript'; } - const translateContext = { ...loadResult, translatorKey, __proto__: null }; + const translateContext = { + ...resolveResult, + ...loadResult, + translatorKey, + __proto__: null, + }; const wrap = this.#translate(url, translateContext, parentURL); assert(wrap instanceof ModuleWrap, `Translator used for require(${url}) should not be async`); return wrap; @@ -482,15 +506,21 @@ class ModuleLoader { /** * Load a module and translate it into a ModuleWrap for ordinary imported ESM. * This may be run asynchronously if there are asynchronous module loader hooks registered. - * @param {string} url URL of the module to be translated. + * @param {ResolveResult} resolveResult Result from the resolve step. * @param {object} loadContext See {@link load} * @param {string|undefined} parentURL URL of the parent module. Undefined if it's the entry point. * @returns {Promise|ModuleWrap} */ - loadAndTranslate(url, loadContext, parentURL) { + loadAndTranslate(resolveResult, loadContext, parentURL) { + const { url } = resolveResult; const maybePromise = this.load(url, loadContext); const afterLoad = (loadResult) => { - const translateContext = { ...loadResult, translatorKey: loadResult.format, __proto__: null }; + const translateContext = { + ...resolveResult, + ...loadResult, + translatorKey: loadResult.format, + __proto__: null, + }; return this.#translate(url, translateContext, parentURL); }; if (isPromise(maybePromise)) { @@ -506,7 +536,7 @@ class ModuleLoader { * the module should be linked by the time this returns. Otherwise it may still have * pending module requests. * @param {string} parentURL See {@link getOrCreateModuleJob} - * @param {{format: string, url: string}} resolveResult + * @param {ResolveResult} resolveResult * @param {ModuleRequest} request Module request. * @param {ModuleRequestType} requestType Type of the module request. * @returns {ModuleJobBase} The (possibly pending) module job @@ -545,11 +575,11 @@ class ModuleLoader { let moduleOrModulePromise; if (requestType === kRequireInImportedCJS) { - moduleOrModulePromise = this.loadAndTranslateForRequireInImportedCJS(url, context, parentURL); + moduleOrModulePromise = this.loadAndTranslateForRequireInImportedCJS(resolveResult, context, parentURL); } else if (requestType === kImportInRequiredESM) { - moduleOrModulePromise = this.loadAndTranslateForImportInRequiredESM(url, context, parentURL, request); + moduleOrModulePromise = this.loadAndTranslateForImportInRequiredESM(resolveResult, context, parentURL, request); } else { - moduleOrModulePromise = this.loadAndTranslate(url, context, parentURL); + moduleOrModulePromise = this.loadAndTranslate(resolveResult, context, parentURL); } if (requestType === kImportInRequiredESM || requestType === kRequireInImportedCJS || @@ -663,7 +693,7 @@ class ModuleLoader { * @param {string} [parentURL] The URL of the module where the module request is initiated. * It's undefined if it's from the root module. * @param {ModuleRequest} request Module request. - * @returns {Promise<{format: string, url: string}>|{format: string, url: string}} + * @returns {Promise|ResolveResult} */ #resolve(parentURL, request) { if (this.isForAsyncLoaderHookWorker) { @@ -699,15 +729,18 @@ class ModuleLoader { /** * This is the default resolve step for module.registerHooks(), which incorporates asynchronous hooks * from module.register() which are run in a blocking fashion for it to be synchronous. + * @param {{isResolvedByDefaultResolve: boolean}} out Output object to track whether the default resolve was used + * without polluting the user-visible resolve result. * @param {string|URL} specifier See {@link resolveSync}. * @param {{ parentURL?: string, importAttributes: ImportAttributes, conditions?: string[]}} context * See {@link resolveSync}. * @returns {{ format: string, url: string }} */ - #resolveAndMaybeBlockOnLoaderThread(specifier, context) { + #resolveAndMaybeBlockOnLoaderThread(out, specifier, context) { if (this.#asyncLoaderHooks?.resolveSync) { return this.#asyncLoaderHooks.resolveSync(specifier, context.parentURL, context.importAttributes); } + out.isResolvedByDefaultResolve = true; return this.#cachedDefaultResolve(specifier, context); } @@ -722,31 +755,45 @@ class ModuleLoader { * @param {boolean} [shouldSkipSyncHooks] Whether to skip the synchronous hooks registered by module.registerHooks(). * This is used to maintain compatibility for the re-invented require.resolve (in imported CJS customized * by module.register()`) which invokes the CJS resolution separately from the hook chain. - * @returns {{ format: string, url: string }} + * @returns {ResolveResult} */ resolveSync(parentURL, request, shouldSkipSyncHooks = false) { const specifier = `${request.specifier}`; const importAttributes = request.attributes ?? kEmptyObject; + // Use an output parameter to track the state and avoid polluting the user-visible resolve results. + const out = { isResolvedByDefaultResolve: false, __proto__: null }; + let result; + let isResolvedBySyncHooks = false; if (!shouldSkipSyncHooks && syncResolveHooks.length) { // Has module.registerHooks() hooks, chain the asynchronous hooks in the default step. - return resolveWithSyncHooks(specifier, parentURL, importAttributes, this.#defaultConditions, - this.#resolveAndMaybeBlockOnLoaderThread.bind(this)); + result = resolveWithSyncHooks(specifier, parentURL, importAttributes, this.#defaultConditions, + this.#resolveAndMaybeBlockOnLoaderThread.bind(this, out)); + // If the default step ran, sync hooks did not short-circuit the resolution. + isResolvedBySyncHooks = !out.isResolvedByDefaultResolve; + } else { + const context = { + ...request, + conditions: this.#defaultConditions, + parentURL, + importAttributes, + __proto__: null, + }; + result = this.#resolveAndMaybeBlockOnLoaderThread(out, specifier, context); } - const context = { - ...request, - conditions: this.#defaultConditions, - parentURL, - importAttributes, - __proto__: null, - }; - return this.#resolveAndMaybeBlockOnLoaderThread(specifier, context); + result.isResolvedBySyncHooks = isResolvedBySyncHooks; + return result; } /** * Provide source that is understood by one of Node's translators. Handles customization hooks, * if any. - * @typedef { {format: ModuleFormat, source: ModuleSource }} LoadResult + * @typedef {{ + * format: ModuleFormat, + * source: ModuleSource, + * responseURL?: string, + * isSourceLoadedSynchronously: boolean, + * }} LoadResult * @param {string} url The URL of the module to be loaded. * @param {object} context Metadata about the module * @returns {Promise | LoadResult}} @@ -762,14 +809,19 @@ class ModuleLoader { /** * This is the default load step for module.registerHooks(), which incorporates asynchronous hooks * from module.register() which are run in a blocking fashion for it to be synchronous. + * @param {{isSourceLoadedSynchronously: boolean}} out + * Output object to track whether the source was loaded synchronously without polluting + * the user-visible load result. * @param {string} url See {@link load} * @param {object} context See {@link load} * @returns {{ format: ModuleFormat, source: ModuleSource }} */ - #loadAndMaybeBlockOnLoaderThread(url, context) { + #loadAndMaybeBlockOnLoaderThread(out, url, context) { if (this.#asyncLoaderHooks?.loadSync) { + out.isSourceLoadedSynchronously = false; return this.#asyncLoaderHooks.loadSync(url, context); } + out.isSourceLoadedSynchronously = true; return defaultLoadSync(url, context); } @@ -780,17 +832,32 @@ class ModuleLoader { * This is here to support `require()` in imported CJS and `module.registerHooks()` hooks. * @param {string} url See {@link load} * @param {object} [context] See {@link load} - * @returns {{ format: ModuleFormat, source: ModuleSource }} + * @returns {LoadResult} */ #loadSync(url, context) { + // Use an output parameter to track the state and avoid polluting the user-visible resolve results. + const out = { + isSourceLoadedSynchronously: true, + __proto__: null, + }; + let result; if (syncLoadHooks.length) { // Has module.registerHooks() hooks, chain the asynchronous hooks in the default step. // TODO(joyeecheung): construct the ModuleLoadContext in the loaders directly instead // of converting them from plain objects in the hooks. - return loadWithSyncHooks(url, context.format, context.importAttributes, this.#defaultConditions, - this.#loadAndMaybeBlockOnLoaderThread.bind(this), validateLoadSloppy); + result = loadWithSyncHooks( + url, + context.format, + context.importAttributes, + this.#defaultConditions, + this.#loadAndMaybeBlockOnLoaderThread.bind(this, out), + validateLoadSloppy, + ); + } else { + result = this.#loadAndMaybeBlockOnLoaderThread(out, url, context); } - return this.#loadAndMaybeBlockOnLoaderThread(url, context); + result.isSourceLoadedSynchronously = out.isSourceLoadedSynchronously; + return result; } validateLoadResult(url, format) { diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js index c947bf8f69c1bd..c453e2b54f5957 100644 --- a/lib/internal/modules/esm/translators.js +++ b/lib/internal/modules/esm/translators.js @@ -22,7 +22,6 @@ const { const { BuiltinModule } = require('internal/bootstrap/realm'); const assert = require('internal/assert'); -const fs = require('fs'); const { dirname, extname } = require('path'); const { assertBufferSource, @@ -97,6 +96,8 @@ const kShouldSkipModuleHooks = { __proto__: null, shouldSkipModuleHooks: true }; const kShouldNotSkipModuleHooks = { __proto__: null, shouldSkipModuleHooks: false }; /** + * This may be eventually removed when module.register() reaches end-of-life. + * * Loads a CommonJS module via the ESM Loader sync CommonJS translator. * This translator creates its own version of the `require` function passed into CommonJS modules. * Any monkey patches applied to the CommonJS Loader will not affect this module. @@ -106,8 +107,9 @@ const kShouldNotSkipModuleHooks = { __proto__: null, shouldSkipModuleHooks: fals * @param {string} url - The URL of the module. * @param {string} filename - The filename of the module. * @param {boolean} isMain - Whether the module is the entrypoint + * @param {TranslateContext} translateContext Context for the translator */ -function loadCJSModule(module, source, url, filename, isMain) { +function loadCJSModuleWithSpecialRequire(module, source, url, filename, isMain, translateContext) { // Use the full URL as the V8 resource name so that any search params // (e.g. ?node-test-mock) are preserved in coverage reports. const compileResult = compileFunctionForCJSLoader(source, url, false /* is_sea_main */, false); @@ -194,21 +196,24 @@ const cjsCache = new SafeMap(); /** * Creates a ModuleWrap object for a CommonJS module. * @param {string} url - The URL of the module. - * @param {{ format: ModuleFormat, source: ModuleSource }} translateContext Context for the translator + * @param {import('./loader').TranslateContext} translateContext Context for the translator * @param {string|undefined} parentURL URL of the module initiating the module loading for the first time. * Undefined if it's the entry point. - * @param {typeof loadCJSModule} [loadCJS] - The function to load the CommonJS module. * @returns {ModuleWrap} The ModuleWrap object for the CommonJS module. */ -function createCJSModuleWrap(url, translateContext, parentURL, loadCJS = loadCJSModule) { +function createCJSModuleWrap(url, translateContext, parentURL) { debug(`Translating CJSModule ${url}`, translateContext); const { format: sourceFormat } = translateContext; let { source } = translateContext; const isMain = (parentURL === undefined); const filename = urlToFilename(url); - // In case the source was not provided by the `load` step, we need fetch it now. - source = stringify(source ?? getSourceSync(new URL(url)).source); + try { + // In case the source was not provided by the `load` step, we need fetch it now. + source = stringify(source ?? getSourceSync(new URL(url)).source); + } catch { + // Continue regardless of error. + } const { exportNames, module } = cjsPreparseModuleExports(filename, source, sourceFormat); cjsCache.set(url, module); @@ -229,7 +234,19 @@ function createCJSModuleWrap(url, translateContext, parentURL, loadCJS = loadCJS debug(`Loading CJSModule ${url}`); if (!module.loaded) { - loadCJS(module, source, url, filename, !!isMain); + // For backward-compatibility, it's possible for async hooks to return a nullish value for + // CJS source associated with a `file:` URL - that usually means the source is not + // customized (is loaded by default load) or the hook author wants it to be reloaded + // through CJS routine. In this case, the source is obtained by calling the + // Module._load(). + if (translateContext.translatorKey === 'commonjs-sync' || + translateContext.isSourceLoadedSynchronously || + translateContext.source == null) { + loadCJSModuleWithModuleLoad(module, source, url, filename, !!isMain, translateContext); + } else { // CommonJS with source customized by async hooks + // This may be eventually removed when module.register() reaches end-of-life. + loadCJSModuleWithSpecialRequire(module, source, url, filename, !!isMain, translateContext); + } } let exports; @@ -303,55 +320,73 @@ function createCJSNoSourceModuleWrap(url, parentURL) { } translators.set('commonjs-sync', function requireCommonJS(url, translateContext, parentURL) { - return createCJSModuleWrap(url, translateContext, parentURL, loadCJSModuleWithModuleLoad); + return createCJSModuleWrap(url, translateContext, parentURL); }); -// Handle CommonJS modules referenced by `require` calls. -// This translator function must be sync, as `require` is sync. +// Handle CommonJS modules referenced by `require` calls using re-invented require. +// This path is only used by require() from imported CJS customized by the *async* +// loader hooks. translators.set('require-commonjs', (url, translateContext, parentURL) => { return createCJSModuleWrap(url, translateContext, parentURL); }); -// Handle CommonJS modules referenced by `require` calls. -// This translator function must be sync, as `require` is sync. +// Handle TypeScript CommonJS modules referenced by `require` calls using re-invented require. +// This path is only used by require() from imported CJS customized by the *async* +// loader hooks. translators.set('require-commonjs-typescript', (url, translateContext, parentURL) => { translateContext.source = stripTypeScriptModuleTypes(stringify(translateContext.source), url); return createCJSModuleWrap(url, translateContext, parentURL); }); // This goes through Module._load to accommodate monkey-patchers. -function loadCJSModuleWithModuleLoad(module, source, url, filename, isMain) { +/** + * Loads a CommonJS module through Module._load to accommodate monkey-patchers. + * If the module was resolved by synchronous hooks (i.e. not by the default resolver), + * passes the pre-resolved information and source to Module._load to avoid + * re-resolving and re-loading. + * @param {import('internal/modules/cjs/loader').Module} module - The module to load. + * @param {string} source - The source code of the module. + * @param {string} url - The URL of the module. + * @param {string} filename - The filename of the module. + * @param {boolean} isMain - Whether the module is the entrypoint + * @param {import('./loader').TranslateContext} translateContext Context for the translator + */ +function loadCJSModuleWithModuleLoad(module, source, url, filename, isMain, translateContext) { assert(module === CJSModule._cache[filename]); - // If it gets here in the translators, the hooks must have already been invoked - // in the loader. Skip them in the synthetic module evaluation step. - wrapModuleLoad(filename, undefined, isMain, kShouldSkipModuleHooks); + debug(`loadCJSModuleWithModuleLoad ${url}`); + let exports; + if (translateContext.isResolvedBySyncHooks) { + exports = wrapModuleLoad(filename, undefined, isMain, { + __proto__: null, + resolved: { + __proto__: null, + filename, + format: translateContext.format, + url, + }, + shouldSkipModuleHooks: true, + source, + }); + } else { + // If it gets here in the translators, the hooks must have already been invoked + // in the loader. Skip them in the synthetic module evaluation step. + exports = wrapModuleLoad(filename, undefined, isMain, kShouldSkipModuleHooks); + } + + // Patched Module._load implementations may return exports without updating the + // ESM-created cache entry. Mirror the returned value into the translator-owned + // module so the synthetic module namespace observes the loaded exports. + if (!module.loaded) { + module.exports = exports; + module.loaded = true; + } + module[kModuleExport] = exports; } // Handle CommonJS modules referenced by `import` statements or expressions, // or as the initial entry point when the ESM loader handles a CommonJS entry. translators.set('commonjs', function commonjsStrategy(url, translateContext, parentURL) { - // For backward-compatibility, it's possible to return a nullish value for - // CJS source associated with a `file:` URL - that usually means the source is not - // customized (is loaded by default load) or the hook author wants it to be reloaded - // through CJS routine. In this case, the source is obtained by calling the - // monkey-patchable CJS loader. - // TODO(joyeecheung): just use wrapModuleLoad and let the CJS loader - // invoke the off-thread hooks. Use a special parent to avoid invoking in-thread - // hooks twice. - const shouldReloadByCJSLoader = (translateContext.shouldBeReloadedByCJSLoader || translateContext.source == null); - const cjsLoader = shouldReloadByCJSLoader ? loadCJSModuleWithModuleLoad : loadCJSModule; - - try { - // We still need to read the FS to detect the exports. - // If you are reading this code to figure out how to patch Node.js module loading - // behavior - DO NOT depend on the patchability in new code: Node.js - // internals may stop going through the JavaScript fs module entirely. - // Prefer module.registerHooks() or other more formal fs hooks released in the future. - translateContext.source ??= fs.readFileSync(new URL(url), 'utf8'); - } catch { - // Continue regardless of error. - } - return createCJSModuleWrap(url, translateContext, parentURL, cjsLoader); + return createCJSModuleWrap(url, translateContext, parentURL); }); /** diff --git a/lib/internal/test_runner/mock/mock.js b/lib/internal/test_runner/mock/mock.js index fb1ed322b414fc..d15ace222b2132 100644 --- a/lib/internal/test_runner/mock/mock.js +++ b/lib/internal/test_runner/mock/mock.js @@ -51,8 +51,15 @@ const { validateOneOf, } = require('internal/validators'); const { MockTimers } = require('internal/test_runner/mock/mock_timers'); -const { Module } = require('internal/modules/cjs/loader'); -const { _load, _nodeModulePaths, _resolveFilename, isBuiltin } = Module; +const { + Module, +} = require('internal/modules/cjs/loader'); +const { + _load, + _nodeModulePaths, + _resolveFilename, + isBuiltin, +} = Module; function kDefaultFunction() {} const enableModuleMocking = getOptionValue('--experimental-test-module-mocks'); const kSupportedFormats = [ @@ -905,6 +912,21 @@ function setupSharedModuleState() { } function cjsMockModuleLoad(request, parent, isMain) { + // Imported mocked URLs may re-enter Module._load with the mock query attached. + // Strip it to pass into methods that expect a normal request. + // TODO(joyeecheung): it might be better to strip the search params from the filename in + // the translator but that might have a bigger blast radius as other mocker might have also + // come to rely on this to create multiple cache identities for the same module. + try { + const parsedRequest = URLParse(request); + if (parsedRequest?.searchParams.has(kMockSearchParam)) { + parsedRequest.searchParams.delete(kMockSearchParam); + request = parsedRequest.href; + } + } catch { + // Not a valid URL, treat as a normal request. + } + let resolved; if (isBuiltin(request)) { diff --git a/test/module-hooks/test-module-hooks-load-import-cjs-custom-source.js b/test/module-hooks/test-module-hooks-load-import-cjs-custom-source.js new file mode 100644 index 00000000000000..723f5158cebc9f --- /dev/null +++ b/test/module-hooks/test-module-hooks-load-import-cjs-custom-source.js @@ -0,0 +1,41 @@ +'use strict'; +// Test that imported CJS loaded from sync hooks are handled correctly and +// won't invoke the CJS loading steps again (in which case it would throw +// because the source is not on disk). + +const common = require('../common'); +const assert = require('assert'); +const { registerHooks } = require('module'); + +const virtualModules = new Map([ + ['virtual:shared', 'module.exports.greet = (name) => "hello " + name;'], + ['virtual:entry', 'const { greet } = require("virtual:shared");\nmodule.exports = greet("world");'], +]); + +const hook = registerHooks({ + resolve: common.mustCall((specifier, context, nextResolve) => { + if (virtualModules.has(specifier)) { + return { + url: specifier, + format: 'commonjs', + shortCircuit: true, + }; + } + return nextResolve(specifier, context); + }, 2), + load: common.mustCall((url, context, nextLoad) => { + if (virtualModules.has(url)) { + return { + format: 'commonjs', + source: virtualModules.get(url), + shortCircuit: true, + }; + } + return nextLoad(url, context); + }, 2), +}); + +import('virtual:entry').then(common.mustCall((ns) => { + assert.strictEqual(ns.default, 'hello world'); + hook.deregister(); +})); From 1fd494962864ce545cb0a2fb961a3056210273ab Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Thu, 7 May 2026 21:02:13 +0200 Subject: [PATCH 088/168] crypto: reject invalid raw key imports Signed-off-by: Filip Skokan PR-URL: https://github.com/nodejs/node/pull/63134 Reviewed-By: Anna Henningsen Reviewed-By: Yagiz Nizipli Reviewed-By: James M Snell --- lib/internal/crypto/keys.js | 4 + lib/internal/crypto/ml_kem.js | 4 +- src/crypto/crypto_keys.cc | 121 ++++++++++++------ src/crypto/crypto_pqc.cc | 10 ++ src/crypto/crypto_pqc.h | 7 + test/parallel/test-crypto-key-objects-raw.js | 68 +++++++++- .../test-crypto-pqc-key-objects-slh-dsa.js | 6 + 7 files changed, 181 insertions(+), 39 deletions(-) diff --git a/lib/internal/crypto/keys.js b/lib/internal/crypto/keys.js index 03ace95df21dca..f9fd873d371e71 100644 --- a/lib/internal/crypto/keys.js +++ b/lib/internal/crypto/keys.js @@ -666,6 +666,10 @@ function prepareAsymmetricKey(key, ctx, name = 'key') { return { data, format: kKeyFormatJWK }; } else if (format === 'raw-public' || format === 'raw-private' || format === 'raw-seed') { + if ((ctx === kConsumePrivate || ctx === kCreatePrivate) && + format === 'raw-public') { + throw new ERR_INVALID_ARG_VALUE(`${name}.format`, format); + } if (!isArrayBufferView(data) && !isAnyArrayBuffer(data)) { throw new ERR_INVALID_ARG_TYPE( `${name}.key`, diff --git a/lib/internal/crypto/ml_kem.js b/lib/internal/crypto/ml_kem.js index 67f5ddd0ff2499..abb156ee07262d 100644 --- a/lib/internal/crypto/ml_kem.js +++ b/lib/internal/crypto/ml_kem.js @@ -13,8 +13,8 @@ const { KEMDecapsulateJob, KEMEncapsulateJob, kKeyFormatDER, - kKeyFormatRawPrivate, kKeyFormatRawPublic, + kKeyFormatRawSeed, kWebCryptoKeyFormatPKCS8, kWebCryptoKeyFormatRaw, kWebCryptoKeyFormatSPKI, @@ -178,7 +178,7 @@ function mlKemImportKey( case 'raw-seed': { const isPublic = format === 'raw-public'; verifyAcceptableMlKemKeyUse(name, isPublic, usagesSet); - handle = importRawKey(isPublic, keyData, isPublic ? kKeyFormatRawPublic : kKeyFormatRawPrivate, name); + handle = importRawKey(isPublic, keyData, isPublic ? kKeyFormatRawPublic : kKeyFormatRawSeed, name); break; } case 'jwk': { diff --git a/src/crypto/crypto_keys.cc b/src/crypto/crypto_keys.cc index 92bb7dbb9714ce..560e13903e88e3 100644 --- a/src/crypto/crypto_keys.cc +++ b/src/crypto/crypto_keys.cc @@ -336,6 +336,85 @@ int GetNidFromName(const char* name) { } return NID_undef; } + +bool IsUnavailablePqcKeyType(Environment* env, Local key_type) { + return key_type->StringEquals(env->crypto_ml_dsa_44_string()) || + key_type->StringEquals(env->crypto_ml_dsa_65_string()) || + key_type->StringEquals(env->crypto_ml_dsa_87_string()) || + key_type->StringEquals(env->crypto_ml_kem_512_string()) || + key_type->StringEquals(env->crypto_ml_kem_768_string()) || + key_type->StringEquals(env->crypto_ml_kem_1024_string()) || + key_type->StringEquals(env->crypto_slh_dsa_sha2_128f_string()) || + key_type->StringEquals(env->crypto_slh_dsa_sha2_128s_string()) || + key_type->StringEquals(env->crypto_slh_dsa_sha2_192f_string()) || + key_type->StringEquals(env->crypto_slh_dsa_sha2_192s_string()) || + key_type->StringEquals(env->crypto_slh_dsa_sha2_256f_string()) || + key_type->StringEquals(env->crypto_slh_dsa_sha2_256s_string()) || + key_type->StringEquals(env->crypto_slh_dsa_shake_128f_string()) || + key_type->StringEquals(env->crypto_slh_dsa_shake_128s_string()) || + key_type->StringEquals(env->crypto_slh_dsa_shake_192f_string()) || + key_type->StringEquals(env->crypto_slh_dsa_shake_192s_string()) || + key_type->StringEquals(env->crypto_slh_dsa_shake_256f_string()) || + key_type->StringEquals(env->crypto_slh_dsa_shake_256s_string()); +} + +bool IsUnsupportedRawKeyType(Environment* env, Local key_type) { + return key_type->StringEquals(env->crypto_rsa_string()) || + key_type->StringEquals(env->crypto_rsa_pss_string()) || + key_type->StringEquals(env->crypto_dsa_string()) || + key_type->StringEquals(env->crypto_dh_string()); +} + +void ValidateRawKeyImportFormat(Environment* env, + Local key_type, + const char* key_type_name, + int id, + EVPKeyPointer::PKFormatType format) { + auto validate_raw_format = + [&](EVPKeyPointer::PKFormatType expected_private_format) { + if (format == EVPKeyPointer::PKFormatType::RAW_PUBLIC || + format == expected_private_format) { + return; + } + THROW_ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS(env); + }; + + if (key_type->StringEquals(env->crypto_ec_string())) { + return validate_raw_format(EVPKeyPointer::PKFormatType::RAW_PRIVATE); + } + + switch (id) { + case EVP_PKEY_X25519: + case EVP_PKEY_X448: + case EVP_PKEY_ED25519: + case EVP_PKEY_ED448: + return validate_raw_format(EVPKeyPointer::PKFormatType::RAW_PRIVATE); + default: + break; + } + +#if OPENSSL_WITH_PQC + if (IsPqcSeedKeyId(id)) { + return validate_raw_format(EVPKeyPointer::PKFormatType::RAW_SEED); + } + if (IsPqcRawPrivateKeyId(id)) { + return validate_raw_format(EVPKeyPointer::PKFormatType::RAW_PRIVATE); + } +#endif + + if (IsUnavailablePqcKeyType(env, key_type)) { + THROW_ERR_INVALID_ARG_VALUE(env, "Unsupported key type"); + return; + } + + if (IsUnsupportedRawKeyType(env, key_type)) { + THROW_ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS(env); + return; + } + + THROW_ERR_INVALID_ARG_VALUE( + env, "Invalid asymmetricKeyType: %s", key_type_name); +} } // namespace bool KeyObjectData::ToEncodedPublicKey( @@ -585,6 +664,12 @@ static KeyObjectData ImportRawKey(Environment* env, } }; + const int id = GetNidFromName(key_type_name); + ValidateRawKeyImportFormat(env, key_type, key_type_name, id, format); + if (env->isolate()->HasPendingException()) { + return {}; + } + // EC keys if (key_type->StringEquals(env->crypto_ec_string())) { int curve_nid = ncrypto::Ec::GetCurveIdFromName(named_curve); @@ -642,8 +727,6 @@ static KeyObjectData ImportRawKey(Environment* env, return KeyObjectData::CreateAsymmetric(target_type, std::move(pkey)); } - int id = GetNidFromName(key_type_name); - typedef EVPKeyPointer (*new_key_fn)( int, const ncrypto::Buffer&); new_key_fn fn = nullptr; @@ -698,40 +781,6 @@ static KeyObjectData ImportRawKey(Environment* env, return KeyObjectData::CreateAsymmetric(target_type, std::move(pkey)); } - if (key_type->StringEquals(env->crypto_rsa_string()) || - key_type->StringEquals(env->crypto_rsa_pss_string()) || - key_type->StringEquals(env->crypto_dsa_string()) || - key_type->StringEquals(env->crypto_dh_string())) { - THROW_ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS(env); - return {}; - } - -#if !OPENSSL_WITH_PQC - if (key_type->StringEquals(env->crypto_ml_dsa_44_string()) || - key_type->StringEquals(env->crypto_ml_dsa_65_string()) || - key_type->StringEquals(env->crypto_ml_dsa_87_string()) || - key_type->StringEquals(env->crypto_ml_kem_512_string()) || - key_type->StringEquals(env->crypto_ml_kem_768_string()) || - key_type->StringEquals(env->crypto_ml_kem_1024_string()) || - key_type->StringEquals(env->crypto_slh_dsa_sha2_128f_string()) || - key_type->StringEquals(env->crypto_slh_dsa_sha2_128s_string()) || - key_type->StringEquals(env->crypto_slh_dsa_sha2_192f_string()) || - key_type->StringEquals(env->crypto_slh_dsa_sha2_192s_string()) || - key_type->StringEquals(env->crypto_slh_dsa_sha2_256f_string()) || - key_type->StringEquals(env->crypto_slh_dsa_sha2_256s_string()) || - key_type->StringEquals(env->crypto_slh_dsa_shake_128f_string()) || - key_type->StringEquals(env->crypto_slh_dsa_shake_128s_string()) || - key_type->StringEquals(env->crypto_slh_dsa_shake_192f_string()) || - key_type->StringEquals(env->crypto_slh_dsa_shake_192s_string()) || - key_type->StringEquals(env->crypto_slh_dsa_shake_256f_string()) || - key_type->StringEquals(env->crypto_slh_dsa_shake_256s_string())) { - THROW_ERR_INVALID_ARG_VALUE(env, "Unsupported key type"); - return {}; - } -#endif - - THROW_ERR_INVALID_ARG_VALUE( - env, "Invalid asymmetricKeyType: %s", key_type_name); return {}; } diff --git a/src/crypto/crypto_pqc.cc b/src/crypto/crypto_pqc.cc index cd2024cbe2f05d..bf40052fb6ea1e 100644 --- a/src/crypto/crypto_pqc.cc +++ b/src/crypto/crypto_pqc.cc @@ -175,6 +175,16 @@ KeyObjectData ImportJWKPqcKey(Environment* env, Local jwk) { return KeyObjectData::CreateAsymmetric(type, std::move(pkey)); } + +bool IsPqcRawPrivateKeyId(int id) { + const PqcAlgorithm* alg = FindPqcAlgorithmById(id); + return alg != nullptr && !alg->use_seed; +} + +bool IsPqcSeedKeyId(int id) { + const PqcAlgorithm* alg = FindPqcAlgorithmById(id); + return alg != nullptr && alg->use_seed; +} #endif } // namespace crypto } // namespace node diff --git a/src/crypto/crypto_pqc.h b/src/crypto/crypto_pqc.h index 7a805c0e36c6a3..156066097bbfb9 100644 --- a/src/crypto/crypto_pqc.h +++ b/src/crypto/crypto_pqc.h @@ -15,6 +15,13 @@ bool ExportJwkPqcKey(Environment* env, v8::Local target); KeyObjectData ImportJWKPqcKey(Environment* env, v8::Local jwk); + +// Returns true for PQC algorithms that support raw private key export/import. +bool IsPqcRawPrivateKeyId(int id); +// Returns true for PQC algorithms that carry the private key as a seed +// (ML-DSA, ML-KEM). Returns false for algorithms that use the expanded +// private key (SLH-DSA), or for non-PQC ids. +bool IsPqcSeedKeyId(int id); #endif } // namespace crypto } // namespace node diff --git a/test/parallel/test-crypto-key-objects-raw.js b/test/parallel/test-crypto-key-objects-raw.js index 9ef4bd3b9004d1..311659ef004ea2 100644 --- a/test/parallel/test-crypto-key-objects-raw.js +++ b/test/parallel/test-crypto-key-objects-raw.js @@ -59,6 +59,47 @@ const { hasOpenSSL } = require('../common/crypto'); } } +// Raw public keys cannot be imported as private keys. +{ + const rawPublicKeys = [ + ['ec', 'ec_p256_public.pem', { namedCurve: 'P-256' }], + ['ed25519', 'ed25519_public.pem'], + ['x25519', 'x25519_public.pem'], + ]; + + if (!process.features.openssl_is_boringssl) { + rawPublicKeys.push( + ['ed448', 'ed448_public.pem'], + ['x448', 'x448_public.pem'], + ); + } else { + common.printSkipMessage('Skipping unsupported ed448/x448 test cases'); + } + + if (hasOpenSSL(3, 5) || process.features.openssl_is_boringssl) { + rawPublicKeys.push( + ['ml-dsa-44', 'ml_dsa_44_public.pem'], + ['ml-kem-768', 'ml_kem_768_public.pem'], + ); + } + + if (hasOpenSSL(3, 5)) { + rawPublicKeys.push( + ['slh-dsa-sha2-128f', 'slh_dsa_sha2_128f_public.pem'], + ); + } + + for (const [asymmetricKeyType, fixture, options = {}] of rawPublicKeys) { + const publicKey = crypto.createPublicKey(fixtures.readKey(fixture, 'ascii')); + assert.throws(() => crypto.createPrivateKey({ + key: publicKey.export({ format: 'raw-public' }), + format: 'raw-public', + asymmetricKeyType, + ...options, + }), { code: 'ERR_INVALID_ARG_VALUE' }); + } +} + // Raw seed imports do not support strings. if (hasOpenSSL(3, 5)) { const privKeyObj = crypto.createPrivateKey( @@ -113,7 +154,11 @@ if (hasOpenSSL(3, 5)) { assert.throws(() => privKeyObj.export({ format: 'raw-private' }), { code: 'ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS' }); - for (const format of ['raw-public', 'raw-private', 'raw-seed']) { + assert.throws(() => crypto.createPrivateKey({ + key: Buffer.alloc(32), format: 'raw-public', asymmetricKeyType: 'dh', + }), { code: 'ERR_INVALID_ARG_VALUE' }); + + for (const format of ['raw-private', 'raw-seed']) { assert.throws(() => crypto.createPrivateKey({ key: Buffer.alloc(32), format, asymmetricKeyType: 'dh', }), { code: 'ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS' }); @@ -274,6 +319,12 @@ if (hasOpenSSL(3, 5)) { fixtures.readKey('ec_p256_private.pem', 'ascii')); assert.throws(() => ecPriv.export({ format: 'raw-seed' }), { code: 'ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS' }); + assert.throws(() => crypto.createPrivateKey({ + key: ecPriv.export({ format: 'raw-private' }), + format: 'raw-seed', + asymmetricKeyType: 'ec', + namedCurve: 'P-256', + }), { code: 'ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS' }); if (process.features.openssl_is_boringssl) { common.printSkipMessage('Skipping unsupported ed448/x448 test cases'); @@ -285,6 +336,11 @@ if (hasOpenSSL(3, 5)) { fixtures.readKey(`${type}_private.pem`, 'ascii')); assert.throws(() => priv.export({ format: 'raw-seed' }), { code: 'ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS' }); + assert.throws(() => crypto.createPrivateKey({ + key: priv.export({ format: 'raw-private' }), + format: 'raw-seed', + asymmetricKeyType: type, + }), { code: 'ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS' }); } if (hasOpenSSL(3, 5)) { @@ -292,6 +348,11 @@ if (hasOpenSSL(3, 5)) { fixtures.readKey('slh_dsa_sha2_128f_private.pem', 'ascii')); assert.throws(() => slhPriv.export({ format: 'raw-seed' }), { code: 'ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS' }); + assert.throws(() => crypto.createPrivateKey({ + key: slhPriv.export({ format: 'raw-private' }), + format: 'raw-seed', + asymmetricKeyType: 'slh-dsa-sha2-128f', + }), { code: 'ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS' }); } } @@ -302,6 +363,11 @@ if (hasOpenSSL(3, 5)) { fixtures.readKey(`${type.replaceAll('-', '_')}_private.pem`, 'ascii')); assert.throws(() => priv.export({ format: 'raw-private' }), { code: 'ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS' }); + assert.throws(() => crypto.createPrivateKey({ + key: priv.export({ format: 'raw-seed' }), + format: 'raw-private', + asymmetricKeyType: type, + }), { code: 'ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS' }); } } diff --git a/test/parallel/test-crypto-pqc-key-objects-slh-dsa.js b/test/parallel/test-crypto-pqc-key-objects-slh-dsa.js index 98af15dc795f8b..eff309468c3117 100644 --- a/test/parallel/test-crypto-pqc-key-objects-slh-dsa.js +++ b/test/parallel/test-crypto-pqc-key-objects-slh-dsa.js @@ -91,6 +91,12 @@ for (const asymmetricKeyType of [ key: rawPriv, format: 'raw-private', asymmetricKeyType, }); assert.strictEqual(importedPriv.equals(key), true); + assert.throws(() => createPrivateKey({ + key: rawPriv, format: 'raw-seed', asymmetricKeyType, + }), { code: 'ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS' }); + assert.throws(() => createPublicKey({ + key: rawPriv, format: 'raw-seed', asymmetricKeyType, + }), { code: 'ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS' }); } if (!hasOpenSSL(3, 5)) { From b3ae59d7c604d7715c34db1e678591d0ffcb202a Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Mon, 4 May 2026 11:52:07 +0200 Subject: [PATCH 089/168] crypto: harden KeyObject internal slots Move KeyObject type and handle storage behind NativeKeyObject and expose it to JS through a module-private slot reader, mirroring the CryptoKey hardening. Cache the native slot tuple in a private field and lazily derive secret and asymmetric metadata from the cached KeyObjectHandle. Update internal crypto, QUIC, and comparison callers to use private helpers instead of public KeyObject accessors. Keep getKeyObjectSlots restricted to internal/crypto/keys with an ESLint guard. Add regression coverage for brand checks, hidden slots, clone and transfer behavior, own-property reflection, and post-clone crypto operations. Extend the CryptoKey brand test to assert getSlots is not reachable through the public constructor or prototype chain. Signed-off-by: Filip Skokan PR-URL: https://github.com/nodejs/node/pull/63111 Reviewed-By: James M Snell Reviewed-By: Yagiz Nizipli --- lib/eslint.config_partial.mjs | 4 + lib/internal/crypto/aes.js | 7 +- lib/internal/crypto/cfrg.js | 8 +- lib/internal/crypto/chacha20_poly1305.js | 4 +- lib/internal/crypto/ec.js | 8 +- lib/internal/crypto/hkdf.js | 7 +- lib/internal/crypto/keys.js | 316 +++++++++++++----- lib/internal/crypto/mac.js | 7 +- lib/internal/crypto/ml_dsa.js | 8 +- lib/internal/crypto/ml_kem.js | 8 +- lib/internal/crypto/rsa.js | 8 +- lib/internal/crypto/x509.js | 10 +- lib/internal/quic/quic.js | 7 +- lib/internal/util/comparisons.js | 13 +- src/crypto/README.md | 12 +- src/crypto/crypto_keys.cc | 43 ++- src/crypto/crypto_keys.h | 14 + src/crypto/crypto_util.cc | 6 +- src/env_properties.h | 1 + .../test-crypto-keyobject-brand-check.js | 96 ++++++ .../test-crypto-keyobject-clone-transfer.js | 138 ++++++++ .../test-crypto-keyobject-hidden-slots.js | 213 ++++++++++++ .../test-crypto-keyobject-no-own-symbols.js | 42 +++ .../test-webcrypto-cryptokey-brand-check.js | 6 + 24 files changed, 858 insertions(+), 128 deletions(-) create mode 100644 test/parallel/test-crypto-keyobject-brand-check.js create mode 100644 test/parallel/test-crypto-keyobject-clone-transfer.js create mode 100644 test/parallel/test-crypto-keyobject-hidden-slots.js create mode 100644 test/parallel/test-crypto-keyobject-no-own-symbols.js diff --git a/lib/eslint.config_partial.mjs b/lib/eslint.config_partial.mjs index 61632a7ee447e6..3c9bf0bc4e177c 100644 --- a/lib/eslint.config_partial.mjs +++ b/lib/eslint.config_partial.mjs @@ -75,6 +75,10 @@ export default [ selector: "VariableDeclarator[init.type='CallExpression'][init.callee.name='internalBinding'][init.arguments.0.value='crypto'] > ObjectPattern > Property[key.name='getCryptoKeySlots']", message: "Use `const { getCryptoKeySlots } = require('internal/crypto/keys');` instead of destructuring it from `internalBinding('crypto')`.", }, + { + selector: "VariableDeclarator[init.type='CallExpression'][init.callee.name='internalBinding'][init.arguments.0.value='crypto'] > ObjectPattern > Property[key.name='getKeyObjectSlots']", + message: "Use `const { getKeyObjectSlots } = require('internal/crypto/keys');` instead of destructuring it from `internalBinding('crypto')`.", + }, ], 'no-restricted-globals': [ 'error', diff --git a/lib/internal/crypto/aes.js b/lib/internal/crypto/aes.js index 123babf6fd570d..73fdde03d73ba8 100644 --- a/lib/internal/crypto/aes.js +++ b/lib/internal/crypto/aes.js @@ -30,7 +30,6 @@ const { getUsagesMask, hasAnyNotIn, jobPromise, - kHandle, } = require('internal/crypto/util'); const { @@ -41,6 +40,8 @@ const { InternalCryptoKey, getCryptoKeyAlgorithm, getCryptoKeyHandle, + getKeyObjectHandle, + getKeyObjectSymmetricKeySize, } = require('internal/crypto/keys'); const { @@ -219,9 +220,9 @@ function aesImportKey( let length; switch (format) { case 'KeyObject': { - length = keyData.symmetricKeySize * 8; + length = getKeyObjectSymmetricKeySize(keyData) * 8; validateKeyLength(length); - handle = keyData[kHandle]; + handle = getKeyObjectHandle(keyData); break; } case 'raw-secret': diff --git a/lib/internal/crypto/cfrg.js b/lib/internal/crypto/cfrg.js index f3e3e008b629f3..8d26a2888200ff 100644 --- a/lib/internal/crypto/cfrg.js +++ b/lib/internal/crypto/cfrg.js @@ -28,7 +28,6 @@ const { getUsagesUnion, hasAnyNotIn, jobPromise, - kHandle, } = require('internal/crypto/util'); const { @@ -38,6 +37,8 @@ const { const { getCryptoKeyHandle, getCryptoKeyType, + getKeyObjectHandle, + getKeyObjectType, InternalCryptoKey, } = require('internal/crypto/keys'); @@ -188,8 +189,9 @@ function cfrgImportKey( const usagesSet = new SafeSet(keyUsages); switch (format) { case 'KeyObject': { - verifyAcceptableCfrgKeyUse(name, keyData.type === 'public', usagesSet); - handle = keyData[kHandle]; + verifyAcceptableCfrgKeyUse( + name, getKeyObjectType(keyData) === 'public', usagesSet); + handle = getKeyObjectHandle(keyData); break; } case 'spki': { diff --git a/lib/internal/crypto/chacha20_poly1305.js b/lib/internal/crypto/chacha20_poly1305.js index ca7ec501bf4a0c..1bd173cab36191 100644 --- a/lib/internal/crypto/chacha20_poly1305.js +++ b/lib/internal/crypto/chacha20_poly1305.js @@ -14,7 +14,6 @@ const { getUsagesMask, hasAnyNotIn, jobPromise, - kHandle, } = require('internal/crypto/util'); const { @@ -24,6 +23,7 @@ const { const { InternalCryptoKey, getCryptoKeyHandle, + getKeyObjectHandle, } = require('internal/crypto/keys'); const { @@ -87,7 +87,7 @@ function c20pImportKey( let handle; switch (format) { case 'KeyObject': { - handle = keyData[kHandle]; + handle = getKeyObjectHandle(keyData); break; } case 'raw-secret': { diff --git a/lib/internal/crypto/ec.js b/lib/internal/crypto/ec.js index e399071228e4e8..983bfde2e8efa6 100644 --- a/lib/internal/crypto/ec.js +++ b/lib/internal/crypto/ec.js @@ -34,7 +34,6 @@ const { hasAnyNotIn, jobPromise, normalizeHashName, - kHandle, kNamedCurveAliases, } = require('internal/crypto/util'); @@ -47,6 +46,8 @@ const { getCryptoKeyAlgorithm, getCryptoKeyHandle, getCryptoKeyType, + getKeyObjectHandle, + getKeyObjectType, } = require('internal/crypto/keys'); const { @@ -189,8 +190,9 @@ function ecImportKey( const usagesSet = new SafeSet(keyUsages); switch (format) { case 'KeyObject': { - verifyAcceptableEcKeyUse(name, keyData.type === 'public', usagesSet); - handle = keyData[kHandle]; + verifyAcceptableEcKeyUse( + name, getKeyObjectType(keyData) === 'public', usagesSet); + handle = getKeyObjectHandle(keyData); break; } case 'spki': { diff --git a/lib/internal/crypto/hkdf.js b/lib/internal/crypto/hkdf.js index 4203e3ee21c701..424c56fd894961 100644 --- a/lib/internal/crypto/hkdf.js +++ b/lib/internal/crypto/hkdf.js @@ -29,6 +29,7 @@ const { const { createSecretKey, getCryptoKeyHandle, + getKeyObjectHandle, isKeyObject, } = require('internal/crypto/keys'); @@ -75,10 +76,10 @@ const validateParameters = hideStackFrames((hash, key, salt, info, length) => { function prepareKey(key) { if (isKeyObject(key)) - return key; + return getKeyObjectHandle(key); if (isAnyArrayBuffer(key)) - return createSecretKey(key); + return getKeyObjectHandle(createSecretKey(key)); key = toBuf(key); @@ -96,7 +97,7 @@ function prepareKey(key) { key); } - return createSecretKey(key); + return getKeyObjectHandle(createSecretKey(key)); } function hkdf(hash, key, salt, info, length, callback) { diff --git a/lib/internal/crypto/keys.js b/lib/internal/crypto/keys.js index f9fd873d371e71..42ff6cd227b5e3 100644 --- a/lib/internal/crypto/keys.js +++ b/lib/internal/crypto/keys.js @@ -3,10 +3,8 @@ const { ArrayPrototypeSlice, ObjectDefineProperties, - ObjectDefineProperty, ObjectSetPrototypeOf, SafeSet, - Symbol, SymbolToStringTag, Uint8Array, } = primordials; @@ -14,6 +12,8 @@ const { const { KeyObjectHandle, createNativeKeyObjectClass, + // eslint-disable-next-line no-restricted-syntax -- intended here + getKeyObjectSlots: nativeGetKeyObjectSlots, createCryptoKeyClass, // eslint-disable-next-line no-restricted-syntax -- intended here getCryptoKeySlots: nativeGetCryptoKeySlots, @@ -57,7 +57,6 @@ const { } = require('internal/errors'); const { - kHandle, getArrayBufferOrView, bigIntArrayToUnsignedBigInt, normalizeAlgorithm, @@ -76,18 +75,12 @@ const { customInspectSymbol: kInspect, getDeprecationWarningEmitter, kEnumerableProperty, + kEmptyObject, lazyDOMException, } = require('internal/util'); const { inspect } = require('internal/util/inspect'); -// Module-local symbol used by KeyObject to store its `type` string -// ("secret"/"public"/"private"). It is also used by `isKeyObject` to -// distinguish KeyObject instances from other types. CryptoKey no longer -// uses any module-local symbol slots - its state lives in C++ internal -// fields on `NativeCryptoKey`. -const kKeyType = Symbol('kKeyType'); - const emitDEP0203 = getDeprecationWarningEmitter( 'DEP0203', 'Passing a CryptoKey to node:crypto functions is deprecated.', @@ -112,6 +105,32 @@ for (const m of [[kKeyEncodingPKCS1, 'pkcs1'], [kKeyEncodingPKCS8, 'pkcs8'], [kKeyEncodingSPKI, 'spki'], [kKeyEncodingSEC1, 'sec1']]) encodingNames[m[0]] = m[1]; +// KeyObject state lives on the native NativeKeyObject base class. JS reads +// the native type enum and a KeyObjectHandle in one call and caches that +// slot tuple in a private field so no forgeable own Symbols are exposed on +// public KeyObject instances. +let getKeyObjectSlots; // Populated by the createNativeKeyObjectClass callback. + +const kKeyObjectSlotType = 0; +const kKeyObjectSlotHandle = 1; +// The native slot tuple stops at kKeyObjectSlotHandle. The remaining entries +// are JS-side lazy cache slots derived from the KeyObjectHandle on first use. +const kKeyObjectSlotSymmetricKeySize = 2; +const kKeyObjectSlotAsymmetricKeyType = 3; +const kKeyObjectSlotAsymmetricKeyDetails = 4; + +function normalizeKeyDetails(details = kEmptyObject) { + if (details.publicExponent !== undefined) { + return { + __proto__: null, + ...details, + publicExponent: + bigIntArrayToUnsignedBigInt(new Uint8Array(details.publicExponent)), + }; + } + return details; +} + // Creating the KeyObject class is a little complicated due to inheritance // and the fact that KeyObjects should be transferable between threads, // which requires the KeyObject base class to be implemented in C++. @@ -125,6 +144,8 @@ const { } = createNativeKeyObjectClass((NativeKeyObject) => { // Publicly visible KeyObject class. class KeyObject extends NativeKeyObject { + #slots; + constructor(type, handle) { if (type !== 'secret' && type !== 'public' && type !== 'private') throw new ERR_INVALID_ARG_VALUE('type', type); @@ -132,20 +153,10 @@ const { throw new ERR_INVALID_ARG_TYPE('handle', 'object', handle); super(handle); - - this[kKeyType] = type; - - ObjectDefineProperty(this, kHandle, { - __proto__: null, - value: handle, - enumerable: false, - configurable: false, - writable: false, - }); } get type() { - return this[kKeyType]; + return getKeyObjectType(this); } static from(key) { @@ -168,8 +179,25 @@ const { 'otherKeyObject', 'KeyObject', otherKeyObject); } - return otherKeyObject.type === this.type && - this[kHandle].equals(otherKeyObject[kHandle]); + const slots = getKeyObjectSlots(this); + const otherSlots = getKeyObjectSlots(otherKeyObject); + return slots[kKeyObjectSlotType] === otherSlots[kKeyObjectSlotType] && + slots[kKeyObjectSlotHandle].equals( + otherSlots[kKeyObjectSlotHandle]); + } + + static { + getKeyObjectSlots = (key) => { + if (!key || typeof key !== 'object') + throw new ERR_INVALID_THIS('KeyObject'); + if (#slots in key) { + const cached = key.#slots; + if (cached !== undefined) return cached; + } + const slots = nativeGetKeyObjectSlots(key); + key.#slots = slots; + return slots; + }; } } @@ -189,19 +217,20 @@ const { } get symmetricKeySize() { - return this[kHandle].getSymmetricKeySize(); + return getKeyObjectSymmetricKeySize(this); } export(options) { + const handle = getKeyObjectHandle(this); if (options !== undefined) { validateObject(options, 'options'); validateOneOf( options.format, 'options.format', [undefined, 'buffer', 'jwk']); if (options.format === 'jwk') { - return this[kHandle].exportJwk({}, false); + return handle.exportJwk({}, false); } } - return this[kHandle].export(); + return handle.export(); } toCryptoKey(algorithm, extractable, keyUsages) { @@ -266,37 +295,13 @@ const { } } - const kAsymmetricKeyType = Symbol('kAsymmetricKeyType'); - const kAsymmetricKeyDetails = Symbol('kAsymmetricKeyDetails'); - - function normalizeKeyDetails(details = {}) { - if (details.publicExponent !== undefined) { - return { - ...details, - publicExponent: - bigIntArrayToUnsignedBigInt(new Uint8Array(details.publicExponent)), - }; - } - return details; - } - class AsymmetricKeyObject extends KeyObject { get asymmetricKeyType() { - return this[kAsymmetricKeyType] ||= this[kHandle].getAsymmetricKeyType(); + return getKeyObjectAsymmetricKeyType(this); } get asymmetricKeyDetails() { - switch (this.asymmetricKeyType) { - case 'rsa': - case 'rsa-pss': - case 'dsa': - case 'ec': - return this[kAsymmetricKeyDetails] ||= normalizeKeyDetails( - this[kHandle].keyDetail({}), - ); - default: - return {}; - } + return { ...getKeyObjectAsymmetricKeyDetails(this) }; } toCryptoKey(algorithm, extractable, keyUsages) { @@ -370,23 +375,27 @@ const { export(options) { switch (options?.format) { case 'jwk': - return this[kHandle].exportJwk({}, false); + return getKeyObjectHandle(this).exportJwk({}, false); case 'raw-public': { - if (this.asymmetricKeyType === 'ec') { + const handle = getKeyObjectHandle(this); + const asymmetricKeyType = getKeyObjectAsymmetricKeyType(this); + if (asymmetricKeyType === 'ec') { const { type = 'uncompressed' } = options; validateOneOf(type, 'options.type', ['compressed', 'uncompressed']); const form = type === 'compressed' ? POINT_CONVERSION_COMPRESSED : POINT_CONVERSION_UNCOMPRESSED; - return this[kHandle].exportECPublicRaw(form); + return handle.exportECPublicRaw(form); } - return this[kHandle].rawPublicKey(); + return handle.rawPublicKey(); } default: { + const asymmetricKeyType = getKeyObjectAsymmetricKeyType(this); + const handle = getKeyObjectHandle(this); const { format, type, - } = parsePublicKeyEncoding(options, this.asymmetricKeyType); - return this[kHandle].export(format, type); + } = parsePublicKeyEncoding(options, asymmetricKeyType); + return handle.export(format, type); } } } @@ -405,23 +414,27 @@ const { } switch (options?.format) { case 'jwk': - return this[kHandle].exportJwk({}, false); + return getKeyObjectHandle(this).exportJwk({}, false); case 'raw-private': { - if (this.asymmetricKeyType === 'ec') { - return this[kHandle].exportECPrivateRaw(); + const handle = getKeyObjectHandle(this); + const asymmetricKeyType = getKeyObjectAsymmetricKeyType(this); + if (asymmetricKeyType === 'ec') { + return handle.exportECPrivateRaw(); } - return this[kHandle].rawPrivateKey(); + return handle.rawPrivateKey(); } case 'raw-seed': - return this[kHandle].rawSeed(); + return getKeyObjectHandle(this).rawSeed(); default: { + const asymmetricKeyType = getKeyObjectAsymmetricKeyType(this); + const handle = getKeyObjectHandle(this); const { format, type, cipher, passphrase, - } = parsePrivateKeyEncoding(options, this.asymmetricKeyType); - return this[kHandle].export(format, type, cipher, passphrase); + } = parsePrivateKeyEncoding(options, asymmetricKeyType); + return handle.export(format, type, cipher, passphrase); } } } @@ -635,8 +648,9 @@ function getKeyTypes(allowKeyObject, bufferOnly = false) { function prepareAsymmetricKey(key, ctx, name = 'key') { if (isKeyObject(key)) { // Best case: A key object, as simple as that. - validateAsymmetricKeyType(key.type, ctx, key); - return { data: key[kHandle] }; + const type = getKeyObjectType(key); + validateAsymmetricKeyType(type, ctx, key); + return { data: getKeyObjectHandle(key) }; } if (isCryptoKey(key)) { emitDEP0203(); @@ -653,8 +667,9 @@ function prepareAsymmetricKey(key, ctx, name = 'key') { // The 'key' property can be a KeyObject as well to allow specifying // additional options such as padding along with the key. if (isKeyObject(data)) { - validateAsymmetricKeyType(data.type, ctx, data); - return { data: data[kHandle] }; + const type = getKeyObjectType(data); + validateAsymmetricKeyType(type, ctx, data); + return { data: getKeyObjectHandle(data) }; } if (isCryptoKey(data)) { emitDEP0203(); @@ -722,9 +737,10 @@ function preparePublicOrPrivateKey(key, name) { function prepareSecretKey(key, encoding, bufferOnly = false) { if (!bufferOnly) { if (isKeyObject(key)) { - if (key.type !== 'secret') - throw new ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE(key.type, 'secret'); - return key[kHandle]; + const type = getKeyObjectType(key); + if (type !== 'secret') + throw new ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE(type, 'secret'); + return getKeyObjectHandle(key); } if (isCryptoKey(key)) { emitDEP0203(); @@ -770,8 +786,132 @@ function createPrivateKey(key) { return new PrivateKeyObject(handle); } +function keyObjectTypeToString(type) { + switch (type) { + case kKeyTypeSecret: return 'secret'; + case kKeyTypePublic: return 'public'; + case kKeyTypePrivate: return 'private'; + default: { + const assert = require('internal/assert'); + assert.fail('Unreachable code'); + } + } +} + +// The helpers below return a KeyObject's native-backed slot values, +// populating the per-instance cache on first access via a single native +// call. The public getters delegate to these helpers, and internal +// consumers use them directly to avoid user-replaceable public accessors. +// Derived metadata such as key size and asymmetric key details is expanded +// lazily from the cached KeyObjectHandle. The public asymmetric key details +// getter returns a clone so the cached details object stays internal. + +/** + * Returns the KeyObject's native type slot as a string. + * @param {KeyObject} key + * @returns {'secret' | 'public' | 'private'} + */ +function getKeyObjectType(key) { + return keyObjectTypeToString(getKeyObjectSlots(key)[kKeyObjectSlotType]); +} + +/** + * Returns the KeyObjectHandle wrapping the KeyObject's underlying key + * material. + * @param {KeyObject} key + * @returns {KeyObjectHandle} + */ +function getKeyObjectHandle(key) { + return getKeyObjectSlots(key)[kKeyObjectSlotHandle]; +} + +/** + * Returns the KeyObject's symmetric key size, bypassing the public + * `symmetricKeySize` getter. The value is derived lazily from the cached + * KeyObjectHandle. + * @param {SecretKeyObject} key + * @returns {number} + */ +function getKeyObjectSymmetricKeySize(key) { + const slots = getKeyObjectSlots(key); + if (slots[kKeyObjectSlotType] !== kKeyTypeSecret) + throw new ERR_INVALID_THIS('SecretKeyObject'); + + let cached = slots[kKeyObjectSlotSymmetricKeySize]; + if (cached === undefined) { + cached = slots[kKeyObjectSlotHandle].getSymmetricKeySize(); + slots[kKeyObjectSlotSymmetricKeySize] = cached; + } + return cached; +} + +/** + * Returns the KeyObject's asymmetric key type, bypassing the public + * `asymmetricKeyType` getter. The value is derived lazily from the cached + * KeyObjectHandle. + * @param {PublicKeyObject|PrivateKeyObject} key + * @returns {string} + */ +function getKeyObjectAsymmetricKeyType(key) { + const slots = getKeyObjectSlots(key); + if (slots[kKeyObjectSlotType] === kKeyTypeSecret) + throw new ERR_INVALID_THIS('AsymmetricKeyObject'); + + let cached = slots[kKeyObjectSlotAsymmetricKeyType]; + if (cached === undefined) { + cached = slots[kKeyObjectSlotHandle].getAsymmetricKeyType(); + slots[kKeyObjectSlotAsymmetricKeyType] = cached; + } + return cached; +} + +/** + * Returns the KeyObject's cached asymmetric key details, bypassing the + * public `asymmetricKeyDetails` getter (which returns a cloned copy). + * The value is derived lazily from the cached KeyObjectHandle. + * @param {PublicKeyObject|PrivateKeyObject} key + * @returns {object} + */ +function getKeyObjectAsymmetricKeyDetails(key) { + const slots = getKeyObjectSlots(key); + if (slots[kKeyObjectSlotType] === kKeyTypeSecret) + throw new ERR_INVALID_THIS('AsymmetricKeyObject'); + + let cached = slots[kKeyObjectSlotAsymmetricKeyDetails]; + if (cached === undefined) { + let asymmetricKeyType = slots[kKeyObjectSlotAsymmetricKeyType]; + if (asymmetricKeyType === undefined) { + asymmetricKeyType = slots[kKeyObjectSlotHandle].getAsymmetricKeyType(); + slots[kKeyObjectSlotAsymmetricKeyType] = asymmetricKeyType; + } + switch (asymmetricKeyType) { + case 'rsa': + case 'rsa-pss': + case 'dsa': + case 'ec': + cached = normalizeKeyDetails( + slots[kKeyObjectSlotHandle].keyDetail({ __proto__: null }), + ); + break; + default: + cached = kEmptyObject; + break; + } + slots[kKeyObjectSlotAsymmetricKeyDetails] = cached; + } + return cached; +} + function isKeyObject(obj) { - return obj != null && obj[kKeyType] !== undefined; + if (obj == null || typeof obj !== 'object') + return false; + + try { + getKeyObjectSlots(obj); + return true; + } catch { + return false; + } } // CryptoKey is a plain JS class whose prototype's [[Prototype]] is @@ -873,19 +1013,20 @@ const { class InternalCryptoKey extends NativeCryptoKey { #slots; - static getSlots(key) { - if (!key || typeof key !== 'object') - throw new ERR_INVALID_THIS('CryptoKey'); - if (#slots in key) { - const cached = key.#slots; - if (cached !== undefined) return cached; - } - const slots = nativeGetCryptoKeySlots(key); - key.#slots = slots; - return slots; + static { + getSlots = (key) => { + if (!key || typeof key !== 'object') + throw new ERR_INVALID_THIS('CryptoKey'); + if (#slots in key) { + const cached = key.#slots; + if (cached !== undefined) return cached; + } + const slots = nativeGetCryptoKeySlots(key); + key.#slots = slots; + return slots; + }; } } - getSlots = InternalCryptoKey.getSlots; // Hide NativeCryptoKey from user code. InternalCryptoKey.prototype.constructor = CryptoKey; ObjectSetPrototypeOf(InternalCryptoKey.prototype, CryptoKey.prototype); @@ -1036,7 +1177,7 @@ function importGenericSecretKey( let handle; switch (format) { case 'KeyObject': { - handle = keyData[kHandle]; + handle = getKeyObjectHandle(keyData); break; } case 'raw-secret': @@ -1076,6 +1217,11 @@ module.exports = { PublicKeyObject, PrivateKeyObject, isKeyObject, + getKeyObjectType, + getKeyObjectHandle, + getKeyObjectSymmetricKeySize, + getKeyObjectAsymmetricKeyType, + getKeyObjectAsymmetricKeyDetails, isCryptoKey, getCryptoKeyType, getCryptoKeyExtractable, diff --git a/lib/internal/crypto/mac.js b/lib/internal/crypto/mac.js index 6554e05a892ff4..57576f729b7b41 100644 --- a/lib/internal/crypto/mac.js +++ b/lib/internal/crypto/mac.js @@ -20,7 +20,6 @@ const { hasAnyNotIn, jobPromise, normalizeHashName, - kHandle, } = require('internal/crypto/util'); const { @@ -31,6 +30,8 @@ const { InternalCryptoKey, getCryptoKeyAlgorithm, getCryptoKeyHandle, + getKeyObjectHandle, + getKeyObjectSymmetricKeySize, } = require('internal/crypto/keys'); const { @@ -106,8 +107,8 @@ function macImportKey( let length; switch (format) { case 'KeyObject': { - length = keyData.symmetricKeySize * 8; - handle = keyData[kHandle]; + length = getKeyObjectSymmetricKeySize(keyData) * 8; + handle = getKeyObjectHandle(keyData); break; } case 'raw-secret': diff --git a/lib/internal/crypto/ml_dsa.js b/lib/internal/crypto/ml_dsa.js index 173ef666c29736..bd93327f93aa5f 100644 --- a/lib/internal/crypto/ml_dsa.js +++ b/lib/internal/crypto/ml_dsa.js @@ -29,7 +29,6 @@ const { getUsagesUnion, hasAnyNotIn, jobPromise, - kHandle, } = require('internal/crypto/util'); const { @@ -39,6 +38,8 @@ const { const { getCryptoKeyHandle, getCryptoKeyType, + getKeyObjectHandle, + getKeyObjectType, InternalCryptoKey, } = require('internal/crypto/keys'); @@ -151,8 +152,9 @@ function mlDsaImportKey( const usagesSet = new SafeSet(keyUsages); switch (format) { case 'KeyObject': { - verifyAcceptableMlDsaKeyUse(name, keyData.type === 'public', usagesSet); - handle = keyData[kHandle]; + verifyAcceptableMlDsaKeyUse( + name, getKeyObjectType(keyData) === 'public', usagesSet); + handle = getKeyObjectHandle(keyData); break; } case 'spki': { diff --git a/lib/internal/crypto/ml_kem.js b/lib/internal/crypto/ml_kem.js index abb156ee07262d..99367290ea22cd 100644 --- a/lib/internal/crypto/ml_kem.js +++ b/lib/internal/crypto/ml_kem.js @@ -29,7 +29,6 @@ const { getUsagesUnion, hasAnyNotIn, jobPromise, - kHandle, } = require('internal/crypto/util'); const { @@ -39,6 +38,8 @@ const { const { getCryptoKeyHandle, getCryptoKeyType, + getKeyObjectHandle, + getKeyObjectType, InternalCryptoKey, } = require('internal/crypto/keys'); @@ -147,8 +148,9 @@ function mlKemImportKey( const usagesSet = new SafeSet(keyUsages); switch (format) { case 'KeyObject': { - verifyAcceptableMlKemKeyUse(name, keyData.type === 'public', usagesSet); - handle = keyData[kHandle]; + verifyAcceptableMlKemKeyUse( + name, getKeyObjectType(keyData) === 'public', usagesSet); + handle = getKeyObjectHandle(keyData); break; } case 'spki': { diff --git a/lib/internal/crypto/rsa.js b/lib/internal/crypto/rsa.js index a019e70e0268b7..6034ed64e69514 100644 --- a/lib/internal/crypto/rsa.js +++ b/lib/internal/crypto/rsa.js @@ -36,7 +36,6 @@ const { jobPromise, normalizeHashName, validateMaxBufferLength, - kHandle, } = require('internal/crypto/util'); const { @@ -48,6 +47,8 @@ const { getCryptoKeyAlgorithm, getCryptoKeyHandle, getCryptoKeyType, + getKeyObjectHandle, + getKeyObjectType, } = require('internal/crypto/keys'); const { @@ -217,8 +218,9 @@ function rsaImportKey( let handle; switch (format) { case 'KeyObject': { - verifyAcceptableRsaKeyUse(algorithm.name, keyData.type === 'public', usagesSet); - handle = keyData[kHandle]; + verifyAcceptableRsaKeyUse( + algorithm.name, getKeyObjectType(keyData) === 'public', usagesSet); + handle = getKeyObjectHandle(keyData); break; } case 'spki': { diff --git a/lib/internal/crypto/x509.js b/lib/internal/crypto/x509.js index fcec607fb648de..cd5b5457e3ca67 100644 --- a/lib/internal/crypto/x509.js +++ b/lib/internal/crypto/x509.js @@ -18,6 +18,8 @@ const { const { PublicKeyObject, + getKeyObjectHandle, + getKeyObjectType, isKeyObject, } = require('internal/crypto/keys'); @@ -374,17 +376,17 @@ class X509Certificate { checkPrivateKey(pkey) { if (!isKeyObject(pkey)) throw new ERR_INVALID_ARG_TYPE('pkey', 'KeyObject', pkey); - if (pkey.type !== 'private') + if (getKeyObjectType(pkey) !== 'private') throw new ERR_INVALID_ARG_VALUE('pkey', pkey); - return this[kHandle].checkPrivateKey(pkey[kHandle]); + return this[kHandle].checkPrivateKey(getKeyObjectHandle(pkey)); } verify(pkey) { if (!isKeyObject(pkey)) throw new ERR_INVALID_ARG_TYPE('pkey', 'KeyObject', pkey); - if (pkey.type !== 'public') + if (getKeyObjectType(pkey) !== 'public') throw new ERR_INVALID_ARG_VALUE('pkey', pkey); - return this[kHandle].verify(pkey[kHandle]); + return this[kHandle].verify(getKeyObjectHandle(pkey)); } toLegacyObject() { diff --git a/lib/internal/quic/quic.js b/lib/internal/quic/quic.js index b9cbc8feb62e20..6ca59469faf2de 100644 --- a/lib/internal/quic/quic.js +++ b/lib/internal/quic/quic.js @@ -143,6 +143,8 @@ const { } = require('internal/streams/iter/from'); const { + getKeyObjectHandle, + getKeyObjectType, isKeyObject, } = require('internal/crypto/keys'); @@ -201,7 +203,6 @@ const { kTrailers, kVersionNegotiation, kInspect, - kKeyObjectHandle, kWantsHeaders, kWantsTrailers, } = require('internal/quic/symbols'); @@ -4583,11 +4584,11 @@ function processIdentityOptions(identity, label) { const keyInputs = ArrayIsArray(keys) ? keys : [keys]; for (const key of keyInputs) { if (isKeyObject(key)) { - if (key.type !== 'private') { + if (getKeyObjectType(key) !== 'private') { throw new ERR_INVALID_ARG_VALUE(`${label}.keys`, key, 'must be a private key'); } - ArrayPrototypePush(keyHandles, key[kKeyObjectHandle]); + ArrayPrototypePush(keyHandles, getKeyObjectHandle(key)); } else { throw new ERR_INVALID_ARG_TYPE(`${label}.keys`, 'KeyObject', key); } diff --git a/lib/internal/util/comparisons.js b/lib/internal/util/comparisons.js index 2f21740fcb84bf..80d39756cf155a 100644 --- a/lib/internal/util/comparisons.js +++ b/lib/internal/util/comparisons.js @@ -132,6 +132,8 @@ let getCryptoKeyType; let getCryptoKeyExtractable; let getCryptoKeyAlgorithm; let getCryptoKeyUsagesMask; +let getKeyObjectHandle; +let getKeyObjectType; const kStrict = 2; const kStrictWithoutPrototypes = 3; @@ -410,7 +412,16 @@ function objectComparisonStart(val1, val2, mode, memos) { return false; } } else if (isKeyObject(val1)) { - if (!isKeyObject(val2) || !val1.equals(val2)) { + if (getKeyObjectHandle === undefined) { + ({ + getKeyObjectHandle, + getKeyObjectType, + } = require('internal/crypto/keys')); + } + if (!isKeyObject(val2) || + getKeyObjectType(val1) !== getKeyObjectType(val2) || + !getKeyObjectHandle(val1).equals(getKeyObjectHandle(val2)) + ) { return false; } } else if (isCryptoKey(val1)) { diff --git a/src/crypto/README.md b/src/crypto/README.md index 672b15c13d4962..263a512cdefc9b 100644 --- a/src/crypto/README.md +++ b/src/crypto/README.md @@ -155,18 +155,22 @@ a Secret key. It is the shared backing representation used by `KeyObject`, #### `KeyObjectHandle` -`KeyObjectHandle` is the JavaScript-visible C++ handle for a +`KeyObjectHandle` is the internal JavaScript-visible C++ handle for a `KeyObjectData`. It exposes operations that internal JavaScript uses to initialize, inspect, compare, and export key material. Native code passes `KeyObjectData` across threads and jobs; a `KeyObjectHandle` is created when -JavaScript needs access to those operations. +JavaScript needs access to those operations and is kept out of user-visible +`KeyObject` own properties. #### `KeyObject` A `KeyObject` is the public Node.js-specific API for keys. It extends a native `NativeKeyObject`, which stores `KeyObjectData` for structured -cloning, and it owns one `KeyObjectHandle` used by the JavaScript API -surface. +cloning. The JavaScript API surface reads its key type and a +`KeyObjectHandle` through a hidden native-backed slot tuple, caching that +tuple in a private field outside user-visible own properties. Derived +metadata, such as symmetric key size and asymmetric key details, is read +from the cached handle and appended lazily to the same private-field cache. #### `CryptoKey` diff --git a/src/crypto/crypto_keys.cc b/src/crypto/crypto_keys.cc index 560e13903e88e3..0ca1d536c16582 100644 --- a/src/crypto/crypto_keys.cc +++ b/src/crypto/crypto_keys.cc @@ -1735,18 +1735,26 @@ void NativeKeyObject::Initialize(Environment* env, Local target) { target, "createNativeKeyObjectClass", NativeKeyObject::CreateNativeKeyObjectClass); + SetMethod( + env->context(), target, "getKeyObjectSlots", NativeKeyObject::GetSlots); } void NativeKeyObject::RegisterExternalReferences( ExternalReferenceRegistry* registry) { registry->Register(NativeKeyObject::CreateNativeKeyObjectClass); + registry->Register(NativeKeyObject::GetSlots); registry->Register(NativeKeyObject::New); } +bool NativeKeyObject::HasInstance(Environment* env, Local value) { + auto t = env->crypto_key_object_constructor_template(); + return !t.IsEmpty() && t->HasInstance(value); +} + void NativeKeyObject::New(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args); CHECK_EQ(args.Length(), 1); - CHECK(args[0]->IsObject()); + CHECK(KeyObjectHandle::HasInstance(env, args[0])); KeyObjectHandle* handle = Unwrap(args[0].As()); CHECK_NOT_NULL(handle); new NativeKeyObject(env, args.This(), handle->Data()); @@ -1765,6 +1773,8 @@ void NativeKeyObject::CreateNativeKeyObjectClass( NewFunctionTemplate(isolate, NativeKeyObject::New); t->InstanceTemplate()->SetInternalFieldCount( NativeKeyObject::kInternalFieldCount); + CHECK(env->crypto_key_object_constructor_template().IsEmpty()); + env->set_crypto_key_object_constructor_template(t); Local ctor; if (!t->GetFunction(env->context()).ToLocal(&ctor)) @@ -1786,6 +1796,34 @@ void NativeKeyObject::CreateNativeKeyObjectClass( args.GetReturnValue().Set(ret); } +// Returns the key's native hidden slot tuple as a single Array: +// [type enum, handle]. JS-side helpers call this once per key to prime +// a per-instance cache; derived metadata is appended lazily from JS by +// calling methods on the returned KeyObjectHandle. +void NativeKeyObject::GetSlots(const FunctionCallbackInfo& args) { + Environment* env = Environment::GetCurrent(args); + CHECK_EQ(args.Length(), 1); + if (!HasInstance(env, args[0])) { + THROW_ERR_INVALID_THIS(env, "Value of \"this\" must be of type KeyObject"); + return; + } + + NativeKeyObject* native = Unwrap(args[0].As()); + CHECK_NOT_NULL(native); + + Local handle; + if (!KeyObjectHandle::Create(env, native->handle_data_).ToLocal(&handle)) { + return; + } + + Isolate* isolate = env->isolate(); + Local slots[] = { + Uint32::NewFromUnsigned(isolate, native->handle_data_.GetKeyType()), + handle, + }; + args.GetReturnValue().Set(Array::New(isolate, slots, arraysize(slots))); +} + BaseObjectPtr NativeKeyObject::KeyObjectTransferData::Deserialize( Environment* env, Local context, @@ -1825,7 +1863,7 @@ BaseObjectPtr NativeKeyObject::KeyObjectTransferData::Deserialize( if (!key_ctor->NewInstance(context, 1, &handle).ToLocal(&key)) return {}; - return BaseObjectPtr(Unwrap(key.As())); + return BaseObjectPtr(Unwrap(key.As())); } BaseObject::TransferMode NativeKeyObject::GetTransferMode() const { @@ -1946,6 +1984,7 @@ void NativeCryptoKey::GetSlots(const FunctionCallbackInfo& args) { } Local obj = args[0].As(); NativeCryptoKey* native = Unwrap(obj); + CHECK_NOT_NULL(native); Local handle; if (!KeyObjectHandle::Create(env, native->handle_data_).ToLocal(&handle)) { diff --git a/src/crypto/crypto_keys.h b/src/crypto/crypto_keys.h index bab640138e909d..8bba206a08239e 100644 --- a/src/crypto/crypto_keys.h +++ b/src/crypto/crypto_keys.h @@ -189,6 +189,11 @@ class KeyObjectHandle : public BaseObject { KeyObjectData data_; }; +// NativeKeyObject is the native base class for the Node.js-specific +// `KeyObject`. It holds the underlying KeyObjectData for structured +// cloning and exposes the native hidden slot tuple that JS needs: +// [type enum, KeyObjectHandle]. JS primes a per-instance private-field +// cache from that result and lazily appends derived metadata there. class NativeKeyObject : public BaseObject { public: static void Initialize(Environment* env, v8::Local target); @@ -198,6 +203,15 @@ class NativeKeyObject : public BaseObject { static void CreateNativeKeyObjectClass( const v8::FunctionCallbackInfo& args); + // True if `value` is a real NativeKeyObject instance. Uses the + // FunctionTemplate stored on the Environment as a brand check. + // Used by `GetSlots` to validate its receiver. + static bool HasInstance(Environment* env, v8::Local value); + + // Returns [type, handle] in one call so JS can prime a per-instance cache + // on first access. Derived metadata is not returned from native here. + static void GetSlots(const v8::FunctionCallbackInfo& args); + SET_NO_MEMORY_INFO() SET_MEMORY_INFO_NAME(NativeKeyObject) SET_SELF_SIZE(NativeKeyObject) diff --git a/src/crypto/crypto_util.cc b/src/crypto/crypto_util.cc index 0e743135e8de15..53d6142917dc58 100644 --- a/src/crypto/crypto_util.cc +++ b/src/crypto/crypto_util.cc @@ -479,9 +479,9 @@ ByteSource ByteSource::FromBuffer(Local buffer, bool ntc) { ByteSource ByteSource::FromSecretKeyBytes( Environment* env, Local value) { - // A key can be passed as a string, buffer or KeyObject with type 'secret'. - // If it is a string, we need to convert it to a buffer. We are not doing that - // in JS to avoid creating an unprotected copy on the heap. + // JS normalizes secret KeyObject/CryptoKey inputs to a KeyObjectHandle. + // Strings are converted here instead of in JS to avoid creating an + // unprotected copy on the heap. return value->IsString() || IsAnyBufferSource(value) ? ByteSource::FromStringOrBuffer(env, value) : ByteSource::FromSymmetricKeyObjectHandle(value); diff --git a/src/env_properties.h b/src/env_properties.h index 60a5d75708ac85..6530f89ec918ac 100644 --- a/src/env_properties.h +++ b/src/env_properties.h @@ -409,6 +409,7 @@ V(cpu_usage_template, v8::DictionaryTemplate) \ V(crypto_cryptokey_constructor_template, v8::FunctionTemplate) \ V(crypto_key_object_handle_constructor, v8::FunctionTemplate) \ + V(crypto_key_object_constructor_template, v8::FunctionTemplate) \ V(env_proxy_template, v8::ObjectTemplate) \ V(env_proxy_ctor_template, v8::FunctionTemplate) \ V(ephemeral_key_template, v8::DictionaryTemplate) \ diff --git a/test/parallel/test-crypto-keyobject-brand-check.js b/test/parallel/test-crypto-keyobject-brand-check.js new file mode 100644 index 00000000000000..ac0cf1b65f709b --- /dev/null +++ b/test/parallel/test-crypto-keyobject-brand-check.js @@ -0,0 +1,96 @@ +'use strict'; + +// KeyObject instances are backed by NativeKeyObject and must be +// recognized by native brand, not by public prototype shape or +// forgeable own properties. + +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); + +const assert = require('node:assert'); +const { + createHmac, + createSecretKey, + generateKeyPairSync, + KeyObject, +} = require('node:crypto'); +const { types: { isKeyObject } } = require('node:util'); + +const invalidThis = { code: 'ERR_INVALID_THIS', name: 'TypeError' }; + +function getter(proto, name) { + return Object.getOwnPropertyDescriptor(proto, name).get; +} + +{ + const secret = createSecretKey(Buffer.alloc(16)); + const { publicKey } = generateKeyPairSync('rsa', { modulusLength: 1024 }); + + const type = getter(KeyObject.prototype, 'type'); + const symmetricKeySize = + getter(Object.getPrototypeOf(secret), 'symmetricKeySize'); + const asymmetricProto = Object.getPrototypeOf(Object.getPrototypeOf(publicKey)); + const asymmetricKeyType = getter(asymmetricProto, 'asymmetricKeyType'); + const asymmetricKeyDetails = getter(asymmetricProto, 'asymmetricKeyDetails'); + + assert.strictEqual(isKeyObject(secret), true); + assert.strictEqual(isKeyObject(publicKey), true); + assert.strictEqual(Object.hasOwn(KeyObject, 'getSlots'), false); + for (const key of [secret, publicKey]) { + for (let proto = Object.getPrototypeOf(key); + proto !== null; + proto = Object.getPrototypeOf(proto)) { + assert.strictEqual(Object.hasOwn(proto, 'getSlots'), false); + assert.strictEqual('getSlots' in proto, false); + if (Object.hasOwn(proto, 'constructor')) { + assert.strictEqual(Object.hasOwn(proto.constructor, 'getSlots'), false); + assert.strictEqual(proto.constructor.getSlots, undefined); + } + } + } + + for (const value of [{}, { __proto__: null }, 1, null, undefined, + Buffer.alloc(1), function() {}]) { + assert.throws(() => type.call(value), invalidThis); + assert.throws(() => symmetricKeySize.call(value), invalidThis); + assert.throws(() => asymmetricKeyType.call(value), invalidThis); + assert.throws(() => asymmetricKeyDetails.call(value), invalidThis); + } + + assert.throws(() => symmetricKeySize.call(publicKey), invalidThis); + assert.throws(() => asymmetricKeyType.call(secret), invalidThis); + assert.throws(() => asymmetricKeyDetails.call(secret), invalidThis); + + const spoofed = {}; + Object.setPrototypeOf(spoofed, Object.getPrototypeOf(secret)); + assert.strictEqual(spoofed instanceof KeyObject, true); + assert.strictEqual(isKeyObject(spoofed), false); + assert.throws(() => type.call(spoofed), invalidThis); + assert.throws(() => symmetricKeySize.call(spoofed), invalidThis); + assert.throws(() => createHmac('sha256', spoofed), { + code: 'ERR_INVALID_ARG_TYPE', + }); + + const originalHasInstance = + Object.getOwnPropertyDescriptor(KeyObject, Symbol.hasInstance); + Object.defineProperty(KeyObject, Symbol.hasInstance, { + configurable: true, + value: () => true, + }); + try { + const buf = Buffer.alloc(16); + assert.strictEqual(buf instanceof KeyObject, true); + assert.strictEqual(isKeyObject(buf), false); + assert.throws(() => type.call(buf), invalidThis); + assert.throws(() => symmetricKeySize.call(buf), invalidThis); + assert.throws(() => asymmetricKeyType.call(buf), invalidThis); + assert.throws(() => asymmetricKeyDetails.call(buf), invalidThis); + } finally { + if (originalHasInstance === undefined) { + delete KeyObject[Symbol.hasInstance]; + } else { + Object.defineProperty(KeyObject, Symbol.hasInstance, originalHasInstance); + } + } +} diff --git a/test/parallel/test-crypto-keyobject-clone-transfer.js b/test/parallel/test-crypto-keyobject-clone-transfer.js new file mode 100644 index 00000000000000..1d68e4b9911a0a --- /dev/null +++ b/test/parallel/test-crypto-keyobject-clone-transfer.js @@ -0,0 +1,138 @@ +'use strict'; + +// KeyObject instances must survive structured cloning with their +// native backing data and hidden JS slot semantics preserved. + +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); + +const assert = require('node:assert'); +const { once } = require('node:events'); +const { + createHmac, + createSecretKey, + generateKeyPairSync, + sign, + verify, +} = require('node:crypto'); +const { MessageChannel, Worker } = require('node:worker_threads'); +const { types: { isKeyObject } } = require('node:util'); + +function assertNoOwnKeys(key) { + assert.deepStrictEqual(Object.getOwnPropertySymbols(key), []); + assert.deepStrictEqual(Object.getOwnPropertyNames(key), []); + assert.deepStrictEqual(Reflect.ownKeys(key), []); +} + +function assertSameKeyObject(original, clone) { + assert.notStrictEqual(original, clone); + assert.strictEqual(isKeyObject(clone), true); + assert.strictEqual(original.type, clone.type); + assert.strictEqual(original.equals(clone), true); + assert.deepStrictEqual(original, clone); + if (clone.type === 'secret') { + assert.strictEqual(original.symmetricKeySize, clone.symmetricKeySize); + } else { + assert.strictEqual(original.asymmetricKeyType, clone.asymmetricKeyType); + assert.deepStrictEqual( + original.asymmetricKeyDetails, + clone.asymmetricKeyDetails); + } + assertNoOwnKeys(original); + assertNoOwnKeys(clone); +} + +async function roundTripViaMessageChannel(key) { + const { port1, port2 } = new MessageChannel(); + port1.postMessage(key); + const [received] = await once(port2, 'message'); + port1.close(); + port2.close(); + return received; +} + +async function roundTripViaWorker(key) { + const worker = new Worker(` + 'use strict'; + const { parentPort } = require('node:worker_threads'); + const { types: { isKeyObject } } = require('node:util'); + + parentPort.once('message', ({ key, expectedType }) => { + try { + if (!isKeyObject(key) || key.type !== expectedType) { + throw new Error('KeyObject slot mismatch in worker'); + } + parentPort.postMessage({ key }); + } catch (err) { + parentPort.postMessage({ error: err.stack || err.message }); + } + }); + `, { eval: true }); + + worker.postMessage({ key, expectedType: key.type }); + const [msg] = await once(worker, 'message'); + await worker.terminate(); + + assert.strictEqual(msg.error, undefined, msg.error); + return msg.key; +} + +function hmacDigest(key) { + return createHmac('sha256', key).update('payload').digest('hex'); +} + +(async () => { + const secret = createSecretKey(Buffer.alloc(16)); + const { publicKey, privateKey } = generateKeyPairSync('rsa', { + modulusLength: 1024, + }); + + for (const key of [secret, publicKey, privateKey]) { + const cloned = structuredClone(key); + assertSameKeyObject(key, cloned); + + const viaPort = await roundTripViaMessageChannel(key); + assertSameKeyObject(key, viaPort); + + const clonedAgain = structuredClone(viaPort); + assertSameKeyObject(key, clonedAgain); + + const viaWorker = await roundTripViaWorker(key); + assertSameKeyObject(key, viaWorker); + } + + const secretClones = [ + secret, + structuredClone(secret), + await roundTripViaMessageChannel(secret), + await roundTripViaWorker(secret), + ]; + const digest = hmacDigest(secret); + for (const key of secretClones) { + assert.strictEqual(hmacDigest(key), digest); + } + + const data = Buffer.from('payload'); + const publicClones = [ + publicKey, + structuredClone(publicKey), + await roundTripViaMessageChannel(publicKey), + await roundTripViaWorker(publicKey), + ]; + const privateClones = [ + privateKey, + structuredClone(privateKey), + await roundTripViaMessageChannel(privateKey), + await roundTripViaWorker(privateKey), + ]; + + const signature = sign('sha256', data, privateKey); + for (const key of publicClones) { + assert.strictEqual(verify('sha256', data, key, signature), true); + } + for (const key of privateClones) { + const clonedSignature = sign('sha256', data, key); + assert.strictEqual(verify('sha256', data, publicKey, clonedSignature), true); + } +})().then(common.mustCall()); diff --git a/test/parallel/test-crypto-keyobject-hidden-slots.js b/test/parallel/test-crypto-keyobject-hidden-slots.js new file mode 100644 index 00000000000000..1ea243ba0ab818 --- /dev/null +++ b/test/parallel/test-crypto-keyobject-hidden-slots.js @@ -0,0 +1,213 @@ +'use strict'; + +// KeyObject public getters and methods are configurable JS properties. +// Internal consumers must read key state through hidden native-backed +// slots, not through user-replaceable accessors. + +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); + +const assert = require('node:assert'); +const { + createCipheriv, + createDecipheriv, + createHmac, + createPrivateKey, + createPublicKey, + createSecretKey, + createSign, + createVerify, + diffieHellman, + generateKeyPairSync, + hkdfSync, + KeyObject, + privateDecrypt, + publicEncrypt, + sign, + verify, + X509Certificate, +} = require('node:crypto'); +const { readFileSync } = require('node:fs'); +const fixtures = require('../common/fixtures'); + +function updateFinal(cipher, data = Buffer.alloc(16)) { + return Buffer.concat([cipher.update(data), cipher.final()]); +} + +{ + const secret = createSecretKey(Buffer.alloc(16)); + const secretProto = Object.getPrototypeOf(secret); + const originalType = + Object.getOwnPropertyDescriptor(KeyObject.prototype, 'type'); + const originalSize = + Object.getOwnPropertyDescriptor(secretProto, 'symmetricKeySize'); + + Object.defineProperty(KeyObject.prototype, 'type', { + configurable: true, + get() { return 'public'; }, + }); + Object.defineProperty(secretProto, 'symmetricKeySize', { + configurable: true, + get() { return 1; }, + }); + + try { + assert.strictEqual(secret.type, 'public'); + assert.strictEqual(secret.symmetricKeySize, 1); + + assert.strictEqual( + createHmac('sha256', secret).update('payload').digest('hex').length, + 64); + + const ciphertext = updateFinal( + createCipheriv('aes-128-ecb', secret, null)); + const plaintext = updateFinal( + createDecipheriv('aes-128-ecb', secret, null), ciphertext); + assert.deepStrictEqual(plaintext, Buffer.alloc(16)); + + assert.strictEqual( + hkdfSync('sha256', secret, Buffer.alloc(0), Buffer.alloc(0), 16) + .byteLength, + 16); + + const cryptoKey = secret.toCryptoKey( + { name: 'AES-GCM' }, true, ['encrypt']); + assert.strictEqual(cryptoKey.algorithm.length, 128); + } finally { + Object.defineProperty(KeyObject.prototype, 'type', originalType); + Object.defineProperty(secretProto, 'symmetricKeySize', originalSize); + } +} + +{ + const { + privateKey: ecPrivateKey, + publicKey, + } = generateKeyPairSync('ec', { namedCurve: 'P-256' }); + const asymmetricProto = Object.getPrototypeOf(Object.getPrototypeOf(publicKey)); + const originalAsymmetricKeyType = + Object.getOwnPropertyDescriptor(asymmetricProto, 'asymmetricKeyType'); + + Object.defineProperty(asymmetricProto, 'asymmetricKeyType', { + configurable: true, + get() { return 'rsa'; }, + }); + + try { + assert.strictEqual(publicKey.asymmetricKeyType, 'rsa'); + assert.strictEqual( + publicKey.export({ format: 'raw-public', type: 'compressed' }).length, + 33); + + assert.strictEqual( + diffieHellman({ privateKey: ecPrivateKey, publicKey }).byteLength, + 32); + } finally { + Object.defineProperty( + asymmetricProto, 'asymmetricKeyType', originalAsymmetricKeyType); + } +} + +{ + const { publicKey } = generateKeyPairSync('rsa', { + modulusLength: 1024, + }); + + const details = publicKey.asymmetricKeyDetails; + assert.strictEqual(details.modulusLength, 1024); + assert.strictEqual(details.publicExponent, 65537n); + + details.modulusLength = 1; + details.publicExponent = 3n; + details.extra = true; + + const freshDetails = publicKey.asymmetricKeyDetails; + assert.notStrictEqual(freshDetails, details); + assert.strictEqual(freshDetails.modulusLength, 1024); + assert.strictEqual(freshDetails.publicExponent, 65537n); + assert.strictEqual(freshDetails.extra, undefined); +} + +{ + Object.defineProperty(Object.prototype, 'publicExponent', { + configurable: true, + value: new Uint8Array([1, 0, 1]), + }); + + try { + const { publicKey } = generateKeyPairSync('ec', { namedCurve: 'P-256' }); + assert.deepStrictEqual(publicKey.asymmetricKeyDetails, { + namedCurve: 'prime256v1', + }); + assert.strictEqual( + Object.hasOwn(publicKey.asymmetricKeyDetails, 'publicExponent'), + false); + } finally { + delete Object.prototype.publicExponent; + } +} + +{ + const { privateKey, publicKey } = generateKeyPairSync('rsa', { + modulusLength: 1024, + }); + const originalType = + Object.getOwnPropertyDescriptor(KeyObject.prototype, 'type'); + const data = Buffer.from('payload'); + + Object.defineProperty(KeyObject.prototype, 'type', { + configurable: true, + get() { return 'secret'; }, + }); + + try { + assert.strictEqual(privateKey.type, 'secret'); + assert.strictEqual(publicKey.type, 'secret'); + + const signature = sign('sha256', data, privateKey); + assert.strictEqual(verify('sha256', data, publicKey, signature), true); + + const signer = createSign('sha256'); + signer.update(data); + const streamSignature = signer.sign(privateKey); + const verifier = createVerify('sha256'); + verifier.update(data); + assert.strictEqual(verifier.verify(publicKey, streamSignature), true); + + const ciphertext = publicEncrypt(publicKey, data); + assert.deepStrictEqual(privateDecrypt(privateKey, ciphertext), data); + + assert.strictEqual(publicKey.equals(createPublicKey(privateKey)), true); + + const x509 = new X509Certificate( + readFileSync(fixtures.path('keys', 'agent1-cert.pem'))); + const x509PrivateKey = createPrivateKey( + readFileSync(fixtures.path('keys', 'agent1-key.pem'))); + const ca = new X509Certificate( + readFileSync(fixtures.path('keys', 'ca1-cert.pem'))); + + assert.strictEqual(x509.checkPrivateKey(x509PrivateKey), true); + assert.strictEqual(x509.verify(ca.publicKey), true); + } finally { + Object.defineProperty(KeyObject.prototype, 'type', originalType); + } +} + +{ + const a = createSecretKey(Buffer.alloc(16)); + const b = createSecretKey(Buffer.alloc(16, 1)); + const originalEquals = + Object.getOwnPropertyDescriptor(KeyObject.prototype, 'equals'); + + Object.defineProperty(KeyObject.prototype, 'equals', { + configurable: true, + value: () => true, + }); + + try { + assert.notDeepStrictEqual(a, b); + } finally { + Object.defineProperty(KeyObject.prototype, 'equals', originalEquals); + } +} diff --git a/test/parallel/test-crypto-keyobject-no-own-symbols.js b/test/parallel/test-crypto-keyobject-no-own-symbols.js new file mode 100644 index 00000000000000..f1539c6a0f7ab5 --- /dev/null +++ b/test/parallel/test-crypto-keyobject-no-own-symbols.js @@ -0,0 +1,42 @@ +'use strict'; + +// KeyObject instances must not expose own string or Symbol properties, even +// after the native slot tuple and lazy metadata cache have been populated. + +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); + +const assert = require('node:assert'); +const { + createSecretKey, + generateKeyPairSync, +} = require('node:crypto'); + +function assertNoOwnKeys(key) { + assert.deepStrictEqual(Object.getOwnPropertySymbols(key), []); + assert.deepStrictEqual(Object.getOwnPropertyNames(key), []); + assert.deepStrictEqual(Reflect.ownKeys(key), []); +} + +{ + const secret = createSecretKey(Buffer.alloc(16)); + const { publicKey, privateKey } = generateKeyPairSync('rsa', { + modulusLength: 1024, + }); + + for (const key of [secret, publicKey, privateKey]) { + const type = key.type; + assert.notStrictEqual(type, undefined); + if (type === 'secret') { + assert.strictEqual(key.symmetricKeySize, 16); + key.export(); + } else { + assert.notStrictEqual(key.asymmetricKeyType, undefined); + assert.notStrictEqual(key.asymmetricKeyDetails, undefined); + key.export({ format: 'pem', type: 'pkcs1' }); + } + key.equals(key); + assertNoOwnKeys(key); + } +} diff --git a/test/parallel/test-webcrypto-cryptokey-brand-check.js b/test/parallel/test-webcrypto-cryptokey-brand-check.js index 5b5c0386693865..3fe8aaa181a226 100644 --- a/test/parallel/test-webcrypto-cryptokey-brand-check.js +++ b/test/parallel/test-webcrypto-cryptokey-brand-check.js @@ -46,6 +46,12 @@ const { subtle } = globalThis.crypto; assert.notStrictEqual(getter.call(key), undefined, `baseline ${name}`); }); assert.strictEqual(isCryptoKey(key), true); + assert.strictEqual(Object.hasOwn(CryptoKey, 'getSlots'), false); + const internalProto = Object.getPrototypeOf(key); + assert.strictEqual(Object.hasOwn(internalProto, 'getSlots'), false); + assert.strictEqual('getSlots' in internalProto, false); + assert.strictEqual(internalProto.constructor, CryptoKey); + assert.strictEqual(Object.getPrototypeOf(internalProto), CryptoKey.prototype); const invalidThis = { code: 'ERR_INVALID_THIS', name: 'TypeError' }; From f7c2628ef8eb23b9acdadf4231965e9cd473cc9b Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Mon, 4 May 2026 11:53:08 +0200 Subject: [PATCH 090/168] crypto: harden CryptoKey algorithm slots Clone CryptoKey algorithm dictionaries into null-prototype objects before storing or caching them internally. Copy nested hash dictionaries and publicExponent bytes so internal consumers and transferred keys do not observe user-mutable input objects or polluted Object.prototype fields. Keep public algorithm and inspect output as ordinary objects. Make the clone path check only own hash and publicExponent properties. Signed-off-by: Filip Skokan PR-URL: https://github.com/nodejs/node/pull/63111 Reviewed-By: James M Snell Reviewed-By: Yagiz Nizipli --- lib/internal/crypto/keys.js | 36 ++++++++-- .../test-webcrypto-cryptokey-hidden-slots.js | 65 +++++++++++++++++++ 2 files changed, 97 insertions(+), 4 deletions(-) diff --git a/lib/internal/crypto/keys.js b/lib/internal/crypto/keys.js index 42ff6cd227b5e3..2722ecc0520e2c 100644 --- a/lib/internal/crypto/keys.js +++ b/lib/internal/crypto/keys.js @@ -3,6 +3,7 @@ const { ArrayPrototypeSlice, ObjectDefineProperties, + ObjectPrototypeHasOwnProperty, ObjectSetPrototypeOf, SafeSet, SymbolToStringTag, @@ -932,6 +933,8 @@ function isKeyObject(obj) { // CryptoKey's hidden class pristine. The `getCryptoKey{Type, // Extractable,Algorithm,Usages,Handle}` helpers index into that // array and convert native enums/masks back to Web Crypto strings. +// The internal algorithm object is stored as a null-prototype clone +// so it cannot observe polluted Object.prototype properties. // The public `algorithm` getter caches a cloned dictionary and the // public `usages` getter caches a synthesized array (as Web Crypto // requires repeat reads to return the same object so a consumer's @@ -949,9 +952,27 @@ const kSlotUsages = 7; function cloneAlgorithm(raw) { const cloned = { ...raw }; - if (cloned.hash !== undefined) cloned.hash = { ...cloned.hash }; - if (cloned.publicExponent !== undefined) + if (ObjectPrototypeHasOwnProperty(cloned, 'hash') && + cloned.hash !== undefined) { + cloned.hash = { ...cloned.hash }; + } + if (ObjectPrototypeHasOwnProperty(cloned, 'publicExponent') && + cloned.publicExponent !== undefined) { + cloned.publicExponent = new Uint8Array(cloned.publicExponent); + } + return cloned; +} + +function cloneInternalAlgorithm(raw) { + const cloned = { __proto__: null, ...raw }; + if (ObjectPrototypeHasOwnProperty(cloned, 'hash') && + cloned.hash !== undefined) { + cloned.hash = { __proto__: null, ...cloned.hash }; + } + if (ObjectPrototypeHasOwnProperty(cloned, 'publicExponent') && + cloned.publicExponent !== undefined) { cloned.publicExponent = new Uint8Array(cloned.publicExponent); + } return cloned; } @@ -976,8 +997,8 @@ const { return `CryptoKey ${inspect({ type: getCryptoKeyType(this), extractable: getCryptoKeyExtractable(this), - algorithm: getCryptoKeyAlgorithm(this), - usages: getCryptoKeyUsages(this), + algorithm: cloneAlgorithm(getCryptoKeyAlgorithm(this)), + usages: ArrayPrototypeSlice(getCryptoKeyUsages(this), 0), }, opts)}`; } @@ -1013,6 +1034,12 @@ const { class InternalCryptoKey extends NativeCryptoKey { #slots; + constructor(handle, algorithm, usagesMask, extractable) { + if (algorithm !== undefined) + algorithm = cloneInternalAlgorithm(algorithm); + super(handle, algorithm, usagesMask, extractable); + } + static { getSlots = (key) => { if (!key || typeof key !== 'object') @@ -1022,6 +1049,7 @@ const { if (cached !== undefined) return cached; } const slots = nativeGetCryptoKeySlots(key); + slots[kSlotAlgorithm] = cloneInternalAlgorithm(slots[kSlotAlgorithm]); key.#slots = slots; return slots; }; diff --git a/test/parallel/test-webcrypto-cryptokey-hidden-slots.js b/test/parallel/test-webcrypto-cryptokey-hidden-slots.js index 4e042fef697d67..792a1a59c4c5eb 100644 --- a/test/parallel/test-webcrypto-cryptokey-hidden-slots.js +++ b/test/parallel/test-webcrypto-cryptokey-hidden-slots.js @@ -47,6 +47,71 @@ common.expectWarning({ false, ['sign', 'verify'], ); + const { publicKey: rsaPublicKey } = await subtle.generateKey( + { + name: 'RSA-PSS', + modulusLength: 1024, + publicExponent: new Uint8Array([1, 0, 1]), + hash: 'SHA-256', + }, + true, + ['sign', 'verify'], + ); + + // Public algorithm/usages objects are mutable, but they must be + // separate from the native-backed internal slots. + rsaPublicKey.algorithm.name = 'FORGED-ALGORITHM'; + rsaPublicKey.algorithm.hash.name = 'FORGED-HASH'; + rsaPublicKey.algorithm.publicExponent[0] = 0xff; + rsaPublicKey.usages.push('forged-usage'); + + const clonedRsaPublicKey = structuredClone(rsaPublicKey); + assert.strictEqual(clonedRsaPublicKey.algorithm.name, 'RSA-PSS'); + assert.strictEqual(clonedRsaPublicKey.algorithm.hash.name, 'SHA-256'); + assert.deepStrictEqual( + clonedRsaPublicKey.algorithm.publicExponent, + new Uint8Array([1, 0, 1])); + assert.deepStrictEqual(clonedRsaPublicKey.usages, ['verify']); + + const rsaJwk = await subtle.exportKey('jwk', rsaPublicKey); + assert.strictEqual(rsaJwk.alg, 'PS256'); + assert.deepStrictEqual(rsaJwk.key_ops, ['verify']); + + Object.defineProperties(Object.prototype, { + hash: { + configurable: true, + value: { name: 'FORGED-HASH' }, + }, + publicExponent: { + configurable: true, + value: new Uint8Array([0xff]), + }, + }); + + try { + const aesKey = await subtle.generateKey( + { name: 'AES-GCM', length: 128 }, + true, + ['encrypt'], + ); + assert.deepStrictEqual(aesKey.algorithm, { + name: 'AES-GCM', + length: 128, + }); + assert.strictEqual(Object.hasOwn(aesKey.algorithm, 'hash'), false); + assert.strictEqual( + Object.hasOwn(aesKey.algorithm, 'publicExponent'), + false); + + const clonedAesKey = structuredClone(aesKey); + assert.deepStrictEqual(clonedAesKey.algorithm, { + name: 'AES-GCM', + length: 128, + }); + } finally { + delete Object.prototype.hash; + delete Object.prototype.publicExponent; + } // Snapshot the real values BEFORE tampering. const realType = key.type; From 9adddc552bbeaabb7a43ee053a2a4fc084dd00a6 Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Mon, 4 May 2026 11:52:37 +0200 Subject: [PATCH 091/168] tools: prevent lib code from reading KeyObject and CryptoKey accessors Add ESLint rules that reject public KeyObject and CryptoKey accessor reads after internal brand checks. Internal code must use the private key helpers so it reads native-backed slots instead of user-replaceable properties. Add a separate rule that rejects instanceof checks against KeyObject and CryptoKey constructors, including the global CryptoKey constructor. Signed-off-by: Filip Skokan PR-URL: https://github.com/nodejs/node/pull/63111 Reviewed-By: James M Snell Reviewed-By: Yagiz Nizipli --- lib/eslint.config_partial.mjs | 3 + ...st-eslint-no-cryptokey-public-accessors.js | 88 ++++++ ...slint-no-keyobject-cryptokey-instanceof.js | 78 +++++ ...st-eslint-no-keyobject-public-accessors.js | 85 ++++++ .../no-cryptokey-public-accessors.js | 277 +++++++++++++++++ .../no-keyobject-cryptokey-instanceof.js | 122 ++++++++ .../no-keyobject-public-accessors.js | 284 ++++++++++++++++++ 7 files changed, 937 insertions(+) create mode 100644 test/parallel/test-eslint-no-cryptokey-public-accessors.js create mode 100644 test/parallel/test-eslint-no-keyobject-cryptokey-instanceof.js create mode 100644 test/parallel/test-eslint-no-keyobject-public-accessors.js create mode 100644 tools/eslint-rules/no-cryptokey-public-accessors.js create mode 100644 tools/eslint-rules/no-keyobject-cryptokey-instanceof.js create mode 100644 tools/eslint-rules/no-keyobject-public-accessors.js diff --git a/lib/eslint.config_partial.mjs b/lib/eslint.config_partial.mjs index 3c9bf0bc4e177c..d4c3fd688314c2 100644 --- a/lib/eslint.config_partial.mjs +++ b/lib/eslint.config_partial.mjs @@ -424,6 +424,9 @@ export default [ 'node-core/lowercase-name-for-primitive': 'error', 'node-core/non-ascii-character': 'error', 'node-core/no-array-destructuring': 'error', + 'node-core/no-cryptokey-public-accessors': 'error', + 'node-core/no-keyobject-cryptokey-instanceof': 'error', + 'node-core/no-keyobject-public-accessors': 'error', 'node-core/prefer-primordials': [ 'error', { name: 'AggregateError' }, diff --git a/test/parallel/test-eslint-no-cryptokey-public-accessors.js b/test/parallel/test-eslint-no-cryptokey-public-accessors.js new file mode 100644 index 00000000000000..1b0cd7f930f569 --- /dev/null +++ b/test/parallel/test-eslint-no-cryptokey-public-accessors.js @@ -0,0 +1,88 @@ +'use strict'; + +const common = require('../common'); +common.skipIfEslintMissing(); + +const RuleTester = require('../../tools/eslint/node_modules/eslint').RuleTester; +const rule = require('../../tools/eslint-rules/no-cryptokey-public-accessors'); + +new RuleTester().run('no-cryptokey-public-accessors', rule, { + valid: [ + 'foo.algorithm;', + ` + const { isCryptoKey, getCryptoKeyAlgorithm } = + require('internal/crypto/keys'); + if (isCryptoKey(key)) { + getCryptoKeyAlgorithm(key); + } + `, + ` + const { CryptoKey } = require('internal/crypto/keys'); + class Key extends CryptoKey { + get type() { return 'secret'; } + } + `, + ` + key = webidl.converters.KeyFormat(key); + key.algorithm; + `, + ], + invalid: [ + { + code: ` + const { isCryptoKey } = require('internal/crypto/keys'); + if (isCryptoKey(key)) { + key.type; + } + `, + errors: [{ messageId: 'noPublicAccessor' }], + }, + { + code: ` + const { isCryptoKey: check } = require('internal/crypto/keys'); + if (check(key) && key.extractable) {} + `, + errors: [{ messageId: 'noPublicAccessor' }], + }, + { + code: ` + const { isCryptoKey } = require('internal/crypto/keys'); + if (!isCryptoKey(key)) { + throw new TypeError(); + } + key.algorithm.name; + `, + errors: [{ messageId: 'noPublicAccessor' }], + }, + { + code: ` + const keys = require('internal/crypto/keys'); + if (!keys.isCryptoKey(key)) throw new TypeError(); + key['usages']; + `, + errors: [{ messageId: 'noPublicAccessor' }], + }, + { + code: ` + key = webidl.converters.CryptoKey(key); + key.algorithm; + `, + errors: [{ messageId: 'noPublicAccessor' }], + }, + { + code: ` + const key = webidl.converters.CryptoKey(value); + key.usages; + `, + errors: [{ messageId: 'noPublicAccessor' }], + }, + { + code: ` + class CryptoKey { + inspect() { return this.algorithm; } + } + `, + errors: [{ messageId: 'noPublicAccessor' }], + }, + ], +}); diff --git a/test/parallel/test-eslint-no-keyobject-cryptokey-instanceof.js b/test/parallel/test-eslint-no-keyobject-cryptokey-instanceof.js new file mode 100644 index 00000000000000..29b70c9ec58ab8 --- /dev/null +++ b/test/parallel/test-eslint-no-keyobject-cryptokey-instanceof.js @@ -0,0 +1,78 @@ +'use strict'; + +const common = require('../common'); +common.skipIfEslintMissing(); + +const RuleTester = require('../../tools/eslint/node_modules/eslint').RuleTester; +const rule = require('../../tools/eslint-rules/no-keyobject-cryptokey-instanceof'); + +new RuleTester().run('no-keyobject-cryptokey-instanceof', rule, { + valid: [ + 'key instanceof Buffer;', + 'key instanceof KeyObject;', + ` + const { isKeyObject } = require('internal/crypto/keys'); + isKeyObject(key); + `, + ` + const { isCryptoKey } = require('internal/crypto/keys'); + isCryptoKey(key); + `, + ], + invalid: [ + { + code: ` + const { KeyObject } = require('internal/crypto/keys'); + key instanceof KeyObject; + `, + errors: [{ messageId: 'noKeyObjectInstanceof' }], + }, + { + code: ` + const { KeyObject: KO } = require('internal/crypto/keys'); + key instanceof KO; + `, + errors: [{ messageId: 'noKeyObjectInstanceof' }], + }, + { + code: ` + const keys = require('internal/crypto/keys'); + key instanceof keys.KeyObject; + `, + errors: [{ messageId: 'noKeyObjectInstanceof' }], + }, + { + code: ` + key instanceof CryptoKey; + `, + errors: [{ messageId: 'noCryptoKeyInstanceof' }], + }, + { + code: ` + const { CryptoKey } = require('internal/crypto/keys'); + key instanceof CryptoKey; + `, + errors: [{ messageId: 'noCryptoKeyInstanceof' }], + }, + { + code: ` + const { CryptoKey: CK } = require('internal/crypto/webcrypto'); + key instanceof CK; + `, + errors: [{ messageId: 'noCryptoKeyInstanceof' }], + }, + { + code: ` + const webcrypto = require('internal/crypto/webcrypto'); + key instanceof webcrypto.CryptoKey; + `, + errors: [{ messageId: 'noCryptoKeyInstanceof' }], + }, + { + code: ` + key instanceof globalThis.CryptoKey; + `, + errors: [{ messageId: 'noCryptoKeyInstanceof' }], + }, + ], +}); diff --git a/test/parallel/test-eslint-no-keyobject-public-accessors.js b/test/parallel/test-eslint-no-keyobject-public-accessors.js new file mode 100644 index 00000000000000..2420ae48763995 --- /dev/null +++ b/test/parallel/test-eslint-no-keyobject-public-accessors.js @@ -0,0 +1,85 @@ +'use strict'; + +const common = require('../common'); +common.skipIfEslintMissing(); + +const RuleTester = require('../../tools/eslint/node_modules/eslint').RuleTester; +const rule = require('../../tools/eslint-rules/no-keyobject-public-accessors'); + +new RuleTester().run('no-keyobject-public-accessors', rule, { + valid: [ + 'foo.type;', + ` + const { isKeyObject, getKeyObjectType } = + require('internal/crypto/keys'); + if (isKeyObject(key)) { + getKeyObjectType(key); + } + `, + ` + const { isKeyObject } = require('internal/crypto/keys'); + if (format === 'raw-public') { + key.asymmetricKeyType; + } + `, + ` + const { KeyObject } = require('internal/crypto/keys'); + class Key extends KeyObject { + get type() { return 'secret'; } + } + `, + ], + invalid: [ + { + code: ` + const { isKeyObject } = require('internal/crypto/keys'); + if (isKeyObject(key)) { + key.type; + } + `, + errors: [{ messageId: 'noPublicAccessor' }], + }, + { + code: ` + const { isKeyObject: check } = require('internal/crypto/keys'); + if (check(key) && key.symmetricKeySize === 32) {} + `, + errors: [{ messageId: 'noPublicAccessor' }], + }, + { + code: ` + const { isKeyObject } = require('internal/crypto/keys'); + if (!isKeyObject(otherKeyObject)) { + throw new TypeError(); + } + otherKeyObject.asymmetricKeyType; + `, + errors: [{ messageId: 'noPublicAccessor' }], + }, + { + code: ` + const keys = require('internal/crypto/keys'); + if (!keys.isKeyObject(otherKeyObject)) throw new TypeError(); + otherKeyObject.asymmetricKeyDetails; + `, + errors: [{ messageId: 'noPublicAccessor' }], + }, + { + code: ` + class SecretKeyObject extends KeyObject { + export() { return this.symmetricKeySize; } + } + `, + errors: [{ messageId: 'noPublicAccessor' }], + }, + { + code: ` + const { isKeyObject } = require('internal/crypto/keys'); + if (isKeyObject(key)) { + key.equals(otherKey); + } + `, + errors: [{ messageId: 'noPublicAccessor' }], + }, + ], +}); diff --git a/tools/eslint-rules/no-cryptokey-public-accessors.js b/tools/eslint-rules/no-cryptokey-public-accessors.js new file mode 100644 index 00000000000000..cec9198d740fc3 --- /dev/null +++ b/tools/eslint-rules/no-cryptokey-public-accessors.js @@ -0,0 +1,277 @@ +/** + * @file Prevent internal code from using public CryptoKey accessors. + */ +'use strict'; + +const { isRequireCall, isString } = require('./rules-utils.js'); + +const CRYPTO_KEYS_MODULE = 'internal/crypto/keys'; +const WEBCRYPTO_MODULE = 'internal/crypto/webcrypto'; + +const accessors = new Map([ + ['type', 'getCryptoKeyType(key)'], + ['extractable', 'getCryptoKeyExtractable(key)'], + ['algorithm', 'getCryptoKeyAlgorithm(key)'], + ['usages', 'getCryptoKeyUsages(key)'], +]); + +const cryptoKeyClassNames = new Set([ + 'CryptoKey', + 'InternalCryptoKey', +]); + +function isCryptoKeyModuleRequire(node) { + return node?.type === 'CallExpression' && + isRequireCall(node) && + isString(node.arguments[0]) && + (node.arguments[0].value === CRYPTO_KEYS_MODULE || + node.arguments[0].value === WEBCRYPTO_MODULE); +} + +function getPropertyName(node) { + if (!node) return undefined; + if (node.computed) { + return node.property.type === 'Literal' ? node.property.value : undefined; + } + return node.property.name; +} + +function getIdentifierArgument(node) { + const arg = node.arguments[0]; + return arg?.type === 'Identifier' ? arg.name : undefined; +} + +function isNodeWithin(node, ancestor) { + return node.range[0] >= ancestor.range[0] && + node.range[1] <= ancestor.range[1]; +} + +function exits(statement) { + if (!statement) return false; + switch (statement.type) { + case 'BlockStatement': + return statement.body.length > 0 && exits(statement.body.at(-1)); + case 'ReturnStatement': + case 'ThrowStatement': + return true; + default: + return false; + } +} + +function findStatementInBlock(node) { + let current = node; + while (current?.parent) { + if ((current.parent.type === 'BlockStatement' || + current.parent.type === 'Program') && + current.parent.body.includes(current)) { + return { block: current.parent, statement: current }; + } + current = current.parent; + } +} + +function isWebIDLCryptoKeyConverter(node) { + if (node?.type !== 'CallExpression') return false; + if (node.callee.type !== 'MemberExpression') return false; + if (getPropertyName(node.callee) !== 'CryptoKey') return false; + + const converter = node.callee.object; + return converter?.type === 'MemberExpression' && + getPropertyName(converter) === 'converters'; +} + +module.exports = { + meta: { + messages: { + noPublicAccessor: 'Use `{{replacement}}` instead of the public CryptoKey `{{property}}` accessor.', + }, + schema: [], + }, + + create(context) { + const isCryptoKeyNames = new Set(); + const namespaceNames = new Set(); + const knownCryptoKeyNames = new Set(); + const knownCryptoKeyClassNames = new Set(cryptoKeyClassNames); + + function isIsCryptoKeyCall(node) { + if (node?.type !== 'CallExpression') return false; + + if (node.callee.type === 'Identifier') { + return isCryptoKeyNames.has(node.callee.name); + } + + if (node.callee.type === 'MemberExpression' && + !node.callee.computed && + node.callee.object.type === 'Identifier' && + namespaceNames.has(node.callee.object.name)) { + return node.callee.property.name === 'isCryptoKey'; + } + + return false; + } + + function getConsequentCryptoKeys(test) { + const names = new Set(); + if (isIsCryptoKeyCall(test)) { + names.add(getIdentifierArgument(test)); + } else if (test?.type === 'LogicalExpression' && test.operator === '&&') { + for (const name of getConsequentCryptoKeys(test.left)) { + names.add(name); + } + for (const name of getConsequentCryptoKeys(test.right)) { + names.add(name); + } + } + names.delete(undefined); + return names; + } + + function getAlternateCryptoKeys(test) { + const names = new Set(); + if (test?.type === 'UnaryExpression' && + test.operator === '!' && + isIsCryptoKeyCall(test.argument)) { + names.add(getIdentifierArgument(test.argument)); + } + names.delete(undefined); + return names; + } + + function isCryptoKeyFactory(node) { + if (node?.type === 'NewExpression' && + node.callee.type === 'Identifier') { + return knownCryptoKeyClassNames.has(node.callee.name); + } + + return isWebIDLCryptoKeyConverter(node); + } + + function isInCryptoKeyBranch(name, node) { + for (let current = node.parent; current; current = current.parent) { + if (current.type !== 'IfStatement') continue; + if (isNodeWithin(node, current.consequent) && + getConsequentCryptoKeys(current.test).has(name)) { + return true; + } + if (current.alternate && + isNodeWithin(node, current.alternate) && + getAlternateCryptoKeys(current.test).has(name)) { + return true; + } + } + return false; + } + + function followsExitingCryptoKeyGuard(name, node) { + const location = findStatementInBlock(node); + if (!location) return false; + const index = location.block.body.indexOf(location.statement); + for (let i = 0; i < index; i++) { + const statement = location.block.body[i]; + if (statement.type === 'IfStatement' && + exits(statement.consequent) && + getAlternateCryptoKeys(statement.test).has(name)) { + return true; + } + } + return false; + } + + function followsLogicalCryptoKeyCheck(name, node) { + for (let current = node; current.parent; current = current.parent) { + const parent = current.parent; + if (parent.type !== 'LogicalExpression' || parent.operator !== '&&') { + continue; + } + if (parent.right === current && + getConsequentCryptoKeys(parent.left).has(name)) { + return true; + } + } + return false; + } + + function isInsideCryptoKeyClass(node) { + for (let current = node.parent; current; current = current.parent) { + if (current.type !== 'ClassDeclaration' && + current.type !== 'ClassExpression') { + continue; + } + + const className = current.id?.name; + const superName = current.superClass?.type === 'Identifier' ? + current.superClass.name : undefined; + return knownCryptoKeyClassNames.has(className) || + knownCryptoKeyClassNames.has(superName); + } + return false; + } + + function isKnownCryptoKey(node) { + if (node.type === 'ThisExpression') { + return isInsideCryptoKeyClass(node); + } + + if (node.type !== 'Identifier') return false; + return knownCryptoKeyNames.has(node.name) || + isInCryptoKeyBranch(node.name, node) || + followsLogicalCryptoKeyCheck(node.name, node) || + followsExitingCryptoKeyGuard(node.name, node); + } + + return { + VariableDeclarator(node) { + if (isCryptoKeyModuleRequire(node.init)) { + if (node.id.type === 'Identifier') { + namespaceNames.add(node.id.name); + return; + } + + if (node.id.type !== 'ObjectPattern') return; + + for (const property of node.id.properties) { + if (property.type !== 'Property') continue; + const keyName = property.key.name ?? property.key.value; + if (property.value.type !== 'Identifier') continue; + const localName = property.value.name; + if (keyName === 'isCryptoKey') { + isCryptoKeyNames.add(localName); + } else if (cryptoKeyClassNames.has(keyName)) { + knownCryptoKeyClassNames.add(localName); + } + } + return; + } + + if (node.id.type === 'Identifier' && isCryptoKeyFactory(node.init)) { + knownCryptoKeyNames.add(node.id.name); + } + }, + + AssignmentExpression(node) { + if (node.left.type === 'Identifier' && isCryptoKeyFactory(node.right)) { + knownCryptoKeyNames.add(node.left.name); + } + }, + + MemberExpression(node) { + const property = getPropertyName(node); + const replacement = accessors.get(property); + if (replacement === undefined) return; + if (!isKnownCryptoKey(node.object)) return; + + context.report({ + node: node.property, + messageId: 'noPublicAccessor', + data: { + property, + replacement, + }, + }); + }, + + }; + }, +}; diff --git a/tools/eslint-rules/no-keyobject-cryptokey-instanceof.js b/tools/eslint-rules/no-keyobject-cryptokey-instanceof.js new file mode 100644 index 00000000000000..19e13437247a5e --- /dev/null +++ b/tools/eslint-rules/no-keyobject-cryptokey-instanceof.js @@ -0,0 +1,122 @@ +/** + * @file Prevent internal code from brand-checking keys with instanceof. + */ +'use strict'; + +const { isRequireCall, isString } = require('./rules-utils.js'); + +const CRYPTO_KEYS_MODULE = 'internal/crypto/keys'; +const WEBCRYPTO_MODULE = 'internal/crypto/webcrypto'; + +const keyObjectClassNames = new Set([ + 'KeyObject', + 'SecretKeyObject', + 'AsymmetricKeyObject', + 'PublicKeyObject', + 'PrivateKeyObject', +]); + +const cryptoKeyClassNames = new Set([ + 'CryptoKey', + 'InternalCryptoKey', +]); + +function isKeyModuleRequire(node) { + return node?.type === 'CallExpression' && + isRequireCall(node) && + isString(node.arguments[0]) && + (node.arguments[0].value === CRYPTO_KEYS_MODULE || + node.arguments[0].value === WEBCRYPTO_MODULE); +} + +function getPropertyName(node) { + if (!node) return undefined; + if (node.computed) { + return node.property.type === 'Literal' ? node.property.value : undefined; + } + return node.property.name; +} + +module.exports = { + meta: { + messages: { + noKeyObjectInstanceof: 'Use `isKeyObject(value)` instead of `value instanceof KeyObject`.', + noCryptoKeyInstanceof: 'Use `isCryptoKey(value)` instead of `value instanceof CryptoKey`.', + }, + schema: [], + }, + + create(context) { + const namespaceNames = new Set(); + const keyObjectConstructorNames = new Set(); + const cryptoKeyConstructorNames = new Set(['CryptoKey']); + + function registerRequire(node) { + if (!isKeyModuleRequire(node.init)) return; + + if (node.id.type === 'Identifier') { + namespaceNames.add(node.id.name); + return; + } + + if (node.id.type !== 'ObjectPattern') return; + + for (const property of node.id.properties) { + if (property.type !== 'Property') continue; + const keyName = property.key.name ?? property.key.value; + if (property.value.type !== 'Identifier') continue; + const localName = property.value.name; + if (keyObjectClassNames.has(keyName)) { + keyObjectConstructorNames.add(localName); + } else if (cryptoKeyClassNames.has(keyName)) { + cryptoKeyConstructorNames.add(localName); + } + } + } + + function constructorKind(node) { + if (node.type === 'Identifier') { + if (keyObjectConstructorNames.has(node.name)) return 'KeyObject'; + if (cryptoKeyConstructorNames.has(node.name)) return 'CryptoKey'; + return undefined; + } + + if (node.type !== 'MemberExpression') return undefined; + + const property = getPropertyName(node); + if (node.object.type === 'Identifier') { + if (namespaceNames.has(node.object.name)) { + if (keyObjectClassNames.has(property)) return 'KeyObject'; + if (cryptoKeyClassNames.has(property)) return 'CryptoKey'; + } + if (node.object.name === 'globalThis' && + cryptoKeyClassNames.has(property)) { + return 'CryptoKey'; + } + } + + return undefined; + } + + return { + VariableDeclarator: registerRequire, + + BinaryExpression(node) { + if (node.operator !== 'instanceof') return; + + const kind = constructorKind(node.right); + if (kind === 'KeyObject') { + context.report({ + node, + messageId: 'noKeyObjectInstanceof', + }); + } else if (kind === 'CryptoKey') { + context.report({ + node, + messageId: 'noCryptoKeyInstanceof', + }); + } + }, + }; + }, +}; diff --git a/tools/eslint-rules/no-keyobject-public-accessors.js b/tools/eslint-rules/no-keyobject-public-accessors.js new file mode 100644 index 00000000000000..64b93f4a70e65e --- /dev/null +++ b/tools/eslint-rules/no-keyobject-public-accessors.js @@ -0,0 +1,284 @@ +/** + * @file Prevent internal code from using public KeyObject accessors. + */ +'use strict'; + +const { isRequireCall, isString } = require('./rules-utils.js'); + +const KEYOBJECT_MODULE = 'internal/crypto/keys'; + +const accessors = new Map([ + ['type', 'getKeyObjectType(key)'], + ['symmetricKeySize', 'getKeyObjectSymmetricKeySize(key)'], + ['asymmetricKeyType', 'getKeyObjectAsymmetricKeyType(key)'], + ['asymmetricKeyDetails', 'getKeyObjectAsymmetricKeyDetails(key)'], + ['equals', 'getKeyObjectType(key) and getKeyObjectHandle(key)'], +]); + +const keyObjectClassNames = new Set([ + 'KeyObject', + 'SecretKeyObject', + 'AsymmetricKeyObject', + 'PublicKeyObject', + 'PrivateKeyObject', +]); + +const keyObjectFactoryNames = new Set([ + 'createSecretKey', + 'createPublicKey', + 'createPrivateKey', +]); + +function isInternalCryptoKeysRequire(node) { + return node?.type === 'CallExpression' && + isRequireCall(node) && + isString(node.arguments[0]) && + node.arguments[0].value === KEYOBJECT_MODULE; +} + +function getPropertyName(node) { + if (!node) return undefined; + if (node.computed) { + return node.property.type === 'Literal' ? node.property.value : undefined; + } + return node.property.name; +} + +function getIdentifierArgument(node) { + const arg = node.arguments[0]; + return arg?.type === 'Identifier' ? arg.name : undefined; +} + +function isNodeWithin(node, ancestor) { + return node.range[0] >= ancestor.range[0] && + node.range[1] <= ancestor.range[1]; +} + +function exits(statement) { + if (!statement) return false; + switch (statement.type) { + case 'BlockStatement': + return statement.body.length > 0 && exits(statement.body.at(-1)); + case 'ReturnStatement': + case 'ThrowStatement': + return true; + default: + return false; + } +} + +function findStatementInBlock(node) { + let current = node; + while (current?.parent) { + if ((current.parent.type === 'BlockStatement' || + current.parent.type === 'Program') && + current.parent.body.includes(current)) { + return { block: current.parent, statement: current }; + } + current = current.parent; + } +} + +module.exports = { + meta: { + messages: { + noPublicAccessor: 'Use `{{replacement}}` instead of the public KeyObject `{{property}}` accessor.', + }, + schema: [], + }, + + create(context) { + const isKeyObjectNames = new Set(); + const namespaceNames = new Set(); + const knownKeyObjectNames = new Set(); + const knownKeyObjectClassNames = new Set(keyObjectClassNames); + + function isIsKeyObjectCall(node) { + if (node?.type !== 'CallExpression') return false; + + if (node.callee.type === 'Identifier') { + return isKeyObjectNames.has(node.callee.name); + } + + if (node.callee.type === 'MemberExpression' && + !node.callee.computed && + node.callee.object.type === 'Identifier' && + namespaceNames.has(node.callee.object.name)) { + return node.callee.property.name === 'isKeyObject'; + } + + return false; + } + + function getConsequentKeyObjects(test) { + const names = new Set(); + if (isIsKeyObjectCall(test)) { + names.add(getIdentifierArgument(test)); + } else if (test?.type === 'LogicalExpression' && test.operator === '&&') { + for (const name of getConsequentKeyObjects(test.left)) { + names.add(name); + } + for (const name of getConsequentKeyObjects(test.right)) { + names.add(name); + } + } + names.delete(undefined); + return names; + } + + function getAlternateKeyObjects(test) { + const names = new Set(); + if (test?.type === 'UnaryExpression' && + test.operator === '!' && + isIsKeyObjectCall(test.argument)) { + names.add(getIdentifierArgument(test.argument)); + } + names.delete(undefined); + return names; + } + + function isKeyObjectFactory(node) { + if (node?.type === 'NewExpression' && + node.callee.type === 'Identifier') { + return knownKeyObjectClassNames.has(node.callee.name); + } + + if (node?.type !== 'CallExpression') return false; + + if (node.callee.type === 'Identifier') { + return keyObjectFactoryNames.has(node.callee.name); + } + + if (node.callee.type !== 'MemberExpression') return false; + const object = node.callee.object; + const property = getPropertyName(node.callee); + if (object.type === 'Identifier' && + knownKeyObjectClassNames.has(object.name)) { + return property === 'from'; + } + return object.type === 'Identifier' && + namespaceNames.has(object.name) && + keyObjectFactoryNames.has(property); + } + + function isInKeyObjectBranch(name, node) { + for (let current = node.parent; current; current = current.parent) { + if (current.type !== 'IfStatement') continue; + if (isNodeWithin(node, current.consequent) && + getConsequentKeyObjects(current.test).has(name)) { + return true; + } + if (current.alternate && + isNodeWithin(node, current.alternate) && + getAlternateKeyObjects(current.test).has(name)) { + return true; + } + } + return false; + } + + function followsExitingKeyObjectGuard(name, node) { + const location = findStatementInBlock(node); + if (!location) return false; + const index = location.block.body.indexOf(location.statement); + for (let i = 0; i < index; i++) { + const statement = location.block.body[i]; + if (statement.type === 'IfStatement' && + exits(statement.consequent) && + getAlternateKeyObjects(statement.test).has(name)) { + return true; + } + } + return false; + } + + function followsLogicalKeyObjectCheck(name, node) { + for (let current = node; current.parent; current = current.parent) { + const parent = current.parent; + if (parent.type !== 'LogicalExpression' || parent.operator !== '&&') { + continue; + } + if (parent.right === current && + getConsequentKeyObjects(parent.left).has(name)) { + return true; + } + } + return false; + } + + function isInsideKeyObjectClass(node) { + for (let current = node.parent; current; current = current.parent) { + if (current.type !== 'ClassDeclaration' && + current.type !== 'ClassExpression') { + continue; + } + + const className = current.id?.name; + const superName = current.superClass?.type === 'Identifier' ? + current.superClass.name : undefined; + return knownKeyObjectClassNames.has(className) || + knownKeyObjectClassNames.has(superName); + } + return false; + } + + function isKnownKeyObject(node) { + if (node.type === 'ThisExpression') { + return isInsideKeyObjectClass(node); + } + + if (node.type !== 'Identifier') return false; + return knownKeyObjectNames.has(node.name) || + isInKeyObjectBranch(node.name, node) || + followsLogicalKeyObjectCheck(node.name, node) || + followsExitingKeyObjectGuard(node.name, node); + } + + return { + VariableDeclarator(node) { + if (isInternalCryptoKeysRequire(node.init)) { + if (node.id.type === 'Identifier') { + namespaceNames.add(node.id.name); + return; + } + + if (node.id.type !== 'ObjectPattern') return; + + for (const property of node.id.properties) { + if (property.type !== 'Property') continue; + const keyName = property.key.name ?? property.key.value; + if (property.value.type !== 'Identifier') continue; + const localName = property.value.name; + if (keyName === 'isKeyObject') { + isKeyObjectNames.add(localName); + } else if (keyObjectClassNames.has(keyName)) { + knownKeyObjectClassNames.add(localName); + } + } + return; + } + + if (node.id.type === 'Identifier' && isKeyObjectFactory(node.init)) { + knownKeyObjectNames.add(node.id.name); + } + }, + + MemberExpression(node) { + const property = getPropertyName(node); + const replacement = accessors.get(property); + if (replacement === undefined) return; + if (!isKnownKeyObject(node.object)) return; + + context.report({ + node: node.property, + messageId: 'noPublicAccessor', + data: { + property, + replacement, + }, + }); + }, + + }; + }, +}; From a9b98b21bda46ae6bf68276cfa00781c79ee6bb9 Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Fri, 8 May 2026 10:23:08 +0200 Subject: [PATCH 092/168] doc: fix deprecation list in 26.0.0 changelog Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/63147 Reviewed-By: Filip Skokan Reviewed-By: James M Snell Reviewed-By: Luigi Pinca Reviewed-By: Trivikram Kamat --- doc/changelogs/CHANGELOG_V26.md | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/doc/changelogs/CHANGELOG_V26.md b/doc/changelogs/CHANGELOG_V26.md index 408f7a06f58ca5..0576adcb2a3966 100644 --- a/doc/changelogs/CHANGELOG_V26.md +++ b/doc/changelogs/CHANGELOG_V26.md @@ -403,17 +403,21 @@ Undici has been updated to version 8.0.2, bringing new features and improvements #### Deprecations and Removals * \[[`dff46c07c3`](https://github.com/nodejs/node/commit/dff46c07c3)] - **(SEMVER-MAJOR)** **crypto**: move DEP0182 to End-of-Life (Tobias Nießen) [#61084](https://github.com/nodejs/node/pull/61084) + * \[[`93c25815ee`](https://github.com/nodejs/node/commit/93c25815ee)] - **(SEMVER-MAJOR)** **http**: move writeHeader to end-of-life (Sebastian Beltran) [#60635](https://github.com/nodejs/node/pull/60635) -`http.Server.prototype.writeHeader()` is now fully removed. Use `http.Server.prototype.writeHead()` instead. + `http.Server.prototype.writeHeader()` is now fully removed. Use `http.Server.prototype.writeHead()` instead. * \[[`c755b0113c`](https://github.com/nodejs/node/commit/c755b0113c)] - **(SEMVER-MAJOR)** **stream**: move \_stream\_\* to end-of-life (Sebastian Beltran) [#60657](https://github.com/nodejs/node/pull/60657) -The legacy `_stream_wrap`, `_stream_readable`, `_stream_writable`, `_stream_duplex`, `_stream_transform`, and `_stream_passthrough` modules are now fully removed. + The legacy `_stream_wrap`, `_stream_readable`, `_stream_writable`, `_stream_duplex`, `_stream_transform`, and `_stream_passthrough` modules are now fully removed. * \[[`adac077484`](https://github.com/nodejs/node/commit/adac077484)] - **(SEMVER-MAJOR)** **crypto**: runtime-deprecate DEP0203 and DEP0204 (Filip Skokan) [#62453](https://github.com/nodejs/node/pull/62453) + * \[[`ac6375417a`](https://github.com/nodejs/node/commit/ac6375417a)] - **(SEMVER-MAJOR)** **stream**: promote DEP0201 to runtime deprecation (René) [#62173](https://github.com/nodejs/node/pull/62173) + * \[[`98907f560f`](https://github.com/nodejs/node/commit/98907f560f)] - **(SEMVER-MAJOR)** **module**: runtime-deprecate module.register() (Geoffrey Booth) [#62401](https://github.com/nodejs/node/pull/62401) + * \[[`89f4b6cddb`](https://github.com/nodejs/node/commit/89f4b6cddb)] - **(SEMVER-MAJOR)** **module**: remove --experimental-transform-types (Marco Ippolito) [#61803](https://github.com/nodejs/node/pull/61803) ### Semver-Major Commits From bd654678dacda31b3d388555320797aa9f9ab2a3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ren=C3=A9?= Date: Fri, 8 May 2026 14:29:34 +0100 Subject: [PATCH 093/168] test: use ERM to destroy sqlite database handles after tests Signed-off-by: Renegade334 PR-URL: https://github.com/nodejs/node/pull/63076 Refs: https://github.com/nodejs/node/issues/63052 Reviewed-By: Chemi Atlow Reviewed-By: Luigi Pinca Reviewed-By: Edy Silva --- .../test-sqlite-database-sync-dispose.js | 33 ------- test/parallel/test-sqlite-database-sync.js | 99 +++++++++---------- 2 files changed, 46 insertions(+), 86 deletions(-) delete mode 100644 test/parallel/test-sqlite-database-sync-dispose.js diff --git a/test/parallel/test-sqlite-database-sync-dispose.js b/test/parallel/test-sqlite-database-sync-dispose.js deleted file mode 100644 index 67a1ab6757b848..00000000000000 --- a/test/parallel/test-sqlite-database-sync-dispose.js +++ /dev/null @@ -1,33 +0,0 @@ -'use strict'; -const { skipIfSQLiteMissing } = require('../common'); -skipIfSQLiteMissing(); -const tmpdir = require('../common/tmpdir'); -const assert = require('node:assert'); -const { join } = require('node:path'); -const { DatabaseSync } = require('node:sqlite'); -const { suite, test } = require('node:test'); -let cnt = 0; - -tmpdir.refresh(); - -function nextDb() { - return join(tmpdir.path, `database-${cnt++}.db`); -} - -suite('DatabaseSync.prototype[Symbol.dispose]()', () => { - test('closes an open database', () => { - const db = new DatabaseSync(nextDb()); - db[Symbol.dispose](); - assert.throws(() => { - db.close(); - }, /database is not open/); - }); - - test('supports databases that are not open', () => { - const db = new DatabaseSync(nextDb(), { open: false }); - db[Symbol.dispose](); - assert.throws(() => { - db.close(); - }, /database is not open/); - }); -}); diff --git a/test/parallel/test-sqlite-database-sync.js b/test/parallel/test-sqlite-database-sync.js index d778f839098737..ac3a3c66d6469a 100644 --- a/test/parallel/test-sqlite-database-sync.js +++ b/test/parallel/test-sqlite-database-sync.js @@ -89,19 +89,18 @@ suite('DatabaseSync() constructor', () => { test('is not read-only by default', (t) => { const dbPath = nextDb(); - const db = new DatabaseSync(dbPath); + using db = new DatabaseSync(dbPath); db.exec('CREATE TABLE foo (id INTEGER PRIMARY KEY)'); }); test('is read-only if readOnly is set', (t) => { const dbPath = nextDb(); { - const db = new DatabaseSync(dbPath); + using db = new DatabaseSync(dbPath); db.exec('CREATE TABLE foo (id INTEGER PRIMARY KEY)'); - db.close(); } { - const db = new DatabaseSync(dbPath, { readOnly: true }); + using db = new DatabaseSync(dbPath, { readOnly: true }); t.assert.throws(() => { db.exec('CREATE TABLE bar (id INTEGER PRIMARY KEY)'); }, { @@ -122,12 +121,11 @@ suite('DatabaseSync() constructor', () => { test('enables foreign key constraints by default', (t) => { const dbPath = nextDb(); - const db = new DatabaseSync(dbPath); + using db = new DatabaseSync(dbPath); db.exec(` CREATE TABLE foo (id INTEGER PRIMARY KEY); CREATE TABLE bar (foo_id INTEGER REFERENCES foo(id)); `); - t.after(() => { db.close(); }); t.assert.throws(() => { db.exec('INSERT INTO bar (foo_id) VALUES (1)'); }, { @@ -138,12 +136,11 @@ suite('DatabaseSync() constructor', () => { test('allows disabling foreign key constraints', (t) => { const dbPath = nextDb(); - const db = new DatabaseSync(dbPath, { enableForeignKeyConstraints: false }); + using db = new DatabaseSync(dbPath, { enableForeignKeyConstraints: false }); db.exec(` CREATE TABLE foo (id INTEGER PRIMARY KEY); CREATE TABLE bar (foo_id INTEGER REFERENCES foo(id)); `); - t.after(() => { db.close(); }); db.exec('INSERT INTO bar (foo_id) VALUES (1)'); }); @@ -158,8 +155,7 @@ suite('DatabaseSync() constructor', () => { test('disables double-quoted string literals by default', (t) => { const dbPath = nextDb(); - const db = new DatabaseSync(dbPath); - t.after(() => { db.close(); }); + using db = new DatabaseSync(dbPath); t.assert.throws(() => { db.exec('SELECT "foo";'); }, { @@ -170,8 +166,7 @@ suite('DatabaseSync() constructor', () => { test('allows enabling double-quoted string literals', (t) => { const dbPath = nextDb(); - const db = new DatabaseSync(dbPath, { enableDoubleQuotedStringLiterals: true }); - t.after(() => { db.close(); }); + using db = new DatabaseSync(dbPath, { enableDoubleQuotedStringLiterals: true }); db.exec('SELECT "foo";'); }); @@ -186,8 +181,7 @@ suite('DatabaseSync() constructor', () => { test('allows reading big integers', (t) => { const dbPath = nextDb(); - const db = new DatabaseSync(dbPath, { readBigInts: true }); - t.after(() => { db.close(); }); + using db = new DatabaseSync(dbPath, { readBigInts: true }); const setup = db.exec(` CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT; @@ -216,8 +210,7 @@ suite('DatabaseSync() constructor', () => { test('allows returning arrays', (t) => { const dbPath = nextDb(); - const db = new DatabaseSync(dbPath, { returnArrays: true }); - t.after(() => { db.close(); }); + using db = new DatabaseSync(dbPath, { returnArrays: true }); const setup = db.exec(` CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT; INSERT INTO data (key, val) VALUES (1, 'one'); @@ -240,8 +233,7 @@ suite('DatabaseSync() constructor', () => { test('throws if bare named parameters are used when option is false', (t) => { const dbPath = nextDb(); - const db = new DatabaseSync(dbPath, { allowBareNamedParameters: false }); - t.after(() => { db.close(); }); + using db = new DatabaseSync(dbPath, { allowBareNamedParameters: false }); const setup = db.exec( 'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;' ); @@ -267,8 +259,7 @@ suite('DatabaseSync() constructor', () => { test('allows unknown named parameters', (t) => { const dbPath = nextDb(); - const db = new DatabaseSync(dbPath, { allowUnknownNamedParameters: true }); - t.after(() => { db.close(); }); + using db = new DatabaseSync(dbPath, { allowUnknownNamedParameters: true }); const setup = db.exec( 'CREATE TABLE data(key INTEGER, val INTEGER) STRICT;' ); @@ -284,8 +275,7 @@ suite('DatabaseSync() constructor', () => { test('has sqlite-type symbol property', (t) => { const dbPath = nextDb(); - const db = new DatabaseSync(dbPath); - t.after(() => { db.close(); }); + using db = new DatabaseSync(dbPath); const sqliteTypeSymbol = Symbol.for('sqlite-type'); t.assert.strictEqual(db[sqliteTypeSymbol], 'node:sqlite'); @@ -295,8 +285,7 @@ suite('DatabaseSync() constructor', () => { suite('DatabaseSync.prototype.open()', () => { test('opens a database connection', (t) => { const dbPath = nextDb(); - const db = new DatabaseSync(dbPath, { open: false }); - t.after(() => { db.close(); }); + using db = new DatabaseSync(dbPath, { open: false }); t.assert.strictEqual(db.isOpen, false); t.assert.strictEqual(existsSync(dbPath), false); @@ -306,8 +295,7 @@ suite('DatabaseSync.prototype.open()', () => { }); test('throws if database is already open', (t) => { - const db = new DatabaseSync(nextDb(), { open: false }); - t.after(() => { db.close(); }); + using db = new DatabaseSync(nextDb(), { open: false }); t.assert.strictEqual(db.isOpen, false); db.open(); @@ -324,7 +312,7 @@ suite('DatabaseSync.prototype.open()', () => { suite('DatabaseSync.prototype.close()', () => { test('closes an open database connection', (t) => { - const db = new DatabaseSync(nextDb()); + using db = new DatabaseSync(nextDb()); t.assert.strictEqual(db.isOpen, true); t.assert.strictEqual(db.close(), undefined); @@ -332,7 +320,7 @@ suite('DatabaseSync.prototype.close()', () => { }); test('throws if database is not open', (t) => { - const db = new DatabaseSync(nextDb(), { open: false }); + using db = new DatabaseSync(nextDb(), { open: false }); t.assert.strictEqual(db.isOpen, false); t.assert.throws(() => { @@ -347,14 +335,13 @@ suite('DatabaseSync.prototype.close()', () => { suite('DatabaseSync.prototype.prepare()', () => { test('returns a prepared statement', (t) => { - const db = new DatabaseSync(nextDb()); - t.after(() => { db.close(); }); + using db = new DatabaseSync(nextDb()); const stmt = db.prepare('CREATE TABLE webstorage(key TEXT)'); t.assert.ok(stmt instanceof StatementSync); }); test('throws if database is not open', (t) => { - const db = new DatabaseSync(nextDb(), { open: false }); + using db = new DatabaseSync(nextDb(), { open: false }); t.assert.throws(() => { db.prepare(); @@ -365,8 +352,7 @@ suite('DatabaseSync.prototype.prepare()', () => { }); test('throws if sql is not a string', (t) => { - const db = new DatabaseSync(nextDb()); - t.after(() => { db.close(); }); + using db = new DatabaseSync(nextDb()); t.assert.throws(() => { db.prepare(); @@ -379,8 +365,7 @@ suite('DatabaseSync.prototype.prepare()', () => { suite('DatabaseSync.prototype.exec()', () => { test('executes SQL', (t) => { - const db = new DatabaseSync(nextDb()); - t.after(() => { db.close(); }); + using db = new DatabaseSync(nextDb()); const result = db.exec(` CREATE TABLE data( key INTEGER PRIMARY KEY, @@ -398,8 +383,7 @@ suite('DatabaseSync.prototype.exec()', () => { }); test('reports errors from SQLite', (t) => { - const db = new DatabaseSync(nextDb()); - t.after(() => { db.close(); }); + using db = new DatabaseSync(nextDb()); t.assert.throws(() => { db.exec('CREATE TABLEEEE'); @@ -419,7 +403,7 @@ suite('DatabaseSync.prototype.exec()', () => { }); test('throws if database is not open', (t) => { - const db = new DatabaseSync(nextDb(), { open: false }); + using db = new DatabaseSync(nextDb(), { open: false }); t.assert.throws(() => { db.exec(); @@ -430,8 +414,7 @@ suite('DatabaseSync.prototype.exec()', () => { }); test('throws if sql is not a string', (t) => { - const db = new DatabaseSync(nextDb()); - t.after(() => { db.close(); }); + using db = new DatabaseSync(nextDb()); t.assert.throws(() => { db.exec(); @@ -444,7 +427,7 @@ suite('DatabaseSync.prototype.exec()', () => { suite('DatabaseSync.prototype.isTransaction', () => { test('correctly detects a committed transaction', (t) => { - const db = new DatabaseSync(':memory:'); + using db = new DatabaseSync(':memory:'); t.assert.strictEqual(db.isTransaction, false); db.exec('BEGIN'); @@ -456,7 +439,7 @@ suite('DatabaseSync.prototype.isTransaction', () => { }); test('correctly detects a rolled back transaction', (t) => { - const db = new DatabaseSync(':memory:'); + using db = new DatabaseSync(':memory:'); t.assert.strictEqual(db.isTransaction, false); db.exec('BEGIN'); @@ -468,7 +451,7 @@ suite('DatabaseSync.prototype.isTransaction', () => { }); test('throws if database is not open', (t) => { - const db = new DatabaseSync(nextDb(), { open: false }); + using db = new DatabaseSync(nextDb(), { open: false }); t.assert.throws(() => { return db.isTransaction; @@ -481,7 +464,7 @@ suite('DatabaseSync.prototype.isTransaction', () => { suite('DatabaseSync.prototype.location()', () => { test('throws if database is not open', (t) => { - const db = new DatabaseSync(nextDb(), { open: false }); + using db = new DatabaseSync(nextDb(), { open: false }); t.assert.throws(() => { db.location(); @@ -492,8 +475,7 @@ suite('DatabaseSync.prototype.location()', () => { }); test('throws if provided dbName is not string', (t) => { - const db = new DatabaseSync(nextDb()); - t.after(() => { db.close(); }); + using db = new DatabaseSync(nextDb()); t.assert.throws(() => { db.location(null); @@ -504,24 +486,20 @@ suite('DatabaseSync.prototype.location()', () => { }); test('returns null when connected to in-memory database', (t) => { - const db = new DatabaseSync(':memory:'); + using db = new DatabaseSync(':memory:'); t.assert.strictEqual(db.location(), null); }); test('returns db path when connected to a persistent database', (t) => { const dbPath = nextDb(); - const db = new DatabaseSync(dbPath); - t.after(() => { db.close(); }); + using db = new DatabaseSync(dbPath); t.assert.strictEqual(db.location(), dbPath); }); test('returns that specific db path when attached', (t) => { const dbPath = nextDb(); const otherPath = nextDb(); - const db = new DatabaseSync(dbPath); - t.after(() => { db.close(); }); - const other = new DatabaseSync(dbPath); - t.after(() => { other.close(); }); + using db = new DatabaseSync(dbPath); // Adding this escape because the test with unusual chars have a single quote which breaks the query const escapedPath = otherPath.replace("'", "''"); @@ -530,3 +508,18 @@ suite('DatabaseSync.prototype.location()', () => { t.assert.strictEqual(db.location('other'), otherPath); }); }); + +suite('DatabaseSync.prototype[Symbol.dispose]', () => { + test('closes an open database', (t) => { + const db = new DatabaseSync(nextDb()); + t.assert.strictEqual(db.isOpen, true); + db[Symbol.dispose](); + t.assert.strictEqual(db.isOpen, false); + }); + + test('does not throw on databases that are not open', (t) => { + const db = new DatabaseSync(nextDb(), { open: false }); + t.assert.strictEqual(db.isOpen, false); + db[Symbol.dispose](); + }); +}); From 11740ef11394ac9ebaf6903c0d54804f780f9711 Mon Sep 17 00:00:00 2001 From: Edy Silva Date: Fri, 8 May 2026 11:15:57 -0300 Subject: [PATCH 094/168] doc,sqlite: document entryPoint argument for loadExtension MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: geeksilva97 PR-URL: https://github.com/nodejs/node/pull/63152 Reviewed-By: Colin Ihrig Reviewed-By: René --- doc/api/sqlite.md | 28 +++++++++++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-) diff --git a/doc/api/sqlite.md b/doc/api/sqlite.md index ec9c1ad4e8828f..45e045f5f45e01 100644 --- a/doc/api/sqlite.md +++ b/doc/api/sqlite.md @@ -298,7 +298,7 @@ added: v22.5.0 Closes the database connection. An exception is thrown if the database is not open. This method is a wrapper around [`sqlite3_close_v2()`][]. -### `database.loadExtension(path)` +### `database.loadExtension(path[, entryPoint])` * `path` {string} The path to the shared library to load. +* `entryPoint` {string} The name of the extension's entry-point function. When + omitted, SQLite derives the entry point from the shared library's filename; + pass this argument explicitly when the derived name does not match. Loads a shared library into the database connection. This method is a wrapper around [`sqlite3_load_extension()`][]. It is required to enable the `allowExtension` option when constructing the `DatabaseSync` instance. +```mjs +import { DatabaseSync } from 'node:sqlite'; +const database = new DatabaseSync(':memory:', { allowExtension: true }); + +// Load using the entry point derived from the filename. +database.loadExtension('./decimal.dylib'); + +// Override the entry point when the derived name does not match. +database.loadExtension('./base64.dylib', 'sqlite3_base64_init'); +``` + +```cjs +'use strict'; +const { DatabaseSync } = require('node:sqlite'); +const database = new DatabaseSync(':memory:', { allowExtension: true }); + +// Load using the entry point derived from the filename. +database.loadExtension('./decimal.dylib'); + +// Override the entry point when the derived name does not match. +database.loadExtension('./base64.dylib', 'sqlite3_base64_init'); +``` + ### `database.enableLoadExtension(allow)` + +* {Object} + +An object containing commonly used constants for QUIC configuration. + +### `quic.constants.cc` + +* {Object} + +Congestion control algorithm identifiers, for use with the +[`sessionOptions.cc`][] option: + +* `quic.constants.cc.RENO` — Reno congestion control. +* `quic.constants.cc.CUBIC` — CUBIC congestion control. +* `quic.constants.cc.BBR` — BBR congestion control. + +### `quic.constants.DEFAULT_CIPHERS` + +* {string} + +The default TLS 1.3 cipher suite list used when [`sessionOptions.ciphers`][] +is not specified. + +### `quic.constants.DEFAULT_GROUPS` + +* {string} + +The default TLS 1.3 key-exchange group list used when +[`sessionOptions.groups`][] is not specified. + ## Class: `QuicEndpoint` A `QuicEndpoint` encapsulates the local UDP-port binding for QUIC. It can be @@ -206,6 +522,10 @@ True if `endpoint.destroy()` has been called. Read only. ### `endpoint.listening` + + * Type: {boolean} True if the endpoint is actively listening for incoming connections. Read only. @@ -272,7 +592,7 @@ added: v23.8.0 * Type: {quic.QuicEndpoint.Stats} -The statistics collected for an active session. Read only. +The statistics collected for an active endpoint. Read only. ### `endpoint[Symbol.asyncDispose]()` @@ -378,7 +698,7 @@ added: v23.8.0 added: v23.8.0 --> -* Type: {bigint} The total number sessions rejected due to QUIC version mismatch. Read only. +* Type: {bigint} The total number of sessions rejected due to QUIC version mismatch. Read only. ### `endpointStats.statelessResetCount` @@ -412,7 +732,7 @@ added: v23.8.0 * `options` {Object} * `code` {bigint|number} The error code to include in the `CONNECTION_CLOSE` - frame sent to the peer. Defaults to `0` (no error). **Default:** `0`. + frame sent to the peer. **Default:** `0` (no error). * `type` {string} Either `'transport'` or `'application'`. Determines the error code namespace used in the `CONNECTION_CLOSE` frame. When `'transport'` (the default), the frame type is `0x1c` and the code is interpreted as a QUIC @@ -470,6 +790,17 @@ added: v23.8.0 A promise that is fulfilled once the session is destroyed. +### `session.closing` + + + +* Type: {boolean} + +True if [`session.close()`][] has been called and the session has not yet +been destroyed. Read only. + ### `session.destroy([error[, options]])` -* Type: {quic.QuicEndpoint} +* Type: {quic.QuicEndpoint|null} -The endpoint that created this session. Read only. +The endpoint that created this session. Returns `null` if the session +has been destroyed. Read only. ### `session.onerror` + + * Type: {Function|undefined} An optional callback invoked when the session is destroyed with an error. @@ -558,6 +894,10 @@ The callback to invoke when the status of a datagram is updated. Read/write. ### `session.onearlyrejected` + + * Type: {Function|undefined} The callback to invoke when the server rejects 0-RTT early data. When @@ -757,6 +1097,10 @@ added: v23.8.0 interleaved with data from other streams of the same priority level. When `false`, the stream should be completed before same-priority peers. **Default:** `false`. + * `highWaterMark` {number} The maximum number of bytes that the writer + will buffer before `writeSync()` returns `false`. When the buffered + data exceeds this limit, the caller should wait for drain before + writing more. **Default:** `65536` (64 KB). * `onheaders` {Function} Callback for received initial response headers. Called with `(headers)`. * `ontrailers` {Function} Callback for received trailing headers. @@ -1315,6 +1659,10 @@ the implementation falls back to the negotiated application protocol's ### `stream.early` + + * Type: {boolean} True if any data on this stream was received as 0-RTT (early data) @@ -1331,9 +1679,10 @@ side, it is always `false`. added: v23.8.0 --> -* Type: {string} One of either `'bidi'` or `'uni'`. +* Type: {string|null} One of `'bidi'`, `'uni'`, or `null`. -The directionality of the stream. Read only. +The directionality of the stream, or `null` if the stream has been destroyed +or is still pending. Read only. ### `stream.highWaterMark` @@ -1345,8 +1694,7 @@ added: REPLACEME The maximum number of bytes that the writer will buffer before `writeSync()` returns `false`. When the buffered data exceeds this limit, -the caller should wait for the `drainableProtocol` promise to resolve -before writing more. +the caller should wait for drain before writing more. The value can be changed dynamically at any time. This is particularly useful for streams received via the `onstream` callback, where the @@ -1359,12 +1707,17 @@ The valid range is `0` to `4294967295`. added: v23.8.0 --> -* Type: {bigint} +* Type: {bigint|null} -The stream ID. Read only. +The stream ID, or `null` if the stream has been destroyed or is still +pending. Read only. ### `stream.onerror` + + * Type: {Function|undefined} An optional callback invoked when the stream is destroyed with an error. @@ -1694,9 +2047,10 @@ the writer has been accessed. added: v23.8.0 --> -* Type: {quic.QuicSession} +* Type: {quic.QuicSession|null} -The session that created this stream. Read only. +The session that created this stream, or `null` if the stream has been +destroyed. Read only. ### `stream.stats` @@ -1842,7 +2196,7 @@ added: v23.8.0 The endpoint maintains an internal cache of validated socket addresses as a performance optimization. This option sets the maximum number of addresses -that are cache. This is an advanced option that users typically won't have +that are cached. This is an advanced option that users typically won't have need to specify. #### `endpointOptions.disableStatelessReset` @@ -2108,8 +2462,8 @@ added: v23.8.0 * Type: {string} -Specifies the congestion control algorithm that will be used -. Must be set to one of either `'reno'`, `'cubic'`, or `'bbr'`. +Specifies the congestion control algorithm that will be used. +Must be set to one of either `'reno'`, `'cubic'`, or `'bbr'`. This is an advanced option that users typically won't have need to specify. @@ -2166,7 +2520,7 @@ added: v23.8.0 * Type: {string} -The list of support TLS 1.3 cipher groups. +The list of supported TLS 1.3 cipher groups. #### `sessionOptions.keylog` @@ -2748,14 +3102,19 @@ added: v23.8.0 --> * `this` {quic.QuicSession} -* `sni` {string} -* `alpn` {string} -* `cipher` {string} -* `cipherVersion` {string} -* `validationErrorReason` {string} -* `validationErrorCode` {number} -* `earlyDataAttempted` {boolean} -* `earlyDataAccepted` {boolean} +* `info` {Object} The same object that `session.opened` resolves with. + * `local` {net.SocketAddress} The local socket address. + * `remote` {net.SocketAddress} The remote socket address. + * `servername` {string} The SNI server name negotiated during the handshake. + * `protocol` {string} The ALPN protocol negotiated during the handshake. + * `cipher` {string} The name of the negotiated TLS cipher suite. + * `cipherVersion` {string} The TLS protocol version of the cipher suite. + * `validationErrorReason` {string} If certificate validation failed, the + reason string. Empty string if validation succeeded. + * `validationErrorCode` {number} If certificate validation failed, the + error code. `0` if validation succeeded. + * `earlyDataAttempted` {boolean} Whether 0-RTT early data was attempted. + * `earlyDataAccepted` {boolean} Whether 0-RTT early data was accepted. ### Callback: `OnNewTokenCallback` @@ -2931,8 +3290,10 @@ const stream = await session.createBidirectionalStream({ }); const decoder = new TextDecoder(); -for await (const chunk of stream) { - process.stdout.write(decoder.decode(chunk, { stream: true })); +for await (const chunks of stream) { + for (const chunk of chunks) { + process.stdout.write(decoder.decode(chunk, { stream: true })); + } } await session.close(); @@ -2947,8 +3308,8 @@ A few things to note: regular headers in a single object with lowercase string keys. After the callback returns, the same object is also accessible via [`stream.headers`][]. -* Reading `for await (const chunk of stream)` consumes the response - body as `Uint8Array` chunks. +* Reading `for await (const chunks of stream)` consumes the response + body. Each iteration yields a `Uint8Array[]` batch of chunks. * HTTP semantic helpers (URL parsing, method/status validation, redirects, content negotiation, and so on) are intentionally not built in. The caller is responsible for any HTTP-level handling @@ -3492,6 +3853,23 @@ throughput issues caused by flow control. [Callback error handling]: #callback-error-handling [JSON-SEQ]: https://www.rfc-editor.org/rfc/rfc7464 [NSS Key Log Format]: https://udn.realityripple.com/docs/Mozilla/Projects/NSS/Key_Log_Format +[RFC 8999]: https://www.rfc-editor.org/rfc/rfc8999 +[RFC 9000]: https://www.rfc-editor.org/rfc/rfc9000 +[RFC 9001]: https://www.rfc-editor.org/rfc/rfc9001 +[RFC 9002]: https://www.rfc-editor.org/rfc/rfc9002 +[RFC 9114]: https://www.rfc-editor.org/rfc/rfc9114 +[RFC 9204]: https://www.rfc-editor.org/rfc/rfc9204 +[RFC 9218]: https://www.rfc-editor.org/rfc/rfc9218 +[RFC 9220]: https://www.rfc-editor.org/rfc/rfc9220 +[RFC 9221]: https://www.rfc-editor.org/rfc/rfc9221 +[RFC 9287]: https://www.rfc-editor.org/rfc/rfc9287 +[RFC 9297]: https://www.rfc-editor.org/rfc/rfc9297 +[RFC 9308]: https://www.rfc-editor.org/rfc/rfc9308 +[RFC 9312]: https://www.rfc-editor.org/rfc/rfc9312 +[RFC 9368]: https://www.rfc-editor.org/rfc/rfc9368 +[RFC 9369]: https://www.rfc-editor.org/rfc/rfc9369 +[RFC 9412]: https://www.rfc-editor.org/rfc/rfc9412 +[RFC 9443]: https://www.rfc-editor.org/rfc/rfc9443 [`PerformanceEntry`]: perf_hooks.md#class-performanceentry [`PerformanceObserver`]: perf_hooks.md#class-performanceobserver [`QuicError`]: #class-quicerror @@ -3502,23 +3880,35 @@ throughput issues caused by flow control. [`endpoint.maxConnectionsTotal`]: #endpointmaxconnectionstotal [`error.errorCode`]: #errorerrorcode [`fs.promises.open(path, 'r')`]: fs.md#fspromisesopenpath-flags-mode +[`maxDatagramFrameSize`]: #transportparamsmaxdatagramframesize [`quic.connect()`]: #quicconnectaddress-options -[`quic.listen()`]: #quiclistencallback-options +[`quic.listen()`]: #quiclistenonsession-options [`session.close()`]: #sessioncloseoptions +[`session.createBidirectionalStream()`]: #sessioncreatebidirectionalstreamoptions +[`session.createUnidirectionalStream()`]: #sessioncreateunidirectionalstreamoptions [`session.destroy()`]: #sessiondestroyerror-options [`session.maxPendingDatagrams`]: #sessionmaxpendingdatagrams [`session.ondatagram`]: #sessionondatagram +[`session.ondatagramstatus`]: #sessionondatagramstatus +[`session.onearlyrejected`]: #sessiononearlyrejected [`session.onerror`]: #sessiononerror [`session.ongoaway`]: #sessionongoaway [`session.onkeylog`]: #sessiononkeylog [`session.onnewtoken`]: #sessiononnewtoken [`session.onorigin`]: #sessiononorigin [`session.onqlog`]: #sessiononqlog +[`session.onsessionticket`]: #sessiononsessionticket +[`session.onstream`]: #sessiononstream [`session.sendDatagram()`]: #sessionsenddatagramdatagram-encoding +[`sessionOptions.cc`]: #sessionoptionscc +[`sessionOptions.ciphers`]: #sessionoptionsciphers [`sessionOptions.datagramDropPolicy`]: #sessionoptionsdatagramdroppolicy +[`sessionOptions.groups`]: #sessionoptionsgroups [`sessionOptions.keylog`]: #sessionoptionskeylog [`sessionOptions.qlog`]: #sessionoptionsqlog +[`sessionOptions.sessionTicket`]: #sessionoptionssessionticket [`sessionOptions.sni`]: #sessionoptionssni-server-only +[`sessionOptions.token`]: #sessionoptionstoken-client-only [`stream.destroy()`]: #streamdestroyerror-options [`stream.headers`]: #streamheaders [`stream.onerror`]: #streamonerror From bbc6f7dab65b95d57131e9c5a457a44b6d48a70b Mon Sep 17 00:00:00 2001 From: "Node.js GitHub Bot" Date: Fri, 8 May 2026 14:54:32 -0400 Subject: [PATCH 098/168] deps: update ngtcp2 to 1.22.1 PR-URL: https://github.com/nodejs/node/pull/62812 Reviewed-By: James M Snell --- deps/ngtcp2/ngtcp2/lib/includes/ngtcp2/version.h | 4 ++-- deps/ngtcp2/ngtcp2/lib/ngtcp2_qlog.c | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/deps/ngtcp2/ngtcp2/lib/includes/ngtcp2/version.h b/deps/ngtcp2/ngtcp2/lib/includes/ngtcp2/version.h index 88e0107a55ac85..a1f09e7148bd84 100644 --- a/deps/ngtcp2/ngtcp2/lib/includes/ngtcp2/version.h +++ b/deps/ngtcp2/ngtcp2/lib/includes/ngtcp2/version.h @@ -36,7 +36,7 @@ * * Version number of the ngtcp2 library release. */ -#define NGTCP2_VERSION "1.22.0" +#define NGTCP2_VERSION "1.22.1" /** * @macro @@ -46,6 +46,6 @@ * number, 8 bits for minor and 8 bits for patch. Version 1.2.3 * becomes 0x010203. */ -#define NGTCP2_VERSION_NUM 0x011600 +#define NGTCP2_VERSION_NUM 0x011601 #endif /* !defined(NGTCP2_VERSION_H) */ diff --git a/deps/ngtcp2/ngtcp2/lib/ngtcp2_qlog.c b/deps/ngtcp2/ngtcp2/lib/ngtcp2_qlog.c index ed08eb1b5ac2b4..42609481ec4757 100644 --- a/deps/ngtcp2/ngtcp2/lib/ngtcp2_qlog.c +++ b/deps/ngtcp2/ngtcp2/lib/ngtcp2_qlog.c @@ -902,7 +902,7 @@ void ngtcp2_qlog_pkt_sent_end(ngtcp2_qlog *qlog, const ngtcp2_pkt_hd *hd, void ngtcp2_qlog_parameters_set_transport_params( ngtcp2_qlog *qlog, const ngtcp2_transport_params *params, int server, ngtcp2_qlog_side side) { - uint8_t buf[1024]; + uint8_t buf[2048]; uint8_t *p = buf; const ngtcp2_preferred_addr *paddr; const ngtcp2_sockaddr_in *sa_in; From 34e62e967a31316faa5c2991f93162a79d7d978f Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Tue, 5 May 2026 14:12:16 +0200 Subject: [PATCH 099/168] tls: add unsupported renegotiation error Map BoringSSL's native renegotiation failure to ERR_TLS_RENEGOTIATION_UNSUPPORTED when TLSSocket#renegotiate() is called. This avoids exposing an implementation-specific OpenSSL error when the TLS backend does not support caller-initiated renegotiation. Signed-off-by: Filip Skokan PR-URL: https://github.com/nodejs/node/pull/63161 Reviewed-By: Tim Perry Reviewed-By: Anna Henningsen Reviewed-By: Yagiz Nizipli --- doc/api/errors.md | 7 ++++++ lib/internal/errors.js | 2 ++ lib/internal/tls/wrap.js | 8 ++++++- .../test-tls-client-renegotiation-13.js | 24 ++++++++++++------- 4 files changed, 32 insertions(+), 9 deletions(-) diff --git a/doc/api/errors.md b/doc/api/errors.md index 2275835e40b26e..f2aafb1b165ca7 100644 --- a/doc/api/errors.md +++ b/doc/api/errors.md @@ -3132,6 +3132,13 @@ Failed to set PSK identity hint. Hint may be too long. An attempt was made to renegotiate TLS on a socket instance with renegotiation disabled. + + +### `ERR_TLS_RENEGOTIATION_UNSUPPORTED` + +An attempt was made to renegotiate TLS, but the TLS implementation does not +support caller-initiated renegotiation. + ### `ERR_TLS_REQUIRED_SERVER_NAME` diff --git a/lib/internal/errors.js b/lib/internal/errors.js index 1d31e2b43dc2bd..a93bb57e6cf0ad 100644 --- a/lib/internal/errors.js +++ b/lib/internal/errors.js @@ -1843,6 +1843,8 @@ E('ERR_TLS_PROTOCOL_VERSION_CONFLICT', 'TLS protocol version %j conflicts with secureProtocol %j', TypeError); E('ERR_TLS_RENEGOTIATION_DISABLED', 'TLS session renegotiation disabled for this socket', Error); +E('ERR_TLS_RENEGOTIATION_UNSUPPORTED', + 'TLS session renegotiation is unsupported by this TLS implementation', Error); // This should probably be a `TypeError`. E('ERR_TLS_REQUIRED_SERVER_NAME', diff --git a/lib/internal/tls/wrap.js b/lib/internal/tls/wrap.js index d89e501432968a..05ce6955ed9217 100644 --- a/lib/internal/tls/wrap.js +++ b/lib/internal/tls/wrap.js @@ -72,6 +72,7 @@ const { ERR_TLS_INVALID_CONTEXT, ERR_TLS_INVALID_STATE, ERR_TLS_RENEGOTIATION_DISABLED, + ERR_TLS_RENEGOTIATION_UNSUPPORTED, ERR_TLS_REQUIRED_SERVER_NAME, ERR_TLS_SESSION_ATTACK, ERR_TLS_SNI_FROM_SERVER, @@ -1014,8 +1015,13 @@ TLSSocket.prototype.renegotiate = function(options, callback) { try { this._handle.renegotiate(); } catch (err) { + const isBoringSSLRenegotiationUnsupported = + process.features.openssl_is_boringssl && + err?.code === 'ERR_SSL_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED'; + const error = isBoringSSLRenegotiationUnsupported ? + new ERR_TLS_RENEGOTIATION_UNSUPPORTED() : err; if (callback) { - process.nextTick(callback, err); + process.nextTick(callback, error); } return false; } diff --git a/test/parallel/test-tls-client-renegotiation-13.js b/test/parallel/test-tls-client-renegotiation-13.js index 5afa8389ed37ca..80c4753d065ec1 100644 --- a/test/parallel/test-tls-client-renegotiation-13.js +++ b/test/parallel/test-tls-client-renegotiation-13.js @@ -32,14 +32,22 @@ connect({ assert.strictEqual(client.getProtocol(), 'TLSv1.3'); const ok = client.renegotiate({}, common.mustCall((err) => { - assert.throws(() => { throw err; }, { - message: hasOpenSSL3 ? - 'error:0A00010A:SSL routines::wrong ssl version' : - 'error:1420410A:SSL routines:SSL_renegotiate:wrong ssl version', - code: 'ERR_SSL_WRONG_SSL_VERSION', - library: 'SSL routines', - reason: 'wrong ssl version', - }); + if (process.features.openssl_is_boringssl) { + assert.throws(() => { throw err; }, { + message: 'TLS session renegotiation is unsupported by this TLS ' + + 'implementation', + code: 'ERR_TLS_RENEGOTIATION_UNSUPPORTED', + }); + } else { + assert.throws(() => { throw err; }, { + message: hasOpenSSL3 ? + 'error:0A00010A:SSL routines::wrong ssl version' : + 'error:1420410A:SSL routines:SSL_renegotiate:wrong ssl version', + code: 'ERR_SSL_WRONG_SSL_VERSION', + library: 'SSL routines', + reason: 'wrong ssl version', + }); + } cleanup(); })); From bbf51ad24cbd80d5cf7b5a4df6e2ae1692c33d85 Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Tue, 5 May 2026 14:13:39 +0200 Subject: [PATCH 100/168] test: update tls/crypto behaviour expectations when using BoringSSL Signed-off-by: Filip Skokan PR-URL: https://github.com/nodejs/node/pull/63161 Reviewed-By: Tim Perry Reviewed-By: Anna Henningsen Reviewed-By: Yagiz Nizipli --- test/addons/openssl-get-ssl-ctx/binding.cc | 10 +- test/common/boringssl.js | 346 ++++++++++++++++++ test/parallel/test-crypto-dh-stateless.js | 226 +++++++----- test/parallel/test-crypto-keygen.js | 51 ++- test/parallel/test-crypto.js | 105 +++--- .../test-https-agent-session-reuse.js | 5 + .../test-https-client-renegotiation-limit.js | 5 + test/parallel/test-https-foafssl.js | 4 +- .../test-https-options-boolean-check.js | 43 ++- test/parallel/test-tls-alert.js | 27 ++ test/parallel/test-tls-client-auth.js | 5 +- .../test-tls-client-getephemeralkeyinfo.js | 6 + test/parallel/test-tls-client-mindhsize.js | 38 +- test/parallel/test-tls-client-reject.js | 15 +- .../test-tls-client-renegotiation-limit.js | 5 + test/parallel/test-tls-dhe.js | 5 + .../test-tls-disable-renegotiation.js | 5 + test/parallel/test-tls-ecdh-multiple.js | 4 +- test/parallel/test-tls-empty-sni-context.js | 9 +- test/parallel/test-tls-finished.js | 6 +- test/parallel/test-tls-getcipher.js | 58 ++- test/parallel/test-tls-getprotocol.js | 10 +- test/parallel/test-tls-handshake-error.js | 2 +- test/parallel/test-tls-honorcipherorder.js | 69 ++-- test/parallel/test-tls-junk-server.js | 2 +- test/parallel/test-tls-key-mismatch.js | 8 +- test/parallel/test-tls-max-send-fragment.js | 12 +- test/parallel/test-tls-min-max-version.js | 6 + test/parallel/test-tls-multi-key.js | 5 + test/parallel/test-tls-multi-pfx.js | 5 + test/parallel/test-tls-no-cert-required.js | 13 +- .../test-tls-options-boolean-check.js | 43 ++- test/parallel/test-tls-passphrase.js | 2 +- ...ls-psk-alpn-callback-exception-handling.js | 5 + test/parallel/test-tls-psk-circuit.js | 5 + test/parallel/test-tls-psk-server.js | 5 + .../test-tls-reduced-SECLEVEL-in-cipher.js | 5 + ...rver-failed-handshake-emits-clienterror.js | 2 +- test/parallel/test-tls-server-verify.js | 11 +- test/parallel/test-tls-session-cache.js | 7 +- test/parallel/test-tls-set-ciphers-error.js | 8 +- ...ls-set-default-ca-certificates-recovery.js | 4 +- test/parallel/test-tls-set-sigalgs.js | 14 +- ...tls-socket-failed-handshake-emits-error.js | 2 +- test/parallel/test-tls-ticket-cluster.js | 5 + test/parallel/test-tls-ticket.js | 6 + test/parallel/test-x509-escaping.js | 14 +- test/sequential/test-tls-connect.js | 2 +- test/sequential/test-tls-psk-client.js | 5 + 49 files changed, 968 insertions(+), 287 deletions(-) create mode 100644 test/common/boringssl.js diff --git a/test/addons/openssl-get-ssl-ctx/binding.cc b/test/addons/openssl-get-ssl-ctx/binding.cc index 3945ec870fb8b9..47468ffbcd789d 100644 --- a/test/addons/openssl-get-ssl-ctx/binding.cc +++ b/test/addons/openssl-get-ssl-ctx/binding.cc @@ -18,12 +18,12 @@ void GetSSLCtx(const v8::FunctionCallbackInfo& args) { return; } - // Verify the pointer is a valid SSL_CTX by calling an OpenSSL function. - const SSL_METHOD* method = SSL_CTX_get_ssl_method(ctx); - if (method == nullptr) { + // Verify the pointer is a valid SSL_CTX by calling a function available + // across OpenSSL-compatible TLS backends and checking context-owned state. + STACK_OF(SSL_CIPHER)* ciphers = SSL_CTX_get_ciphers(ctx); + if (ciphers == nullptr) { isolate->ThrowException(v8::Exception::Error( - v8::String::NewFromUtf8(isolate, - "SSL_CTX_get_ssl_method returned nullptr") + v8::String::NewFromUtf8(isolate, "SSL_CTX_get_ciphers returned nullptr") .ToLocalChecked())); return; } diff --git a/test/common/boringssl.js b/test/common/boringssl.js new file mode 100644 index 00000000000000..e6e91387c304c7 --- /dev/null +++ b/test/common/boringssl.js @@ -0,0 +1,346 @@ +/* eslint-disable node-core/crypto-check */ + +'use strict'; +const common = require('../common'); +const assert = require('assert'); +const fixtures = require('../common/fixtures'); +const tls = require('tls'); + +// This module is for BoringSSL-specific branches in tests whose original +// OpenSSL coverage cannot run unchanged. Each helper should assert the +// observable BoringSSL behavior that explains why the OpenSSL-specific +// assertions are bypassed. + +/** + * BoringSSL exposes many removed or disabled TLS cipher suites as "no match" + * at secure-context creation time. This is used for suites such as + * finite-field DHE and anonymous ECDH that OpenSSL builds may still negotiate + * in tests. + * @param {Function} fn + */ +function assertNoCipherMatch(fn) { + assert.throws(fn, { + code: 'ERR_SSL_NO_CIPHER_MATCH', + library: 'SSL routines', + function: 'OPENSSL_internal', + reason: 'NO_CIPHER_MATCH', + }); +} + +/** + * BoringSSL does not parse OpenSSL cipher-string commands such as `@SECLEVEL`. + * Those are OpenSSL policy directives, not cipher names. + * @param {Function} fn + */ +function assertInvalidCommand(fn) { + assert.throws(fn, { + code: 'ERR_SSL_INVALID_COMMAND', + library: 'SSL routines', + function: 'OPENSSL_internal', + reason: 'INVALID_COMMAND', + }); +} + +/** + * Node's DHE tests exercise OpenSSL's finite-field DHE cipher support and DH + * parameter-size policy. BoringSSL does not offer these DHE cipher suites on + * this surface, so creating a server context with a DHE-only cipher list fails + * before a handshake can test DH parameter behavior. + */ +function assertFiniteFieldDheUnsupported() { + assertNoCipherMatch(() => { + tls.createServer({ + key: fixtures.readKey('agent2-key.pem'), + cert: fixtures.readKey('agent2-cert.pem'), + ciphers: 'DHE-RSA-AES128-GCM-SHA256', + }); + }); +} + +/** + * OpenSSL security levels reject small keys by policy and can be adjusted with + * `@SECLEVEL` in the cipher string. BoringSSL does not implement those security + * levels: the small-key server context is accepted, while the OpenSSL-specific + * `@SECLEVEL` command is rejected as invalid cipher-string syntax. + */ +function assertOpenSSLSecurityLevelsUnsupported() { + const options = { + key: fixtures.readKey('agent11-key.pem'), + cert: fixtures.readKey('agent11-cert.pem'), + ciphers: 'DEFAULT', + }; + + tls.createServer(options).close(); + + options.ciphers = 'DEFAULT:@SECLEVEL=0'; + assertInvalidCommand(() => tls.createServer(options)); +} + +/** + * Node's multi-key tests rely on OpenSSL accepting an array of private keys and + * matching them with an array of certificates. BoringSSL rejects this mixed + * EC/RSA identity configuration while configuring the certificate chain, before + * a client can negotiate either identity. + */ +function assertMultiKeyUnsupported() { + assert.throws(() => { + tls.createServer({ + key: [ + fixtures.readKey('ec10-key.pem'), + fixtures.readKey('agent1-key.pem'), + ], + cert: [ + fixtures.readKey('agent1-cert.pem'), + fixtures.readKey('ec10-cert.pem'), + ], + }); + }, { + code: 'ERR_OSSL_X509_KEY_TYPE_MISMATCH', + library: 'X.509 certificate routines', + function: 'OPENSSL_internal', + reason: 'KEY_TYPE_MISMATCH', + }); +} + +/** + * BoringSSL does not support caller-initiated renegotiation. Even on a TLS 1.2 + * connection, TLSSocket#renegotiate() returns false and the callback receives + * Node's BoringSSL-specific unsupported-renegotiation error instead of + * entering the native binding or exercising Node's renegotiation-limit logic. + */ +function testRenegotiationUnsupported() { + const server = tls.createServer({ + key: fixtures.readKey('rsa_private.pem'), + cert: fixtures.readKey('rsa_cert.crt'), + maxVersion: 'TLSv1.2', + }, (socket) => socket.resume()); + + server.listen(0, common.mustCall(() => { + const client = tls.connect({ + port: server.address().port, + rejectUnauthorized: false, + maxVersion: 'TLSv1.2', + }, common.mustCall(() => { + const ok = client.renegotiate({}, common.mustCall((err) => { + assert.throws(() => { throw err; }, { + code: 'ERR_TLS_RENEGOTIATION_UNSUPPORTED', + message: 'TLS session renegotiation is unsupported by this TLS ' + + 'implementation', + }); + client.destroy(); + server.close(); + })); + assert.strictEqual(ok, false); + })); + client.on('error', common.mustNotCall()); + })); +} + +/** + * OpenSSL exposes the negotiated ephemeral key type, name, and size for TLS + * clients. With BoringSSL the same ECDHE TLS 1.2 handshake succeeds, but + * getEphemeralKeyInfo() returns null on the server side and an object whose + * fields are undefined on the client side. + */ +function testEphemeralKeyInfoUnsupported() { + const server = tls.createServer({ + key: fixtures.readKey('agent2-key.pem'), + cert: fixtures.readKey('agent2-cert.pem'), + ciphers: 'ECDHE-RSA-AES256-GCM-SHA384', + ecdhCurve: 'prime256v1', + maxVersion: 'TLSv1.2', + }, common.mustCall((socket) => { + assert.strictEqual(socket.getEphemeralKeyInfo(), null); + socket.end(); + })); + + server.listen(0, common.mustCall(() => { + const client = tls.connect({ + port: server.address().port, + rejectUnauthorized: false, + maxVersion: 'TLSv1.2', + }, common.mustCall(() => { + assert.deepStrictEqual(client.getEphemeralKeyInfo(), { + type: undefined, + name: undefined, + size: undefined, + }); + server.close(); + })); + })); +} + +/** + * The protocol matrix tests cover OpenSSL behavior for legacy TLS protocols. + * For BoringSSL we only need to exhibit that a TLSv1-only client cannot connect + * to a server whose minimum protocol is TLS 1.2; the client receives the + * protocol-version alert instead of the OpenSSL version-specific matrix. + */ +function testLegacyProtocolUnsupported() { + const server = tls.createServer({ + key: fixtures.readKey('agent2-key.pem'), + cert: fixtures.readKey('agent2-cert.pem'), + minVersion: 'TLSv1.2', + }, common.mustNotCall()); + + server.on('tlsClientError', common.mustCall()); + server.listen(0, common.mustCall(() => { + const client = tls.connect({ + port: server.address().port, + rejectUnauthorized: false, + secureProtocol: 'TLSv1_method', + }, common.mustNotCall()); + client.on('error', common.mustCall((err) => { + assert.strictEqual(err.code, 'ERR_SSL_TLSV1_ALERT_PROTOCOL_VERSION'); + server.close(); + })); + })); +} + +/** + * BoringSSL can load a multi-PFX option well enough to serve the ECDSA + * identity, but it does not provide the same OpenSSL multi-identity selection + * behavior. After the ECDSA handshake succeeds, an RSA-only client fails with + * no shared cipher instead of selecting the RSA identity from the same PFX list. + */ +function testMultiPfxSelectionDifference() { + const server = tls.createServer({ + pfx: [ + { + buf: fixtures.readKey('agent1.pfx'), + passphrase: 'sample', + }, + fixtures.readKey('ec.pfx'), + ], + }, common.mustCallAtLeast((socket) => socket.end(), 1)); + + server.listen(0, common.mustCall(() => { + const ecdsa = tls.connect(server.address().port, { + ciphers: 'ECDHE-ECDSA-AES256-GCM-SHA384', + maxVersion: 'TLSv1.2', + rejectUnauthorized: false, + }, common.mustCall(() => { + assert.strictEqual(ecdsa.getCipher().name, + 'ECDHE-ECDSA-AES256-GCM-SHA384'); + ecdsa.end(); + + server.once('tlsClientError', common.mustCall((err) => { + assert.strictEqual(err.code, 'ERR_SSL_NO_SHARED_CIPHER'); + })); + const rsa = tls.connect(server.address().port, { + ciphers: 'ECDHE-RSA-AES256-GCM-SHA384', + maxVersion: 'TLSv1.2', + rejectUnauthorized: false, + }, common.mustNotCall()); + rsa.on('error', common.mustCall((err) => { + assert.strictEqual(err.code, 'ERR_SSL_SSLV3_ALERT_HANDSHAKE_FAILURE'); + server.close(); + })); + })); + })); +} + +/** + * PSK works for TLS 1.2 in BoringSSL, but Node's PSK tests also cover the + * default TLS 1.3 path. In that path BoringSSL does not complete a certificate- + * less PSK-only handshake through Node's current server setup: the server + * reports NO_CERTIFICATE_SET and the client receives an internal-error alert. + */ +function testPskTls13Unsupported() { + const key = Buffer.from('d731ef57be09e5204f0b205b60627028', 'hex'); + let gotClientError = false; + let gotServerError = false; + function maybeClose(server) { + if (gotClientError && gotServerError) + server.close(); + } + + const server = tls.createServer({ + ciphers: 'PSK+HIGH', + pskCallback() { return key; }, + }, common.mustNotCall()); + + server.once('tlsClientError', common.mustCall((err) => { + assert.strictEqual(err.code, 'ERR_SSL_NO_CERTIFICATE_SET'); + gotServerError = true; + maybeClose(server); + })); + + server.listen(0, common.mustCall(() => { + const client = tls.connect({ + port: server.address().port, + ciphers: 'PSK+HIGH', + checkServerIdentity() {}, + pskCallback() { + return { psk: key, identity: 'TestUser' }; + }, + }, common.mustNotCall()); + client.on('error', common.mustCall((err) => { + assert.strictEqual(err.code, 'ERR_SSL_TLSV1_ALERT_INTERNAL_ERROR'); + gotClientError = true; + maybeClose(server); + })); + })); +} + +/** + * The OpenSSL ticket tests assume that once a TLS 1.3 session is reused, the + * client will not necessarily receive a replacement session event before close. + * BoringSSL emits new session tickets on both the initial and resumed TLS 1.3 + * connections, so the resumed connection still emits at least one 'session' + * event while isSessionReused() is true. + */ +function testTls13SessionTicketSemanticsDiffer() { + const server = tls.createServer({ + key: fixtures.readKey('agent1-key.pem'), + cert: fixtures.readKey('agent1-cert.pem'), + }, (socket) => socket.end()); + + let session; + let secondSessionEvents = 0; + + server.listen(0, common.mustCall(() => { + const first = tls.connect({ + port: server.address().port, + rejectUnauthorized: false, + }, common.mustCall(() => { + assert.strictEqual(first.isSessionReused(), false); + })); + first.on('session', common.mustCallAtLeast((sess) => { + session = sess; + }, 1)); + first.on('close', common.mustCall(() => { + assert(Buffer.isBuffer(session)); + + const second = tls.connect({ + port: server.address().port, + rejectUnauthorized: false, + session, + }, common.mustCall(() => { + assert.strictEqual(second.isSessionReused(), true); + })); + second.on('session', common.mustCallAtLeast(() => { + secondSessionEvents++; + }, 1)); + second.on('close', common.mustCall(() => { + assert(secondSessionEvents > 0); + server.close(); + })); + second.resume(); + })); + first.resume(); + })); +} + +module.exports = { + assertFiniteFieldDheUnsupported, + assertMultiKeyUnsupported, + assertNoCipherMatch, + assertOpenSSLSecurityLevelsUnsupported, + testEphemeralKeyInfoUnsupported, + testLegacyProtocolUnsupported, + testMultiPfxSelectionDifference, + testPskTls13Unsupported, + testRenegotiationUnsupported, + testTls13SessionTicketSemanticsDiffer, +}; diff --git a/test/parallel/test-crypto-dh-stateless.js b/test/parallel/test-crypto-dh-stateless.js index 9e13c62595ef26..0ade828eb2342b 100644 --- a/test/parallel/test-crypto-dh-stateless.js +++ b/test/parallel/test-crypto-dh-stateless.js @@ -6,6 +6,7 @@ if (!common.hasCrypto) const assert = require('assert'); const crypto = require('crypto'); const { hasOpenSSL } = require('../common/crypto'); +const isBoringSSL = process.features.openssl_is_boringssl; // Error code for a key-type mismatch during (EC)DH. The underlying OpenSSL // error code varies by version, and in OpenSSL 4.0 by platform: some builds @@ -212,8 +213,28 @@ function testDHError(options, expected) { })); } -const alicePrivateKey = crypto.createPrivateKey({ - key: '-----BEGIN PRIVATE KEY-----\n' + +{ + const { privateKey, publicKey } = crypto.generateKeyPairSync('ec', { + namedCurve: 'P-256', + }); + + assert.throws(() => crypto.diffieHellman({ privateKey }), { + name: 'TypeError', + code: 'ERR_INVALID_ARG_TYPE', + }); + + assert.throws(() => crypto.diffieHellman({ publicKey }), { + name: 'TypeError', + code: 'ERR_INVALID_ARG_TYPE', + }); +} + +if (isBoringSSL) { + common.printSkipMessage('Skipping finite-field DH KeyObject import and ' + + 'generation tests unsupported by BoringSSL'); +} else { + const alicePrivateKey = crypto.createPrivateKey({ + key: '-----BEGIN PRIVATE KEY-----\n' + 'MIIBoQIBADCB1QYJKoZIhvcNAQMBMIHHAoHBAP//////////yQ/aoiFowjTExmKL\n' + 'gNwc0SkCTgiKZ8x0Agu+pjsTmyJRSgh5jjQE3e+VGbPNOkMbMCsKbfJfFDdP4TVt\n' + 'bVHCReSFtXZiXn7G9ExC6aY37WsL/1y29Aa37e44a/taiZ+lrp8kEXxLH+ZJKGZR\n' + @@ -224,10 +245,10 @@ const alicePrivateKey = crypto.createPrivateKey({ 'iIt9FmvFaaOVe2DupqSr6xzbf/zyON+WF5B5HNVOWXswgpgdUsCyygs98hKy/Xje\n' + 'TGzJUoWInW39t0YgMXenJrkS0m6wol8Rhxx81AGgELNV7EHZqg==\n' + '-----END PRIVATE KEY-----', - format: 'pem' -}); -const alicePublicKey = crypto.createPublicKey({ - key: '-----BEGIN PUBLIC KEY-----\n' + + format: 'pem' + }); + const alicePublicKey = crypto.createPublicKey({ + key: '-----BEGIN PUBLIC KEY-----\n' + 'MIIBnzCB1QYJKoZIhvcNAQMBMIHHAoHBAP//////////yQ/aoiFowjTExmKLgNwc\n' + '0SkCTgiKZ8x0Agu+pjsTmyJRSgh5jjQE3e+VGbPNOkMbMCsKbfJfFDdP4TVtbVHC\n' + 'ReSFtXZiXn7G9ExC6aY37WsL/1y29Aa37e44a/taiZ+lrp8kEXxLH+ZJKGZR7ORb\n' + @@ -238,11 +259,11 @@ const alicePublicKey = crypto.createPublicKey({ 'rDEz8mjIlnvbWpKB9+uYmbjfVoc3leFvUBqfG2In2m23Md1swsPxr3n7g68H66JX\n' + 'iBJKZLQMqNdbY14G9rdKmhhTJrQjC+i7Q/wI8JPhOFzHIGA=\n' + '-----END PUBLIC KEY-----', - format: 'pem' -}); + format: 'pem' + }); -const bobPrivateKey = crypto.createPrivateKey({ - key: '-----BEGIN PRIVATE KEY-----\n' + + const bobPrivateKey = crypto.createPrivateKey({ + key: '-----BEGIN PRIVATE KEY-----\n' + 'MIIBoQIBADCB1QYJKoZIhvcNAQMBMIHHAoHBAP//////////yQ/aoiFowjTExmKL\n' + 'gNwc0SkCTgiKZ8x0Agu+pjsTmyJRSgh5jjQE3e+VGbPNOkMbMCsKbfJfFDdP4TVt\n' + 'bVHCReSFtXZiXn7G9ExC6aY37WsL/1y29Aa37e44a/taiZ+lrp8kEXxLH+ZJKGZR\n' + @@ -253,11 +274,11 @@ const bobPrivateKey = crypto.createPrivateKey({ 'GagGtIy3dV5f4FA0B/2C97jQ1pO16ah8gSLQRKsNpTCw2rqsZusE0rK6RaYAef7H\n' + 'y/0tmLIsHxLIn+WK9CANqMbCWoP4I178BQaqhiOBkNyNZ0ndqA==\n' + '-----END PRIVATE KEY-----', - format: 'pem' -}); + format: 'pem' + }); -const bobPublicKey = crypto.createPublicKey({ - key: '-----BEGIN PUBLIC KEY-----\n' + + const bobPublicKey = crypto.createPublicKey({ + key: '-----BEGIN PUBLIC KEY-----\n' + 'MIIBoDCB1QYJKoZIhvcNAQMBMIHHAoHBAP//////////yQ/aoiFowjTExmKLgNwc\n' + '0SkCTgiKZ8x0Agu+pjsTmyJRSgh5jjQE3e+VGbPNOkMbMCsKbfJfFDdP4TVtbVHC\n' + 'ReSFtXZiXn7G9ExC6aY37WsL/1y29Aa37e44a/taiZ+lrp8kEXxLH+ZJKGZR7ORb\n' + @@ -268,83 +289,83 @@ const bobPublicKey = crypto.createPublicKey({ 'QFKfjzNaJRNMFFd4f2Dn8MSB4yu1xpA1T2i0JSk24vS2H55jx24xhUYtfhT2LJgK\n' + 'JvnaODey/xtY4Kql10ZKf43Lw6gdQC3G8opC9OxVxt9oNR7Z\n' + '-----END PUBLIC KEY-----', - format: 'pem' -}); + format: 'pem' + }); -assert.throws(() => crypto.diffieHellman({ privateKey: alicePrivateKey }), { - name: 'TypeError', - code: 'ERR_INVALID_ARG_TYPE', -}); + assert.throws(() => crypto.diffieHellman({ privateKey: alicePrivateKey }), { + name: 'TypeError', + code: 'ERR_INVALID_ARG_TYPE', + }); -assert.throws(() => crypto.diffieHellman({ publicKey: alicePublicKey }), { - name: 'TypeError', - code: 'ERR_INVALID_ARG_TYPE', -}); + assert.throws(() => crypto.diffieHellman({ publicKey: alicePublicKey }), { + name: 'TypeError', + code: 'ERR_INVALID_ARG_TYPE', + }); -const privateKey = Buffer.from( - '487CD880159D835FD0A8DBA9848898317283DB07E822741B344AD397BA84CDDD3920A51588' + + const privateKey = Buffer.from( + '487CD880159D835FD0A8DBA9848898317283DB07E822741B344AD397BA84CDDD3920A51588' + 'B891B03B3EBEF3C9F767D921FAC1294D4B5E09CABB6D1DE3EB4527989754FEB64D007EBBDA' + '2E6C8CE7A17EF41DE3C2DFE7CEAAF963199F55D5DBD9A415E77552FE69B7A41D87888B7D16' + '6BC569A3957B60EEA6A4ABEB1CDB7FFCF238DF961790791CD54E597B3082981D52C0B2CA0B' + '3DF212B2FD78DE4C6CC95285889D6DFDB746203177A726B912D26EB0A25F11871C7CD401A0' + '10B355EC41D9AA', 'hex'); -const publicKey = Buffer.from( - '8b6ea8abccff18d4819b7ce280db7b480edc02b5016d3c4835af622d85a9e9bc6bbc22b00d' + + const publicKey = Buffer.from( + '8b6ea8abccff18d4819b7ce280db7b480edc02b5016d3c4835af622d85a9e9bc6bbc22b00d' + '0c0848ddfafd0530f275007bc691c8cb74a189fecbabd63f0e4e94ef932eb51e94c5456800' + 'c4ce8628987d335466f4b16e1a04df21682d266eb3edf50b21802be3af58443c49da40529f' + '8f335a25134c1457787f60e7f0c481e32bb5c690354f68b4252936e2f4b61f9e63c76e3185' + '462d7e14f62c980a26f9da3837b2ff1b58e0aaa5d7464a7f8dcbc3a81d402dc6f28a42f4ec' + '55c6df68351ed9', 'hex'); -const group = crypto.getDiffieHellman('modp5'); -const dh = crypto.createDiffieHellman(group.getPrime(), group.getGenerator()); -dh.setPrivateKey(privateKey); + const group = crypto.getDiffieHellman('modp5'); + const dh = crypto.createDiffieHellman(group.getPrime(), group.getGenerator()); + dh.setPrivateKey(privateKey); -// Test simple Diffie-Hellman, no curves involved. -test({ publicKey: alicePublicKey, privateKey: alicePrivateKey }, - { publicKey: bobPublicKey, privateKey: bobPrivateKey }, - dh.computeSecret(publicKey)); + // Test simple Diffie-Hellman, no curves involved. + test({ publicKey: alicePublicKey, privateKey: alicePrivateKey }, + { publicKey: bobPublicKey, privateKey: bobPrivateKey }, + dh.computeSecret(publicKey)); -test(crypto.generateKeyPairSync('dh', { group: 'modp5' }), - crypto.generateKeyPairSync('dh', { group: 'modp5' })); + test(crypto.generateKeyPairSync('dh', { group: 'modp5' }), + crypto.generateKeyPairSync('dh', { group: 'modp5' })); -test(crypto.generateKeyPairSync('dh', { group: 'modp5' }), - crypto.generateKeyPairSync('dh', { prime: group.getPrime() })); + test(crypto.generateKeyPairSync('dh', { group: 'modp5' }), + crypto.generateKeyPairSync('dh', { prime: group.getPrime() })); -// DH parameter mismatch tests -{ - const list = [ + // DH parameter mismatch tests + { + const list = [ // Same generator, but different primes. - [{ group: 'modp5' }, { group: 'modp18' }]]; + [{ group: 'modp5' }, { group: 'modp18' }]]; - // TODO(danbev): Take a closer look if there should be a check in OpenSSL3 - // when the dh parameters differ. - if (!hasOpenSSL(3)) { + // TODO(danbev): Take a closer look if there should be a check in OpenSSL3 + // when the dh parameters differ. + if (!hasOpenSSL(3)) { // Same primes, but different generator. - list.push([{ group: 'modp5' }, { prime: group.getPrime(), generator: 5 }]); - // Same generator, but different primes. - list.push([{ primeLength: 1024 }, { primeLength: 1024 }]); - } + list.push([{ group: 'modp5' }, { prime: group.getPrime(), generator: 5 }]); + // Same generator, but different primes. + list.push([{ primeLength: 1024 }, { primeLength: 1024 }]); + } - for (const [params1, params2] of list) { - const options = { - privateKey: crypto.generateKeyPairSync('dh', params1).privateKey, - publicKey: crypto.generateKeyPairSync('dh', params2).publicKey, - }; - testDHError(options, { - name: 'Error', - code: hasOpenSSL(3) ? - 'ERR_OSSL_MISMATCHING_DOMAIN_PARAMETERS' : - 'ERR_OSSL_EVP_DIFFERENT_PARAMETERS' - }); + for (const [params1, params2] of list) { + const options = { + privateKey: crypto.generateKeyPairSync('dh', params1).privateKey, + publicKey: crypto.generateKeyPairSync('dh', params2).publicKey, + }; + testDHError(options, { + name: 'Error', + code: hasOpenSSL(3) ? + 'ERR_OSSL_MISMATCHING_DOMAIN_PARAMETERS' : + 'ERR_OSSL_EVP_DIFFERENT_PARAMETERS' + }); + } } -} -// This key combination will result in an unusually short secret, and should -// not cause an assertion failure. -{ - const shortPrivateKey = crypto.createPrivateKey({ - key: '-----BEGIN PRIVATE KEY-----\n' + + // This key combination will result in an unusually short secret, and should + // not cause an assertion failure. + { + const shortPrivateKey = crypto.createPrivateKey({ + key: '-----BEGIN PRIVATE KEY-----\n' + 'MIIBoQIBADCB1QYJKoZIhvcNAQMBMIHHAoHBAP//////////yQ/aoiFowjTExmKL\n' + 'gNwc0SkCTgiKZ8x0Agu+pjsTmyJRSgh5jjQE3e+VGbPNOkMbMCsKbfJfFDdP4TVt\n' + 'bVHCReSFtXZiXn7G9ExC6aY37WsL/1y29Aa37e44a/taiZ+lrp8kEXxLH+ZJKGZR\n' + @@ -355,9 +376,9 @@ test(crypto.generateKeyPairSync('dh', { group: 'modp5' }), 'RQD0QogW7ejSwMG8hCYibfrvMm0b5PHlwimISyEKh7VtDQ1frYN/Wr9ZbiV+FePJ\n' + '2j6RUKYNj1Pv+B4zdMgiLLjILAs8WUfbHciU21KSJh1izVQaUQ==\n' + '-----END PRIVATE KEY-----' - }); - const shortPublicKey = crypto.createPublicKey({ - key: '-----BEGIN PUBLIC KEY-----\n' + + }); + const shortPublicKey = crypto.createPublicKey({ + key: '-----BEGIN PUBLIC KEY-----\n' + 'MIIBoDCB1QYJKoZIhvcNAQMBMIHHAoHBAP//////////yQ/aoiFowjTExmKLgNwc\n' + '0SkCTgiKZ8x0Agu+pjsTmyJRSgh5jjQE3e+VGbPNOkMbMCsKbfJfFDdP4TVtbVHC\n' + 'ReSFtXZiXn7G9ExC6aY37WsL/1y29Aa37e44a/taiZ+lrp8kEXxLH+ZJKGZR7ORb\n' + @@ -368,19 +389,20 @@ test(crypto.generateKeyPairSync('dh', { group: 'modp5' }), 'taGX4mP3247golVx2DS4viDYs7UtaMdx03dWaP6y5StNUZQlgCIUzL7MYpC16V5y\n' + 'KkFrE+Kp/Z77gEjivaG6YuxVj4GPLxJYbNFVTel42oSVeKuq\n' + '-----END PUBLIC KEY-----', - format: 'pem' - }); + format: 'pem' + }); - testDH({ publicKey: shortPublicKey, privateKey: shortPrivateKey }, - Buffer.from( - '0099d0fa242af5db9ea7330e23937a27db041f79c581500fc7f9976' + + testDH({ publicKey: shortPublicKey, privateKey: shortPrivateKey }, + Buffer.from( + '0099d0fa242af5db9ea7330e23937a27db041f79c581500fc7f9976' + '554d59d5b9ced934778d72e19a1fefc81e9d981013198748c0b5c6c' + '762985eec687dc5bec5c9367b05837daee9d0bcc29024ed7f3abba1' + '2794b65a745117fb0d87bc5b1b2b68c296c3f686cc29e450e4e1239' + - '21f56a5733fe58aabf71f14582954059c2185d342b9b0fa10c2598a' + - '5426c2baee7f9a686fc1e16cd4757c852bf7225a2732250548efe28' + - 'debc26f1acdec51efe23d20786a6f8a14d360803bbc71972e87fd3', - 'hex')); + '21f56a5733fe58aabf71f14582954059c2185d342b9b0fa10c2598a' + + '5426c2baee7f9a686fc1e16cd4757c852bf7225a2732250548efe28' + + 'debc26f1acdec51efe23d20786a6f8a14d360803bbc71972e87fd3', + 'hex')); + } } // Test ECDH. @@ -401,20 +423,25 @@ test(crypto.generateKeyPairSync('ec', { namedCurve: 'P-256' }), }); } -test(crypto.generateKeyPairSync('x448'), - crypto.generateKeyPairSync('x448')); +if (isBoringSSL) { + common.printSkipMessage('Skipping x448 diffieHellman test cases ' + + 'unsupported by BoringSSL'); +} else { + test(crypto.generateKeyPairSync('x448'), + crypto.generateKeyPairSync('x448')); + + { + const options = { + privateKey: crypto.generateKeyPairSync('x448').privateKey, + publicKey: crypto.generateKeyPairSync('x25519').publicKey, + }; + testDHError(options, { code: keyTypeMismatchCode }); + } +} test(crypto.generateKeyPairSync('x25519'), crypto.generateKeyPairSync('x25519')); -{ - const options = { - privateKey: crypto.generateKeyPairSync('x448').privateKey, - publicKey: crypto.generateKeyPairSync('x25519').publicKey, - }; - testDHError(options, { code: keyTypeMismatchCode }); -} - // Test all key encoding formats for (const { privateKey: alicePriv, publicKey: bobPub } of [ crypto.generateKeyPairSync('ec', { namedCurve: 'P-256' }), @@ -514,7 +541,7 @@ for (const { privateKey: alicePriv, publicKey: bobPub } of [ { const ec256 = crypto.generateKeyPairSync('ec', { namedCurve: 'P-256' }); const ec384 = crypto.generateKeyPairSync('ec', { namedCurve: 'P-384' }); - const x448 = crypto.generateKeyPairSync('x448'); + const x448 = isBoringSSL ? null : crypto.generateKeyPairSync('x448'); const x25519 = crypto.generateKeyPairSync('x25519'); const ed25519 = crypto.generateKeyPairSync('ed25519'); @@ -564,18 +591,21 @@ for (const { privateKey: alicePriv, publicKey: bobPub } of [ /^ERR_OSSL_EVP_(OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE|INTERNAL_ERROR)$/ : 'ERR_OSSL_EVP_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE' }); - // Incompatible key types (x448 + x25519) - testDHError({ - privateKey: privKey(x448.privateKey), - publicKey: pubKey(x25519.publicKey), - }, { code: keyTypeMismatchCode }); + if (!isBoringSSL) { + // Incompatible key types (x448 + x25519) + testDHError({ + privateKey: privKey(x448.privateKey), + publicKey: pubKey(x25519.publicKey), + }, { code: keyTypeMismatchCode }); + } // Zero x25519 public key testDHError({ privateKey: privKey(x25519.privateKey), publicKey: pubKey(zeroX25519PublicKey), - }, hasOpenSSL(3) ? - { code: 'ERR_OSSL_FAILED_DURING_DERIVATION' } : - { message: /Deriving bits failed/ }); + }, isBoringSSL ? { code: 'ERR_OSSL_EVP_INVALID_PEER_KEY' } : + hasOpenSSL(3) ? + { code: 'ERR_OSSL_FAILED_DURING_DERIVATION' } : + { message: /Deriving bits failed/ }); } } diff --git a/test/parallel/test-crypto-keygen.js b/test/parallel/test-crypto-keygen.js index 7911520af34481..751029e1921edb 100644 --- a/test/parallel/test-crypto-keygen.js +++ b/test/parallel/test-crypto-keygen.js @@ -15,6 +15,7 @@ const { const { inspect } = require('util'); const { hasOpenSSL3 } = require('../common/crypto'); +const isBoringSSL = process.features.openssl_is_boringssl; // Test invalid parameter encoding. { @@ -361,13 +362,24 @@ const { hasOpenSSL3 } = require('../common/crypto'); // Test invalid exponents. (caught by OpenSSL) for (const publicExponent of [1, 1 + 0x10001]) { - generateKeyPair('rsa', { - modulusLength: 4096, - publicExponent - }, common.mustCall((err) => { - assert.strictEqual(err.name, 'Error'); - assert.match(err.message, hasOpenSSL3 ? /exponent/ : /bad e value/); - })); + if (isBoringSSL) { + assert.throws(() => generateKeyPair('rsa', { + modulusLength: 4096, + publicExponent + }, common.mustNotCall()), { + name: 'RangeError', + code: 'ERR_OUT_OF_RANGE', + message: 'publicExponent is invalid', + }); + } else { + generateKeyPair('rsa', { + modulusLength: 4096, + publicExponent + }, common.mustCall((err) => { + assert.strictEqual(err.name, 'Error'); + assert.match(err.message, hasOpenSSL3 ? /exponent/ : /bad e value/); + })); + } } } @@ -494,16 +506,21 @@ const { hasOpenSSL3 } = require('../common/crypto'); }); })); - generateKeyPair('ec', { - namedCurve: 'secp256k1', - }, common.mustSucceed((publicKey, privateKey) => { - assert.deepStrictEqual(publicKey.asymmetricKeyDetails, { - namedCurve: 'secp256k1' - }); - assert.deepStrictEqual(privateKey.asymmetricKeyDetails, { - namedCurve: 'secp256k1' - }); - })); + if (isBoringSSL) { + common.printSkipMessage('Skipping secp256k1 keygen test case ' + + 'unsupported by BoringSSL'); + } else { + generateKeyPair('ec', { + namedCurve: 'secp256k1', + }, common.mustSucceed((publicKey, privateKey) => { + assert.deepStrictEqual(publicKey.asymmetricKeyDetails, { + namedCurve: 'secp256k1' + }); + assert.deepStrictEqual(privateKey.asymmetricKeyDetails, { + namedCurve: 'secp256k1' + }); + })); + } } { diff --git a/test/parallel/test-crypto.js b/test/parallel/test-crypto.js index fbb065dd442876..46f4571b33dfe8 100644 --- a/test/parallel/test-crypto.js +++ b/test/parallel/test-crypto.js @@ -62,7 +62,7 @@ assert.throws(() => { // Throws general Error, so there is no opensslErrorStack property. return err instanceof Error && err.name === 'Error' && - /^Error: mac verify failure$/.test(err) && + /^Error: (mac verify failure|INCORRECT_PASSWORD)$/.test(err) && !('opensslErrorStack' in err); }); @@ -72,7 +72,7 @@ assert.throws(() => { // Throws general Error, so there is no opensslErrorStack property. return err instanceof Error && err.name === 'Error' && - /^Error: mac verify failure$/.test(err) && + /^Error: (mac verify failure|INCORRECT_PASSWORD)$/.test(err) && !('opensslErrorStack' in err); }); @@ -82,7 +82,7 @@ assert.throws(() => { // Throws general Error, so there is no opensslErrorStack property. return err instanceof Error && err.name === 'Error' && - /^Error: not enough data$/.test(err) && + /^Error: (not enough data|BAD_PKCS12_DATA)$/.test(err) && !('opensslErrorStack' in err); }); @@ -211,49 +211,72 @@ assert.throws(() => { ].join('\n'); crypto.createSign('SHA256').update('test').sign(priv); }, (err) => { - if (!hasOpenSSL3) - assert.ok(!('opensslErrorStack' in err)); - assert.throws(() => { throw err; }, hasOpenSSL3 ? { - name: 'Error', - message: 'error:02000070:rsa routines::digest too big for rsa key', - library: 'rsa routines', - } : { - name: 'Error', - message: /routines:RSA_sign:digest too big for rsa key$/, - library: /rsa routines/i, - function: 'RSA_sign', - reason: /digest[\s_]too[\s_]big[\s_]for[\s_]rsa[\s_]key/i, - code: 'ERR_OSSL_RSA_DIGEST_TOO_BIG_FOR_RSA_KEY' - }); + if (process.features.openssl_is_boringssl) { + // BoringSSL rejects the tiny RSA key while decoding it, before signing. + assert.throws(() => { throw err; }, { + name: 'Error', + message: 'error:06000066:public key routines:OPENSSL_internal:' + + 'DECODE_ERROR', + library: 'public key routines', + function: 'OPENSSL_internal', + reason: 'DECODE_ERROR', + code: 'ERR_OSSL_EVP_DECODE_ERROR' + }); + assert(Array.isArray(err.opensslErrorStack)); + assert(err.opensslErrorStack.length > 0); + } else { + if (!hasOpenSSL3) + assert.ok(!('opensslErrorStack' in err)); + assert.throws(() => { throw err; }, hasOpenSSL3 ? { + name: 'Error', + message: 'error:02000070:rsa routines::digest too big for rsa key', + library: 'rsa routines', + } : { + name: 'Error', + message: /routines:RSA_sign:digest too big for rsa key$/, + library: /rsa routines/i, + function: 'RSA_sign', + reason: /digest[\s_]too[\s_]big[\s_]for[\s_]rsa[\s_]key/i, + code: 'ERR_OSSL_RSA_DIGEST_TOO_BIG_FOR_RSA_KEY' + }); + } return true; }); if (!hasOpenSSL3) { - assert.throws(() => { - // The correct header inside `rsa_private_pkcs8_bad.pem` should have been - // -----BEGIN PRIVATE KEY----- and -----END PRIVATE KEY----- - // instead of - // -----BEGIN RSA PRIVATE KEY----- and -----END RSA PRIVATE KEY----- - const sha1_privateKey = fixtures.readKey('rsa_private_pkcs8_bad.pem', - 'ascii'); - // This would inject errors onto OpenSSL's error stack - crypto.createSign('sha1').sign(sha1_privateKey); - }, (err) => { - // Do the standard checks, but then do some custom checks afterwards. - assert.throws(() => { throw err; }, { - message: 'error:0D0680A8:asn1 encoding routines:asn1_check_tlen:' + - 'wrong tag', - library: 'asn1 encoding routines', - function: 'asn1_check_tlen', - reason: 'wrong tag', - code: 'ERR_OSSL_ASN1_WRONG_TAG', + // The correct header inside `rsa_private_pkcs8_bad.pem` should have been + // -----BEGIN PRIVATE KEY----- and -----END PRIVATE KEY----- + // instead of + // -----BEGIN RSA PRIVATE KEY----- and -----END RSA PRIVATE KEY----- + const sha1_privateKey = fixtures.readKey('rsa_private_pkcs8_bad.pem', + 'ascii'); + + if (process.features.openssl_is_boringssl) { + // BoringSSL accepts the PKCS#8 payload despite the legacy PEM label. + const signature = crypto.createSign('sha1').sign(sha1_privateKey); + assert(Buffer.isBuffer(signature)); + assert.strictEqual(signature.length, 256); + } else { + assert.throws(() => { + // This would inject errors onto OpenSSL's error stack + crypto.createSign('sha1').sign(sha1_privateKey); + }, (err) => { + // Do the standard checks, but then do some custom checks afterwards. + assert.throws(() => { throw err; }, { + message: 'error:0D0680A8:asn1 encoding routines:asn1_check_tlen:' + + 'wrong tag', + library: 'asn1 encoding routines', + function: 'asn1_check_tlen', + reason: 'wrong tag', + code: 'ERR_OSSL_ASN1_WRONG_TAG', + }); + // Throws crypto error, so there is an opensslErrorStack property. + // The openSSL stack should have content. + assert(Array.isArray(err.opensslErrorStack)); + assert(err.opensslErrorStack.length > 0); + return true; }); - // Throws crypto error, so there is an opensslErrorStack property. - // The openSSL stack should have content. - assert(Array.isArray(err.opensslErrorStack)); - assert(err.opensslErrorStack.length > 0); - return true; - }); + } } // Make sure memory isn't released before being returned diff --git a/test/parallel/test-https-agent-session-reuse.js b/test/parallel/test-https-agent-session-reuse.js index 485f4b1ca308c9..c5b7b78b8e0272 100644 --- a/test/parallel/test-https-agent-session-reuse.js +++ b/test/parallel/test-https-agent-session-reuse.js @@ -5,6 +5,11 @@ const assert = require('assert'); if (!common.hasCrypto) common.skip('missing crypto'); +if (process.features.openssl_is_boringssl) { + require('../common/boringssl').testTls13SessionTicketSemanticsDiffer(); + return; +} + const https = require('https'); const crypto = require('crypto'); const fixtures = require('../common/fixtures'); diff --git a/test/parallel/test-https-client-renegotiation-limit.js b/test/parallel/test-https-client-renegotiation-limit.js index 6614090e737614..729176b7c1aa21 100644 --- a/test/parallel/test-https-client-renegotiation-limit.js +++ b/test/parallel/test-https-client-renegotiation-limit.js @@ -25,6 +25,11 @@ if (!common.hasCrypto) { common.skip('missing crypto'); } +if (process.features.openssl_is_boringssl) { + require('../common/boringssl').testRenegotiationUnsupported(); + return; +} + const assert = require('assert'); const tls = require('tls'); const https = require('https'); diff --git a/test/parallel/test-https-foafssl.js b/test/parallel/test-https-foafssl.js index ffa44f218b935d..a191bdcf32b73e 100644 --- a/test/parallel/test-https-foafssl.js +++ b/test/parallel/test-https-foafssl.js @@ -56,8 +56,8 @@ const server = https.createServer(options, common.mustCall(function(req, res) { cert = req.connection.getPeerCertificate(); assert.strictEqual(cert.subjectaltname, webIdUrl); - assert.strictEqual(cert.exponent, exponent); - assert.strictEqual(cert.modulus, modulus); + assert.strictEqual(cert.exponent.toLowerCase(), exponent.toLowerCase()); + assert.strictEqual(cert.modulus.toLowerCase(), modulus.toLowerCase()); res.writeHead(200, { 'content-type': 'text/plain' }); res.end(body, () => { console.log('stream finished'); }); console.log('sent response'); diff --git a/test/parallel/test-https-options-boolean-check.js b/test/parallel/test-https-options-boolean-check.js index 9740704e169f1e..fa02a165b80f10 100644 --- a/test/parallel/test-https-options-boolean-check.js +++ b/test/parallel/test-https-options-boolean-check.js @@ -40,9 +40,23 @@ const keyDataView = toDataView(keyBuff); const certDataView = toDataView(certBuff); const caArrDataView = toDataView(caCert); +function filterBoringSSLKeyCertArrayCases(options, setName) { + if (!process.features.openssl_is_boringssl) + return options; + + // The array-valued cases exercise multi-identity key/cert handling. + // BoringSSL may reject those cases with backend key/cert mismatch errors + // before the boolean/type validation this test is targeting. Keep the scalar + // cases so https.createServer() option type validation is still covered. + common.printSkipMessage( + `BoringSSL: skipping ${setName} key/cert array cases`); + return options.filter(([key, cert]) => !Array.isArray(key) && + !Array.isArray(cert)); +} + // Checks to ensure https.createServer doesn't throw an error // Format ['key', 'cert'] -[ +const validOptions = [ [keyBuff, certBuff], [false, certBuff], [keyBuff, false], @@ -62,13 +76,16 @@ const caArrDataView = toDataView(caCert); [false, [certStr, certStr2]], [[{ pem: keyBuff }], false], [[{ pem: keyBuff }, { pem: keyBuff }], false], -].forEach(([key, cert]) => { - https.createServer({ key, cert }); -}); +]; + +filterBoringSSLKeyCertArrayCases(validOptions, 'valid') + .forEach(([key, cert]) => { + https.createServer({ key, cert }); + }); // Checks to ensure https.createServer predictably throws an error // Format ['key', 'cert', 'expected message'] -[ +const invalidKeyOptions = [ [true, certBuff], [true, certStr], [true, certArrBuff], @@ -81,7 +98,10 @@ const caArrDataView = toDataView(caCert); [[true, keyStr2], [certStr, certStr2], 0], [[true, false], [certBuff, certBuff2], 0], [true, [certBuff, certBuff2]], -].forEach(([key, cert, index]) => { +]; + +for (const [key, cert, index] of + filterBoringSSLKeyCertArrayCases(invalidKeyOptions, 'invalid key')) { const val = index === undefined ? key : key[index]; assert.throws(() => { https.createServer({ key, cert }); @@ -92,9 +112,9 @@ const caArrDataView = toDataView(caCert); 'instance of Buffer, TypedArray, or DataView.' + common.invalidArgTypeHelper(val) }); -}); +} -[ +const invalidCertOptions = [ [keyBuff, true], [keyStr, true], [keyArrBuff, true], @@ -107,7 +127,10 @@ const caArrDataView = toDataView(caCert); [[keyStr, keyStr2], [certStr, true], 1], [[keyStr, keyStr2], [true, false], 0], [[keyStr, keyStr2], true], -].forEach(([key, cert, index]) => { +]; + +for (const [key, cert, index] of + filterBoringSSLKeyCertArrayCases(invalidCertOptions, 'invalid cert')) { const val = index === undefined ? cert : cert[index]; assert.throws(() => { https.createServer({ key, cert }); @@ -118,7 +141,7 @@ const caArrDataView = toDataView(caCert); 'instance of Buffer, TypedArray, or DataView.' + common.invalidArgTypeHelper(val) }); -}); +} // Checks to ensure https.createServer works with the CA parameter // Format ['key', 'cert', 'ca'] diff --git a/test/parallel/test-tls-alert.js b/test/parallel/test-tls-alert.js index 23c92e7293458f..64b7080e39ba25 100644 --- a/test/parallel/test-tls-alert.js +++ b/test/parallel/test-tls-alert.js @@ -48,6 +48,33 @@ const server = tls.Server({ key: loadPEM('agent2-key'), cert: loadPEM('agent2-cert') }, null).listen(0, common.mustCall(() => { + if (process.features.openssl_is_boringssl) { + let gotClientError = false; + let gotServerError = false; + function maybeClose() { + if (gotClientError && gotServerError) + server.close(); + } + + server.once('tlsClientError', common.mustCall((err) => { + assert.strictEqual(err.code, 'ERR_SSL_UNSUPPORTED_PROTOCOL'); + gotServerError = true; + maybeClose(); + })); + + const client = tls.connect({ + port: server.address().port, + rejectUnauthorized: false, + secureProtocol: 'TLSv1_1_method', + }, common.mustNotCall()); + client.once('error', common.mustCall((err) => { + assert.strictEqual(err.code, 'ERR_SSL_TLSV1_ALERT_PROTOCOL_VERSION'); + gotClientError = true; + maybeClose(); + })); + return; + } + const args = ['s_client', '-quiet', '-tls1_1', '-cipher', (hasOpenSSL(3, 1) ? 'DEFAULT:@SECLEVEL=0' : 'DEFAULT'), '-connect', `127.0.0.1:${server.address().port}`]; diff --git a/test/parallel/test-tls-client-auth.js b/test/parallel/test-tls-client-auth.js index 67aed40914c9fe..517054c6e290dc 100644 --- a/test/parallel/test-tls-client-auth.js +++ b/test/parallel/test-tls-client-auth.js @@ -111,7 +111,10 @@ if (tls.DEFAULT_MAX_VERSION === 'TLSv1.3') connect({ // and sends a fatal Alert to the client that the client discovers there has // been a fatal error. pair.client.conn.once('error', common.mustCall((err) => { - assert.strictEqual(err.code, 'ERR_SSL_TLSV13_ALERT_CERTIFICATE_REQUIRED'); + const expectedErr = process.features.openssl_is_boringssl ? + 'ERR_SSL_TLSV1_ALERT_CERTIFICATE_REQUIRED' : + 'ERR_SSL_TLSV13_ALERT_CERTIFICATE_REQUIRED'; + assert.strictEqual(err.code, expectedErr); cleanup(); })); })); diff --git a/test/parallel/test-tls-client-getephemeralkeyinfo.js b/test/parallel/test-tls-client-getephemeralkeyinfo.js index 19728e3733d868..2107d024012c4d 100644 --- a/test/parallel/test-tls-client-getephemeralkeyinfo.js +++ b/test/parallel/test-tls-client-getephemeralkeyinfo.js @@ -2,6 +2,12 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); + +if (process.features.openssl_is_boringssl) { + require('../common/boringssl').testEphemeralKeyInfoUnsupported(); + return; +} + const fixtures = require('../common/fixtures'); const { hasOpenSSL } = require('../common/crypto'); diff --git a/test/parallel/test-tls-client-mindhsize.js b/test/parallel/test-tls-client-mindhsize.js index cd7b16ea566fe8..fa494c583a2f3b 100644 --- a/test/parallel/test-tls-client-mindhsize.js +++ b/test/parallel/test-tls-client-mindhsize.js @@ -85,21 +85,25 @@ function testDHE3072() { test(3072, false, null); } -if (hasOpenSSL(4, 0)) { - // OpenSSL 4.0 implements RFC 7919 FFDHE negotiation for TLS 1.2 and - // ignores the server-supplied dhparam in favor of FFDHE-2048. The 3072 - // success case is therefore replaced by a 2048 success case. - testDHE2048(true, () => test(2048, false, null, 2048)); -} else if (secLevel > 1) { - // Minimum size for OpenSSL security level 2 and above is 2048 by default - testDHE2048(true, testDHE3072); +if (!process.features.openssl_is_boringssl) { + if (hasOpenSSL(4, 0)) { + // OpenSSL 4.0 implements RFC 7919 FFDHE negotiation for TLS 1.2 and + // ignores the server-supplied dhparam in favor of FFDHE-2048. The 3072 + // success case is therefore replaced by a 2048 success case. + testDHE2048(true, () => test(2048, false, null, 2048)); + } else if (secLevel > 1) { + // Minimum size for OpenSSL security level 2 and above is 2048 by default + testDHE2048(true, testDHE3072); + } else { + testDHE1024(); + } + + assert.throws(() => test(512, true, common.mustNotCall()), + /DH parameter is less than 1024 bits/); } else { - testDHE1024(); + require('../common/boringssl').assertFiniteFieldDheUnsupported(); } -assert.throws(() => test(512, true, common.mustNotCall()), - /DH parameter is less than 1024 bits/); - for (const minDHSize of [0, -1, -Infinity, NaN]) { assert.throws(() => { tls.connect({ minDHSize }); @@ -118,7 +122,9 @@ for (const minDHSize of [true, false, null, undefined, {}, [], '', '1']) { }); } -process.on('exit', function() { - assert.strictEqual(nsuccess, 1); - assert.strictEqual(nerror, 1); -}); +if (!process.features.openssl_is_boringssl) { + process.on('exit', function() { + assert.strictEqual(nsuccess, 1); + assert.strictEqual(nerror, 1); + }); +} diff --git a/test/parallel/test-tls-client-reject.js b/test/parallel/test-tls-client-reject.js index 68922e3690eac0..cff0aabc89a774 100644 --- a/test/parallel/test-tls-client-reject.js +++ b/test/parallel/test-tls-client-reject.js @@ -30,7 +30,8 @@ const fixtures = require('../common/fixtures'); const options = { key: fixtures.readKey('rsa_private.pem'), - cert: fixtures.readKey('rsa_cert.crt') + cert: fixtures.readKey('rsa_cert.crt'), + ...(process.features.openssl_is_boringssl ? { maxVersion: 'TLSv1.2' } : {}), }; const server = tls.createServer(options, function(socket) { @@ -46,7 +47,8 @@ function unauthorized() { const socket = tls.connect({ port: server.address().port, servername: 'localhost', - rejectUnauthorized: false + rejectUnauthorized: false, + ...(process.features.openssl_is_boringssl ? { maxVersion: 'TLSv1.2' } : {}), }, common.mustCall(function() { let _data; assert(!socket.authorized); @@ -67,7 +69,8 @@ function unauthorized() { function rejectUnauthorized() { console.log('reject unauthorized'); const socket = tls.connect(server.address().port, { - servername: 'localhost' + servername: 'localhost', + ...(process.features.openssl_is_boringssl ? { maxVersion: 'TLSv1.2' } : {}), }, common.mustNotCall()); socket.on('data', common.mustNotCall()); socket.on('error', common.mustCall(function(err) { @@ -80,7 +83,8 @@ function rejectUnauthorizedUndefined() { console.log('reject unauthorized undefined'); const socket = tls.connect(server.address().port, { servername: 'localhost', - rejectUnauthorized: undefined + rejectUnauthorized: undefined, + ...(process.features.openssl_is_boringssl ? { maxVersion: 'TLSv1.2' } : {}), }, common.mustNotCall()); socket.on('data', common.mustNotCall()); socket.on('error', common.mustCall(function(err) { @@ -93,7 +97,8 @@ function authorized() { console.log('connect authorized'); const socket = tls.connect(server.address().port, { ca: [fixtures.readKey('rsa_cert.crt')], - servername: 'localhost' + servername: 'localhost', + ...(process.features.openssl_is_boringssl ? { maxVersion: 'TLSv1.2' } : {}), }, common.mustCall(function() { console.log('... authorized'); assert(socket.authorized); diff --git a/test/parallel/test-tls-client-renegotiation-limit.js b/test/parallel/test-tls-client-renegotiation-limit.js index 86111d6da0b402..9b7f62865b336d 100644 --- a/test/parallel/test-tls-client-renegotiation-limit.js +++ b/test/parallel/test-tls-client-renegotiation-limit.js @@ -31,6 +31,11 @@ if (!opensslCli) { common.skip('node compiled without OpenSSL CLI.'); } +if (process.features.openssl_is_boringssl) { + require('../common/boringssl').testRenegotiationUnsupported(); + return; +} + const assert = require('assert'); const tls = require('tls'); const fixtures = require('../common/fixtures'); diff --git a/test/parallel/test-tls-dhe.js b/test/parallel/test-tls-dhe.js index 03750bc206adbe..b788d153293899 100644 --- a/test/parallel/test-tls-dhe.js +++ b/test/parallel/test-tls-dhe.js @@ -26,6 +26,11 @@ if (!common.hasCrypto) { common.skip('missing crypto'); } +if (process.features.openssl_is_boringssl) { + require('../common/boringssl').assertFiniteFieldDheUnsupported(); + return; +} + const { opensslCli, hasOpenSSL, diff --git a/test/parallel/test-tls-disable-renegotiation.js b/test/parallel/test-tls-disable-renegotiation.js index f91868c6345d71..84a6ead4a5441c 100644 --- a/test/parallel/test-tls-disable-renegotiation.js +++ b/test/parallel/test-tls-disable-renegotiation.js @@ -8,6 +8,11 @@ const fixtures = require('../common/fixtures'); if (!common.hasCrypto) common.skip('missing crypto'); +if (process.features.openssl_is_boringssl) { + require('../common/boringssl').testRenegotiationUnsupported(); + return; +} + const tls = require('tls'); // Renegotiation as a protocol feature was dropped after TLS1.2. diff --git a/test/parallel/test-tls-ecdh-multiple.js b/test/parallel/test-tls-ecdh-multiple.js index ee52f288610956..ed60044197d7da 100644 --- a/test/parallel/test-tls-ecdh-multiple.js +++ b/test/parallel/test-tls-ecdh-multiple.js @@ -26,7 +26,7 @@ function loadPEM(n) { // OpenSSL 4.0 disables support for deprecated elliptic curves from RFC 8422 // (including secp256k1) by default. -const ecdhCurve = hasOpenSSL(4, 0) ? +const ecdhCurve = process.features.openssl_is_boringssl || hasOpenSSL(4, 0) ? 'prime256v1:secp521r1' : 'secp256k1:prime256v1:secp521r1'; @@ -67,7 +67,7 @@ const server = tls.createServer(options, (conn) => { } // Deprecated RFC 8422 curves are disabled by default in OpenSSL 4.0. - if (hasOpenSSL(4, 0)) { + if (process.features.openssl_is_boringssl || hasOpenSSL(4, 0)) { unsupportedCurves.push('secp256k1'); } diff --git a/test/parallel/test-tls-empty-sni-context.js b/test/parallel/test-tls-empty-sni-context.js index e4136ff71e1d52..6ecdfbeecbe3c9 100644 --- a/test/parallel/test-tls-empty-sni-context.js +++ b/test/parallel/test-tls-empty-sni-context.js @@ -16,7 +16,7 @@ const options = { const server = tls.createServer(options, (c) => { assert.fail('Should not be called'); }).on('tlsClientError', common.mustCall((err, c) => { - assert.match(err.message, /no suitable signature algorithm/i); + assert.match(err.message, /no suitable signature algorithm|NO_CERTIFICATE_SET/i); server.close(); })).listen(0, common.mustCall(() => { const c = tls.connect({ @@ -26,9 +26,10 @@ const server = tls.createServer(options, (c) => { }, common.mustNotCall()); c.on('error', common.mustCall((err) => { - const expectedErr = hasOpenSSL(4, 0) ? - 'ERR_SSL_TLS_ALERT_HANDSHAKE_FAILURE' : hasOpenSSL(3, 2) ? - 'ERR_SSL_SSL/TLS_ALERT_HANDSHAKE_FAILURE' : 'ERR_SSL_SSLV3_ALERT_HANDSHAKE_FAILURE'; + const expectedErr = process.features.openssl_is_boringssl ? + 'ERR_SSL_TLSV1_ALERT_INTERNAL_ERROR' : hasOpenSSL(4, 0) ? + 'ERR_SSL_TLS_ALERT_HANDSHAKE_FAILURE' : hasOpenSSL(3, 2) ? + 'ERR_SSL_SSL/TLS_ALERT_HANDSHAKE_FAILURE' : 'ERR_SSL_SSLV3_ALERT_HANDSHAKE_FAILURE'; assert.strictEqual(err.code, expectedErr); })); })); diff --git a/test/parallel/test-tls-finished.js b/test/parallel/test-tls-finished.js index 8b52934b049d95..b23b4567d27ec6 100644 --- a/test/parallel/test-tls-finished.js +++ b/test/parallel/test-tls-finished.js @@ -20,7 +20,8 @@ const msg = {}; const pem = (n) => fixtures.readKey(`${n}.pem`); const server = tls.createServer({ key: pem('agent1-key'), - cert: pem('agent1-cert') + cert: pem('agent1-cert'), + ...(process.features.openssl_is_boringssl ? { maxVersion: 'TLSv1.2' } : {}), }, common.mustCall((alice) => { msg.server = { alice: alice.getFinished(), @@ -32,7 +33,8 @@ const server = tls.createServer({ server.listen(0, common.mustCall(() => { const bob = tls.connect({ port: server.address().port, - rejectUnauthorized: false + rejectUnauthorized: false, + ...(process.features.openssl_is_boringssl ? { maxVersion: 'TLSv1.2' } : {}), }, common.mustCall(() => { msg.client = { alice: bob.getPeerFinished(), diff --git a/test/parallel/test-tls-getcipher.js b/test/parallel/test-tls-getcipher.js index 4d5042d6e6beab..2d4de5639afb70 100644 --- a/test/parallel/test-tls-getcipher.js +++ b/test/parallel/test-tls-getcipher.js @@ -36,27 +36,42 @@ const options = { honorCipherOrder: true }; +const isBoringSSL = process.features.openssl_is_boringssl; let clients = 0; +const expectedClients = isBoringSSL ? 1 : 2; const server = tls.createServer(options, common.mustCall(() => { if (--clients === 0) server.close(); -}, 2)); +}, expectedClients)); server.listen(0, '127.0.0.1', common.mustCall(function() { - clients++; - tls.connect({ - host: '127.0.0.1', - port: this.address().port, - ciphers: 'AES256-SHA256', - rejectUnauthorized: false, - maxVersion: 'TLSv1.2', - }, common.mustCall(function() { - const cipher = this.getCipher(); - assert.strictEqual(cipher.name, 'AES256-SHA256'); - assert.strictEqual(cipher.standardName, 'TLS_RSA_WITH_AES_256_CBC_SHA256'); - assert.strictEqual(cipher.version, 'TLSv1.2'); - this.end(); - })); + if (isBoringSSL) { + // BoringSSL does not provide this static RSA TLS 1.2 cipher suite on + // Node's supported cipher surface, so keep the OpenSSL getCipher() + // assertion below limited to backends that can create the context. + common.printSkipMessage('BoringSSL does not provide AES256-SHA256'); + assert.throws(() => tls.createSecureContext({ ciphers: 'AES256-SHA256' }), { + code: 'ERR_SSL_NO_CIPHER_MATCH', + library: 'SSL routines', + function: 'OPENSSL_internal', + reason: 'NO_CIPHER_MATCH', + }); + } else { + clients++; + tls.connect({ + host: '127.0.0.1', + port: this.address().port, + ciphers: 'AES256-SHA256', + rejectUnauthorized: false, + maxVersion: 'TLSv1.2', + }, common.mustCall(function() { + const cipher = this.getCipher(); + assert.strictEqual(cipher.name, 'AES256-SHA256'); + assert.strictEqual(cipher.standardName, 'TLS_RSA_WITH_AES_256_CBC_SHA256'); + assert.strictEqual(cipher.version, 'TLSv1.2'); + this.end(); + })); + } clients++; tls.connect({ @@ -70,7 +85,9 @@ server.listen(0, '127.0.0.1', common.mustCall(function() { assert.strictEqual(cipher.name, 'ECDHE-RSA-AES256-GCM-SHA384'); assert.strictEqual(cipher.standardName, 'TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384'); - assert.strictEqual(cipher.version, 'TLSv1.2'); + assert.strictEqual(cipher.version, isBoringSSL ? + 'TLSv1/SSLv3' : + 'TLSv1.2'); this.end(); })); })); @@ -90,9 +107,14 @@ tls.createServer({ rejectUnauthorized: false }, common.mustCall(() => { const cipher = client.getCipher(); - assert.strictEqual(cipher.name, 'TLS_AES_256_GCM_SHA384'); + const expectedCipher = isBoringSSL ? + 'TLS_AES_128_GCM_SHA256' : + 'TLS_AES_256_GCM_SHA384'; + assert.strictEqual(cipher.name, expectedCipher); assert.strictEqual(cipher.standardName, cipher.name); - assert.strictEqual(cipher.version, 'TLSv1.3'); + assert.strictEqual(cipher.version, isBoringSSL ? + 'TLSv1/SSLv3' : + 'TLSv1.3'); client.end(); })); })); diff --git a/test/parallel/test-tls-getprotocol.js b/test/parallel/test-tls-getprotocol.js index 5fe46c43c376cf..2945ff99b5a290 100644 --- a/test/parallel/test-tls-getprotocol.js +++ b/test/parallel/test-tls-getprotocol.js @@ -12,7 +12,7 @@ const assert = require('assert'); const tls = require('tls'); const fixtures = require('../common/fixtures'); -const clientConfigs = [ +let clientConfigs = [ { secureProtocol: 'TLSv1_method', version: 'TLSv1', @@ -27,6 +27,14 @@ const clientConfigs = [ }, ]; +if (process.features.openssl_is_boringssl) { + // Remove the TLSv1 and TLSv1.1 cases. BoringSSL does not negotiate those + // legacy protocols in this configuration; keep TLSv1.2 to cover getProtocol() + // on a successful BoringSSL TLS handshake. + common.printSkipMessage('BoringSSL: skipping TLSv1/TLSv1.1 getProtocol cases'); + clientConfigs = clientConfigs.filter(({ version }) => version === 'TLSv1.2'); +} + const serverConfig = { secureProtocol: 'TLS_method', key: fixtures.readKey('agent2-key.pem'), diff --git a/test/parallel/test-tls-handshake-error.js b/test/parallel/test-tls-handshake-error.js index 5547964780cd60..94a21a14975b5d 100644 --- a/test/parallel/test-tls-handshake-error.js +++ b/test/parallel/test-tls-handshake-error.js @@ -20,7 +20,7 @@ const server = tls.createServer({ port: this.address().port, ciphers: 'no-such-cipher' }, common.mustNotCall()); - }, /no cipher match/i); + }, /no[_ ]cipher[_ ]match/i); server.close(); })); diff --git a/test/parallel/test-tls-honorcipherorder.js b/test/parallel/test-tls-honorcipherorder.js index 5f123cd739a4c0..d86a59aa4cdc6d 100644 --- a/test/parallel/test-tls-honorcipherorder.js +++ b/test/parallel/test-tls-honorcipherorder.js @@ -16,14 +16,40 @@ const util = require('util'); // default method is updated in the future const SSL_Method = 'TLSv1_2_method'; const localhost = '127.0.0.1'; +const config = process.features.openssl_is_boringssl ? { + serverCiphers: + 'ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256', + clientPreferenceCiphers: + 'ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384', + clientPreferredCipher: 'ECDHE-RSA-AES128-GCM-SHA256', + serverPreferredCipher: 'ECDHE-RSA-AES256-GCM-SHA384', + singleCipher: 'ECDHE-RSA-AES128-GCM-SHA256', + defaultCipher: 'ECDHE-RSA-AES256-GCM-SHA384', + limitedDefaultCipher: 'ECDHE-RSA-AES128-GCM-SHA256', + extraCases: [], +} : { + serverCiphers: 'AES256-SHA256:AES128-GCM-SHA256:AES128-SHA256:' + + 'ECDHE-RSA-AES128-GCM-SHA256', + clientPreferenceCiphers: 'AES128-GCM-SHA256:AES256-SHA256:AES128-SHA256', + clientPreferredCipher: 'AES128-GCM-SHA256', + serverPreferredCipher: 'AES256-SHA256', + singleCipher: 'AES128-SHA256', + defaultCipher: 'AES256-SHA256', + limitedDefaultCipher: 'ECDHE-RSA-AES128-GCM-SHA256', + extraCases: [ + // Server has the preference of cipher suites. AES128-GCM-SHA256 is given + // higher priority over AES128-SHA256 among client cipher suites. + [true, 'AES128-SHA256:AES128-GCM-SHA256', 'AES128-GCM-SHA256'], + [undefined, 'AES128-SHA256:AES128-GCM-SHA256', 'AES128-GCM-SHA256'], + ], +}; function test(honorCipherOrder, clientCipher, expectedCipher, defaultCiphers) { const soptions = { secureProtocol: SSL_Method, key: fixtures.readKey('agent2-key.pem'), cert: fixtures.readKey('agent2-cert.pem'), - ciphers: 'AES256-SHA256:AES128-GCM-SHA256:AES128-SHA256:' + - 'ECDHE-RSA-AES128-GCM-SHA256', + ciphers: config.serverCiphers, honorCipherOrder: honorCipherOrder, }; @@ -57,34 +83,27 @@ function test(honorCipherOrder, clientCipher, expectedCipher, defaultCiphers) { } // Client explicitly has the preference of cipher suites, not the default. -test(false, 'AES128-GCM-SHA256:AES256-SHA256:AES128-SHA256', - 'AES128-GCM-SHA256'); +test(false, config.clientPreferenceCiphers, config.clientPreferredCipher); -// Server has the preference of cipher suites, and AES256-SHA256 is -// the server's top choice. -test(true, 'AES128-GCM-SHA256:AES256-SHA256:AES128-SHA256', - 'AES256-SHA256'); -test(undefined, 'AES128-GCM-SHA256:AES256-SHA256:AES128-SHA256', - 'AES256-SHA256'); - -// Server has the preference of cipher suites. AES128-GCM-SHA256 is given -// higher priority over AES128-SHA256 among client cipher suites. -test(true, 'AES128-SHA256:AES128-GCM-SHA256', 'AES128-GCM-SHA256'); -test(undefined, 'AES128-SHA256:AES128-GCM-SHA256', 'AES128-GCM-SHA256'); +// Server has the preference of cipher suites. +test(true, config.clientPreferenceCiphers, config.serverPreferredCipher); +test(undefined, config.clientPreferenceCiphers, config.serverPreferredCipher); +for (const args of config.extraCases) { + test(...args); +} // As client has only one cipher, server has no choice, irrespective // of honorCipherOrder. -test(true, 'AES128-SHA256', 'AES128-SHA256'); -test(undefined, 'AES128-SHA256', 'AES128-SHA256'); +test(true, config.singleCipher, config.singleCipher); +test(undefined, config.singleCipher, config.singleCipher); -// Client did not explicitly set ciphers and client offers -// tls.DEFAULT_CIPHERS. All ciphers of the server are included in the -// default list so the negotiated cipher is selected according to the -// server's top preference of AES256-SHA256. -test(true, tls.DEFAULT_CIPHERS, 'AES256-SHA256'); -test(true, null, 'AES256-SHA256'); -test(undefined, null, 'AES256-SHA256'); +// Client did not explicitly set ciphers and client offers tls.DEFAULT_CIPHERS. +// All ciphers of the server are included in the default list so the negotiated +// cipher is selected according to server preference. +test(true, tls.DEFAULT_CIPHERS, config.defaultCipher); +test(true, null, config.defaultCipher); +test(undefined, null, config.defaultCipher); // Ensure that `tls.DEFAULT_CIPHERS` is used when its a limited cipher set. -test(true, null, 'ECDHE-RSA-AES128-GCM-SHA256', 'ECDHE-RSA-AES128-GCM-SHA256'); +test(true, null, config.limitedDefaultCipher, config.limitedDefaultCipher); diff --git a/test/parallel/test-tls-junk-server.js b/test/parallel/test-tls-junk-server.js index 42f089f8f90ed2..b6ff3cd2a467f2 100644 --- a/test/parallel/test-tls-junk-server.js +++ b/test/parallel/test-tls-junk-server.js @@ -24,7 +24,7 @@ server.listen(0, common.mustCall(function() { // Different OpenSSL versions report different errors for junk data on a // TLS connection, depending on which record validation check fires first. const expectedErrorMessage = - /wrong version number|packet length too long|bad record type/; + /wrong[ _]version[ _]number|packet length too long|bad record type/i; req.once('error', common.mustCall(function(err) { assert.match(err.message, expectedErrorMessage); server.close(); diff --git a/test/parallel/test-tls-key-mismatch.js b/test/parallel/test-tls-key-mismatch.js index df8848a03de4a9..797c7c171dc5ff 100644 --- a/test/parallel/test-tls-key-mismatch.js +++ b/test/parallel/test-tls-key-mismatch.js @@ -31,9 +31,11 @@ const { hasOpenSSL3 } = require('../common/crypto'); const assert = require('assert'); const tls = require('tls'); -const errorMessageRegex = hasOpenSSL3 ? - /^Error: error:05800074:x509 certificate routines::key values mismatch$/ : - /^Error: error:0B080074:x509 certificate routines:X509_check_private_key:key values mismatch$/; +const errorMessageRegex = process.features.openssl_is_boringssl ? + /^Error: error:0b000074:X\.509 certificate routines:OPENSSL_internal:KEY_VALUES_MISMATCH$/ : + hasOpenSSL3 ? + /^Error: error:05800074:x509 certificate routines::key values mismatch$/ : + /^Error: error:0B080074:x509 certificate routines:X509_check_private_key:key values mismatch$/; const options = { key: fixtures.readKey('agent1-key.pem'), diff --git a/test/parallel/test-tls-max-send-fragment.js b/test/parallel/test-tls-max-send-fragment.js index 009021045624bb..2e319fcdaeafea 100644 --- a/test/parallel/test-tls-max-send-fragment.js +++ b/test/parallel/test-tls-max-send-fragment.js @@ -60,9 +60,15 @@ const server = tls.createServer({ assert.throws(() => c.setMaxSendFragment(Symbol()), { name: 'TypeError' }); - // Lower and upper limits. - assert(!c.setMaxSendFragment(511)); - assert(!c.setMaxSendFragment(16385)); + // OpenSSL enforces Node's documented fragment size range. BoringSSL accepts + // both out-of-range values and reports success, so assert that difference + // explicitly instead of using a truthiness shortcut. + const acceptsOutOfRangeFragmentSize = + process.features.openssl_is_boringssl; + assert.strictEqual(c.setMaxSendFragment(511), + acceptsOutOfRangeFragmentSize); + assert.strictEqual(c.setMaxSendFragment(16385), + acceptsOutOfRangeFragmentSize); // Correct fragment size. assert(c.setMaxSendFragment(maxChunk)); diff --git a/test/parallel/test-tls-min-max-version.js b/test/parallel/test-tls-min-max-version.js index 4903d92f5c5700..abddbbeb0eba1b 100644 --- a/test/parallel/test-tls-min-max-version.js +++ b/test/parallel/test-tls-min-max-version.js @@ -4,6 +4,12 @@ const common = require('../common'); if (!common.hasCrypto) { common.skip('missing crypto'); } + +if (process.features.openssl_is_boringssl) { + require('../common/boringssl').testLegacyProtocolUnsupported(); + return; +} + const { hasOpenSSL, hasOpenSSL3, diff --git a/test/parallel/test-tls-multi-key.js b/test/parallel/test-tls-multi-key.js index 89f9931e5bdd77..0a9c6f108bf675 100644 --- a/test/parallel/test-tls-multi-key.js +++ b/test/parallel/test-tls-multi-key.js @@ -27,6 +27,11 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); +if (process.features.openssl_is_boringssl) { + require('../common/boringssl').assertMultiKeyUnsupported(); + return; +} + const fixtures = require('../common/fixtures'); const assert = require('assert'); const tls = require('tls'); diff --git a/test/parallel/test-tls-multi-pfx.js b/test/parallel/test-tls-multi-pfx.js index 526b77b1484cd3..fec697cd3b7093 100644 --- a/test/parallel/test-tls-multi-pfx.js +++ b/test/parallel/test-tls-multi-pfx.js @@ -3,6 +3,11 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); +if (process.features.openssl_is_boringssl) { + require('../common/boringssl').testMultiPfxSelectionDifference(); + return; +} + const assert = require('assert'); const tls = require('tls'); const fixtures = require('../common/fixtures'); diff --git a/test/parallel/test-tls-no-cert-required.js b/test/parallel/test-tls-no-cert-required.js index b3dcfa516ab502..499ab2dfd14ed2 100644 --- a/test/parallel/test-tls-no-cert-required.js +++ b/test/parallel/test-tls-no-cert-required.js @@ -28,10 +28,15 @@ const assert = require('assert'); const tls = require('tls'); // Omitting the cert or pfx option to tls.createServer() should not throw. -// AECDH-NULL-SHA is a no-authentication/no-encryption cipher and hence -// doesn't need a certificate. -tls.createServer({ ciphers: 'AECDH-NULL-SHA' }) - .listen(0, common.mustCall(close)); +if (process.features.openssl_is_boringssl) { + // AECDH-NULL-SHA is a no-authentication/no-encryption cipher and hence + // does not need a certificate. BoringSSL does not provide that anonymous + // cipher suite, so only this cipher-specific no-cert case is skipped. + common.printSkipMessage('BoringSSL: skipping anonymous AECDH-NULL-SHA case'); +} else { + tls.createServer({ ciphers: 'AECDH-NULL-SHA' }) + .listen(0, common.mustCall(close)); +} tls.createServer(assert.fail) .listen(0, common.mustCall(close)); diff --git a/test/parallel/test-tls-options-boolean-check.js b/test/parallel/test-tls-options-boolean-check.js index 900a39f0c1cd42..f7dd7bb102f361 100644 --- a/test/parallel/test-tls-options-boolean-check.js +++ b/test/parallel/test-tls-options-boolean-check.js @@ -40,9 +40,23 @@ const keyDataView = toDataView(keyBuff); const certDataView = toDataView(certBuff); const caArrDataView = toDataView(caCert); +function filterBoringSSLKeyCertArrayCases(options, setName) { + if (!process.features.openssl_is_boringssl) + return options; + + // The array-valued cases exercise multi-identity key/cert handling. + // BoringSSL may reject those cases with backend key/cert mismatch errors + // before the boolean/type validation this test is targeting. Keep the scalar + // cases so tls.createServer() option type validation is still covered. + common.printSkipMessage( + `BoringSSL: skipping ${setName} key/cert array cases`); + return options.filter(([key, cert]) => !Array.isArray(key) && + !Array.isArray(cert)); +} + // Checks to ensure tls.createServer doesn't throw an error // Format ['key', 'cert'] -[ +const validOptions = [ [keyBuff, certBuff], [false, certBuff], [keyBuff, false], @@ -62,13 +76,16 @@ const caArrDataView = toDataView(caCert); [false, [certStr, certStr2]], [[{ pem: keyBuff }], false], [[{ pem: keyBuff }, { pem: keyBuff }], false], -].forEach(([key, cert]) => { - tls.createServer({ key, cert }); -}); +]; + +filterBoringSSLKeyCertArrayCases(validOptions, 'valid') + .forEach(([key, cert]) => { + tls.createServer({ key, cert }); + }); // Checks to ensure tls.createServer predictably throws an error // Format ['key', 'cert', 'expected message'] -[ +const invalidKeyOptions = [ [true, certBuff], [true, certStr], [true, certArrBuff], @@ -80,7 +97,10 @@ const caArrDataView = toDataView(caCert); [[true, keyStr2], [certStr, certStr2], 0], [[true, false], [certBuff, certBuff2], 0], [true, [certBuff, certBuff2]], -].forEach(([key, cert, index]) => { +]; + +for (const [key, cert, index] of + filterBoringSSLKeyCertArrayCases(invalidKeyOptions, 'invalid key')) { const val = index === undefined ? key : key[index]; assert.throws(() => { tls.createServer({ key, cert }); @@ -91,9 +111,9 @@ const caArrDataView = toDataView(caCert); 'instance of Buffer, TypedArray, or DataView.' + common.invalidArgTypeHelper(val) }); -}); +} -[ +const invalidCertOptions = [ [keyBuff, true], [keyStr, true], [keyArrBuff, true], @@ -106,7 +126,10 @@ const caArrDataView = toDataView(caCert); [[keyStr, keyStr2], [certStr, true], 1], [[keyStr, keyStr2], [true, false], 0], [[keyStr, keyStr2], true], -].forEach(([key, cert, index]) => { +]; + +for (const [key, cert, index] of + filterBoringSSLKeyCertArrayCases(invalidCertOptions, 'invalid cert')) { const val = index === undefined ? cert : cert[index]; assert.throws(() => { tls.createServer({ key, cert }); @@ -117,7 +140,7 @@ const caArrDataView = toDataView(caCert); 'instance of Buffer, TypedArray, or DataView.' + common.invalidArgTypeHelper(val) }); -}); +} // Checks to ensure tls.createServer works with the CA parameter // Format ['key', 'cert', 'ca'] diff --git a/test/parallel/test-tls-passphrase.js b/test/parallel/test-tls-passphrase.js index 8d802400f6ee3b..4372da249bb509 100644 --- a/test/parallel/test-tls-passphrase.js +++ b/test/parallel/test-tls-passphrase.js @@ -223,7 +223,7 @@ server.listen(0, common.mustCall(function() { }, onSecureConnect()); })).unref(); -const errMessageDecrypt = /bad decrypt/; +const errMessageDecrypt = /bad[ _]decrypt/i; // Missing passphrase assert.throws(function() { diff --git a/test/parallel/test-tls-psk-alpn-callback-exception-handling.js b/test/parallel/test-tls-psk-alpn-callback-exception-handling.js index 881215672ecd0d..cdeb9f3b31f8fe 100644 --- a/test/parallel/test-tls-psk-alpn-callback-exception-handling.js +++ b/test/parallel/test-tls-psk-alpn-callback-exception-handling.js @@ -14,6 +14,11 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); +if (process.features.openssl_is_boringssl) { + require('../common/boringssl').testPskTls13Unsupported(); + return; +} + const assert = require('assert'); const { describe, it } = require('node:test'); const tls = require('tls'); diff --git a/test/parallel/test-tls-psk-circuit.js b/test/parallel/test-tls-psk-circuit.js index bdf9c86c26a7b6..c9c93d53350165 100644 --- a/test/parallel/test-tls-psk-circuit.js +++ b/test/parallel/test-tls-psk-circuit.js @@ -5,6 +5,11 @@ if (!common.hasCrypto) { common.skip('missing crypto'); } +if (process.features.openssl_is_boringssl) { + require('../common/boringssl').testPskTls13Unsupported(); + return; +} + const { hasOpenSSL } = require('../common/crypto'); const assert = require('assert'); const tls = require('tls'); diff --git a/test/parallel/test-tls-psk-server.js b/test/parallel/test-tls-psk-server.js index af038493469880..692550fc1c198b 100644 --- a/test/parallel/test-tls-psk-server.js +++ b/test/parallel/test-tls-psk-server.js @@ -5,6 +5,11 @@ if (!common.hasCrypto) { common.skip('missing crypto'); } +if (process.features.openssl_is_boringssl) { + require('../common/boringssl').testPskTls13Unsupported(); + return; +} + const { opensslCli } = require('../common/crypto'); if (!opensslCli) { diff --git a/test/parallel/test-tls-reduced-SECLEVEL-in-cipher.js b/test/parallel/test-tls-reduced-SECLEVEL-in-cipher.js index 9f4458e0a7d671..cca22067a0fe19 100644 --- a/test/parallel/test-tls-reduced-SECLEVEL-in-cipher.js +++ b/test/parallel/test-tls-reduced-SECLEVEL-in-cipher.js @@ -4,6 +4,11 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); +if (process.features.openssl_is_boringssl) { + require('../common/boringssl').assertOpenSSLSecurityLevelsUnsupported(); + return; +} + const assert = require('assert'); const tls = require('tls'); const fixtures = require('../common/fixtures'); diff --git a/test/parallel/test-tls-server-failed-handshake-emits-clienterror.js b/test/parallel/test-tls-server-failed-handshake-emits-clienterror.js index 2fb43b9cbbf87a..9c30989af0afb3 100644 --- a/test/parallel/test-tls-server-failed-handshake-emits-clienterror.js +++ b/test/parallel/test-tls-server-failed-handshake-emits-clienterror.js @@ -22,7 +22,7 @@ const server = tls.createServer({}) 'Instance of Error should be passed to error handler'); assert.match( e.message, - /SSL routines:[^:]*:wrong version number/, + /SSL routines:[^:]*:wrong[ _]version[ _]number/i, ); server.close(); diff --git a/test/parallel/test-tls-server-verify.js b/test/parallel/test-tls-server-verify.js index 94f372d37a3b1f..439e321310305a 100644 --- a/test/parallel/test-tls-server-verify.js +++ b/test/parallel/test-tls-server-verify.js @@ -47,7 +47,7 @@ const { SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION } = const tls = require('tls'); const fixtures = require('../common/fixtures'); -const testCases = +let testCases = [{ title: 'Do not request certs. Everyone is unauthorized.', requestCert: false, rejectUnauthorized: false, @@ -125,6 +125,15 @@ const testCases = ] }, ]; +if (process.features.openssl_is_boringssl) { + // Remove the delayed client-certificate verification case. It depends on TLS + // renegotiation to request a client certificate after the initial handshake, + // but BoringSSL does not support caller-initiated renegotiation. + common.printSkipMessage( + 'BoringSSL: skipping renegotiated client certificate verification case'); + testCases = testCases.filter((tcase) => !tcase.renegotiate); +} + function filenamePEM(n) { return fixtures.path('keys', `${n}.pem`); } diff --git a/test/parallel/test-tls-session-cache.js b/test/parallel/test-tls-session-cache.js index aaf9c2c03c83e9..ae560e567980c9 100644 --- a/test/parallel/test-tls-session-cache.js +++ b/test/parallel/test-tls-session-cache.js @@ -37,6 +37,7 @@ const fixtures = require('../common/fixtures'); const assert = require('assert'); const tls = require('tls'); const { spawn } = require('child_process'); +const isBoringSSL = process.features.openssl_is_boringssl; doTest({ tickets: false }, function() { doTest({ tickets: true }, function() { @@ -56,7 +57,9 @@ function doTest(testOptions, callback) { requestCert: true, rejectUnauthorized: false, secureProtocol: 'TLS_method', - ciphers: 'RSA@SECLEVEL=0' + // BoringSSL supports the RSA cipher selector, but not OpenSSL's + // cipher-string policy command syntax. + ciphers: isBoringSSL ? 'RSA' : 'RSA@SECLEVEL=0' }; let requestCount = 0; let resumeCount = 0; @@ -105,7 +108,7 @@ function doTest(testOptions, callback) { server.listen(0, common.mustCall(function() { const args = [ 's_client', - '-tls1', + isBoringSSL ? '-tls1_2' : '-tls1', '-cipher', (hasOpenSSL(3, 1) ? 'DEFAULT:@SECLEVEL=0' : 'DEFAULT'), '-connect', `localhost:${this.address().port}`, '-servername', 'ohgod', diff --git a/test/parallel/test-tls-set-ciphers-error.js b/test/parallel/test-tls-set-ciphers-error.js index 3cfc8c391bf7d5..b79bd512ffe1db 100644 --- a/test/parallel/test-tls-set-ciphers-error.js +++ b/test/parallel/test-tls-set-ciphers-error.js @@ -21,8 +21,12 @@ const { hasOpenSSL } = require('../common/crypto'); assert.throws(() => tls.createServer(options, common.mustNotCall()), /no[_ ]cipher[_ ]match/i); options.ciphers = 'TLS_not_a_cipher'; - assert.throws(() => tls.createServer(options, common.mustNotCall()), - /no[_ ]cipher[_ ]match/i); + if (process.features.openssl_is_boringssl) { + tls.createServer(options).close(); + } else { + assert.throws(() => tls.createServer(options, common.mustNotCall()), + /no[_ ]cipher[_ ]match/i); + } } // Cipher name matching is case-sensitive prior to OpenSSL 4.0, and diff --git a/test/parallel/test-tls-set-default-ca-certificates-recovery.js b/test/parallel/test-tls-set-default-ca-certificates-recovery.js index e3eb0e84149ae8..ea6f98d5686e03 100644 --- a/test/parallel/test-tls-set-default-ca-certificates-recovery.js +++ b/test/parallel/test-tls-set-default-ca-certificates-recovery.js @@ -27,7 +27,9 @@ function testRecovery(expectedCerts) { { const invalidCert = '-----BEGIN CERTIFICATE-----\nvalid cert content\n-----END CERTIFICATE-----'; assert.throws(() => tls.setDefaultCACertificates([fixtureCert, invalidCert]), { - code: 'ERR_OSSL_PEM_ASN1_LIB', + code: process.features.openssl_is_boringssl ? + 'ERR_OSSL_PEM_ASN.1_ENCODING_ROUTINES' : + 'ERR_OSSL_PEM_ASN1_LIB', }); assertEqualCerts(tls.getCACertificates('default'), expectedCerts); } diff --git a/test/parallel/test-tls-set-sigalgs.js b/test/parallel/test-tls-set-sigalgs.js index 1bce814f3e8604..e1bf8b93f8a342 100644 --- a/test/parallel/test-tls-set-sigalgs.js +++ b/test/parallel/test-tls-set-sigalgs.js @@ -39,9 +39,14 @@ function test(csigalgs, ssigalgs, shared_sigalgs, cerr, serr) { assert.ifError(pair.client.err); assert(pair.server.conn); assert(pair.client.conn); + // BoringSSL's OpenSSL-compatible SSL_get_shared_sigalgs() API always + // returns zero, so a successful handshake still reports an empty list. + const expectedSharedSigalgs = process.features.openssl_is_boringssl ? + [] : + shared_sigalgs; assert.deepStrictEqual( pair.server.conn.getSharedSigalgs(), - shared_sigalgs + expectedSharedSigalgs ); } else { if (serr) { @@ -69,10 +74,13 @@ test('RSA-PSS+SHA256:RSA-PSS+SHA512:ECDSA+SHA256', const handshakeErr = hasOpenSSL(4, 0) ? 'ERR_SSL_TLS_ALERT_HANDSHAKE_FAILURE' : hasOpenSSL(3, 2) ? 'ERR_SSL_SSL/TLS_ALERT_HANDSHAKE_FAILURE' : 'ERR_SSL_SSLV3_ALERT_HANDSHAKE_FAILURE'; +const noSharedSigalgsErr = process.features.openssl_is_boringssl ? + 'ERR_SSL_NO_COMMON_SIGNATURE_ALGORITHMS' : + 'ERR_SSL_NO_SHARED_SIGNATURE_ALGORITHMS'; test('RSA-PSS+SHA384', 'ECDSA+SHA256', undefined, handshakeErr, - 'ERR_SSL_NO_SHARED_SIGNATURE_ALGORITHMS'); + noSharedSigalgsErr); test('RSA-PSS+SHA384:ECDSA+SHA256', 'ECDSA+SHA384:RSA-PSS+SHA256', undefined, handshakeErr, - 'ERR_SSL_NO_SHARED_SIGNATURE_ALGORITHMS'); + noSharedSigalgsErr); diff --git a/test/parallel/test-tls-socket-failed-handshake-emits-error.js b/test/parallel/test-tls-socket-failed-handshake-emits-error.js index c88f0c3a1855f2..c64d4ad4aabe8d 100644 --- a/test/parallel/test-tls-socket-failed-handshake-emits-error.js +++ b/test/parallel/test-tls-socket-failed-handshake-emits-error.js @@ -22,7 +22,7 @@ const server = net.createServer(common.mustCall((c) => { 'Instance of Error should be passed to error handler'); assert.match( e.message, - /SSL routines:[^:]*:wrong version number/, + /SSL routines:[^:]*:wrong[ _]version[ _]number/i, ); })); diff --git a/test/parallel/test-tls-ticket-cluster.js b/test/parallel/test-tls-ticket-cluster.js index 2ed4abb93c8d47..f183b53f24c0b9 100644 --- a/test/parallel/test-tls-ticket-cluster.js +++ b/test/parallel/test-tls-ticket-cluster.js @@ -24,6 +24,11 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); +if (process.features.openssl_is_boringssl) { + require('../common/boringssl').testTls13SessionTicketSemanticsDiffer(); + return; +} + const assert = require('assert'); const tls = require('tls'); const cluster = require('cluster'); diff --git a/test/parallel/test-tls-ticket.js b/test/parallel/test-tls-ticket.js index 0a77e52fb275cd..8316f5e8da8d8f 100644 --- a/test/parallel/test-tls-ticket.js +++ b/test/parallel/test-tls-ticket.js @@ -30,6 +30,12 @@ const net = require('net'); const crypto = require('crypto'); const fixtures = require('../common/fixtures'); +if (process.features.openssl_is_boringssl && + tls.DEFAULT_MAX_VERSION !== 'TLSv1.2') { + require('../common/boringssl').testTls13SessionTicketSemanticsDiffer(); + return; +} + const keys = crypto.randomBytes(48); const serverLog = []; const ticketLog = []; diff --git a/test/parallel/test-x509-escaping.js b/test/parallel/test-x509-escaping.js index a5937a09cb1535..ab91e334555669 100644 --- a/test/parallel/test-x509-escaping.js +++ b/test/parallel/test-x509-escaping.js @@ -438,7 +438,9 @@ const { hasOpenSSL3 } = require('../common/crypto'); const cert = fixtures.readKey('incorrect_san_correct_subject-cert.pem'); // The hostname is the CN, but not a SAN entry. - const servername = process.features.openssl_is_boringssl ? undefined : 'good.example.com'; + const servername = 'good.example.com'; + const cnFallback = process.features.openssl_is_boringssl ? undefined : + servername; const certX509 = new X509Certificate(cert); assert.strictEqual(certX509.subject, `CN=${servername}`); assert.strictEqual(certX509.subjectAltName, 'DNS:evil.example.com'); @@ -448,7 +450,7 @@ const { hasOpenSSL3 } = require('../common/crypto'); assert.strictEqual(certX509.checkHost(servername, { subject: 'default' }), undefined); assert.strictEqual(certX509.checkHost(servername, { subject: 'always' }), - servername); + cnFallback); assert.strictEqual(certX509.checkHost(servername, { subject: 'never' }), undefined); @@ -483,11 +485,13 @@ const { hasOpenSSL3 } = require('../common/crypto'); assert.strictEqual(certX509.subjectAltName, 'IP Address:1.2.3.4'); // The newer X509Certificate API allows customizing this behavior: - assert.strictEqual(certX509.checkHost(servername), servername); + const cnFallback = process.features.openssl_is_boringssl ? undefined : + servername; + assert.strictEqual(certX509.checkHost(servername), cnFallback); assert.strictEqual(certX509.checkHost(servername, { subject: 'default' }), - servername); + cnFallback); assert.strictEqual(certX509.checkHost(servername, { subject: 'always' }), - servername); + cnFallback); assert.strictEqual(certX509.checkHost(servername, { subject: 'never' }), undefined); diff --git a/test/sequential/test-tls-connect.js b/test/sequential/test-tls-connect.js index 189b9afa6352bb..ca8a1d8128554e 100644 --- a/test/sequential/test-tls-connect.js +++ b/test/sequential/test-tls-connect.js @@ -57,5 +57,5 @@ const tls = require('tls'); port: common.PORT, ciphers: 'rick-128-roll', }, common.mustNotCall()); - }, /no cipher match/i); + }, /no[_ ]cipher[_ ]match/i); } diff --git a/test/sequential/test-tls-psk-client.js b/test/sequential/test-tls-psk-client.js index 65e628a6f4e0eb..2eb6228f79f265 100644 --- a/test/sequential/test-tls-psk-client.js +++ b/test/sequential/test-tls-psk-client.js @@ -5,6 +5,11 @@ if (!common.hasCrypto) { common.skip('missing crypto'); } +if (process.features.openssl_is_boringssl) { + require('../common/boringssl').testPskTls13Unsupported(); + return; +} + const { opensslCli } = require('../common/crypto'); if (!opensslCli) { From 187b4d3fcd634a7383681b84a3a96ff794693abd Mon Sep 17 00:00:00 2001 From: James M Snell Date: Thu, 7 May 2026 10:21:10 -0700 Subject: [PATCH 101/168] quic: remove unused binding variable in session.cc Signed-off-by: James M Snell PR-URL: https://github.com/nodejs/node/pull/63177 Reviewed-By: Tim Perry Reviewed-By: Anna Henningsen --- src/quic/session.cc | 1 - 1 file changed, 1 deletion(-) diff --git a/src/quic/session.cc b/src/quic/session.cc index b53bc291c20163..4af903e0c2a0af 100644 --- a/src/quic/session.cc +++ b/src/quic/session.cc @@ -1660,7 +1660,6 @@ Session::Session(Endpoint* endpoint, MakeWeak(); Debug(this, "Session created."); - auto& binding = BindingData::Get(env()); JS_DEFINE_READONLY_PROPERTY( env(), object, env()->stats_string(), impl_->stats_.GetArrayBuffer()); From facd71e6856b933894301df00291d24f68e8bfa1 Mon Sep 17 00:00:00 2001 From: James M Snell Date: Thu, 7 May 2026 10:24:31 -0700 Subject: [PATCH 102/168] quic: remove unused env_ variable in session_manager.h/cc Signed-off-by: James M Snell PR-URL: https://github.com/nodejs/node/pull/63177 Reviewed-By: Tim Perry Reviewed-By: Anna Henningsen --- src/quic/bindingdata.cc | 2 +- src/quic/session_manager.cc | 4 ---- src/quic/session_manager.h | 6 ++---- 3 files changed, 3 insertions(+), 9 deletions(-) diff --git a/src/quic/bindingdata.cc b/src/quic/bindingdata.cc index 647808d5a1e6bf..4a3b3dba11f196 100644 --- a/src/quic/bindingdata.cc +++ b/src/quic/bindingdata.cc @@ -225,7 +225,7 @@ BindingData::BindingData(Realm* realm, Local object) SessionManager& BindingData::session_manager() { if (!session_manager_) { - session_manager_ = std::make_unique(env()); + session_manager_ = std::make_unique(); } return *session_manager_; } diff --git a/src/quic/session_manager.cc b/src/quic/session_manager.cc index 4345e726576e69..20f92bb74bb944 100644 --- a/src/quic/session_manager.cc +++ b/src/quic/session_manager.cc @@ -10,10 +10,6 @@ namespace node::quic { -SessionManager::SessionManager(Environment* env) : env_(env) {} - -SessionManager::~SessionManager() = default; - BaseObjectPtr SessionManager::FindSession(const CID& cid) { // Direct SCID match. auto it = sessions_.find(cid); diff --git a/src/quic/session_manager.h b/src/quic/session_manager.h index 760dc7e95415e9..0dfa47b41dd378 100644 --- a/src/quic/session_manager.h +++ b/src/quic/session_manager.h @@ -24,8 +24,8 @@ class Session; // It is not exposed to JavaScript. class SessionManager final { public: - explicit SessionManager(Environment* env); - ~SessionManager(); + explicit SessionManager() = default; + ~SessionManager() = default; // Session routing. The sessions_ map holds BaseObjectPtr (owning // references). SessionManager is the single authority for session ownership. @@ -78,8 +78,6 @@ class SessionManager final { bool is_empty() const; private: - Environment* env_; - // The sessions_ map holds strong owning references keyed by locally- // generated SCIDs. This is the single source of truth for session // ownership. From e15f90559bc62b1e9a8296f1fc8654f5be261baa Mon Sep 17 00:00:00 2001 From: MJSHANG Date: Sun, 10 May 2026 00:38:57 -0700 Subject: [PATCH 103/168] doc: clarify SEA platform support excludes darwin-x64 The Platform support section of the single-executable-applications doc listed `macOS` without qualifying which architecture is supported. SEA on x64 macOS is not supported and is skipped in CI; only arm64 macOS is exercised. Refs: https://github.com/nodejs/node/issues/62893 Signed-off-by: mokashang <64570909+mokashang@users.noreply.github.com> PR-URL: https://github.com/nodejs/node/pull/63181 Reviewed-By: Joyee Cheung Reviewed-By: Chemi Atlow --- doc/api/single-executable-applications.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/doc/api/single-executable-applications.md b/doc/api/single-executable-applications.md index c63b8c8f57c0c3..7480a87d43a556 100644 --- a/doc/api/single-executable-applications.md +++ b/doc/api/single-executable-applications.md @@ -630,7 +630,8 @@ Single-executable support is tested regularly on CI only on the following platforms: * Windows -* macOS +* macOS (arm64 only; x64 is not currently supported and is skipped in the + tests) * Linux (all distributions [supported by Node.js][] except Alpine and all architectures [supported by Node.js][] except s390x) From ccab9ac5062a6fec2cc484506fd9097b647216cb Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Sun, 10 May 2026 16:16:15 +0200 Subject: [PATCH 104/168] doc: fix inconsistencies in CJS code snippets MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/63199 Reviewed-By: Jacob Smith Reviewed-By: Luigi Pinca Reviewed-By: Chemi Atlow Reviewed-By: Ulises Gascón --- doc/api/child_process.md | 5 -- doc/api/cluster.md | 3 -- doc/api/perf_hooks.md | 6 --- doc/api/process.md | 53 +------------------ doc/api/sqlite.md | 2 - doc/api/test.md | 1 - doc/api/tracing.md | 2 - doc/api/v8.md | 3 -- doc/api/wasi.md | 1 - doc/api/worker_threads.md | 51 ------------------ doc/api/zlib.md | 2 - doc/contributing/adding-v8-fast-api.md | 1 - .../writing-and-running-benchmarks.md | 3 -- doc/contributing/writing-tests.md | 6 --- doc/eslint.config_partial.mjs | 9 ++++ 15 files changed, 11 insertions(+), 137 deletions(-) diff --git a/doc/api/child_process.md b/doc/api/child_process.md index 2aeb253337f2df..e90759b16d3fa8 100644 --- a/doc/api/child_process.md +++ b/doc/api/child_process.md @@ -591,7 +591,6 @@ the error passed to the callback will be an `AbortError`: ```cjs const { fork } = require('node:child_process'); -const process = require('node:process'); if (process.argv[2] === 'child') { setTimeout(() => { @@ -933,7 +932,6 @@ Example of a long-running process, by detaching and also ignoring its parent ```cjs const { spawn } = require('node:child_process'); -const process = require('node:process'); const subprocess = spawn(process.argv[0], ['child_program.js'], { detached: true, @@ -1077,7 +1075,6 @@ pipes between the parent and child. The value is one of the following: ```cjs const { spawn } = require('node:child_process'); -const process = require('node:process'); // Child will use parent's stdios. spawn('prg', [], { stdio: 'inherit' }); @@ -1833,7 +1830,6 @@ process to wait for the child process to exit before exiting itself. ```cjs const { spawn } = require('node:child_process'); -const process = require('node:process'); const subprocess = spawn(process.argv[0], ['child_program.js'], { detached: true, @@ -2289,7 +2285,6 @@ the child and the parent processes. ```cjs const { spawn } = require('node:child_process'); -const process = require('node:process'); const subprocess = spawn(process.argv[0], ['child_program.js'], { detached: true, diff --git a/doc/api/cluster.md b/doc/api/cluster.md index fa9942f4668bdf..936a535977c5cb 100644 --- a/doc/api/cluster.md +++ b/doc/api/cluster.md @@ -49,7 +49,6 @@ if (cluster.isPrimary) { const cluster = require('node:cluster'); const http = require('node:http'); const numCPUs = require('node:os').availableParallelism(); -const process = require('node:process'); if (cluster.isPrimary) { console.log(`Primary ${process.pid} is running`); @@ -318,7 +317,6 @@ if (cluster.isPrimary) { const cluster = require('node:cluster'); const http = require('node:http'); const numCPUs = require('node:os').availableParallelism(); -const process = require('node:process'); if (cluster.isPrimary) { @@ -541,7 +539,6 @@ if (cluster.isPrimary) { const cluster = require('node:cluster'); const http = require('node:http'); const numCPUs = require('node:os').availableParallelism(); -const process = require('node:process'); if (cluster.isPrimary) { console.log(`Primary ${process.pid} is running`); diff --git a/doc/api/perf_hooks.md b/doc/api/perf_hooks.md index bd38befcffbedc..e6fac67f64b026 100644 --- a/doc/api/perf_hooks.md +++ b/doc/api/perf_hooks.md @@ -1682,7 +1682,6 @@ setImmediate(() => { ``` ```cjs -'use strict'; const { eventLoopUtilization } = require('node:perf_hooks'); const { spawnSync } = require('node:child_process'); @@ -2132,7 +2131,6 @@ setTimeout(() => {}, 1000); ``` ```cjs -'use strict'; const async_hooks = require('node:async_hooks'); const { performance, @@ -2202,7 +2200,6 @@ await timedImport('some-module'); ```cjs -'use strict'; const { performance, PerformanceObserver, @@ -2259,7 +2256,6 @@ createServer((req, res) => { ``` ```cjs -'use strict'; const { PerformanceObserver } = require('node:perf_hooks'); const http = require('node:http'); @@ -2301,7 +2297,6 @@ createServer((socket) => { ``` ```cjs -'use strict'; const { PerformanceObserver } = require('node:perf_hooks'); const net = require('node:net'); const obs = new PerformanceObserver((items) => { @@ -2335,7 +2330,6 @@ promises.resolve('localhost'); ``` ```cjs -'use strict'; const { PerformanceObserver } = require('node:perf_hooks'); const dns = require('node:dns'); const obs = new PerformanceObserver((items) => { diff --git a/doc/api/process.md b/doc/api/process.md index d8d022799a7016..c5bf5a6b2e3455 100644 --- a/doc/api/process.md +++ b/doc/api/process.md @@ -13,6 +13,8 @@ Node.js process. import process from 'node:process'; ``` + + ```cjs const process = require('node:process'); ``` @@ -62,8 +64,6 @@ console.log('This message is displayed first.'); ``` ```cjs -const process = require('node:process'); - process.on('beforeExit', (code) => { console.log('Process beforeExit event with code: ', code); }); @@ -120,8 +120,6 @@ process.on('exit', (code) => { ``` ```cjs -const process = require('node:process'); - process.on('exit', (code) => { console.log(`About to exit with code: ${code}`); }); @@ -143,8 +141,6 @@ process.on('exit', (code) => { ``` ```cjs -const process = require('node:process'); - process.on('exit', (code) => { setTimeout(() => { console.log('This will not run'); @@ -221,8 +217,6 @@ process.on('rejectionHandled', (promise) => { ``` ```cjs -const process = require('node:process'); - const unhandledRejections = new Map(); process.on('unhandledRejection', (reason, promise) => { unhandledRejections.set(promise, reason); @@ -305,7 +299,6 @@ console.log('This will not run.'); ``` ```cjs -const process = require('node:process'); const fs = require('node:fs'); process.on('uncaughtException', (err, origin) => { @@ -394,8 +387,6 @@ nonexistentFunc(); ``` ```cjs -const process = require('node:process'); - process.on('uncaughtExceptionMonitor', (err, origin) => { MyMonitoringTool.logSync(err, origin); }); @@ -445,8 +436,6 @@ somePromise.then((res) => { ``` ```cjs -const process = require('node:process'); - process.on('unhandledRejection', (reason, promise) => { console.log('Unhandled Rejection at:', promise, 'reason:', reason); // Application specific logging, throwing an error, or other logic here @@ -473,8 +462,6 @@ const resource = new SomeResource(); ``` ```cjs -const process = require('node:process'); - function SomeResource() { // Initially set the loaded status to a rejected promise this.loaded = Promise.reject(new Error('Resource not yet loaded!')); @@ -526,8 +513,6 @@ process.on('warning', (warning) => { ``` ```cjs -const process = require('node:process'); - process.on('warning', (warning) => { console.warn(warning.name); // Print the warning name console.warn(warning.message); // Print the warning message @@ -663,8 +648,6 @@ process.on('SIGTERM', handle); ``` ```cjs -const process = require('node:process'); - // Begin reading from stdin so the process does not exit. process.stdin.resume(); @@ -767,8 +750,6 @@ process.addUncaughtExceptionCaptureCallback((err) => { ``` ```cjs -const process = require('node:process'); - process.addUncaughtExceptionCaptureCallback((err) => { console.error('Caught exception:', err.message); return true; // Indicates exception was handled @@ -1218,8 +1199,6 @@ process.debugPort = 5858; ``` ```cjs -const process = require('node:process'); - process.debugPort = 5858; ``` @@ -1356,8 +1335,6 @@ process.on('warning', (warning) => { ``` ```cjs -const process = require('node:process'); - process.on('warning', (warning) => { console.warn(warning.name); // 'Warning' console.warn(warning.message); // 'Something happened!' @@ -1449,8 +1426,6 @@ process.on('warning', (warning) => { ``` ```cjs -const process = require('node:process'); - process.on('warning', (warning) => { console.warn(warning.name); console.warn(warning.message); @@ -1866,8 +1841,6 @@ if (someConditionNotMet()) { ``` ```cjs -const process = require('node:process'); - // How to properly set the exit code while letting // the process exit gracefully. if (someConditionNotMet()) { @@ -2409,8 +2382,6 @@ if (process.getegid) { ``` ```cjs -const process = require('node:process'); - if (process.getegid) { console.log(`Current gid: ${process.getegid()}`); } @@ -2439,8 +2410,6 @@ if (process.geteuid) { ``` ```cjs -const process = require('node:process'); - if (process.geteuid) { console.log(`Current uid: ${process.geteuid()}`); } @@ -2469,8 +2438,6 @@ if (process.getgid) { ``` ```cjs -const process = require('node:process'); - if (process.getgid) { console.log(`Current gid: ${process.getgid()}`); } @@ -2500,8 +2467,6 @@ if (process.getgroups) { ``` ```cjs -const process = require('node:process'); - if (process.getgroups) { console.log(process.getgroups()); // [ 16, 21, 297 ] } @@ -2530,8 +2495,6 @@ if (process.getuid) { ``` ```cjs -const process = require('node:process'); - if (process.getuid) { console.log(`Current uid: ${process.getuid()}`); } @@ -2736,8 +2699,6 @@ kill(process.pid, 'SIGHUP'); ``` ```cjs -const process = require('node:process'); - process.on('SIGHUP', () => { console.log('Got SIGHUP signal.'); }); @@ -3853,8 +3814,6 @@ if (process.getegid && process.setegid) { ``` ```cjs -const process = require('node:process'); - if (process.getegid && process.setegid) { console.log(`Current gid: ${process.getegid()}`); try { @@ -3898,8 +3857,6 @@ if (process.geteuid && process.seteuid) { ``` ```cjs -const process = require('node:process'); - if (process.geteuid && process.seteuid) { console.log(`Current uid: ${process.geteuid()}`); try { @@ -3943,8 +3900,6 @@ if (process.getgid && process.setgid) { ``` ```cjs -const process = require('node:process'); - if (process.getgid && process.setgid) { console.log(`Current gid: ${process.getgid()}`); try { @@ -3988,8 +3943,6 @@ if (process.getgroups && process.setgroups) { ``` ```cjs -const process = require('node:process'); - if (process.getgroups && process.setgroups) { try { process.setgroups([501]); @@ -4032,8 +3985,6 @@ if (process.getuid && process.setuid) { ``` ```cjs -const process = require('node:process'); - if (process.getuid && process.setuid) { console.log(`Current uid: ${process.getuid()}`); try { diff --git a/doc/api/sqlite.md b/doc/api/sqlite.md index 45e045f5f45e01..f4eb4e9c862961 100644 --- a/doc/api/sqlite.md +++ b/doc/api/sqlite.md @@ -61,7 +61,6 @@ console.log(query.all()); ``` ```cjs -'use strict'; const { DatabaseSync } = require('node:sqlite'); const database = new DatabaseSync(':memory:'); @@ -327,7 +326,6 @@ database.loadExtension('./base64.dylib', 'sqlite3_base64_init'); ``` ```cjs -'use strict'; const { DatabaseSync } = require('node:sqlite'); const database = new DatabaseSync(':memory:', { allowExtension: true }); diff --git a/doc/api/test.md b/doc/api/test.md index e961c13899d668..28b59d749b2f8f 100644 --- a/doc/api/test.md +++ b/doc/api/test.md @@ -851,7 +851,6 @@ test('spies on a function', () => { ``` ```cjs -'use strict'; const assert = require('node:assert'); const { mock, test } = require('node:test'); diff --git a/doc/api/tracing.md b/doc/api/tracing.md index 61c29dd1763393..577ec5c23cd800 100644 --- a/doc/api/tracing.md +++ b/doc/api/tracing.md @@ -326,8 +326,6 @@ collect(); ``` ```cjs -'use strict'; - const { Session } = require('node:inspector'); const session = new Session(); session.connect(); diff --git a/doc/api/v8.md b/doc/api/v8.md index f025b03ec495dc..828c0cc96504b5 100644 --- a/doc/api/v8.md +++ b/doc/api/v8.md @@ -107,7 +107,6 @@ stream.pipe(process.stdout); ```js // Print heap snapshot to the console const v8 = require('node:v8'); -const process = require('node:process'); const stream = v8.getHeapSnapshot(); stream.pipe(process.stdout); ``` @@ -1313,8 +1312,6 @@ objects during deserialization of the snapshot. For example, if the `entry.js` contains the following script: ```cjs -'use strict'; - const fs = require('node:fs'); const zlib = require('node:zlib'); const path = require('node:path'); diff --git a/doc/api/wasi.md b/doc/api/wasi.md index 075617796e8034..7303e0eeabbecc 100644 --- a/doc/api/wasi.md +++ b/doc/api/wasi.md @@ -38,7 +38,6 @@ wasi.start(instance); ``` ```cjs -'use strict'; const { readFile } = require('node:fs/promises'); const { WASI } = require('node:wasi'); const { argv, env } = require('node:process'); diff --git a/doc/api/worker_threads.md b/doc/api/worker_threads.md index ce47645977be35..7dabba8efe1d08 100644 --- a/doc/api/worker_threads.md +++ b/doc/api/worker_threads.md @@ -14,8 +14,6 @@ import worker_threads from 'node:worker_threads'; ``` ```cjs -'use strict'; - const worker_threads = require('node:worker_threads'); ``` @@ -57,8 +55,6 @@ export default function parseJSAsync(script) { ``` ```cjs -'use strict'; - const { Worker, isMainThread, @@ -141,8 +137,6 @@ if (isMainThread) { ``` ```cjs -'use strict'; - const { Worker, isMainThread, @@ -182,8 +176,6 @@ console.log(isInternalThread); // true ```cjs // loader.js -'use strict'; - const { isInternalThread } = require('node:worker_threads'); console.log(isInternalThread); // true ``` @@ -196,8 +188,6 @@ console.log(isInternalThread); // false ```cjs // main.js -'use strict'; - const { isInternalThread } = require('node:worker_threads'); console.log(isInternalThread); // false ``` @@ -225,8 +215,6 @@ if (isMainThread) { ``` ```cjs -'use strict'; - const { Worker, isMainThread } = require('node:worker_threads'); if (isMainThread) { @@ -288,8 +276,6 @@ console.log(typedArray2); ``` ```cjs -'use strict'; - const { MessageChannel, markAsUntransferable } = require('node:worker_threads'); const pooledBuffer = new ArrayBuffer(8); @@ -339,8 +325,6 @@ isMarkedAsUntransferable(pooledBuffer); // Returns true. ``` ```cjs -'use strict'; - const { markAsUntransferable, isMarkedAsUntransferable } = require('node:worker_threads'); const pooledBuffer = new ArrayBuffer(8); @@ -384,8 +368,6 @@ try { ``` ```cjs -'use strict'; - const { markAsUncloneable } = require('node:worker_threads'); const anyObject = { foo: 'bar' }; @@ -460,8 +442,6 @@ if (isMainThread) { ``` ```cjs -'use strict'; - const { Worker, isMainThread, parentPort } = require('node:worker_threads'); if (isMainThread) { @@ -553,9 +533,6 @@ channel.onmessage = channel.close; ``` ```cjs -'use strict'; - -const process = require('node:process'); const { postMessageToThread, threadId, @@ -621,8 +598,6 @@ console.log(receiveMessageOnPort(port2)); ``` ```cjs -'use strict'; - const { MessageChannel, receiveMessageOnPort } = require('node:worker_threads'); const { port1, port2 } = new MessageChannel(); port1.postMessage({ hello: 'world' }); @@ -678,8 +653,6 @@ new Worker('process.env.SET_IN_WORKER = "foo"', { eval: true, env: SHARE_ENV }) ``` ```cjs -'use strict'; - const { Worker, SHARE_ENV } = require('node:worker_threads'); new Worker('process.env.SET_IN_WORKER = "foo"', { eval: true, env: SHARE_ENV }) .once('exit', () => { @@ -759,8 +732,6 @@ if (isMainThread) { ``` ```cjs -'use strict'; - const { Worker, isMainThread, workerData } = require('node:worker_threads'); if (isMainThread) { @@ -828,8 +799,6 @@ import { locks } from 'node:worker_threads'; ``` ```cjs -'use strict'; - const { locks } = require('node:worker_threads'); ``` @@ -868,8 +837,6 @@ await locks.request('my_resource', async (lock) => { ``` ```cjs -'use strict'; - const { locks } = require('node:worker_threads'); locks.request('my_resource', async (lock) => { @@ -903,8 +870,6 @@ for (const pending of snapshot.pending) { ``` ```cjs -'use strict'; - const { locks } = require('node:worker_threads'); locks.query().then((snapshot) => { @@ -954,8 +919,6 @@ if (isMainThread) { ``` ```cjs -'use strict'; - const { isMainThread, BroadcastChannel, @@ -1064,8 +1027,6 @@ port2.postMessage({ foo: 'bar' }); ``` ```cjs -'use strict'; - const { MessageChannel } = require('node:worker_threads'); const { port1, port2 } = new MessageChannel(); @@ -1119,8 +1080,6 @@ port1.close(); ``` ```cjs -'use strict'; - const { MessageChannel } = require('node:worker_threads'); const { port1, port2 } = new MessageChannel(); @@ -1254,8 +1213,6 @@ port2.postMessage(circularData); ``` ```cjs -'use strict'; - const { MessageChannel } = require('node:worker_threads'); const { port1, port2 } = new MessageChannel(); @@ -1305,8 +1262,6 @@ port2.postMessage({ port: otherChannel.port1 }, [ otherChannel.port1 ]); ``` ```cjs -'use strict'; - const { MessageChannel } = require('node:worker_threads'); const { port1, port2 } = new MessageChannel(); @@ -1569,8 +1524,6 @@ if (isMainThread) { ``` ```cjs -'use strict'; - const assert = require('node:assert'); const { Worker, MessageChannel, MessagePort, isMainThread, parentPort, @@ -1893,8 +1846,6 @@ if (isMainThread) { ``` ```cjs -'use strict'; - const { Worker, isMainThread, parentPort } = require('node:worker_threads'); if (isMainThread) { @@ -2231,8 +2182,6 @@ if (isMainThread) { ``` ```cjs -'use strict'; - const { Worker, isMainThread, diff --git a/doc/api/zlib.md b/doc/api/zlib.md index ce296a07ac6c05..2faa048914624c 100644 --- a/doc/api/zlib.md +++ b/doc/api/zlib.md @@ -51,7 +51,6 @@ const { createReadStream, createWriteStream, } = require('node:fs'); -const process = require('node:process'); const { createGzip } = require('node:zlib'); const { pipeline } = require('node:stream'); @@ -92,7 +91,6 @@ const { createReadStream, createWriteStream, } = require('node:fs'); -const process = require('node:process'); const { createGzip } = require('node:zlib'); const { pipeline } = require('node:stream/promises'); diff --git a/doc/contributing/adding-v8-fast-api.md b/doc/contributing/adding-v8-fast-api.md index 2299d105bc5817..fa7dc47c480653 100644 --- a/doc/contributing/adding-v8-fast-api.md +++ b/doc/contributing/adding-v8-fast-api.md @@ -501,7 +501,6 @@ force V8 optimizations and check the counters. ```js // Flags: --expose-internals --no-warnings --allow-natives-syntax -'use strict'; const common = require('../common'); const { internalBinding } = require('internal/test/binding'); diff --git a/doc/contributing/writing-and-running-benchmarks.md b/doc/contributing/writing-and-running-benchmarks.md index ff108e1088f5ae..23132d9eb0f70e 100644 --- a/doc/contributing/writing-and-running-benchmarks.md +++ b/doc/contributing/writing-and-running-benchmarks.md @@ -646,7 +646,6 @@ outside the `main` function has side effects. In general, prefer putting the code inside the `main` function if it's more than just declaration. ```js -'use strict'; const common = require('../common.js'); const { Buffer } = require('node:buffer'); @@ -698,8 +697,6 @@ The `bench` object returned by `createBenchmark` implements benchmark HTTP servers. ```js -'use strict'; - const common = require('../common.js'); const bench = common.createBenchmark(main, { diff --git a/doc/contributing/writing-tests.md b/doc/contributing/writing-tests.md index eb4e91b491eb9a..6eba29bd8264c0 100644 --- a/doc/contributing/writing-tests.md +++ b/doc/contributing/writing-tests.md @@ -43,7 +43,6 @@ changes. Let's analyze this basic test from the Node.js test suite: ```js -'use strict'; // 1 const common = require('../common'); // 2 const fixtures = require('../common/fixtures'); // 3 @@ -71,7 +70,6 @@ server.listen(0, () => { // 14 ### **Lines 1-3** ```js -'use strict'; const common = require('../common'); const fixtures = require('../common/fixtures'); ``` @@ -184,7 +182,6 @@ avoid the use of extra variables and the corresponding assertions. Let's explain this with a real test from the test suite. ```js -'use strict'; require('../common'); const assert = require('node:assert'); const http = require('node:http'); @@ -218,7 +215,6 @@ const server = http.createServer((req, res) => { This test could be greatly simplified by using `common.mustCall` like this: ```js -'use strict'; const common = require('../common'); const http = require('node:http'); @@ -288,8 +284,6 @@ test followed by the flags. For example, to allow a test to require some of the A test that would require `internal/freelist` could start like this: ```js -'use strict'; - // Flags: --expose-internals require('../common'); diff --git a/doc/eslint.config_partial.mjs b/doc/eslint.config_partial.mjs index ce914fbad1e302..6348f6ab6247ed 100644 --- a/doc/eslint.config_partial.mjs +++ b/doc/eslint.config_partial.mjs @@ -21,6 +21,15 @@ export default [ selector: `CallExpression[callee.name="require"][arguments.0.type="Literal"]:matches(${builtin.map((name) => `[arguments.0.value="${name}"]`).join(',')}),ImportDeclaration:matches(${builtin.map((name) => `[source.value="${name}"]`).join(',')})`, message: 'Use `node:` prefix.', }, + { + selector: 'Program>ExpressionStatement:first-child[expression.value="use strict"]', + message: 'Do not include "use strict" statement', + }, + { + selector: 'VariableDeclarator[id.name="process"][init.callee.name="require"]' + + '[init.arguments.0.value="node:process"]', + message: 'Use global "process" in CJS snippets', + }, ], 'no-undef': 'off', 'no-unused-expressions': 'off', From 49aef0d3f5d10f7bde0b050c7fcb404271e2ebb4 Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Sun, 10 May 2026 17:06:35 +0200 Subject: [PATCH 105/168] doc: remove unnecessary ` + ```mjs import assert from 'node:assert/strict'; @@ -1720,7 +1720,7 @@ assert.ok(0); // assert.ok(0) ``` - + ```cjs const assert = require('node:assert/strict'); diff --git a/doc/api/console.md b/doc/api/console.md index f0669558abe385..804778bd5fa681 100644 --- a/doc/api/console.md +++ b/doc/api/console.md @@ -240,9 +240,7 @@ added: v8.3.0 Maintains an internal counter specific to `label` and outputs to `stdout` the number of times `console.count()` has been called with the given `label`. - - -```js +```console > console.count() default: 1 undefined @@ -274,9 +272,7 @@ added: v8.3.0 Resets the internal counter specific to `label`. - - -```js +```console > console.count('abc'); abc: 1 undefined diff --git a/doc/api/crypto.md b/doc/api/crypto.md index e8583803e768b1..91cb32a1b9816f 100644 --- a/doc/api/crypto.md +++ b/doc/api/crypto.md @@ -53,8 +53,6 @@ try { } ``` - - When using the lexical ESM `import` keyword, the error can only be caught if a handler for `process.on('uncaughtException')` is registered _before_ any attempt to load the module is made (using, for instance, diff --git a/doc/api/dns.md b/doc/api/dns.md index 5bb0f83b36729e..7ba830048e013d 100644 --- a/doc/api/dns.md +++ b/doc/api/dns.md @@ -205,14 +205,12 @@ Returns an array of IP address strings, formatted according to [RFC 5952][], that are currently configured for DNS resolution. A string will include a port section if a custom port is used. - - -```js +```json [ - '8.8.8.8', - '2001:4860:4860::8888', - '8.8.8.8:1053', - '[2001:4860:4860::8888]:1053', + "8.8.8.8", + "2001:4860:4860::8888", + "8.8.8.8:1053", + "[2001:4860:4860::8888]:1053", ] ``` @@ -559,8 +557,6 @@ will be present on the object: Here is an example of the `ret` object passed to the callback: - - ```js [ { type: 'A', address: '127.0.0.1', ttl: 299 }, { type: 'CNAME', value: 'example.com' }, @@ -574,7 +570,7 @@ Here is an example of the `ret` object passed to the callback: refresh: 900, retry: 900, expire: 1800, - minttl: 60 } ] + minttl: 60 } ]; ``` DNS server operators may choose not to respond to `ANY` @@ -678,17 +674,15 @@ function will contain an array of objects with the following properties: * `order` * `preference` - - ```js -{ +({ flags: 's', service: 'SIP+D2U', regexp: '', replacement: '_sip._udp.example.com', order: 30, - preference: 100 -} + preference: 100, +}); ``` ## `dns.resolveNs(hostname, callback)` @@ -763,18 +757,16 @@ be an object with the following properties: * `expire` * `minttl` - - ```js -{ +({ nsname: 'ns.example.com', hostmaster: 'root.example.com', serial: 2013101809, refresh: 10000, retry: 2400, expire: 604800, - minttl: 3600 -} + minttl: 3600, +}); ``` ## `dns.resolveSrv(hostname, callback)` @@ -803,15 +795,13 @@ be an array of objects with the following properties: * `port` * `name` - - ```js -{ +({ priority: 10, weight: 5, port: 21223, - name: 'service.example.com' -} + name: 'service.example.com', +}); ``` ## `dns.resolveTlsa(hostname, callback)` @@ -840,15 +830,13 @@ array of objects with these properties: * `match` * `data` - - ```js -{ +({ certUsage: 3, selector: 1, match: 1, - data: [ArrayBuffer] -} + data: [ArrayBuffer], +}); ``` ## `dns.resolveTxt(hostname, callback)` @@ -1081,14 +1069,12 @@ Returns an array of IP address strings, formatted according to [RFC 5952][], that are currently configured for DNS resolution. A string will include a port section if a custom port is used. - - -```js +```json [ - '8.8.8.8', - '2001:4860:4860::8888', - '8.8.8.8:1053', - '[2001:4860:4860::8888]:1053', + "8.8.8.8", + "2001:4860:4860::8888", + "8.8.8.8:1053", + "[2001:4860:4860::8888]:1053" ] ``` @@ -1329,8 +1315,6 @@ present on the object: Here is an example of the result object: - - ```js [ { type: 'A', address: '127.0.0.1', ttl: 299 }, { type: 'CNAME', value: 'example.com' }, @@ -1344,7 +1328,7 @@ Here is an example of the result object: refresh: 900, retry: 900, expire: 1800, - minttl: 60 } ] + minttl: 60 } ]; ``` ### `dnsPromises.resolveCaa(hostname)` @@ -1407,17 +1391,15 @@ of objects with the following properties: * `order` * `preference` - - ```js -{ +({ flags: 's', service: 'SIP+D2U', regexp: '', replacement: '_sip._udp.example.com', order: 30, - preference: 100 -} + preference: 100, +}); ``` ### `dnsPromises.resolveNs(hostname)` @@ -1465,18 +1447,16 @@ following properties: * `expire` * `minttl` - - ```js -{ +({ nsname: 'ns.example.com', hostmaster: 'root.example.com', serial: 2013101809, refresh: 10000, retry: 2400, expire: 604800, - minttl: 3600 -} + minttl: 3600, +}); ``` ### `dnsPromises.resolveSrv(hostname)` @@ -1496,15 +1476,13 @@ the following properties: * `port` * `name` - - ```js -{ +({ priority: 10, weight: 5, port: 21223, - name: 'service.example.com' -} + name: 'service.example.com', +}); ``` ### `dnsPromises.resolveTlsa(hostname)` @@ -1526,15 +1504,13 @@ with these properties: * `match` * `data` - - ```js -{ +({ certUsage: 3, selector: 1, match: 1, - data: [ArrayBuffer] -} + data: [ArrayBuffer], +}); ``` ### `dnsPromises.resolveTxt(hostname)` diff --git a/doc/api/esm.md b/doc/api/esm.md index f6ac6f457b8947..ca1f9e8049603c 100644 --- a/doc/api/esm.md +++ b/doc/api/esm.md @@ -569,8 +569,6 @@ console.log(cjs === cjsSugar); This Module Namespace Exotic Object can be directly observed either when using `import * as m from 'cjs'` or a dynamic import: - - ```js import * as m from 'cjs'; console.log(m); diff --git a/doc/api/http.md b/doc/api/http.md index 95674770153bf4..65ed90bca83b48 100644 --- a/doc/api/http.md +++ b/doc/api/http.md @@ -39,15 +39,13 @@ property, which is an array of `[key, value, key2, value2, ...]`. For example, the previous message header object might have a `rawHeaders` list like the following: - - -```js -[ 'ConTent-Length', '123456', - 'content-LENGTH', '123', - 'content-type', 'text/plain', - 'CONNECTION', 'keep-alive', - 'Host', 'example.com', - 'accepT', '*/*' ] +```json +[ "ConTent-Length", "123456", + "content-LENGTH", "123", + "content-type", "text/plain", + "CONNECTION", "keep-alive", + "Host", "example.com", + "accepT", "*/*" ] ``` ## Class: `http.Agent` diff --git a/doc/api/http2.md b/doc/api/http2.md index 89579aa9069af6..dcba89fcedec6d 100644 --- a/doc/api/http2.md +++ b/doc/api/http2.md @@ -4303,10 +4303,8 @@ Accept: text/plain Then `request.url` will be: - - -```js -'/status?name=ryan' +```json +"/status?name=ryan" ``` To parse the url into its parts, `new URL()` can be used: diff --git a/doc/api/module.md b/doc/api/module.md index 79d6c816cae23d..7f47ab0b55e109 100644 --- a/doc/api/module.md +++ b/doc/api/module.md @@ -1128,8 +1128,6 @@ export async function load(url, context, nextLoad) { Unlike synchronous hooks, the asynchronous hooks would not run for these modules loaded in the file that calls `register()`: - - ```mjs // register-hooks.js import { register, createRequire } from 'node:module'; @@ -1137,12 +1135,10 @@ register('./hooks.mjs', import.meta.url); // Asynchronous hooks does not affect modules loaded via custom require() // functions created by module.createRequire(). -const userRequire = createRequire(__filename); +const userRequire = createRequire(import.meta.filename); userRequire('./my-app-2.cjs'); // Hooks won't affect this ``` - - ```cjs // register-hooks.js const { register, createRequire } = require('node:module'); diff --git a/doc/api/modules.md b/doc/api/modules.md index 38cfcf2a4b94ef..5f920ec324bc21 100644 --- a/doc/api/modules.md +++ b/doc/api/modules.md @@ -262,8 +262,6 @@ the default export in the `.default` property, similar to the results returned b To customize what should be returned by `require(esm)` directly, the ES Module can export the desired value using the string name `"module.exports"`. - - ```mjs // point.mjs export default class Point { @@ -273,7 +271,7 @@ export default class Point { // `distance` is lost to CommonJS consumers of this module, unless it's // added to `Point` as a static property. export function distance(a, b) { return Math.sqrt((b.x - a.x) ** 2 + (b.y - a.y) ** 2); } -export { Point as 'module.exports' } +export { Point as 'module.exports' }; ``` @@ -293,8 +291,6 @@ named exports, the module can make sure that the default export is an object wit named exports attached to it as properties. For example with the example above, `distance` can be attached to the default export, the `Point` class, as a static method. - - ```mjs export function distance(a, b) { return Math.sqrt((b.x - a.x) ** 2 + (b.y - a.y) ** 2); } @@ -303,7 +299,7 @@ export default class Point { static distance = distance; } -export { Point as 'module.exports' } +export { Point as 'module.exports' }; ``` diff --git a/doc/api/os.md b/doc/api/os.md index 9f2aa0390cc56a..6b3bb1ddfa554a 100644 --- a/doc/api/os.md +++ b/doc/api/os.md @@ -94,8 +94,6 @@ The properties included on each object include: * `idle` {number} The number of milliseconds the CPU has spent in idle mode. * `irq` {number} The number of milliseconds the CPU has spent in irq mode. - - ```js [ { @@ -142,7 +140,7 @@ The properties included on each object include: irq: 20, }, }, -] +]; ``` `nice` values are POSIX-only. On Windows, the `nice` values of all processors @@ -298,46 +296,44 @@ The properties available on the assigned network address object include: in CIDR notation. If the `netmask` is invalid, this property is set to `null`. - - -```js +```json { - lo: [ + "lo:": [ { - address: '127.0.0.1', - netmask: '255.0.0.0', - family: 'IPv4', - mac: '00:00:00:00:00:00', - internal: true, - cidr: '127.0.0.1/8' + "address:": "127.0.0.1", + "netmask:": "255.0.0.0", + "family:": "IPv4", + "mac:": "00:00:00:00:00:00", + "internal:": true, + "cidr:": "127.0.0.1/8" }, { - address: '::1', - netmask: 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff', - family: 'IPv6', - mac: '00:00:00:00:00:00', - scopeid: 0, - internal: true, - cidr: '::1/128' + "address:": "::1", + "netmask:": "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", + "family:": "IPv6", + "mac:": "00:00:00:00:00:00", + "scopeid:": 0, + "internal:": true, + "cidr:": "::1/128" } ], - eth0: [ + "eth0:": [ { - address: '192.168.1.108', - netmask: '255.255.255.0', - family: 'IPv4', - mac: '01:02:03:0a:0b:0c', - internal: false, - cidr: '192.168.1.108/24' + "address:": "192.168.1.108", + "netmask:": "255.255.255.0", + "family:": "IPv4", + "mac:": "01:02:03:0a:0b:0c", + "internal:": false, + "cidr:": "192.168.1.108/24" }, { - address: 'fe80::a00:27ff:fe4e:66a1', - netmask: 'ffff:ffff:ffff:ffff::', - family: 'IPv6', - mac: '01:02:03:0a:0b:0c', - scopeid: 1, - internal: false, - cidr: 'fe80::a00:27ff:fe4e:66a1/64' + "address:": "fe80::a00:27ff:fe4e:66a1", + "netmask:": "ffff:ffff:ffff:ffff::", + "family:": "IPv6", + "mac:": "01:02:03:0a:0b:0c", + "scopeid:": 1, + "internal:": false, + "cidr:": "fe80::a00:27ff:fe4e:66a1/64" } ] } diff --git a/doc/api/perf_hooks.md b/doc/api/perf_hooks.md index e6fac67f64b026..61634056679062 100644 --- a/doc/api/perf_hooks.md +++ b/doc/api/perf_hooks.md @@ -2173,8 +2173,6 @@ setTimeout(() => {}, 1000); The following example measures the duration of `require()` operations to load dependencies: - - ```mjs import { performance, PerformanceObserver } from 'node:perf_hooks'; diff --git a/doc/api/process.md b/doc/api/process.md index c5bf5a6b2e3455..28b60d93836429 100644 --- a/doc/api/process.md +++ b/doc/api/process.md @@ -1038,30 +1038,28 @@ when running the `./configure` script. An example of the possible output looks like: - - -```js +```json { - target_defaults: - { cflags: [], - default_configuration: 'Release', - defines: [], - include_dirs: [], - libraries: [] }, - variables: + "target_defaults": + { "cflags": [], + "default_configuration": "Release", + "defines": [], + "include_dirs": [], + "libraries": [] }, + "variables": { - host_arch: 'x64', - napi_build_version: 5, - node_install_npm: 'true', - node_prefix: '', - node_shared_cares: 'false', - node_shared_http_parser: 'false', - node_shared_libuv: 'false', - node_shared_zlib: 'false', - node_use_openssl: 'true', - node_shared_openssl: 'false', - target_arch: 'x64', - v8_use_snapshot: 1 + "host_arch": "x64", + "napi_build_version": 5, + "node_install_npm": "true", + "node_prefix": "", + "node_shared_cares": "false", + "node_shared_http_parser": "false", + "node_shared_libuv": "false", + "node_shared_zlib": "false", + "node_use_openssl": "true", + "node_shared_openssl": "false", + "target_arch": "x64", + "v8_use_snapshot": 1 } } ``` @@ -1537,20 +1535,18 @@ See environ(7). An example of this object looks like: - - -```js +```json { - TERM: 'xterm-256color', - SHELL: '/usr/local/bin/bash', - USER: 'maciej', - PATH: '~/.bin/:/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin', - PWD: '/Users/maciej', - EDITOR: 'vim', - SHLVL: '1', - HOME: '/Users/maciej', - LOGNAME: 'maciej', - _: '/usr/local/bin/node' + "TERM": "xterm-256color", + "SHELL": "/usr/local/bin/bash", + "USER": "maciej", + "PATH": "~/.bin/:/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin", + "PWD": "/Users/maciej", + "EDITOR": "vim", + "SHLVL": "1", + "HOME": "/Users/maciej", + "LOGNAME": "maciej", + "_": "/usr/local/bin/node" } ``` @@ -1679,10 +1675,8 @@ Results in `process.execArgv`: And `process.argv`: - - -```js -['/usr/local/bin/node', 'script.js', '--version'] +```json +["/usr/local/bin/node", "script.js", "--version"] ``` Refer to [`Worker` constructor][] for the detailed behavior of worker @@ -1699,10 +1693,8 @@ added: v0.1.100 The `process.execPath` property returns the absolute pathname of the executable that started the Node.js process. Symbolic links, if any, are resolved. - - -```js -'/usr/local/bin/node' +```json +"/usr/local/bin/node" ``` ## `process.execve(file[, args[, env]])` @@ -3320,15 +3312,13 @@ tarball. * `'Hydrogen'` for the 18.x LTS line beginning with 18.12.0. For other LTS Release code names, see [Node.js Changelog Archive](https://github.com/nodejs/node/blob/HEAD/doc/changelogs/CHANGELOG_ARCHIVE.md) - - -```js +```json { - name: 'node', - lts: 'Hydrogen', - sourceUrl: 'https://nodejs.org/download/release/v18.12.0/node-v18.12.0.tar.gz', - headersUrl: 'https://nodejs.org/download/release/v18.12.0/node-v18.12.0-headers.tar.gz', - libUrl: 'https://nodejs.org/download/release/v18.12.0/win-x64/node.lib' + "name": "node", + "lts": "Hydrogen", + "sourceUrl": "https://nodejs.org/download/release/v18.12.0/node-v18.12.0.tar.gz", + "headersUrl": "https://nodejs.org/download/release/v18.12.0/node-v18.12.0-headers.tar.gz", + "libUrl": "https://nodejs.org/download/release/v18.12.0/win-x64/node.lib" } ``` diff --git a/doc/api/stream.md b/doc/api/stream.md index 1c661ce44b383e..5e30121673b7a1 100644 --- a/doc/api/stream.md +++ b/doc/api/stream.md @@ -3658,8 +3658,6 @@ of the four basic stream classes (`stream.Writable`, `stream.Readable`, `stream.Duplex`, or `stream.Transform`), making sure they call the appropriate parent class constructor: - - ```js const { Writable } = require('node:stream'); diff --git a/doc/api/v8.md b/doc/api/v8.md index 828c0cc96504b5..fee6b067596fde 100644 --- a/doc/api/v8.md +++ b/doc/api/v8.md @@ -54,14 +54,12 @@ following properties: * `external_script_source_size` {number} * `cpu_profiler_metadata_size` {number} - - -```js +```json { - code_and_metadata_size: 212208, - bytecode_and_metadata_size: 161368, - external_script_source_size: 1410794, - cpu_profiler_metadata_size: 0, + "code_and_metadata_size": 212208, + "bytecode_and_metadata_size": 161368, + "external_script_source_size": 1410794, + "cpu_profiler_metadata_size": 0 } ``` @@ -266,24 +264,22 @@ buffers and external strings. `total_allocated_bytes` The value of total allocated bytes since the Isolate creation - - -```js +```json { - total_heap_size: 7326976, - total_heap_size_executable: 4194304, - total_physical_size: 7326976, - total_available_size: 1152656, - used_heap_size: 3476208, - heap_size_limit: 1535115264, - malloced_memory: 16384, - peak_malloced_memory: 1127496, - does_zap_garbage: 0, - number_of_native_contexts: 1, - number_of_detached_contexts: 0, - total_global_handles_size: 8192, - used_global_handles_size: 3296, - external_memory: 318824 + "total_heap_size": 7326976, + "total_heap_size_executable": 4194304, + "total_physical_size": 7326976, + "total_available_size": 1152656, + "used_heap_size": 3476208, + "heap_size_limit": 1535115264, + "malloced_memory": 16384, + "peak_malloced_memory": 1127496, + "does_zap_garbage": 0, + "number_of_native_contexts": 1, + "number_of_detached_contexts": 0, + "total_global_handles_size": 8192, + "used_global_handles_size": 3296, + "external_memory": 318824 } ``` diff --git a/doc/api/vm.md b/doc/api/vm.md index 1b7394928065db..4e6cca38002111 100644 --- a/doc/api/vm.md +++ b/doc/api/vm.md @@ -1103,8 +1103,6 @@ import foo from 'foo'; import source Foo from 'foo'; ``` - - The `modules` array must contain two references to the same instance, because the two module requests are identical but in two phases. @@ -1146,8 +1144,6 @@ import withAttrs from '../with-attrs.ts' with { arbitraryAttr: 'attr-val' }; import source Module from 'wasm-mod.wasm'; ``` - - The value of the `sourceTextModule.moduleRequests` will be: ```js diff --git a/doc/api/worker_threads.md b/doc/api/worker_threads.md index 7dabba8efe1d08..8f4b152bc26a68 100644 --- a/doc/api/worker_threads.md +++ b/doc/api/worker_threads.md @@ -1347,8 +1347,6 @@ not preserved. In particular, {Buffer} objects will be read as plain {Uint8Array}s on the receiving side, and instances of JavaScript classes will be cloned as plain JavaScript objects. - - ```js const b = Symbol('b'); @@ -1359,7 +1357,7 @@ class Foo { this.c = 3; } - get d() { return 4; } + get d() { return this.#a + 3; } } const { port1, port2 } = new MessageChannel(); diff --git a/doc/api/zlib.md b/doc/api/zlib.md index 2faa048914624c..e0516e923cb502 100644 --- a/doc/api/zlib.md +++ b/doc/api/zlib.md @@ -452,10 +452,8 @@ From `zlib/zconf.h`, modified for Node.js usage: The memory requirements for deflate are (in bytes): - - ```js -(1 << (windowBits + 2)) + (1 << (memLevel + 9)) +(1 << (windowBits + 2)) + (1 << (memLevel + 9)); ``` That is: 128K for `windowBits` = 15 + 128K for `memLevel` = 8 diff --git a/doc/contributing/erm-guidelines.md b/doc/contributing/erm-guidelines.md index b35e7d1bb2d98d..d57acbb8bba282 100644 --- a/doc/contributing/erm-guidelines.md +++ b/doc/contributing/erm-guidelines.md @@ -280,25 +280,25 @@ The `Symbol.dispose` method should return `undefined` and the `Symbol.asyncDispose` method should return a `Promise` that resolves to `undefined`. - + ```js -[Symbol.dispose]() { - return void this.dispose(); - // or - this.dispose(); - // or - return; - // or - // no return -} +class MyIterable { + [Symbol.dispose]() { + this.dispose(); + // or + return; + // or + // no return + } + + async [Symbol.asyncDispose]() { + await this.dispose(); + // or -async [Symbol.asyncDispose]() { - await this.dispose(); - // or - return; - // or - // no return + // or + // no return + } } ``` @@ -312,21 +312,21 @@ directly. For example: - + ```js // Do something like this: -function dispose() { ... } +function dispose() { /* ... */ } return { dispose, - [Symbol.dispose]() { this.dispose(); } + [Symbol.dispose]() { this.dispose(); }, }; // Rather than this: -function dispose() { ... } +function dispose() { /* ... */ } return { dispose, - [Symbol.dispose]: dispose + [Symbol.dispose]: dispose, }; ``` diff --git a/doc/contributing/maintaining/maintaining-icu.md b/doc/contributing/maintaining/maintaining-icu.md index 00992258ae2611..e83aa8a5b0c407 100644 --- a/doc/contributing/maintaining/maintaining-icu.md +++ b/doc/contributing/maintaining/maintaining-icu.md @@ -132,8 +132,6 @@ make test-ci Also running - - ```js new Intl.DateTimeFormat('es', { month: 'long' }).format(new Date(9E8)); ``` @@ -159,8 +157,6 @@ make * Test this newly default-generated Node.js - - ```js process.versions.icu; new Intl.DateTimeFormat('es', { month: 'long' }).format(new Date(9E8)); diff --git a/doc/contributing/using-internal-errors.md b/doc/contributing/using-internal-errors.md index b24c96d9ccd243..db63abfe28a41f 100644 --- a/doc/contributing/using-internal-errors.md +++ b/doc/contributing/using-internal-errors.md @@ -65,17 +65,15 @@ It is possible to create multiple derived classes by providing additional arguments. The other ones will be exposed as properties of the main class: - - ```js E('EXAMPLE_KEY', 'Error message', TypeError, RangeError); // In another module +const assert = require('node:assert'); const { EXAMPLE_KEY } = require('internal/errors').codes; -// TypeError -throw new EXAMPLE_KEY(); -// RangeError -throw new EXAMPLE_KEY.RangeError(); + +assert.throws(() => { throw new EXAMPLE_KEY(); }, { name: 'TypeError' }); +assert.throws(() => { throw new EXAMPLE_KEY.RangeError(); }, { name: 'RangeError' }); ``` ## Documenting new errors From 130398ab0554f8ba4cb1eea3ac9098d844335b2d Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Mon, 11 May 2026 06:47:51 +0200 Subject: [PATCH 106/168] test: reduce flakiness of `different-registry-per-thread` MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit There was an assumption that the `WeakRef` would be kept alive but it seems to not always be true on Windows. This commit makes sure it's kept alive. Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/63209 Fixes: https://github.com/nodejs/node/issues/63056 Reviewed-By: Moshe Atlow Reviewed-By: Paolo Insogna Reviewed-By: Vinícius Lourenço Claro Cardoso Reviewed-By: Rafael Gonzaga Reviewed-By: Filip Skokan Reviewed-By: Jordan Harband --- .../process/different-registry-per-thread.mjs | 15 +++++++++++++-- test/parallel/test-memory-usage.js | 6 ++++-- 2 files changed, 17 insertions(+), 4 deletions(-) diff --git a/test/fixtures/process/different-registry-per-thread.mjs b/test/fixtures/process/different-registry-per-thread.mjs index 6718ae72b5fd86..018fb42529f6f0 100644 --- a/test/fixtures/process/different-registry-per-thread.mjs +++ b/test/fixtures/process/different-registry-per-thread.mjs @@ -1,15 +1,26 @@ import { isMainThread, Worker } from 'node:worker_threads'; +const registeredRefs = []; + +const ref = { foo: 'foo' }; +registeredRefs.push(ref); + if (isMainThread) { - process.finalization.register({ foo: 'foo' }, () => { + process.finalization.register(ref, () => { process.stdout.write('shutdown on main thread\n'); }); const worker = new Worker(import.meta.filename); + worker.on('error', (err) => { + // Referencing `registeredRefs` here to avoid `ref` being GCed before the worker exits. + console.log(registeredRefs); + throw err; + }); + worker.postMessage('ping'); } else { - process.finalization.register({ foo: 'bar' }, () => { + process.finalization.register(ref, () => { process.stdout.write('shutdown on worker\n'); }); } diff --git a/test/parallel/test-memory-usage.js b/test/parallel/test-memory-usage.js index 8e5ea4de5bf587..9f1160f19ca6e8 100644 --- a/test/parallel/test-memory-usage.js +++ b/test/parallel/test-memory-usage.js @@ -44,6 +44,8 @@ if (r.arrayBuffers > 0) { const after = process.memoryUsage(); assert.ok(after.external - r.external >= size, `${after.external} - ${r.external} >= ${size}`); - assert.strictEqual(after.arrayBuffers - r.arrayBuffers, size, - `${after.arrayBuffers} - ${r.arrayBuffers} === ${size}`); + // `arrayBuffers` is process-wide, so unrelated backing stores may be freed + // between the two snapshots. Check that the live ArrayBuffer is included. + assert.ok(after.arrayBuffers >= size, + `${after.arrayBuffers} >= ${size}`); } From 6f81dc3680433f3c4a891936b1d3b4b697d81436 Mon Sep 17 00:00:00 2001 From: Matteo Collina Date: Mon, 11 May 2026 09:36:07 +0200 Subject: [PATCH 107/168] meta: ignore AI assistants files MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Ignore CLAUDE.md and AGENTS.md in .gitignore, and exclude them from markdown and ESLint linting. Signed-off-by: Matteo Collina PR-URL: https://github.com/nodejs/node/pull/62612 Reviewed-By: James M Snell Reviewed-By: Moshe Atlow Reviewed-By: Marco Ippolito Reviewed-By: Ulises Gascón Reviewed-By: Luigi Pinca Reviewed-By: Daijiro Wachi Reviewed-By: Paolo Insogna Reviewed-By: Trivikram Kamat --- .gitignore | 4 ++++ Makefile | 2 +- eslint.config.mjs | 1 + 3 files changed, 6 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index d283bce868da6c..0b8f1a405bda3a 100644 --- a/.gitignore +++ b/.gitignore @@ -160,6 +160,10 @@ cmake_install.cmake install_manifest.txt *.cbp +# === Rules for AI assistants === +CLAUDE.md +AGENTS.md + # === Global Rules === # Keep last to avoid being excluded *.pyc diff --git a/Makefile b/Makefile index 9c9aa320963c8e..1f35c64eb73626 100644 --- a/Makefile +++ b/Makefile @@ -1448,7 +1448,7 @@ else LINT_MD_NEWER = -newer tools/.mdlintstamp endif -LINT_MD_TARGETS = doc src lib benchmark test tools/doc tools/icu $(wildcard *.md) +LINT_MD_TARGETS = doc src lib benchmark test tools/doc tools/icu $(filter-out CLAUDE.md AGENTS.md,$(wildcard *.md)) LINT_MD_FILES = $(shell $(FIND) $(LINT_MD_TARGETS) -type f \ ! -path '*node_modules*' ! -path 'test/fixtures/*' -name '*.md' \ $(LINT_MD_NEWER)) diff --git a/eslint.config.mjs b/eslint.config.mjs index 74dd82aa1ec7cb..152c530825e273 100644 --- a/eslint.config.mjs +++ b/eslint.config.mjs @@ -395,6 +395,7 @@ export default [ // #region markdown config { files: ['**/*.md'], + ignores: ['CLAUDE.md', 'AGENTS.md'], plugins: { markdown, }, From 0a60e9013bb975ec7c3ea12a324962fd62df7eaa Mon Sep 17 00:00:00 2001 From: RoomWithOutRoof <166608075+Jah-yee@users.noreply.github.com> Date: Mon, 11 May 2026 15:36:19 +0800 Subject: [PATCH 108/168] lib: narrow ReadableStreamBYOBRequest.view return type to Uint8Array Follow WHATWG streams spec update: https://github.com/whatwg/streams/pull/1367 ReadableStreamBYOBRequest.view is always constructed as a Uint8Array. This changes the documented return type from ArrayBufferView to Uint8Array per the updated spec. Fixes: https://github.com/nodejs/node/issues/62952 Signed-off-by: Jah-yee <166608075+Jah-yee@users.noreply.github.com> PR-URL: https://github.com/nodejs/node/pull/63017 Reviewed-By: Mattias Buelens Reviewed-By: Jason Zhang --- lib/internal/webstreams/readablestream.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/internal/webstreams/readablestream.js b/lib/internal/webstreams/readablestream.js index 7abde514cf78a5..876e3a5bf6e2f0 100644 --- a/lib/internal/webstreams/readablestream.js +++ b/lib/internal/webstreams/readablestream.js @@ -665,7 +665,7 @@ class ReadableStreamBYOBRequest { /** * @readonly - * @type {ArrayBufferView} + * @type {Uint8Array} */ get view() { if (!isReadableStreamBYOBRequest(this)) From 20e6a54b552582441411264240c79afc887db622 Mon Sep 17 00:00:00 2001 From: Matteo Collina Date: Mon, 11 May 2026 10:45:18 +0200 Subject: [PATCH 109/168] doc: add large pull requests contributing guide MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Exclude routine dependency/WPT/bot PRs from the policy - Replace design document requirement with detailed PR description - Clarify dependency commit ordering for squash landing - Remove splitting strategies that contradict self-contained PRs - Add links from CONTRIBUTING.md, pull-requests.md, collaborator-guide.md Signed-off-by: Matteo Collina PR-URL: https://github.com/nodejs/node/pull/62829 Fixes: https://github.com/nodejs/node/issues/62752 Reviewed-By: James M Snell Reviewed-By: Trivikram Kamat Reviewed-By: Rafael Gonzaga Reviewed-By: Yagiz Nizipli Reviewed-By: Chengzhong Wu Reviewed-By: Paolo Insogna Reviewed-By: Marco Ippolito Reviewed-By: Gürgün Dayıoğlu Reviewed-By: Ruy Adorno --- CONTRIBUTING.md | 1 + doc/contributing/collaborator-guide.md | 4 + doc/contributing/large-pull-requests.md | 182 ++++++++++++++++++++++++ doc/contributing/pull-requests.md | 6 +- 4 files changed, 192 insertions(+), 1 deletion(-) create mode 100644 doc/contributing/large-pull-requests.md diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 54296234a304d8..e22f23543e5ccc 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -46,6 +46,7 @@ dependencies, and tools contained in the `nodejs/node` repository. * [Setting up your local environment](./doc/contributing/pull-requests.md#setting-up-your-local-environment) * [The Process of Making Changes](./doc/contributing/pull-requests.md#the-process-of-making-changes) * [Reviewing Pull Requests](./doc/contributing/pull-requests.md#reviewing-pull-requests) +* [Large Pull Requests](./doc/contributing/large-pull-requests.md) * [Notes](./doc/contributing/pull-requests.md#notes) ## Automation and bots diff --git a/doc/contributing/collaborator-guide.md b/doc/contributing/collaborator-guide.md index b3e201751b2280..8f29042688ef6e 100644 --- a/doc/contributing/collaborator-guide.md +++ b/doc/contributing/collaborator-guide.md @@ -132,6 +132,9 @@ Pay special attention to pull requests for dependencies which have not been automatically generated and follow the guidance in [Maintaining Dependencies](https://github.com/nodejs/node/blob/main/doc/contributing/maintaining/maintaining-dependencies.md#updating-dependencies). +Pull requests that exceed 5000 lines of changes have additional requirements. +See the [large pull requests][] guide. + In some cases, it might be necessary to summon a GitHub team to a pull request for review by @-mention. See [Who to CC in the issue tracker](#who-to-cc-in-the-issue-tracker). @@ -1068,6 +1071,7 @@ need to be attached anymore, as only important bugfixes will be included. [git-node]: https://github.com/nodejs/node-core-utils/blob/HEAD/docs/git-node.md [git-node-metadata]: https://github.com/nodejs/node-core-utils/blob/HEAD/docs/git-node.md#git-node-metadata [git-username]: https://help.github.com/articles/setting-your-username-in-git/ +[large pull requests]: large-pull-requests.md [macos]: https://github.com/orgs/nodejs/teams/platform-macos [node-core-utils-credentials]: https://github.com/nodejs/node-core-utils#setting-up-credentials [node-core-utils-issues]: https://github.com/nodejs/node-core-utils/issues diff --git a/doc/contributing/large-pull-requests.md b/doc/contributing/large-pull-requests.md new file mode 100644 index 00000000000000..00ceb8452e2abc --- /dev/null +++ b/doc/contributing/large-pull-requests.md @@ -0,0 +1,182 @@ +# Large pull requests + +* [Overview](#overview) +* [What qualifies as a large pull request](#what-qualifies-as-a-large-pull-request) +* [Who can open a large pull request](#who-can-open-a-large-pull-request) +* [Requirements](#requirements) + * [Detailed pull request description](#detailed-pull-request-description) + * [Review guide](#review-guide) + * [Approval requirements](#approval-requirements) + * [Dependency changes](#dependency-changes) +* [Splitting large pull requests](#splitting-large-pull-requests) + * [Feature forks and branches](#feature-forks-and-branches) +* [Guidance for reviewers](#guidance-for-reviewers) + +## Overview + +Large pull requests are difficult to review or sometimes impossible to review in the GitHub UI. They are likely to sit +for a long time without receiving adequate review, and when they do get reviewed, +the quality of that review is often lower due to reviewer fatigue. Contributors +should avoid creating large pull requests except in those cases where it is +Large pull requests are difficult to review or sometimes impossible to review +in the GitHub UI. They are likely to sit for a long time without receiving +adequate review, and when they do get reviewed, the quality of that review is +often lower due to reviewer fatigue. Contributors should avoid creating large +pull requests except in those cases where it is effectively unavoidable, such +as when adding new dependencies. + +This document outlines the policy for authoring and reviewing large pull +requests in the Node.js project. + +## What qualifies as a large pull request + +A pull request is considered large when it exceeds **5000 lines** of net +change (lines added minus lines deleted). This threshold applies across all +files in the pull request, including changes in `deps/`, `test/`, `doc/`, +`lib/`, `src/`, and `tools/`. + +Any pull request that adds a new subsystem, e.g. `node:foo` or `node:foo/bar`, +is automatically considered a large pull request and subject to the same rules. + +Changes in `deps/` are included in this count. Dependency changes are +sensitive because they often receive less scrutiny than first-party code. + +The following categories of pull requests are **excluded** from this policy, +even if they exceed the line threshold: + +* Routine dependency updates (e.g., V8, ICU, undici, uvwasi) generated by + automation or performed by collaborators following the standard dependency + update process. +* Web Platform Tests (WPT) imports and updates. +* Other bot-issued or automated pull requests (e.g., license updates, test + fixture regeneration). +* Test-only refactoring that involves no functional changes. + These pull requests already have established review processes and do not + benefit from the additional requirements described here. + +## Who can open a large pull request + +Large pull requests may only be opened by existing +[collaborators](https://github.com/nodejs/node/#current-project-team-members). +Non-collaborators are strongly discouraged from opening pull requests of this size. +Large pull requests from non-collaborators will be closed unless it has been discussed +in an issue and has a collaborator to champion the work. + +## Requirements + +All large pull requests must satisfy the following requirements in addition to +the standard [pull request requirements](./pull-requests.md). + +### Detailed pull request description + +The pull request description must provide sufficient context for reviewers +to understand the change. The description should explain: + +* The motivation for the change. +* The high-level approach and architecture. +* Any alternatives that were considered and why they were rejected. +* How the change interacts with existing subsystems. + +A thorough pull request description is sufficient. There is no requirement +to produce a separate design document, although contributors may choose to +link to a GitHub issue or other discussion where the design was developed. + +### Review guide + +The pull request description must include a review guide that helps reviewers +navigate the change. The review guide should: + +* Identify the key files and directories to review. +* Describe the order in which files should be reviewed. +* Highlight the most critical sections that need careful attention. +* Include a testing plan explaining how the change has been validated and + how reviewers can verify the behavior. + +### Approval requirements + +Large pull requests follow the same approval path as semver-major changes: + +* At least **two TSC member approvals** are required. +* The standard 48-hour wait time applies. Given the complexity of large pull + requests, authors should expect and allow for a longer review period. +* CI must pass before landing. + +### Dependency changes + +When a large pull request adds or modifies a dependency in `deps/`: + +* Dependency changes should be in a **separate commit** from the rest of the + pull request. This makes it easier to review the dependency update + independently from the first-party code changes. When the pull request is + squashed on landing, the dependency commit should be the one that carries + the squashed commit message, so that `git log` clearly reflects the + overall change. +* The provenance and integrity of the dependency must be verifiable. + Include documentation of how the dependency was obtained and how + reviewers can reproduce the build artifact. + +## Avoiding large pull requests + +Contributors should always consider whether a large pull request can be split +into smaller, independently reviewable pull requests. Strategies include: + +* Landing foundational internal APIs first, then building on top of them. +* Landing refactoring or preparatory changes before the main feature. + +Each pull request in a split series should remain self-contained: it should +include the implementation, tests, and documentation needed for that piece +to stand on its own. + +### Strategies for reducing the review length in single pull requests + +Large pull requests may involve a longer review process that becomes practically +impossible to track on GitHub due to UI limitations. These strategies help reduce +the review length in a single pull request. + +* Open an issue first to confirm a substantial change is indeed desired in core + to reduce lengthy discussions unrelated to the implementation in the pull request. +* Use proposal issues, RFCs, design documents, or other types of venues to + explore high-level design and cross-cutting concerns. +* Keep the initial change provisional to reduce the thoroughness required in a + single pull request. Gate premature changes behind build/runtime flags, or apply + `dont-land-*` labels to avoid releasing the initial changes until it has been more + thoroughly tested and iterated in follow-up pull requests. +* Leave non-blocking issues (e.g. stylistic preferences) to follow-up pull requests + with a TODO comment in appropriate places. + +### Feature forks and branches + +For extremely large or complex changes that develop over time, such as adding +a major new subsystem, contributors should consider using a feature fork. +This approach has been used successfully in the past for subsystems like QUIC. + +The feature fork must be hosted in a **separate GitHub repository**, managed +by the collaborator championing the change. The repository can live in the +[nodejs organization](https://github.com/nodejs) or be a personal repository +of the champion. The champion is responsible for coordinating development, +managing access, and ensuring the fork stays up to date with `main`. + +A feature fork allows: + +* Incremental development with multiple collaborators. +* Review of individual commits rather than one monolithic diff. +* CI validation at each stage of development. +* Independent issue tracking and discussion in the fork repository. + +When the work is ready, the final merge into `main` via a pull request still +requires the same approval and review requirements as any other large pull +request. + +## Guidance for reviewers + +Reviewing a large pull request is a significant time investment. Reviewers +should: + +* Read the pull request description and review guide before diving into the + code. +* Focus review effort on `lib/` and `src/` changes, which have the highest + impact on the runtime. `test/` and `doc/` changes, while important, are + lower risk. +* Not hesitate to request that the author split the pull request if it can + reasonably be broken into smaller pieces. +* Coordinate with other reviewers to divide the review workload when possible. diff --git a/doc/contributing/pull-requests.md b/doc/contributing/pull-requests.md index 0fcf4c339119b8..0893460cbc8b0d 100644 --- a/doc/contributing/pull-requests.md +++ b/doc/contributing/pull-requests.md @@ -187,7 +187,7 @@ A good commit message should describe what changed and why. `Fixes:` and `Refs:` trailers get automatically added to your commit message when the Pull Request lands as long as they are included in the Pull Request's description. If the Pull Request lands in several commits, - by default the trailers found in the description are added to each commit. + by default the trailers found in the description are added to each commits. Examples: @@ -289,6 +289,9 @@ From within GitHub, opening a new pull request will present you with a [pull request template][]. Please try to do your best at filling out the details, but feel free to skip parts if you're not sure what to put. +If your pull request exceeds 5000 lines of changes, see the +[large pull requests][] guide for additional requirements. + Once opened, pull requests are usually reviewed within a few days. To get feedback on your proposed change even though it is not ready @@ -611,6 +614,7 @@ More than one subsystem may be valid for any particular issue or pull request. [guide for writing tests in Node.js]: writing-tests.md [hiding-a-comment]: https://help.github.com/articles/managing-disruptive-comments/#hiding-a-comment [https://ci.nodejs.org/]: https://ci.nodejs.org/ +[large pull requests]: large-pull-requests.md [maintaining dependencies]: ./maintaining/maintaining-dependencies.md [nodejs/core-validate-commit]: https://github.com/nodejs/core-validate-commit/blob/main/lib/rules/subsystem.js [pull request template]: https://raw.githubusercontent.com/nodejs/node/HEAD/.github/PULL_REQUEST_TEMPLATE.md From a349018c94fad62dfa77ca89638e64a2e2e9ac00 Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Mon, 11 May 2026 17:36:41 +0200 Subject: [PATCH 110/168] tools: use different branch for tool updates on staging branches Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/63110 Reviewed-By: James M Snell Reviewed-By: Richard Lau Reviewed-By: Marco Ippolito --- .github/workflows/tools.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/tools.yml b/.github/workflows/tools.yml index c4ac6bc77f70aa..0330e649cdadf8 100644 --- a/.github/workflows/tools.yml +++ b/.github/workflows/tools.yml @@ -336,7 +336,7 @@ jobs: # no-op if the base branch is already up-to-date. with: token: ${{ secrets.GH_USER_TOKEN }} - branch: actions/tools-update-${{ matrix.id }} # Custom branch *just* for this Action. + branch: actions/${{ github.ref_name == 'main' || format('{0}/', github.ref_name) }}tools-update-${{ matrix.id }} # Custom branch *just* for this Action. delete-branch: true commit-message: ${{ env.COMMIT_MSG }} labels: ${{ matrix.label }} From e107f3c3c09c6365f76a4ef249ace8c6def36390 Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Tue, 5 May 2026 11:33:38 +0200 Subject: [PATCH 111/168] src: add BoringSSL EVP enumeration fallback BoringSSL declares EVP_CIPHER_do_all_sorted and EVP_MD_do_all_sorted, but stock no-decrepit builds do not provide those symbols. Add a Node build flag that keeps ncrypto and its dependents on a local BoringSSL fallback list when libdecrepit is absent. Keep embedders that provide the EVP enumeration symbols on the normal OpenSSL-compatible path, matching Electron's patched BoringSSL build. Signed-off-by: Filip Skokan PR-URL: https://github.com/nodejs/node/pull/63206 Reviewed-By: Yagiz Nizipli Reviewed-By: Antoine du Hamel --- deps/ncrypto/ncrypto.cc | 34 +++++++++++++++++++ deps/ncrypto/ncrypto.gyp | 7 ++++ deps/ncrypto/ncrypto.h | 18 ++++++++++ src/crypto/crypto_hash.cc | 29 +++++++++++++++- .../test-crypto-boringssl-evp-list.js | 31 +++++++++++++++++ test/parallel/test-crypto-key-objects-raw.js | 2 +- .../test-crypto-pqc-key-objects-ml-kem.js | 4 +++ test/wpt/status/WebCryptoAPI.cjs | 32 +++++++++++++++++ 8 files changed, 155 insertions(+), 2 deletions(-) create mode 100644 test/parallel/test-crypto-boringssl-evp-list.js diff --git a/deps/ncrypto/ncrypto.cc b/deps/ncrypto/ncrypto.cc index b7a0c96ee2ea60..ae7a343fe49767 100644 --- a/deps/ncrypto/ncrypto.cc +++ b/deps/ncrypto/ncrypto.cc @@ -7,6 +7,11 @@ #include #include #include +#if NCRYPTO_USE_BORINGSSL_EVP_DO_ALL_FALLBACK +#include +#include +#include +#endif #include #include #include @@ -67,6 +72,28 @@ using NetscapeSPKIPointer = DeleteFnPtr; static constexpr int kX509NameFlagsRFC2253WithinUtf8JSON = XN_FLAG_RFC2253 & ~ASN1_STRFLGS_ESC_MSB & ~ASN1_STRFLGS_ESC_CTRL; + +#if NCRYPTO_USE_BORINGSSL_EVP_DO_ALL_FALLBACK +struct BoringSSLCipher { + const EVP_CIPHER* (*get)(); + const char* name; +}; + +constexpr BoringSSLCipher kBoringSSLCiphers[] = { + {EVP_aes_128_cbc, "aes-128-cbc"}, {EVP_aes_128_ctr, "aes-128-ctr"}, + {EVP_aes_128_ecb, "aes-128-ecb"}, {EVP_aes_128_gcm, "aes-128-gcm"}, + {EVP_aes_128_ofb, "aes-128-ofb"}, {EVP_aes_192_cbc, "aes-192-cbc"}, + {EVP_aes_192_ctr, "aes-192-ctr"}, {EVP_aes_192_ecb, "aes-192-ecb"}, + {EVP_aes_192_gcm, "aes-192-gcm"}, {EVP_aes_192_ofb, "aes-192-ofb"}, + {EVP_aes_256_cbc, "aes-256-cbc"}, {EVP_aes_256_ctr, "aes-256-ctr"}, + {EVP_aes_256_ecb, "aes-256-ecb"}, {EVP_aes_256_gcm, "aes-256-gcm"}, + {EVP_aes_256_ofb, "aes-256-ofb"}, {EVP_des_cbc, "des-cbc"}, + {EVP_des_ecb, "des-ecb"}, {EVP_des_ede, "des-ede"}, + {EVP_des_ede3_cbc, "des-ede3-cbc"}, {EVP_des_ede_cbc, "des-ede-cbc"}, + {EVP_rc2_cbc, "rc2-cbc"}, {EVP_rc4, "rc4"}, +}; + +#endif } // namespace // ============================================================================ @@ -4209,6 +4236,12 @@ void Cipher::ForEach(Cipher::CipherNameCallback callback) { CipherCallbackContext context; context.cb = std::move(callback); +#if NCRYPTO_USE_BORINGSSL_EVP_DO_ALL_FALLBACK + for (const auto& cipher : kBoringSSLCiphers) { + static_cast(cipher.get); + context.cb(cipher.name); + } +#else EVP_CIPHER_do_all_sorted( #if OPENSSL_VERSION_MAJOR >= 3 array_push_back, #endif &context); +#endif } // ============================================================================ diff --git a/deps/ncrypto/ncrypto.gyp b/deps/ncrypto/ncrypto.gyp index cf9b7c6cdb6d2c..1747f3ea0149b9 100644 --- a/deps/ncrypto/ncrypto.gyp +++ b/deps/ncrypto/ncrypto.gyp @@ -1,5 +1,6 @@ { 'variables': { + 'ncrypto_bssl_libdecrepit_missing%': 1, 'ncrypto_sources': [ 'engine.cc', 'ncrypto.cc', @@ -11,8 +12,14 @@ 'target_name': 'ncrypto', 'type': 'static_library', 'include_dirs': ['.'], + 'defines': [ + 'NCRYPTO_BSSL_LIBDECREPIT_MISSING=<(ncrypto_bssl_libdecrepit_missing)', + ], 'direct_dependent_settings': { 'include_dirs': ['.'], + 'defines': [ + 'NCRYPTO_BSSL_LIBDECREPIT_MISSING=<(ncrypto_bssl_libdecrepit_missing)', + ], }, 'sources': [ '<@(ncrypto_sources)' ], 'conditions': [ diff --git a/deps/ncrypto/ncrypto.h b/deps/ncrypto/ncrypto.h index 1f116169f57a27..d3b0762f3313bb 100644 --- a/deps/ncrypto/ncrypto.h +++ b/deps/ncrypto/ncrypto.h @@ -22,6 +22,24 @@ #ifndef OPENSSL_NO_ENGINE #include #endif // !OPENSSL_NO_ENGINE + +#ifndef OPENSSL_VERSION_PREREQ +#define OPENSSL_VERSION_PREREQ(maj, min) \ + (OPENSSL_VERSION_NUMBER >= (((maj) << 28) | ((min) << 20))) +#endif + +// BoringSSL declares the EVP_*_do_all* APIs, but their implementation may +// live in libdecrepit. This matches standalone ncrypto's build flag. +#ifndef NCRYPTO_BSSL_LIBDECREPIT_MISSING +#define NCRYPTO_BSSL_LIBDECREPIT_MISSING 0 +#endif + +#if defined(OPENSSL_IS_BORINGSSL) && NCRYPTO_BSSL_LIBDECREPIT_MISSING +#define NCRYPTO_USE_BORINGSSL_EVP_DO_ALL_FALLBACK 1 +#else +#define NCRYPTO_USE_BORINGSSL_EVP_DO_ALL_FALLBACK 0 +#endif + // The FIPS-related functions are only available // when the OpenSSL itself was compiled with FIPS support. #if defined(OPENSSL_FIPS) && OPENSSL_VERSION_MAJOR < 3 diff --git a/src/crypto/crypto_hash.cc b/src/crypto/crypto_hash.cc index 9b76b900049484..c42926bb4ce61f 100644 --- a/src/crypto/crypto_hash.cc +++ b/src/crypto/crypto_hash.cc @@ -7,6 +7,10 @@ #include "threadpoolwork-inl.h" #include "v8.h" +#if NCRYPTO_USE_BORINGSSL_EVP_DO_ALL_FALLBACK +#include +#endif + #include namespace node { @@ -41,6 +45,24 @@ void Hash::MemoryInfo(MemoryTracker* tracker) const { tracker->TrackFieldWithSize("md", digest_ ? md_len_ : 0); } +#if NCRYPTO_USE_BORINGSSL_EVP_DO_ALL_FALLBACK +struct BoringSSLDigest { + const EVP_MD* (*get)(); + const char* name; +}; + +constexpr BoringSSLDigest kBoringSSLDigests[] = { + {EVP_md4, "md4"}, + {EVP_md5, "md5"}, + {EVP_sha1, "sha1"}, + {EVP_sha224, "sha224"}, + {EVP_sha256, "sha256"}, + {EVP_sha384, "sha384"}, + {EVP_sha512, "sha512"}, + {EVP_sha512_256, "sha512-256"}, +}; +#endif + #if OPENSSL_VERSION_MAJOR >= 3 void PushAliases(const char* name, void* data) { static_cast*>(data)->push_back(name); @@ -122,7 +144,12 @@ void SaveSupportedHashAlgorithms(const EVP_MD* md, const std::vector& GetSupportedHashAlgorithms(Environment* env) { if (env->supported_hash_algorithms.empty()) { MarkPopErrorOnReturn mark_pop_error_on_return; -#if OPENSSL_VERSION_MAJOR >= 3 +#if NCRYPTO_USE_BORINGSSL_EVP_DO_ALL_FALLBACK + for (const auto& digest : kBoringSSLDigests) { + static_cast(digest.get); + env->supported_hash_algorithms.emplace_back(digest.name); + } +#elif OPENSSL_VERSION_MAJOR >= 3 // Since we'll fetch the EVP_MD*, cache them along the way to speed up // later lookups instead of throwing them away immediately. EVP_MD_do_all_sorted(SaveSupportedHashAlgorithmsAndCacheMD, env); diff --git a/test/parallel/test-crypto-boringssl-evp-list.js b/test/parallel/test-crypto-boringssl-evp-list.js new file mode 100644 index 00000000000000..3f142c24f28a7c --- /dev/null +++ b/test/parallel/test-crypto-boringssl-evp-list.js @@ -0,0 +1,31 @@ +'use strict'; + +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); + +if (!process.features.openssl_is_boringssl) + common.skip('BoringSSL-only test'); + +const assert = require('assert'); +const { getCiphers, getHashes } = require('crypto'); + +const ciphers = getCiphers(); +[ + 'aes-128-cbc', + 'aes-256-gcm', + 'des-ede', + 'des-ede-cbc', + 'des-ede3-cbc', + 'rc2-cbc', + 'rc4', +].forEach((cipher) => assert(ciphers.includes(cipher), cipher)); + +const hashes = getHashes(); +[ + 'md4', + 'md5', + 'sha1', + 'sha256', + 'sha512-256', +].forEach((hash) => assert(hashes.includes(hash), hash)); diff --git a/test/parallel/test-crypto-key-objects-raw.js b/test/parallel/test-crypto-key-objects-raw.js index 311659ef004ea2..583cd4a1712a83 100644 --- a/test/parallel/test-crypto-key-objects-raw.js +++ b/test/parallel/test-crypto-key-objects-raw.js @@ -76,7 +76,7 @@ const { hasOpenSSL } = require('../common/crypto'); common.printSkipMessage('Skipping unsupported ed448/x448 test cases'); } - if (hasOpenSSL(3, 5) || process.features.openssl_is_boringssl) { + if (hasOpenSSL(3, 5)) { rawPublicKeys.push( ['ml-dsa-44', 'ml_dsa_44_public.pem'], ['ml-kem-768', 'ml_kem_768_public.pem'], diff --git a/test/parallel/test-crypto-pqc-key-objects-ml-kem.js b/test/parallel/test-crypto-pqc-key-objects-ml-kem.js index 0c344ed100c2da..19ed840544320d 100644 --- a/test/parallel/test-crypto-pqc-key-objects-ml-kem.js +++ b/test/parallel/test-crypto-pqc-key-objects-ml-kem.js @@ -4,6 +4,10 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); +if (process.features.openssl_is_boringssl) { + common.skip('Skipping unsupported ML-KEM key tests'); +} + const { hasOpenSSL } = require('../common/crypto'); const assert = require('assert'); diff --git a/test/wpt/status/WebCryptoAPI.cjs b/test/wpt/status/WebCryptoAPI.cjs index 253877f1a970e0..93ec24557e2701 100644 --- a/test/wpt/status/WebCryptoAPI.cjs +++ b/test/wpt/status/WebCryptoAPI.cjs @@ -61,6 +61,38 @@ if (!hasOpenSSL(3, 5)) { ['supports-modern.tentative.https.any.js', /ml-(?:kem|dsa)/i]); } +if (process.features.openssl_is_boringssl) { + skip( + 'derive_bits_keys/cfrg_curves_bits_curve448.tentative.https.any.js', + 'derive_bits_keys/cfrg_curves_keys_curve448.tentative.https.any.js', + 'digest/cshake.tentative.https.any.js', + 'digest/sha3.tentative.https.any.js', + 'encrypt_decrypt/chacha20_poly1305.tentative.https.any.js', + 'generateKey/failures_AES-KW.https.any.js', + 'generateKey/failures_Ed448.tentative.https.any.js', + 'generateKey/failures_X448.tentative.https.any.js', + 'generateKey/failures_chacha20_poly1305.tentative.https.any.js', + 'generateKey/successes_AES-KW.https.any.js', + 'generateKey/successes_Ed448.tentative.https.any.js', + 'generateKey/successes_X448.tentative.https.any.js', + 'generateKey/successes_chacha20_poly1305.tentative.https.any.js', + 'import_export/ChaCha20-Poly1305_importKey.tentative.https.any.js', + 'import_export/okp_importKey_Ed448.tentative.https.any.js', + 'import_export/okp_importKey_failures_Ed448.tentative.https.any.js', + 'import_export/okp_importKey_failures_X448.tentative.https.any.js', + 'import_export/okp_importKey_X448.tentative.https.any.js', + 'sign_verify/eddsa_curve448.tentative.https.any.js'); + + skipSubtests( + ['derive_bits_keys/hkdf.https.any.js', /AES-KW/], + ['derive_bits_keys/pbkdf2.https.any.js', /AES-KW/], + ['import_export/raw_format_aliases.tentative.https.any.js', /AES-KW/], + ['import_export/symmetric_importKey.https.any.js', /AES-KW/], + ['supports.tentative.https.any.js', /AES-KW/], + ['supports-modern.tentative.https.any.js', /ChaCha20-Poly1305/], + ['supports-modern.tentative.https.any.js', /^supports returns true for algorithm objects with valid parameters$/]); +} + function assertNoOverlap(fileSkips, subtestSkips) { const subtestSkipFiles = new Set(Object.keys(subtestSkips)); const overlap = Object.keys(fileSkips).filter((file) => subtestSkipFiles.has(file)); From 1a02250a165c425deca193686de10c460ca1e80e Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Tue, 5 May 2026 16:16:48 +0200 Subject: [PATCH 112/168] tools: add boringssl to tools/nix/openssl-matrix.nix Signed-off-by: Filip Skokan PR-URL: https://github.com/nodejs/node/pull/63206 Reviewed-By: Yagiz Nizipli Reviewed-By: Antoine du Hamel --- tools/dep_updaters/update-nixpkgs-pin.sh | 12 ++++++------ tools/nix/openssl-matrix.nix | 1 + 2 files changed, 7 insertions(+), 6 deletions(-) diff --git a/tools/dep_updaters/update-nixpkgs-pin.sh b/tools/dep_updaters/update-nixpkgs-pin.sh index 97bcd878181c7b..eb5fde1526ab0c 100755 --- a/tools/dep_updaters/update-nixpkgs-pin.sh +++ b/tools/dep_updaters/update-nixpkgs-pin.sh @@ -29,16 +29,16 @@ mv "$TMP_FILE" "$NIXPKGS_PIN_FILE" nix-instantiate -I "nixpkgs=$NIXPKGS_PIN_FILE" --eval --strict --json -E " let pkgs = import {}; + opensslAttrs = builtins.filter + (n: builtins.match \"openssl_[0-9]+(_[0-9]+)?\" n != null) + (builtins.attrNames pkgs); + extraMatrixAttrs = [ \"boringssl\" ]; attrs = builtins.filter (n: let t = builtins.tryEval pkgs.\${n}; in t.success && (builtins.tryEval t.value.version).success ) - ( - builtins.filter - (n: builtins.match \"openssl_[0-9]+(_[0-9]+)?\" n != null) - (builtins.attrNames pkgs) - ); + (opensslAttrs ++ extraMatrixAttrs); in { inherit attrs; @@ -54,7 +54,7 @@ nix-instantiate -I "nixpkgs=$NIXPKGS_PIN_FILE" --eval --strict --json -E " { inherit (pkgs) - \(.attrs | join("\n ")) + \(.attrs | sort | join("\n ")) ; }"' > "$OPENSSL_MATRIX_FILE" diff --git a/tools/nix/openssl-matrix.nix b/tools/nix/openssl-matrix.nix index 3f9476acd7f7e0..36978c5d4efcb0 100644 --- a/tools/nix/openssl-matrix.nix +++ b/tools/nix/openssl-matrix.nix @@ -6,6 +6,7 @@ { inherit (pkgs) + boringssl openssl_1_1 openssl_3 openssl_3_5 From 58cd0b8df278d1932dac036e3ea93c16d1a7aaa6 Mon Sep 17 00:00:00 2001 From: James M Snell Date: Thu, 7 May 2026 21:34:40 -0700 Subject: [PATCH 113/168] quic: support --allow-net permissions MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: James M Snell Assisted-by: Opencode:Opus 4.6 PR-URL: https://github.com/nodejs/node/pull/63184 Reviewed-By: Tim Perry Reviewed-By: Rafael Gonzaga Reviewed-By: Trivikram Kamat Reviewed-By: Juan José Arboleda --- doc/api/quic.md | 20 +++++++++ src/quic/endpoint.cc | 6 +++ test/cctest/test_sockaddr.cc | 2 +- test/parallel/test-permission-net-quic.mjs | 50 ++++++++++++++++++++++ 4 files changed, 77 insertions(+), 1 deletion(-) create mode 100644 test/parallel/test-permission-net-quic.mjs diff --git a/doc/api/quic.md b/doc/api/quic.md index ddeafdc8d3edd1..ecd0d73803888a 100644 --- a/doc/api/quic.md +++ b/doc/api/quic.md @@ -304,6 +304,24 @@ When a `QuicError` is passed to [`stream.destroy()`][] or `STOP_SENDING` frame sent to the peer. Any other error type falls back to the negotiated protocol's generic internal error code. +### Permission model + +When using the [Permission Model][], the `--allow-net` flag must be passed to +allow QUIC network operations. Without it, calling [`quic.connect()`][] or +[`quic.listen()`][] will throw an `ERR_ACCESS_DENIED` error. + +```console +$ node --permission --allow-fs-read=* --experimental-quic index.mjs +Error: Access to this API has been restricted. Use --allow-net to manage permissions. + code: 'ERR_ACCESS_DENIED', + permission: 'Net', +} +``` + +Creating a [`QuicEndpoint`][] instance without connecting or listening +is permitted even without `--allow-net`, since no network I/O occurs until +[`quic.connect()`][] or [`quic.listen()`][] is called. + ## `quic.connect(address[, options])` + +> Stability: 1.0 - Early development + +Run only tests whose tag set contains ``. Tests declare tags via the +`tags` option on `test()`, `it()`, `suite()`, or `describe()`; tags +inherit from suites to nested tests by union. Filtering is +case-insensitive. + +The flag may be specified more than once; tests must contain **every** +filter value to run. See [Test tags][] for details on declaring and +inheriting tags. + ### `--experimental-vm-modules` + +> Stability: 1.0 - Early development + +Tags annotate tests and suites with arbitrary string labels. The +[`--experimental-test-tag-filter`][] CLI flag (or the `testTagFilters` +option on [`run()`][]) selects tests whose tag set contains every +provided filter value. + +Tags are an alternative to encoding metadata into test names. They are +useful for cross-cutting axes such as subsystem, speed bucket, flakiness, +or environment, where a name pattern would be brittle. + +### Authoring tagged tests + +Pass a `tags` array on any of `test()`, `it()`, `suite()`, or `describe()`. +Tags inherit from a suite to its child tests by union—a test inside a +suite tagged `['db']` that declares its own `tags: ['integration']` +effectively has both tags. + +```mjs +import { describe, it } from 'node:test'; + +describe('database', { tags: ['db'] }, () => { + it('reads a row'); // tags: ['db'] + it('writes a row', { tags: ['integration'] }); // tags: ['db', 'integration'] + it('reconnects after disconnect', { tags: ['flaky'] }); // tags: ['db', 'flaky'] +}); +``` + +```cjs +const { describe, it } = require('node:test'); + +describe('database', { tags: ['db'] }, () => { + it('reads a row'); // tags: ['db'] + it('writes a row', { tags: ['integration'] }); // tags: ['db', 'integration'] + it('reconnects after disconnect', { tags: ['flaky'] }); // tags: ['db', 'flaky'] +}); +``` + +Tag values must be non-empty strings. Tags are matched case-insensitively; +the canonical form is lowercase. Duplicates within a single `tags` array +are collapsed on the lowercased form, preserving the first-seen +declaration order. + +Hooks (`before`, `after`, `beforeEach`, `afterEach`) do not declare their +own tags. They run as part of their owning suite, which carries the +suite's tags. + +### Filtering by tag + +Each [`--experimental-test-tag-filter`][] value is a literal tag name. A +test runs only when its tag set contains that name. The flag may be +specified more than once; tests must match **every** filter to run. The +same applies to the `testTagFilters` array on [`run()`][]. Filters are +case-insensitive and AND'd with [`--test-name-pattern`][], +[`--test-skip-pattern`][], and `.only` filtering. + +Untagged tests are excluded under any non-empty filter, since the filter +requires the tag to be present. + +### Reading tags from inside a test + +The [`TestContext`][] object exposes the test's tags as a frozen array +through [`context.tags`][], so tests can branch on their own metadata. + +### Errors + +A tag value that violates the validation rules above throws +`ERR_INVALID_ARG_VALUE` at the registration site, before any test runs. +A non-array `tags` value throws `ERR_INVALID_ARG_TYPE`. + ## Extraneous asynchronous activity Once a test function finishes executing, the results are reported as quickly @@ -750,6 +826,8 @@ test runner functionality: * `--test` - Prevented to avoid recursive test execution * `--experimental-test-coverage` - Managed by the test runner +* `--experimental-test-tag-filter` - Filter values are validated by the parent + process and re-emitted to child processes * `--watch` - Watch mode is handled at the parent level * `--experimental-default-config-file` - Config file loading is handled by the parent * `--test-reporter` - Reporting is managed by the parent process @@ -1568,6 +1646,9 @@ added: - v18.9.0 - v16.19.0 changes: + - version: REPLACEME + pr-url: https://github.com/nodejs/node/pull/63221 + description: Added the `testTagFilters` option. - version: - v25.6.0 - v24.14.0 @@ -1656,6 +1737,10 @@ changes: For each test that is executed, any corresponding test hooks, such as `beforeEach()`, are also run. **Default:** `undefined`. + * `testTagFilters` {string|string\[]} A tag name, or an array of tag names, + used to filter tests by their declared tags. Tests must contain every + listed tag to run. Equivalent to passing [`--experimental-test-tag-filter`][] + on the command line. See [Test tags][]. **Default:** `undefined`. * `timeout` {number} A number of milliseconds the test execution will fail after. If unspecified, subtests inherit this value from their parent. @@ -1799,6 +1884,9 @@ added: - v18.0.0 - v16.17.0 changes: + - version: REPLACEME + pr-url: https://github.com/nodejs/node/pull/63221 + description: Added the `tags` option. - version: - v20.2.0 - v18.17.0 @@ -1842,6 +1930,10 @@ changes: * `skip` {boolean|string} If truthy, the test is skipped. If a string is provided, that string is displayed in the test results as the reason for skipping the test. **Default:** `false`. + * `tags` {string\[]} An array of string labels associated with the test. + Used together with [`--experimental-test-tag-filter`][] to filter which + tests run. Tags inherit from suites to nested tests by union. See + [Test tags][]. **Default:** `[]`. * `todo` {boolean|string} If truthy, the test marked as `TODO`. If a string is provided, that string is displayed in the test results as the reason why the test is `TODO`. **Default:** `false`. @@ -3430,6 +3522,9 @@ Emitted when code coverage is enabled and all tests have completed. `undefined` if the test was run through the REPL. * `name` {string} The test name. * `nesting` {number} The nesting level of the test. + * `tags` {string\[]} The flattened lowercased tags declared on the test + and its ancestor suites, in declaration order. Empty for untagged tests. + See [Test tags][]. * `testId` {number} A numeric identifier for this test instance, unique within the test file's process. Consistent across all events for the same test instance, enabling reliable correlation in custom reporters. @@ -3453,6 +3548,9 @@ The corresponding declaration ordered events are `'test:pass'` and `'test:fail'` `undefined` if the test was run through the REPL. * `name` {string} The test name. * `nesting` {number} The nesting level of the test. + * `tags` {string\[]} The flattened lowercased tags declared on the test + and its ancestor suites, in declaration order. Empty for untagged tests. + See [Test tags][]. * `testId` {number} A numeric identifier for this test instance, unique within the test file's process. Consistent across all events for the same test instance, enabling reliable correlation in custom reporters. @@ -3494,6 +3592,9 @@ defined. `undefined` if the test was run through the REPL. * `name` {string} The test name. * `nesting` {number} The nesting level of the test. + * `tags` {string\[]} The flattened lowercased tags declared on the test + and its ancestor suites, in declaration order. Empty for untagged tests. + See [Test tags][]. * `testId` {number} A numeric identifier for this test instance, unique within the test file's process. Consistent across all events for the same test instance, enabling reliable correlation in custom reporters. @@ -3520,6 +3621,9 @@ Emitted when a test is enqueued for execution. `undefined` if the test was run through the REPL. * `name` {string} The test name. * `nesting` {number} The nesting level of the test. + * `tags` {string\[]} The flattened lowercased tags declared on the test + and its ancestor suites, in declaration order. Empty for untagged tests. + See [Test tags][]. * `testId` {number} A numeric identifier for this test instance, unique within the test file's process. Consistent across all events for the same test instance, enabling reliable correlation in custom reporters. @@ -3579,6 +3683,9 @@ since the parent runner only knows about file-level tests. When using `undefined` if the test was run through the REPL. * `name` {string} The test name. * `nesting` {number} The nesting level of the test. + * `tags` {string\[]} The flattened lowercased tags declared on the test + and its ancestor suites, in declaration order. Empty for untagged tests. + See [Test tags][]. * `testId` {number} A numeric identifier for this test instance, unique within the test file's process. Consistent across all events for the same test instance, enabling reliable correlation in custom reporters. @@ -3618,6 +3725,9 @@ defined. `undefined` if the test was run through the REPL. * `name` {string} The test name. * `nesting` {number} The nesting level of the test. + * `tags` {string\[]} The flattened lowercased tags declared on the test + and its ancestor suites, in declaration order. Empty for untagged tests. + See [Test tags][]. * `testId` {number} A numeric identifier for this test instance, unique within the test file's process. Consistent across all events for the same test instance, enabling reliable correlation in custom reporters. @@ -4121,6 +4231,20 @@ The attempt number of the test. This value is zero-based, so the first attempt i the second attempt is `1`, and so on. This property is useful in conjunction with the `--test-rerun-failures` option to determine which attempt the test is currently running. +### `context.tags` + + + +> Stability: 1.0 - Early development + +* Type: {string\[]} + +A frozen array of the test's flattened lowercased tags, in declaration +order, including any tags inherited from ancestor suites. Empty when the +test has no tags. See [Test tags][]. + ### `context.workerId` ```c @@ -2797,21 +2801,25 @@ napi_status napi_create_typedarray(napi_env env, * `[in] env`: The environment that the API is invoked under. * `[in] type`: Scalar datatype of the elements within the `TypedArray`. * `[in] length`: Number of elements in the `TypedArray`. -* `[in] arraybuffer`: `ArrayBuffer` underlying the typed array. -* `[in] byte_offset`: The byte offset within the `ArrayBuffer` from which to - start projecting the `TypedArray`. +* `[in] arraybuffer`: `ArrayBuffer` or `SharedArrayBuffer` underlying the + typed array. +* `[in] byte_offset`: The byte offset within the `ArrayBuffer` or + `SharedArrayBuffer` from which to start projecting the `TypedArray`. * `[out] result`: A `napi_value` representing a JavaScript `TypedArray`. Returns `napi_ok` if the API succeeded. This API creates a JavaScript `TypedArray` object over an existing -`ArrayBuffer`. `TypedArray` objects provide an array-like view over an -underlying data buffer where each element has the same underlying binary scalar -datatype. +`ArrayBuffer` or `SharedArrayBuffer`. `TypedArray` objects provide an +array-like view over an underlying data buffer where each element has the same +underlying binary scalar datatype. + +It is required that `(length * size_of_element) + byte_offset` is less than or +equal to the size in bytes of the `ArrayBuffer` or `SharedArrayBuffer` passed +in. If not, a `RangeError` exception is raised. -It's required that `(length * size_of_element) + byte_offset` should -be <= the size in bytes of the array passed in. If not, a `RangeError` exception -is raised. +For element sizes greater than 1, `byte_offset` is required to be a multiple +of the element size. If not, a `RangeError` exception is raised. JavaScript `TypedArray` objects are described in [Section TypedArray objects][] of the ECMAScript Language Specification. @@ -3504,7 +3512,8 @@ napi_status napi_get_typedarray_info(napi_env env, the `byte_offset` value so that it points to the first element in the `TypedArray`. If the length of the array is `0`, this may be `NULL` or any other pointer value. -* `[out] arraybuffer`: The `ArrayBuffer` underlying the `TypedArray`. +* `[out] arraybuffer`: The `ArrayBuffer` or `SharedArrayBuffer` underlying the + `TypedArray`. * `[out] byte_offset`: The byte offset within the underlying native array at which the first element of the arrays is located. The value for the data parameter has already been adjusted so that data points to the first element diff --git a/src/js_native_api_v8.cc b/src/js_native_api_v8.cc index 91865ac9bd6634..5e533d2a682275 100644 --- a/src/js_native_api_v8.cc +++ b/src/js_native_api_v8.cc @@ -3276,66 +3276,73 @@ napi_status NAPI_CDECL napi_create_typedarray(napi_env env, CHECK_ARG(env, result); v8::Local value = v8impl::V8LocalValueFromJsValue(arraybuffer); - RETURN_STATUS_IF_FALSE(env, value->IsArrayBuffer(), napi_invalid_arg); + auto create_typedarray = [&](auto buffer) -> napi_status { + v8::Local typedArray; + + switch (type) { + case napi_int8_array: + CREATE_TYPED_ARRAY( + env, Int8Array, 1, buffer, byte_offset, length, typedArray); + break; + case napi_uint8_array: + CREATE_TYPED_ARRAY( + env, Uint8Array, 1, buffer, byte_offset, length, typedArray); + break; + case napi_uint8_clamped_array: + CREATE_TYPED_ARRAY( + env, Uint8ClampedArray, 1, buffer, byte_offset, length, typedArray); + break; + case napi_int16_array: + CREATE_TYPED_ARRAY( + env, Int16Array, 2, buffer, byte_offset, length, typedArray); + break; + case napi_uint16_array: + CREATE_TYPED_ARRAY( + env, Uint16Array, 2, buffer, byte_offset, length, typedArray); + break; + case napi_int32_array: + CREATE_TYPED_ARRAY( + env, Int32Array, 4, buffer, byte_offset, length, typedArray); + break; + case napi_uint32_array: + CREATE_TYPED_ARRAY( + env, Uint32Array, 4, buffer, byte_offset, length, typedArray); + break; + case napi_float32_array: + CREATE_TYPED_ARRAY( + env, Float32Array, 4, buffer, byte_offset, length, typedArray); + break; + case napi_float64_array: + CREATE_TYPED_ARRAY( + env, Float64Array, 8, buffer, byte_offset, length, typedArray); + break; + case napi_bigint64_array: + CREATE_TYPED_ARRAY( + env, BigInt64Array, 8, buffer, byte_offset, length, typedArray); + break; + case napi_biguint64_array: + CREATE_TYPED_ARRAY( + env, BigUint64Array, 8, buffer, byte_offset, length, typedArray); + break; + case napi_float16_array: + CREATE_TYPED_ARRAY( + env, Float16Array, 2, buffer, byte_offset, length, typedArray); + break; + default: + return napi_set_last_error(env, napi_invalid_arg); + } - v8::Local buffer = value.As(); - v8::Local typedArray; + *result = v8impl::JsValueFromV8LocalValue(typedArray); + return GET_RETURN_STATUS(env); + }; - switch (type) { - case napi_int8_array: - CREATE_TYPED_ARRAY( - env, Int8Array, 1, buffer, byte_offset, length, typedArray); - break; - case napi_uint8_array: - CREATE_TYPED_ARRAY( - env, Uint8Array, 1, buffer, byte_offset, length, typedArray); - break; - case napi_uint8_clamped_array: - CREATE_TYPED_ARRAY( - env, Uint8ClampedArray, 1, buffer, byte_offset, length, typedArray); - break; - case napi_int16_array: - CREATE_TYPED_ARRAY( - env, Int16Array, 2, buffer, byte_offset, length, typedArray); - break; - case napi_uint16_array: - CREATE_TYPED_ARRAY( - env, Uint16Array, 2, buffer, byte_offset, length, typedArray); - break; - case napi_int32_array: - CREATE_TYPED_ARRAY( - env, Int32Array, 4, buffer, byte_offset, length, typedArray); - break; - case napi_uint32_array: - CREATE_TYPED_ARRAY( - env, Uint32Array, 4, buffer, byte_offset, length, typedArray); - break; - case napi_float32_array: - CREATE_TYPED_ARRAY( - env, Float32Array, 4, buffer, byte_offset, length, typedArray); - break; - case napi_float64_array: - CREATE_TYPED_ARRAY( - env, Float64Array, 8, buffer, byte_offset, length, typedArray); - break; - case napi_bigint64_array: - CREATE_TYPED_ARRAY( - env, BigInt64Array, 8, buffer, byte_offset, length, typedArray); - break; - case napi_biguint64_array: - CREATE_TYPED_ARRAY( - env, BigUint64Array, 8, buffer, byte_offset, length, typedArray); - break; - case napi_float16_array: - CREATE_TYPED_ARRAY( - env, Float16Array, 2, buffer, byte_offset, length, typedArray); - break; - default: - return napi_set_last_error(env, napi_invalid_arg); + if (value->IsArrayBuffer()) { + return create_typedarray(value.As()); + } else if (value->IsSharedArrayBuffer()) { + return create_typedarray(value.As()); + } else { + return napi_set_last_error(env, napi_invalid_arg); } - - *result = v8impl::JsValueFromV8LocalValue(typedArray); - return GET_RETURN_STATUS(env); } napi_status NAPI_CDECL napi_get_typedarray_info(napi_env env, diff --git a/test/js-native-api/test_typedarray/binding.gyp b/test/js-native-api/test_typedarray/binding.gyp index d708d2d2493bf6..567354445e3de5 100644 --- a/test/js-native-api/test_typedarray/binding.gyp +++ b/test/js-native-api/test_typedarray/binding.gyp @@ -5,6 +5,12 @@ "sources": [ "test_typedarray.c" ] + }, + { + "target_name": "test_typedarray_sharedarraybuffer", + "sources": [ + "test_typedarray_sharedarraybuffer.c" + ] } ] } diff --git a/test/js-native-api/test_typedarray/test_sharedarraybuffer.js b/test/js-native-api/test_typedarray/test_sharedarraybuffer.js new file mode 100644 index 00000000000000..95a39c033231c7 --- /dev/null +++ b/test/js-native-api/test_typedarray/test_sharedarraybuffer.js @@ -0,0 +1,110 @@ +'use strict'; + +// Verify SharedArrayBuffer-backed typed arrays can be created through +// napi_create_typedarray() while preserving existing ArrayBuffer behavior. + +const common = require('../../common'); +const assert = require('assert'); + +const test_typedarray_sharedarraybuffer = + require(`./build/${common.buildType}/test_typedarray_sharedarraybuffer`); + +const typedArrayCases = [ + { type: Int8Array, values: [-1, 0, 127] }, + { type: Uint8Array, values: [1, 2, 255] }, + { type: Uint8ClampedArray, values: [0, 128, 255] }, + { type: Int16Array, values: [-1, 0, 32767] }, + { type: Uint16Array, values: [1, 2, 65535] }, + { type: Int32Array, values: [-1, 0, 123456789] }, + { type: Uint32Array, values: [1, 2, 4294967295] }, + { type: Float16Array, values: [0.5, -1.5, 42.25] }, + { type: Float32Array, values: [0.5, -1.5, 42.25] }, + { type: Float64Array, values: [0.5, -1.5, 42.25] }, + { type: BigInt64Array, values: [1n, -2n, 123456789n] }, + { type: BigUint64Array, values: [1n, 2n, 123456789n] }, +]; + +function createBuffer(Type, BufferType, length) { + const byteOffset = Type.BYTES_PER_ELEMENT; + const byteLength = byteOffset + (length * Type.BYTES_PER_ELEMENT); + return { + buffer: new BufferType(byteLength), + byteOffset, + }; +} + +function createTypedArray(Type, buffer, byteOffset, length) { + const template = new Type(buffer, byteOffset, length); + return test_typedarray_sharedarraybuffer.CreateTypedArray(template, buffer); +} + +function verifyTypedArray(Type, buffer, byteOffset, values) { + const theArray = createTypedArray(Type, buffer, byteOffset, values.length); + const theArrayBuffer = + test_typedarray_sharedarraybuffer.GetArrayBuffer(theArray); + + assert.ok(theArray instanceof Type); + assert.strictEqual(theArray.buffer, buffer); + assert.strictEqual(theArrayBuffer, buffer); + assert.strictEqual(theArray.byteOffset, byteOffset); + assert.strictEqual(theArray.length, values.length); + + theArray.set(values); + assert.deepStrictEqual(Array.from(new Type(buffer, byteOffset, values.length)), + values); +} + +// Keep the existing ArrayBuffer behavior covered while focusing this test +// on SharedArrayBuffer-backed TypedArray creation. +{ + const { buffer, byteOffset } = createBuffer(Uint8Array, ArrayBuffer, 3); + verifyTypedArray(Uint8Array, buffer, byteOffset, [1, 2, 3]); +} + +// Verify all TypedArray variants can be created from SharedArrayBuffer. +typedArrayCases.forEach(({ type, values }) => { + const { buffer, byteOffset } = createBuffer(type, SharedArrayBuffer, + values.length); + verifyTypedArray(type, buffer, byteOffset, values); +}); + +// Test for creating TypedArrays with SharedArrayBuffer and invalid range. +for (const { type, values } of typedArrayCases) { + const { buffer, byteOffset } = createBuffer(type, SharedArrayBuffer, + values.length); + const template = new type(buffer, byteOffset, values.length); + + assert.throws(() => { + test_typedarray_sharedarraybuffer.CreateTypedArray( + template, buffer, values.length + 1, byteOffset); + }, RangeError); +} + +// Test for creating TypedArrays with SharedArrayBuffer and invalid alignment. +for (const { type, values } of typedArrayCases) { + if (type.BYTES_PER_ELEMENT <= 1) { + continue; + } + + const { buffer, byteOffset } = createBuffer(type, SharedArrayBuffer, + values.length); + const template = new type(buffer, byteOffset, values.length); + + assert.throws(() => { + test_typedarray_sharedarraybuffer.CreateTypedArray( + template, buffer, 1, byteOffset + 1); + }, RangeError); +} + +// Test invalid arguments. +{ + const template = new Uint8Array(1); + + assert.throws(() => { + test_typedarray_sharedarraybuffer.CreateTypedArray(template, {}); + }, { name: 'Error', message: 'Invalid argument' }); + + assert.throws(() => { + test_typedarray_sharedarraybuffer.CreateTypedArray(template, 1); + }, { name: 'Error', message: 'Invalid argument' }); +} diff --git a/test/js-native-api/test_typedarray/test_typedarray_sharedarraybuffer.c b/test/js-native-api/test_typedarray/test_typedarray_sharedarraybuffer.c new file mode 100644 index 00000000000000..f03ccfcdbca0f2 --- /dev/null +++ b/test/js-native-api/test_typedarray/test_typedarray_sharedarraybuffer.c @@ -0,0 +1,79 @@ +// Verify napi_create_typedarray() accepts SharedArrayBuffer-backed views +// without changing its existing error handling. + +#include +#include "../common.h" +#include "../entry_point.h" + +static napi_value CreateTypedArray(napi_env env, napi_callback_info info) { + size_t argc = 4; + napi_value args[4]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc == 2 || argc == 4, "Wrong number of arguments"); + + bool is_typedarray; + NODE_API_CALL(env, napi_is_typedarray(env, args[0], &is_typedarray)); + NODE_API_ASSERT(env, + is_typedarray, + "Wrong type of arguments. Expects a typed array as first " + "argument."); + + napi_typedarray_type type; + size_t length; + size_t byte_offset; + NODE_API_CALL(env, + napi_get_typedarray_info( + env, args[0], &type, &length, NULL, NULL, &byte_offset)); + + if (argc == 4) { + uint32_t uint32_length; + NODE_API_CALL(env, napi_get_value_uint32(env, args[2], &uint32_length)); + length = uint32_length; + + uint32_t uint32_byte_offset; + NODE_API_CALL(env, + napi_get_value_uint32(env, args[3], &uint32_byte_offset)); + byte_offset = uint32_byte_offset; + } + + napi_value typedarray; + NODE_API_CALL(env, + napi_create_typedarray( + env, type, length, args[1], byte_offset, &typedarray)); + + return typedarray; +} + +static napi_value GetArrayBuffer(napi_env env, napi_callback_info info) { + size_t argc = 1; + napi_value args[1]; + NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL)); + + NODE_API_ASSERT(env, argc == 1, "Wrong number of arguments"); + + napi_value arraybuffer; + NODE_API_CALL(env, + napi_get_typedarray_info( + env, args[0], NULL, NULL, NULL, &arraybuffer, NULL)); + + return arraybuffer; +} + +EXTERN_C_START +napi_value Init(napi_env env, napi_value exports) { + napi_property_descriptor descriptors[] = { + DECLARE_NODE_API_PROPERTY("CreateTypedArray", CreateTypedArray), + DECLARE_NODE_API_PROPERTY("GetArrayBuffer", GetArrayBuffer), + }; + + NODE_API_CALL( + env, + napi_define_properties(env, + exports, + sizeof(descriptors) / sizeof(*descriptors), + descriptors)); + + return exports; +} +EXTERN_C_END From d2ce815dc56bae06210f1b43289004e8a2ff614c Mon Sep 17 00:00:00 2001 From: "Node.js GitHub Bot" Date: Wed, 13 May 2026 10:55:06 -0400 Subject: [PATCH 131/168] meta: move one or more collaborators to emeritus PR-URL: https://github.com/nodejs/node/pull/63235 Reviewed-By: Moshe Atlow Reviewed-By: Trivikram Kamat Reviewed-By: Marco Ippolito Reviewed-By: Matteo Collina Reviewed-By: Luigi Pinca Reviewed-By: Rafael Gonzaga --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index c137f44f4b7a4e..b5dbf8ea68e92c 100644 --- a/README.md +++ b/README.md @@ -453,8 +453,6 @@ For information about the governance of the Node.js project, see **Vladimir Morozov** <> (he/him) * [watilde](https://github.com/watilde) - **Daijiro Wachi** <> (he/him) -* [zcbenz](https://github.com/zcbenz) - - **Cheng Zhao** <> (he/him) * [ZYSzys](https://github.com/ZYSzys) - **Yongsheng Zhang** <> (he/him) @@ -733,6 +731,8 @@ For information about the governance of the Node.js project, see **Yorkie Liu** <> * [yosuke-furukawa](https://github.com/yosuke-furukawa) - **Yosuke Furukawa** <> +* [zcbenz](https://github.com/zcbenz) - + **Cheng Zhao** <> (he/him) From a192f19ee79057ed4577cc962945b079f927e74b Mon Sep 17 00:00:00 2001 From: ChrisJr404 Date: Wed, 13 May 2026 10:55:20 -0400 Subject: [PATCH 132/168] doc: document Temporal configure flags in BUILDING.md Note the default-on status of Temporal support in Node.js 26 and document the --v8-enable-temporal-support and --v8-disable-temporal-support options along with the cargo and rustc auto-detection behavior introduced in nodejs/node#61806. Refs: https://github.com/nodejs/node/issues/63225 Signed-off-by: ChrisJr404 PR-URL: https://github.com/nodejs/node/pull/63248 Reviewed-By: Stewart X Addison Reviewed-By: Richard Lau Reviewed-By: Stefan Stojanovic Reviewed-By: Rafael Gonzaga --- BUILDING.md | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/BUILDING.md b/BUILDING.md index 27c651469b6958..3c7e6c524d5fe7 100644 --- a/BUILDING.md +++ b/BUILDING.md @@ -1045,11 +1045,24 @@ enable FIPS support in Node.js. Node.js supports the [Temporal](https://github.com/tc39/proposal-temporal) APIs, when linking statically or dynamically with a version of [temporal\_rs](https://github.com/boa-dev/temporal). -To build Node.js with Temporal support, a Rust toolchain is required: +Temporal support is enabled by default starting in Node.js 26. Building it +requires a Rust toolchain: * rustc >= 1.82 (with LLVM >= 19) * cargo >= 1.82 +If `--v8-enable-temporal-support` and `--v8-disable-temporal-support` are both +omitted, `configure.py` probes for `cargo` and `rustc`. If either is missing, +a warning is printed and Temporal support is disabled. + +* Pass `--v8-enable-temporal-support` to `configure.py` to require Temporal + support. The build will stop with an error if `cargo` or `rustc` cannot be + found. +* Pass `--v8-disable-temporal-support` to opt out of Temporal support and + remove the Rust toolchain requirement. + +Passing both options to `configure.py` is an error. + ## Building Node.js with external core modules It is possible to specify one or more JavaScript text files to be bundled in From bf7e79c264eef9bd0c743588aa6a158a26d90103 Mon Sep 17 00:00:00 2001 From: Marco Ippolito Date: Mon, 11 May 2026 16:44:05 +0200 Subject: [PATCH 133/168] 2026-05-13, Version 22.22.3 'Jod' (LTS) PR-URL: https://github.com/nodejs/node/pull/63250 --- CHANGELOG.md | 15 +++++- doc/changelogs/CHANGELOG_V22.md | 92 +++++++++++++++++++++++++++++++++ 2 files changed, 106 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index d3752d6414964f..0edb03a399f5ca 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -102,7 +102,20 @@ release. 23.0.0
-22.15.0
+22.22.3
+22.22.2
+22.22.1
+22.22.0
+22.21.1
+22.21.0
+22.20.0
+22.19.0
+22.18.0
+22.17.1
+22.17.0
+22.16.0
+22.15.1
+22.15.0
22.14.0
22.13.1
22.13.0
diff --git a/doc/changelogs/CHANGELOG_V22.md b/doc/changelogs/CHANGELOG_V22.md index 8942a59f041948..01c3e115076aeb 100644 --- a/doc/changelogs/CHANGELOG_V22.md +++ b/doc/changelogs/CHANGELOG_V22.md @@ -9,6 +9,7 @@ +22.22.3
22.22.2
22.22.1
22.22.0
@@ -74,6 +75,97 @@ * [io.js](CHANGELOG_IOJS.md) * [Archive](CHANGELOG_ARCHIVE.md) + + +## 2026-05-13, Version 22.22.3 'Jod' (LTS), @marco-ippolito + +### Commits + +* \[[`4f780905c5`](https://github.com/nodejs/node/commit/4f780905c5)] - **crypto**: fix potential null pointer dereference when BIO\_meth\_new() fails (Nora Dossche) [#61788](https://github.com/nodejs/node/pull/61788) +* \[[`4a09efb947`](https://github.com/nodejs/node/commit/4a09efb947)] - **crypto**: update root certificates to NSS 3.121 (Node.js GitHub Bot) [#62485](https://github.com/nodejs/node/pull/62485) +* \[[`e4c0d99839`](https://github.com/nodejs/node/commit/e4c0d99839)] - **deps**: update timezone to 2026a (Node.js GitHub Bot) [#62164](https://github.com/nodejs/node/pull/62164) +* \[[`0226c8dd7a`](https://github.com/nodejs/node/commit/0226c8dd7a)] - **deps**: update simdjson to 4.5.0 (Node.js GitHub Bot) [#62382](https://github.com/nodejs/node/pull/62382) +* \[[`e742ab748c`](https://github.com/nodejs/node/commit/e742ab748c)] - **deps**: update sqlite to 3.51.3 (Node.js GitHub Bot) [#62256](https://github.com/nodejs/node/pull/62256) +* \[[`73cac0571a`](https://github.com/nodejs/node/commit/73cac0571a)] - **deps**: update amaro to 1.1.8 (Node.js GitHub Bot) [#62151](https://github.com/nodejs/node/pull/62151) +* \[[`ae5c162b93`](https://github.com/nodejs/node/commit/ae5c162b93)] - **deps**: update amaro to 1.1.7 (Node.js GitHub Bot) [#61730](https://github.com/nodejs/node/pull/61730) +* \[[`b819cb9977`](https://github.com/nodejs/node/commit/b819cb9977)] - **deps**: update amaro to 1.1.6 (Node.js GitHub Bot) [#61603](https://github.com/nodejs/node/pull/61603) +* \[[`bbcce09dc7`](https://github.com/nodejs/node/commit/bbcce09dc7)] - **deps**: update sqlite to 3.52.0 (Node.js GitHub Bot) [#62150](https://github.com/nodejs/node/pull/62150) +* \[[`22ff2d81ce`](https://github.com/nodejs/node/commit/22ff2d81ce)] - **deps**: update simdjson to 4.3.1 (Node.js GitHub Bot) [#61930](https://github.com/nodejs/node/pull/61930) +* \[[`f49b51d75c`](https://github.com/nodejs/node/commit/f49b51d75c)] - **deps**: update acorn-walk to 8.3.5 (Node.js GitHub Bot) [#61928](https://github.com/nodejs/node/pull/61928) +* \[[`1a5cec0d49`](https://github.com/nodejs/node/commit/1a5cec0d49)] - **deps**: update acorn to 8.16.0 (Node.js GitHub Bot) [#61925](https://github.com/nodejs/node/pull/61925) +* \[[`d339497688`](https://github.com/nodejs/node/commit/d339497688)] - **deps**: update nbytes to 0.1.3 (Node.js GitHub Bot) [#61879](https://github.com/nodejs/node/pull/61879) +* \[[`3ff8ffd459`](https://github.com/nodejs/node/commit/3ff8ffd459)] - **deps**: remove stale OpenSSL arch configs (René) [#61834](https://github.com/nodejs/node/pull/61834) +* \[[`b8ddbc1e9a`](https://github.com/nodejs/node/commit/b8ddbc1e9a)] - **deps**: update llhttp to 9.3.1 (Node.js GitHub Bot) [#61827](https://github.com/nodejs/node/pull/61827) +* \[[`ffda97afd4`](https://github.com/nodejs/node/commit/ffda97afd4)] - **deps**: update googletest to 2461743991f9aa53e9a3625eafcbacd81a3c74cd (Node.js GitHub Bot) [#62484](https://github.com/nodejs/node/pull/62484) +* \[[`79aa32cf4f`](https://github.com/nodejs/node/commit/79aa32cf4f)] - **deps**: update googletest to 73a63ea05dc8ca29ec1d2c1d66481dd0de1950f1 (Node.js GitHub Bot) [#61927](https://github.com/nodejs/node/pull/61927) +* \[[`b6957e13b6`](https://github.com/nodejs/node/commit/b6957e13b6)] - **deps**: update archs files for openssl-3.5.6 (Node.js GitHub Bot) [#62629](https://github.com/nodejs/node/pull/62629) +* \[[`3a27669063`](https://github.com/nodejs/node/commit/3a27669063)] - **deps**: upgrade openssl sources to openssl-3.5.6 (Node.js GitHub Bot) [#62629](https://github.com/nodejs/node/pull/62629) +* \[[`d568a1bb53`](https://github.com/nodejs/node/commit/d568a1bb53)] - **deps**: upgrade npm to 10.9.8 (npm team) [#62463](https://github.com/nodejs/node/pull/62463) +* \[[`ec11f3c1d5`](https://github.com/nodejs/node/commit/ec11f3c1d5)] - **deps**: V8: backport 85b390089e51 (Thibaud Michaud) [#62783](https://github.com/nodejs/node/pull/62783) +* \[[`08609712ed`](https://github.com/nodejs/node/commit/08609712ed)] - **deps**: V8: backport 1b27e4674f11 (Thibaud Michaud) [#62783](https://github.com/nodejs/node/pull/62783) +* \[[`dcc60d5ab2`](https://github.com/nodejs/node/commit/dcc60d5ab2)] - **deps**: V8: backport 9997fc013952 (Thibaud Michaud) [#62783](https://github.com/nodejs/node/pull/62783) +* \[[`1d1f4451fb`](https://github.com/nodejs/node/commit/1d1f4451fb)] - **deps**: V8: cherry-pick b96e40d5ac85 (Clemens Backes) [#62783](https://github.com/nodejs/node/pull/62783) +* \[[`2268567237`](https://github.com/nodejs/node/commit/2268567237)] - **deps**: V8: cherry-pick 7cb6188cf913 (Thibaud Michaud) [#62783](https://github.com/nodejs/node/pull/62783) +* \[[`92804cdbea`](https://github.com/nodejs/node/commit/92804cdbea)] - **deps**: V8: cherry-pick e7ccf0af1bdd (Thibaud Michaud) [#62783](https://github.com/nodejs/node/pull/62783) +* \[[`eae2c27a40`](https://github.com/nodejs/node/commit/eae2c27a40)] - **deps**: V8: cherry-pick 8e214ec3ec8c (Thibaud Michaud) [#62783](https://github.com/nodejs/node/pull/62783) +* \[[`a1799a49bb`](https://github.com/nodejs/node/commit/a1799a49bb)] - **deps**: V8: backport 63b8849d73ae (Thibaud Michaud) [#62783](https://github.com/nodejs/node/pull/62783) +* \[[`a2df2d8731`](https://github.com/nodejs/node/commit/a2df2d8731)] - **deps**: V8: backport 323942700cfe (Thibaud Michaud) [#62783](https://github.com/nodejs/node/pull/62783) +* \[[`e3d65c7dca`](https://github.com/nodejs/node/commit/e3d65c7dca)] - **deps**: V8: backport 89dc6eab605c (Thibaud Michaud) [#62783](https://github.com/nodejs/node/pull/62783) +* \[[`5e7db133de`](https://github.com/nodejs/node/commit/5e7db133de)] - **deps**: V8: backport 910cb91733dc (Jakob Kummerow) [#62783](https://github.com/nodejs/node/pull/62783) +* \[[`d0c24a28af`](https://github.com/nodejs/node/commit/d0c24a28af)] - **deps**: V8: cherry-pick b8f91e510e0f (Thibaud Michaud) [#62783](https://github.com/nodejs/node/pull/62783) +* \[[`d358687824`](https://github.com/nodejs/node/commit/d358687824)] - **deps**: V8: cherry-pick cf03d55db2a0 (Thibaud Michaud) [#62783](https://github.com/nodejs/node/pull/62783) +* \[[`67c8b2c349`](https://github.com/nodejs/node/commit/67c8b2c349)] - **deps**: V8: cherry-pick 692f3d526a38 (Sébastien Doeraene) [#62783](https://github.com/nodejs/node/pull/62783) +* \[[`71e5a59ffd`](https://github.com/nodejs/node/commit/71e5a59ffd)] - **deps**: V8: cherry-pick c734674e03f9 (Manos Koukoutos) [#62783](https://github.com/nodejs/node/pull/62783) +* \[[`f0dbe81c7b`](https://github.com/nodejs/node/commit/f0dbe81c7b)] - **deps**: V8: cherry-pick b2f3aea23a01 (Thibaud Michaud) [#62783](https://github.com/nodejs/node/pull/62783) +* \[[`d333f480c3`](https://github.com/nodejs/node/commit/d333f480c3)] - **deps**: V8: cherry-pick 5f1342c20b59 (Matthias Liedtke) [#62783](https://github.com/nodejs/node/pull/62783) +* \[[`db722725bb`](https://github.com/nodejs/node/commit/db722725bb)] - **deps**: use npm undici\@six tag in `update-undici.sh` (Matteo Collina) [#63012](https://github.com/nodejs/node/pull/63012) +* \[[`9b57979d9c`](https://github.com/nodejs/node/commit/9b57979d9c)] - **doc**: add Rafael to last security release steward (Rafael Gonzaga) [#62423](https://github.com/nodejs/node/pull/62423) +* \[[`d8075585bf`](https://github.com/nodejs/node/commit/d8075585bf)] - **doc**: add path to vulnerabilities.json mention (Rafael Gonzaga) [#62355](https://github.com/nodejs/node/pull/62355) +* \[[`6ec9a70204`](https://github.com/nodejs/node/commit/6ec9a70204)] - **doc**: clarify fs.ReadStream and fs.WriteStream are not constructable (Kit Dallege) [#62208](https://github.com/nodejs/node/pull/62208) +* \[[`1fc86fcb6e`](https://github.com/nodejs/node/commit/1fc86fcb6e)] - **doc**: add note (and caveat) for `mock.module` about customization hooks (Jacob Smith) [#62075](https://github.com/nodejs/node/pull/62075) +* \[[`491be80bd9`](https://github.com/nodejs/node/commit/491be80bd9)] - **doc**: add efekrskl as triager (Efe) [#61876](https://github.com/nodejs/node/pull/61876) +* \[[`18558293a3`](https://github.com/nodejs/node/commit/18558293a3)] - **doc**: fix module.stripTypeScriptTypes indentation (René) [#61992](https://github.com/nodejs/node/pull/61992) +* \[[`8e20976522`](https://github.com/nodejs/node/commit/8e20976522)] - **doc**: explicitly mention Slack handle (Rafael Gonzaga) [#61986](https://github.com/nodejs/node/pull/61986) +* \[[`70b8e6b4fb`](https://github.com/nodejs/node/commit/70b8e6b4fb)] - **doc**: rename invalid `function` parameter (René) [#61942](https://github.com/nodejs/node/pull/61942) +* \[[`4045c76f6c`](https://github.com/nodejs/node/commit/4045c76f6c)] - **doc**: clarify status of feature request issues (Antoine du Hamel) [#61505](https://github.com/nodejs/node/pull/61505) +* \[[`c54652f2aa`](https://github.com/nodejs/node/commit/c54652f2aa)] - **doc**: remove incorrect mention of `module` in `typescript.md` (Rob Palmer) [#61839](https://github.com/nodejs/node/pull/61839) +* \[[`9fad6cedf5`](https://github.com/nodejs/node/commit/9fad6cedf5)] - **doc**: clarify async caveats for `events.once()` (René) [#61572](https://github.com/nodejs/node/pull/61572) +* \[[`2f1e5733fe`](https://github.com/nodejs/node/commit/2f1e5733fe)] - **doc**: update Juan's security steward info (Juan José) [#61754](https://github.com/nodejs/node/pull/61754) +* \[[`a64bdb5068`](https://github.com/nodejs/node/commit/a64bdb5068)] - **doc**: fix overstated Date header requirement in response.sendDate (Kit Dallege) [#62206](https://github.com/nodejs/node/pull/62206) +* \[[`02797de923`](https://github.com/nodejs/node/commit/02797de923)] - **doc**: fix small environment\_variables typo (chris) [#62279](https://github.com/nodejs/node/pull/62279) +* \[[`f22ebdc809`](https://github.com/nodejs/node/commit/f22ebdc809)] - **doc**: fix small logic error in DETECT\_MODULE\_SYNTAX (René) [#62025](https://github.com/nodejs/node/pull/62025) +* \[[`9f4508062a`](https://github.com/nodejs/node/commit/9f4508062a)] - **doc**: fix methods being documented as properties in `process.md` (Antoine du Hamel) [#61765](https://github.com/nodejs/node/pull/61765) +* \[[`3ea39ff135`](https://github.com/nodejs/node/commit/3ea39ff135)] - **doc**: fix dropdown menu being obscured at <600px due to stacking context (Jeff) [#61735](https://github.com/nodejs/node/pull/61735) +* \[[`c22445079b`](https://github.com/nodejs/node/commit/c22445079b)] - **doc**: fix spacing in process message event (Aviv Keller) [#61756](https://github.com/nodejs/node/pull/61756) +* \[[`32831b5223`](https://github.com/nodejs/node/commit/32831b5223)] - **doc**: fix broken links of net.md (YuSheng Chen) [#61673](https://github.com/nodejs/node/pull/61673) +* \[[`005508d509`](https://github.com/nodejs/node/commit/005508d509)] - **doc**: remove obsolete Boxstarter automated install (Mike McCready) [#61785](https://github.com/nodejs/node/pull/61785) +* \[[`45b3506eb8`](https://github.com/nodejs/node/commit/45b3506eb8)] - **doc,src,test**: fix dead inspector help URL (semimikoh) [#62745](https://github.com/nodejs/node/pull/62745) +* \[[`37c2fd6f7d`](https://github.com/nodejs/node/commit/37c2fd6f7d)] - **esm**: fix path normalization in `finalizeResolution` (Antoine du Hamel) [#62080](https://github.com/nodejs/node/pull/62080) +* \[[`1769d74613`](https://github.com/nodejs/node/commit/1769d74613)] - **esm**: populate separate cache for require(esm) in imported CJS (Joyee Cheung) [#59679](https://github.com/nodejs/node/pull/59679) +* \[[`ee02966ffc`](https://github.com/nodejs/node/commit/ee02966ffc)] - **http**: fix keep-alive socket reuse race in requestOnFinish (Martin Slota) [#61710](https://github.com/nodejs/node/pull/61710) +* \[[`2fdb5ce6cc`](https://github.com/nodejs/node/commit/2fdb5ce6cc)] - **http2**: fix FileHandle leak in respondWithFile (sangwook) [#61707](https://github.com/nodejs/node/pull/61707) +* \[[`aa2c1eca04`](https://github.com/nodejs/node/commit/aa2c1eca04)] - **lib**: fix source map url parse in dynamic imports (Chengzhong Wu) [#61990](https://github.com/nodejs/node/pull/61990) +* \[[`785b00cbeb`](https://github.com/nodejs/node/commit/785b00cbeb)] - **meta**: pass release version to release worker (flakey5) [#62777](https://github.com/nodejs/node/pull/62777) +* \[[`447fb9a0b5`](https://github.com/nodejs/node/commit/447fb9a0b5)] - **meta**: persist sccache daemon until end of build workflows (René) [#61639](https://github.com/nodejs/node/pull/61639) +* \[[`5065a0acb3`](https://github.com/nodejs/node/commit/5065a0acb3)] - **module**: do not invoke resolve hooks twice for imported cjs (Joyee Cheung) [#61529](https://github.com/nodejs/node/pull/61529) +* \[[`9a2e21305d`](https://github.com/nodejs/node/commit/9a2e21305d)] - **module**: do not wrap module.\_load when tracing is not enabled (Joyee Cheung) [#61479](https://github.com/nodejs/node/pull/61479) +* \[[`b9240bc063`](https://github.com/nodejs/node/commit/b9240bc063)] - **module**: fix sync resolve hooks for require with node: prefixes (Joyee Cheung) [#61088](https://github.com/nodejs/node/pull/61088) +* \[[`2e91b28aaf`](https://github.com/nodejs/node/commit/2e91b28aaf)] - **module**: handle null source from async loader hooks in sync hooks (Joyee Cheung) [#59929](https://github.com/nodejs/node/pull/59929) +* \[[`39147c154e`](https://github.com/nodejs/node/commit/39147c154e)] - **module**: use sync cjs when importing cts (Marco Ippolito) [#60072](https://github.com/nodejs/node/pull/60072) +* \[[`12a2462b2c`](https://github.com/nodejs/node/commit/12a2462b2c)] - **module**: only put directly require-d ESM into require.cache (Joyee Cheung) [#59874](https://github.com/nodejs/node/pull/59874) +* \[[`cf39566277`](https://github.com/nodejs/node/commit/cf39566277)] - **src**: fix flags argument offset in JSUdpWrap (Weixie Cui) [#61948](https://github.com/nodejs/node/pull/61948) +* \[[`578a9a9230`](https://github.com/nodejs/node/commit/578a9a9230)] - **src**: clamp WriteUtf8 capacity to INT\_MAX in EncodeInto (semimikoh) [#62621](https://github.com/nodejs/node/pull/62621) +* \[[`57c3035fec`](https://github.com/nodejs/node/commit/57c3035fec)] - **stream**: fix decoded fromList chunk boundary check (Thomas Watson) [#61884](https://github.com/nodejs/node/pull/61884) +* \[[`57fb008bb8`](https://github.com/nodejs/node/commit/57fb008bb8)] - **test**: update tls junk data error expectations (Filip Skokan) [#62629](https://github.com/nodejs/node/pull/62629) +* \[[`363f9a9d18`](https://github.com/nodejs/node/commit/363f9a9d18)] - **test**: skip `test-url` on `--shared-ada` builds (Antoine du Hamel) [#62019](https://github.com/nodejs/node/pull/62019) +* \[[`daaead342b`](https://github.com/nodejs/node/commit/daaead342b)] - **test**: simplify encodeInto large buffer regression test (semimikoh) [#62621](https://github.com/nodejs/node/pull/62621) +* \[[`ecfa766b41`](https://github.com/nodejs/node/commit/ecfa766b41)] - **tools**: fix auto-start-ci (Antoine du Hamel) [#61900](https://github.com/nodejs/node/pull/61900) +* \[[`17c0a610af`](https://github.com/nodejs/node/commit/17c0a610af)] - **tools**: fix parsing of commit trailers in `lint-release-proposal` GHA (Antoine du Hamel) [#62077](https://github.com/nodejs/node/pull/62077) +* \[[`89ad7dc63b`](https://github.com/nodejs/node/commit/89ad7dc63b)] - **tools**: enforce removal of `lts-watch-*` labels on release proposals (Antoine du Hamel) [#61672](https://github.com/nodejs/node/pull/61672) +* \[[`5f9bb8ef0c`](https://github.com/nodejs/node/commit/5f9bb8ef0c)] - **tools**: revert tools GHA workflow to ubuntu-latest (Richard Lau) [#62024](https://github.com/nodejs/node/pull/62024) +* \[[`977ef80ac1`](https://github.com/nodejs/node/commit/977ef80ac1)] - **url**: process crash via malformed UNC hostname in pathToFileURL() (Nicola Del Gobbo) [#62574](https://github.com/nodejs/node/pull/62574) +* \[[`ad8f518a81`](https://github.com/nodejs/node/commit/ad8f518a81)] - **zlib**: fix use-after-free when reset() is called during write (Matteo Collina) [#62325](https://github.com/nodejs/node/pull/62325) + ## 2026-03-24, Version 22.22.2 'Jod' (LTS), @RafaelGSS prepared by @aduh95 From da860f9e3601585364e7b63659c1924d3172e524 Mon Sep 17 00:00:00 2001 From: Mike McCready <66998419+MikeMcC399@users.noreply.github.com> Date: Thu, 14 May 2026 18:54:38 +0200 Subject: [PATCH 134/168] doc: recommend explicitly Tier 1 or 2 for production applications MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mike McCready <66998419+MikeMcC399@users.noreply.github.com> PR-URL: https://github.com/nodejs/node/pull/63187 Reviewed-By: Paolo Insogna Reviewed-By: Michaël Zasso Reviewed-By: Luigi Pinca --- BUILDING.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/BUILDING.md b/BUILDING.md index 3c7e6c524d5fe7..dbc8e11053da9e 100644 --- a/BUILDING.md +++ b/BUILDING.md @@ -98,7 +98,7 @@ and libc version. The table below lists the support tier for each supported combination. A list of [supported compile toolchains](#supported-toolchains) is also supplied for tier 1 platforms. -**For production applications, run Node.js on supported platforms only.** +**For production applications, run Node.js on supported platforms only (Tier 1 or 2).** Node.js does not support a platform version if a vendor has expired support for it. In other words, Node.js does not support running on End-of-Life (EoL) From 843dc5f0d5ade521552684a161b4f3798e6baa99 Mon Sep 17 00:00:00 2001 From: Mike McCready <66998419+MikeMcC399@users.noreply.github.com> Date: Thu, 14 May 2026 18:54:51 +0200 Subject: [PATCH 135/168] doc: replace Visual Studio 2022 Evergreen version reference with 17.14 Signed-off-by: Mike McCready <66998419+MikeMcC399@users.noreply.github.com> PR-URL: https://github.com/nodejs/node/pull/63211 Reviewed-By: Luigi Pinca Reviewed-By: Stefan Stojanovic Reviewed-By: Rafael Gonzaga --- BUILDING.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/BUILDING.md b/BUILDING.md index dbc8e11053da9e..7597f0114e7f76 100644 --- a/BUILDING.md +++ b/BUILDING.md @@ -752,7 +752,7 @@ Refs: To install it, select the following two optional components: * C++ Clang Compiler for Windows (Microsoft.VisualStudio.Component.VC.Llvm.Clang) * MSBuild support for LLVM (clang-cl) toolset (Microsoft.VisualStudio.Component.VC.Llvm.ClangToolset) -* As an alternative to Visual Studio 2026, download Visual Studio 2022 Current channel Version 17.4 from the +* As an alternative to Visual Studio 2026, download Visual Studio 2022 Current channel Version 17.14 from the [Evergreen bootstrappers](https://learn.microsoft.com/en-us/visualstudio/releases/2022/release-history#evergreen-bootstrappers) table and install using the same workload and optional component selection as described above. * Basic Unix tools required for some tests, From f56c4c5a9dbb7a69a4e9527f9977f26fda7ed334 Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Thu, 14 May 2026 22:51:41 +0200 Subject: [PATCH 136/168] test: move FFI tests to `NATIVE_SUITES` Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/63165 Reviewed-By: Richard Lau Reviewed-By: Luigi Pinca --- Makefile | 2 +- tools/test.py | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/Makefile b/Makefile index 1f35c64eb73626..1e1264619d24bb 100644 --- a/Makefile +++ b/Makefile @@ -603,7 +603,7 @@ test-all-suites: | clear-stalled test-build bench-addons-build doc-only ## Run a $(PYTHON) tools/test.py $(PARALLEL_ARGS) --mode=$(BUILDTYPE_LOWER) test/* JS_SUITES ?= default -NATIVE_SUITES ?= addons js-native-api node-api embedding +NATIVE_SUITES ?= addons ffi js-native-api node-api embedding # CI_* variables should be kept synchronized with the ones in vcbuild.bat CI_NATIVE_SUITES ?= $(NATIVE_SUITES) benchmark CI_JS_SUITES ?= $(JS_SUITES) pummel diff --git a/tools/test.py b/tools/test.py index 6440e1303e5f53..2c2a4d78d80aea 100755 --- a/tools/test.py +++ b/tools/test.py @@ -1597,6 +1597,7 @@ def PrintCrashed(code): 'benchmark', 'doctool', 'embedding', + 'ffi', 'internet', 'js-native-api', 'node-api', From 2edd842e2ad390e75bc226751b784b78287f9575 Mon Sep 17 00:00:00 2001 From: Trivikram Kamat <16024985+trivikr@users.noreply.github.com> Date: Thu, 14 May 2026 13:51:54 -0700 Subject: [PATCH 137/168] stream: cache minimum cursor count in share MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Track the number of consumers at the cached minimum cursor in share() so the minimum is only recomputed when the last consumer at that cursor advances or detaches. This avoids scanning every consumer on each trim attempt when multiple consumers advance through a shared buffer. Signed-off-by: Kamat, Trivikram <16024985+trivikr@users.noreply.github.com> Assisted-by: openai:gpt-5.5 PR-URL: https://github.com/nodejs/node/pull/63262 Reviewed-By: James M Snell Reviewed-By: René --- benchmark/streams/iter-throughput-share.js | 32 +++++ lib/internal/streams/iter/broadcast.js | 3 +- lib/internal/streams/iter/share.js | 142 +++++++++++++++++---- lib/internal/streams/iter/utils.js | 20 +-- 4 files changed, 160 insertions(+), 37 deletions(-) create mode 100644 benchmark/streams/iter-throughput-share.js diff --git a/benchmark/streams/iter-throughput-share.js b/benchmark/streams/iter-throughput-share.js new file mode 100644 index 00000000000000..a0383172c04140 --- /dev/null +++ b/benchmark/streams/iter-throughput-share.js @@ -0,0 +1,32 @@ +'use strict'; + +const common = require('../common.js'); + +const bench = common.createBenchmark(main, { + consumers: [2, 8, 32], + batches: [1e4], + backpressure: ['block'], + n: [5], +}, { + flags: ['--experimental-stream-iter'], +}); + +async function main({ consumers, batches, backpressure, n }) { + const { share, array } = require('stream/iter'); + const chunk = Buffer.alloc(1024); + const totalOps = batches * consumers * n; + + async function* source() { + for (let i = 0; i < batches; i++) { + yield [chunk]; + } + } + + bench.start(); + for (let i = 0; i < n; i++) { + const shared = share(source(), { highWaterMark: 64, backpressure }); + const readers = Array.from({ length: consumers }, () => array(shared.pull())); + await Promise.all(readers); + } + bench.end(totalOps); +} diff --git a/lib/internal/streams/iter/broadcast.js b/lib/internal/streams/iter/broadcast.js index 769f93b5404c30..9b3ccebff9ac89 100644 --- a/lib/internal/streams/iter/broadcast.js +++ b/lib/internal/streams/iter/broadcast.js @@ -343,8 +343,9 @@ class BroadcastImpl { // Private methods #recomputeMinCursor() { - this.#cachedMinCursor = getMinCursor( + const { minCursor } = getMinCursor( this.#consumers, this.#bufferStart + this.#buffer.length); + this.#cachedMinCursor = minCursor; this.#minCursorDirty = false; } diff --git a/lib/internal/streams/iter/share.js b/lib/internal/streams/iter/share.js index 752c0bfcbcab8f..0160bc7eace009 100644 --- a/lib/internal/streams/iter/share.js +++ b/lib/internal/streams/iter/share.js @@ -77,6 +77,8 @@ class ShareImpl { #cancelled = false; #pulling = false; #pullWaiters = []; + #cachedMinCursor = 0; + #cachedMinCursorConsumers = 0; constructor(source, options) { this.#source = source; @@ -114,6 +116,14 @@ class ShareImpl { }; this.#consumers.add(state); + if (this.#consumers.size === 1) { + this.#cachedMinCursor = state.cursor; + this.#cachedMinCursorConsumers = 1; + } else if (state.cursor === this.#cachedMinCursor) { + this.#cachedMinCursorConsumers++; + } else { + this.#recomputeMinCursor(); + } const self = this; return { @@ -139,7 +149,7 @@ class ShareImpl { if (self.#cancelled) { state.detached = true; - self.#consumers.delete(state); + self.#deleteConsumer(state); return { __proto__: null, done: true, value: undefined }; } @@ -147,14 +157,18 @@ class ShareImpl { const bufferIndex = state.cursor - self.#bufferStart; if (bufferIndex < self.#buffer.length) { const chunk = self.#buffer.get(bufferIndex); + const cursor = state.cursor; state.cursor++; - self.#tryTrimBuffer(); + if (cursor === self.#cachedMinCursor && + --self.#cachedMinCursorConsumers === 0) { + self.#tryTrimBuffer(); + } return { __proto__: null, done: false, value: chunk }; } if (self.#sourceExhausted) { state.detached = true; - self.#consumers.delete(state); + self.#deleteConsumer(state); if (self.#sourceError) throw self.#sourceError; return { __proto__: null, done: true, value: undefined }; } @@ -163,7 +177,7 @@ class ShareImpl { const canPull = await self.#waitForBufferSpace(); if (!canPull) { state.detached = true; - self.#consumers.delete(state); + self.#deleteConsumer(state); if (self.#sourceError) throw self.#sourceError; return { __proto__: null, done: true, value: undefined }; } @@ -176,8 +190,9 @@ class ShareImpl { state.detached = true; state.resolve = null; state.reject = null; - self.#consumers.delete(state); - self.#tryTrimBuffer(); + if (self.#deleteConsumer(state)) { + self.#tryTrimBuffer(); + } return { __proto__: null, done: true, value: undefined }; }, @@ -185,8 +200,9 @@ class ShareImpl { state.detached = true; state.resolve = null; state.reject = null; - self.#consumers.delete(state); - self.#tryTrimBuffer(); + if (self.#deleteConsumer(state)) { + self.#tryTrimBuffer(); + } return { __proto__: null, done: true, value: undefined }; }, }; @@ -254,9 +270,11 @@ class ShareImpl { this.#bufferStart++; for (const consumer of this.#consumers) { if (consumer.cursor < this.#bufferStart) { + this.#deleteConsumerFromMin(consumer); consumer.cursor = this.#bufferStart; } } + this.#recomputeMinCursor(); return true; case 'drop-newest': return true; @@ -324,18 +342,41 @@ class ShareImpl { } #tryTrimBuffer() { - const minCursor = getMinCursor( - this.#consumers, this.#bufferStart + this.#buffer.length); - const trimCount = minCursor - this.#bufferStart; + if (this.#cachedMinCursorConsumers === 0) { + this.#recomputeMinCursor(); + } + const trimCount = this.#cachedMinCursor - this.#bufferStart; if (trimCount > 0) { this.#buffer.trimFront(trimCount); - this.#bufferStart = minCursor; + this.#bufferStart = this.#cachedMinCursor; for (let i = 0; i < this.#pullWaiters.length; i++) { this.#pullWaiters[i](); } this.#pullWaiters = []; } } + + #recomputeMinCursor() { + const { minCursor, minCursorConsumers } = getMinCursor( + this.#consumers, this.#bufferStart + this.#buffer.length); + this.#cachedMinCursor = minCursor; + this.#cachedMinCursorConsumers = minCursorConsumers; + } + + #deleteConsumerFromMin(consumer) { + if (consumer.cursor === this.#cachedMinCursor) { + this.#cachedMinCursorConsumers--; + return this.#cachedMinCursorConsumers === 0; + } + return false; + } + + #deleteConsumer(consumer) { + if (this.#consumers.delete(consumer)) { + return this.#deleteConsumerFromMin(consumer); + } + return false; + } } // ============================================================================= @@ -352,6 +393,8 @@ class SyncShareImpl { #sourceExhausted = false; #sourceError = null; #cancelled = false; + #cachedMinCursor = 0; + #cachedMinCursorConsumers = 0; constructor(source, options) { this.#source = source; @@ -383,6 +426,14 @@ class SyncShareImpl { }; this.#consumers.add(state); + if (this.#consumers.size === 1) { + this.#cachedMinCursor = state.cursor; + this.#cachedMinCursorConsumers = 1; + } else if (state.cursor === this.#cachedMinCursor) { + this.#cachedMinCursorConsumers++; + } else { + this.#recomputeMinCursor(); + } const self = this; return { @@ -396,26 +447,30 @@ class SyncShareImpl { } if (self.#sourceError) { state.detached = true; - self.#consumers.delete(state); + self.#deleteConsumer(state); throw self.#sourceError; } if (self.#cancelled) { state.detached = true; - self.#consumers.delete(state); + self.#deleteConsumer(state); return { __proto__: null, done: true, value: undefined }; } const bufferIndex = state.cursor - self.#bufferStart; if (bufferIndex < self.#buffer.length) { const chunk = self.#buffer.get(bufferIndex); + const cursor = state.cursor; state.cursor++; - self.#tryTrimBuffer(); + if (cursor === self.#cachedMinCursor && + --self.#cachedMinCursorConsumers === 0) { + self.#tryTrimBuffer(); + } return { __proto__: null, done: false, value: chunk }; } if (self.#sourceExhausted) { state.detached = true; - self.#consumers.delete(state); + self.#deleteConsumer(state); return { __proto__: null, done: true, value: undefined }; } @@ -436,13 +491,15 @@ class SyncShareImpl { self.#bufferStart++; for (const consumer of self.#consumers) { if (consumer.cursor < self.#bufferStart) { + self.#deleteConsumerFromMin(consumer); consumer.cursor = self.#bufferStart; } } + self.#recomputeMinCursor(); break; case 'drop-newest': state.detached = true; - self.#consumers.delete(state); + self.#deleteConsumer(state); return { __proto__: null, done: true, value: undefined }; } } @@ -451,21 +508,25 @@ class SyncShareImpl { if (self.#sourceError) { state.detached = true; - self.#consumers.delete(state); + self.#deleteConsumer(state); throw self.#sourceError; } const newBufferIndex = state.cursor - self.#bufferStart; if (newBufferIndex < self.#buffer.length) { const chunk = self.#buffer.get(newBufferIndex); + const cursor = state.cursor; state.cursor++; - self.#tryTrimBuffer(); + if (cursor === self.#cachedMinCursor && + --self.#cachedMinCursorConsumers === 0) { + self.#tryTrimBuffer(); + } return { __proto__: null, done: false, value: chunk }; } if (self.#sourceExhausted) { state.detached = true; - self.#consumers.delete(state); + self.#deleteConsumer(state); return { __proto__: null, done: true, value: undefined }; } @@ -474,15 +535,17 @@ class SyncShareImpl { return() { state.detached = true; - self.#consumers.delete(state); - self.#tryTrimBuffer(); + if (self.#deleteConsumer(state)) { + self.#tryTrimBuffer(); + } return { __proto__: null, done: true, value: undefined }; }, throw() { state.detached = true; - self.#consumers.delete(state); - self.#tryTrimBuffer(); + if (self.#deleteConsumer(state)) { + self.#tryTrimBuffer(); + } return { __proto__: null, done: true, value: undefined }; }, }; @@ -532,13 +595,36 @@ class SyncShareImpl { } #tryTrimBuffer() { - const minCursor = getMinCursor( - this.#consumers, this.#bufferStart + this.#buffer.length); - const trimCount = minCursor - this.#bufferStart; + if (this.#cachedMinCursorConsumers === 0) { + this.#recomputeMinCursor(); + } + const trimCount = this.#cachedMinCursor - this.#bufferStart; if (trimCount > 0) { this.#buffer.trimFront(trimCount); - this.#bufferStart = minCursor; + this.#bufferStart = this.#cachedMinCursor; + } + } + + #recomputeMinCursor() { + const { minCursor, minCursorConsumers } = getMinCursor( + this.#consumers, this.#bufferStart + this.#buffer.length); + this.#cachedMinCursor = minCursor; + this.#cachedMinCursorConsumers = minCursorConsumers; + } + + #deleteConsumerFromMin(consumer) { + if (consumer.cursor === this.#cachedMinCursor) { + this.#cachedMinCursorConsumers--; + return this.#cachedMinCursorConsumers === 0; + } + return false; + } + + #deleteConsumer(consumer) { + if (this.#consumers.delete(consumer)) { + return this.#deleteConsumerFromMin(consumer); } + return false; } } diff --git a/lib/internal/streams/iter/utils.js b/lib/internal/streams/iter/utils.js index 0520630b09c4b8..7829afaade832f 100644 --- a/lib/internal/streams/iter/utils.js +++ b/lib/internal/streams/iter/utils.js @@ -70,20 +70,24 @@ function onSignalAbort(signal, handler) { } /** - * Compute the minimum cursor across a set of consumers. - * Returns fallback if the set is empty. + * Compute the minimum cursor across a set of consumers and count how many + * consumers are at that cursor. * @param {Set} consumers - Set of objects with a `cursor` property - * @param {number} fallback - Value to return when set is empty - * @returns {number} + * @param {number} fallback - Cursor to return when set is empty + * @returns {{ minCursor: number, minCursorConsumers: number }} */ function getMinCursor(consumers, fallback) { - let min = Infinity; + let minCursor = fallback; + let minCursorConsumers = 0; for (const consumer of consumers) { - if (consumer.cursor < min) { - min = consumer.cursor; + if (consumer.cursor < minCursor) { + minCursor = consumer.cursor; + minCursorConsumers = 1; + } else if (consumer.cursor === minCursor) { + minCursorConsumers++; } } - return min === Infinity ? fallback : min; + return { __proto__: null, minCursor, minCursorConsumers }; } /** From a73fafb5cb84c2ebf57e91155aa90e2cd5bf953e Mon Sep 17 00:00:00 2001 From: Robin Malfait Date: Fri, 15 May 2026 00:20:00 +0200 Subject: [PATCH 138/168] doc: reference correct function in Module docs MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Robin Malfait PR-URL: https://github.com/nodejs/node/pull/63247 Reviewed-By: René Reviewed-By: Luigi Pinca --- doc/api/module.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/api/module.md b/doc/api/module.md index 7f47ab0b55e109..5ab07802e0588f 100644 --- a/doc/api/module.md +++ b/doc/api/module.md @@ -1020,7 +1020,7 @@ function load(url, context, nextLoad) { }; } -registerHooks({ resolve }); +registerHooks({ load }); ``` In a more advanced scenario, this can also be used to transform an unsupported From 841fc901f1b198ba9f5de8de1df4c85f87404a95 Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Fri, 15 May 2026 01:14:29 +0200 Subject: [PATCH 139/168] tools: fix test426 updater The previous version produces a commit that does pass the linter because of a too-long commit title. Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/63271 Reviewed-By: Colin Ihrig Reviewed-By: Rafael Gonzaga Reviewed-By: Chengzhong Wu Reviewed-By: Luigi Pinca --- tools/dep_updaters/update-test426-fixtures.sh | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/tools/dep_updaters/update-test426-fixtures.sh b/tools/dep_updaters/update-test426-fixtures.sh index a1a97797c29357..e9cca0dfac815e 100755 --- a/tools/dep_updaters/update-test426-fixtures.sh +++ b/tools/dep_updaters/update-test426-fixtures.sh @@ -17,10 +17,10 @@ fi TARBALL_URL=$(curl -fsIo /dev/null -w '%header{Location}' https://github.com/tc39/source-map-tests/archive/HEAD.tar.gz) SHA=$(basename "$TARBALL_URL") -if [ "$CURRENT_SHA" = "$SHA" ]; then - echo "Already up-to-date" - exit 0 -fi +# shellcheck disable=SC1091 +. "$BASE_DIR/tools/dep_updaters/utils.sh" + +compare_dependency_version "test426-fixtures" "$CURRENT_SHA" "$SHA" rm -rf "$TARGET_DIR" mkdir "$TARGET_DIR" @@ -32,4 +32,5 @@ mv "$TMP_FILE" "$README" # The last line of the script should always print the new version, # as we need to add it to $GITHUB_ENV variable. -echo "NEW_VERSION=$SHA" +NEW_VERSION=$(echo "$SHA" | head -c 39) +echo "NEW_VERSION=$NEW_VERSION" From 64820738972c21354c6c6abd96144d449054ac7d Mon Sep 17 00:00:00 2001 From: Trivikram Kamat <16024985+trivikr@users.noreply.github.com> Date: Fri, 15 May 2026 00:00:15 -0700 Subject: [PATCH 140/168] stream: preserve toReadableSync batch after backpressure Keep the current batch and index across _read() calls so chunks that remain after push() returns false are emitted on later reads. Fixes: https://github.com/nodejs/node/issues/63275 Signed-off-by: Kamat, Trivikram <16024985+trivikr@users.noreply.github.com> Assisted-by: openai:gpt-5.5 PR-URL: https://github.com/nodejs/node/pull/63276 Fixes: https://github.com/nodejs/node/issues/63275 Reviewed-By: Matteo Collina Reviewed-By: James M Snell --- lib/internal/streams/iter/classic.js | 22 +++++++++++++++---- test/parallel/test-stream-iter-to-readable.js | 16 ++++++++++++++ 2 files changed, 34 insertions(+), 4 deletions(-) diff --git a/lib/internal/streams/iter/classic.js b/lib/internal/streams/iter/classic.js index 18d1733d6ad648..854f761d071b1c 100644 --- a/lib/internal/streams/iter/classic.js +++ b/lib/internal/streams/iter/classic.js @@ -363,23 +363,37 @@ function toReadableSync(source, options = kNullPrototype) { const ReadableCtor = lazyReadable(); const iterator = source[SymbolIterator](); + let hasBatch = false; + let batch; + let batchIndex = 0; return new ReadableCtor({ __proto__: null, highWaterMark, read() { for (;;) { - const { value: batch, done } = iterator.next(); + if (hasBatch) { + while (batchIndex < batch.length) { + if (!this.push(batch[batchIndex++])) return; + } + batch = undefined; + hasBatch = false; + batchIndex = 0; + } + + const result = iterator.next(); + const { done } = result; if (done) { this.push(null); return; } - for (let i = 0; i < batch.length; i++) { - if (!this.push(batch[i])) return; - } + batch = result.value; + hasBatch = true; } }, destroy(err, cb) { + batch = undefined; + hasBatch = false; if (typeof iterator.return === 'function') iterator.return(); cb(err); }, diff --git a/test/parallel/test-stream-iter-to-readable.js b/test/parallel/test-stream-iter-to-readable.js index 4cb5600e3ba424..3f03090e30960c 100644 --- a/test/parallel/test-stream-iter-to-readable.js +++ b/test/parallel/test-stream-iter-to-readable.js @@ -439,6 +439,21 @@ async function testBackpressureSync() { assert.strictEqual(chunks.length, 10); } +// ============================================================================= +// fromStreamIterSync: backpressure within a batch +// ============================================================================= + +async function testBackpressureSyncMultiChunkBatch() { + function* gen() { + yield [Buffer.from('a'), Buffer.from('b'), Buffer.from('c')]; + } + + const readable = toReadableSync(gen(), { highWaterMark: 1 }); + const result = await collect(readable); + + assert.strictEqual(result.toString(), 'abc'); +} + // ============================================================================= // fromStreamIterSync: source error // ============================================================================= @@ -613,6 +628,7 @@ Promise.all([ testWithTransformAsync(), testBasicSync(), testBackpressureSync(), + testBackpressureSyncMultiChunkBatch(), testErrorSync(), testDestroySync(), testRoundTrip(), From 676e9da784e6ab2b89c097b2ef1cde09cf44bf01 Mon Sep 17 00:00:00 2001 From: Daijiro Wachi Date: Wed, 22 Apr 2026 19:26:10 +0900 Subject: [PATCH 141/168] repl: fix dedup comparing normalized line against raw history Signed-off-by: Daijiro Wachi PR-URL: https://github.com/nodejs/node/pull/62886 Reviewed-By: Luigi Pinca --- lib/internal/repl/history.js | 2 +- .../test-repl-history-dedup-multiline.js | 44 +++++++++++++++++++ 2 files changed, 45 insertions(+), 1 deletion(-) create mode 100644 test/parallel/test-repl-history-dedup-multiline.js diff --git a/lib/internal/repl/history.js b/lib/internal/repl/history.js index e95056ed5c466b..b197c7049cc089 100644 --- a/lib/internal/repl/history.js +++ b/lib/internal/repl/history.js @@ -142,7 +142,7 @@ class ReplHistory { if (this[kHistory].length === 0 || this[kHistory][0] !== normalizedLine) { if (this[kRemoveHistoryDuplicates]) { // Remove older history line if identical to new one - const dupIndex = ArrayPrototypeIndexOf(this[kHistory], line); + const dupIndex = ArrayPrototypeIndexOf(this[kHistory], normalizedLine); if (dupIndex !== -1) ArrayPrototypeSplice(this[kHistory], dupIndex, 1); } diff --git a/test/parallel/test-repl-history-dedup-multiline.js b/test/parallel/test-repl-history-dedup-multiline.js new file mode 100644 index 00000000000000..03dc089fa6144d --- /dev/null +++ b/test/parallel/test-repl-history-dedup-multiline.js @@ -0,0 +1,44 @@ +'use strict'; + +const common = require('../common'); + +if (process.env.TERM === 'dumb') { + common.skip('skipping - dumb terminal'); +} + +const assert = require('assert'); +const readline = require('readline'); +const { EventEmitter } = require('events'); + +class FakeInput extends EventEmitter { + resume() {} + pause() {} + write() {} + end() {} +} +FakeInput.prototype.readable = true; + +{ + const fi = new FakeInput(); + const rli = new readline.Interface({ + input: fi, + output: fi, + terminal: true, + removeHistoryDuplicates: true, + }); + + function submitLine(line) { + rli.line = line; + fi.emit('keypress', '', { name: 'enter' }); + } + + submitLine('line1\nline2'); + submitLine('other'); + submitLine('line1\nline2'); + + assert.strictEqual(rli.history.length, 2); + assert.strictEqual(rli.history[0], 'line2\rline1'); + assert.strictEqual(rli.history[1], 'other'); + + rli.close(); +} From fa1e1f4fd43c086a18b18d522aea0645b9a643f2 Mon Sep 17 00:00:00 2001 From: Moshe Atlow Date: Fri, 15 May 2026 13:46:09 +0300 Subject: [PATCH 142/168] test_runner: fix diagnostics channel context tracking MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Moshe Atlow PR-URL: https://github.com/nodejs/node/pull/63283 Reviewed-By: Chemi Atlow Reviewed-By: Benjamin Gruenbaum Reviewed-By: Gürgün Dayıoğlu --- lib/internal/test_runner/test.js | 31 ++++++++++++------- .../diagnostics-channel-bindstore-end.js | 27 ++++++++++++++++ .../test-runner-diagnostics-channel.js | 20 ++++++++++++ 3 files changed, 67 insertions(+), 11 deletions(-) create mode 100644 test/fixtures/test-runner/diagnostics-channel-bindstore-end.js diff --git a/lib/internal/test_runner/test.js b/lib/internal/test_runner/test.js index 013ba85087f1a0..1dcf2bda1e56dc 100644 --- a/lib/internal/test_runner/test.js +++ b/lib/internal/test_runner/test.js @@ -1308,6 +1308,9 @@ class Test extends AsyncResource { let stopPromise; + let publishEnd = () => testChannel.end.publish(channelContext); + let publishError = (err) => testChannel.error.publish({ __proto__: null, ...channelContext, error: err }); + try { if (this.parent?.hooks.before.length > 0) { // This hook usually runs immediately, we need to wait for it to finish @@ -1326,9 +1329,11 @@ class Test extends AsyncResource { // not the runInAsyncScope call itself, to maintain AsyncLocalStorage bindings. let testFn = this.fn; if (channelContext !== null && testChannel.start.hasSubscribers) { - testFn = (...fnArgs) => testChannel.start.runStores(channelContext, - () => ReflectApply(this.fn, this, fnArgs), - ); + testFn = (...fnArgs) => testChannel.start.runStores(channelContext, () => { + publishEnd = AsyncResource.bind(publishEnd); + publishError = AsyncResource.bind(publishError); + return ReflectApply(this.fn, this, fnArgs); + }); } ArrayPrototypeUnshift(runArgs, testFn, ctx); @@ -1380,9 +1385,8 @@ class Test extends AsyncResource { await afterEach(); await after(); } catch (err) { - // Publish diagnostics_channel error event if the channel has subscribers if (channelContext !== null && testChannel.error.hasSubscribers) { - testChannel.error.publish({ __proto__: null, ...channelContext, error: err }); + publishError(err); } if (isTestFailureError(err)) { if (err.failureType === kTestTimeoutFailure) { @@ -1406,7 +1410,7 @@ class Test extends AsyncResource { // Publish diagnostics_channel end event if the channel has subscribers (in both success and error cases) if (channelContext !== null && testChannel.end.hasSubscribers) { - testChannel.end.publish(channelContext); + publishEnd(); } } @@ -1751,6 +1755,9 @@ class Suite extends Test { file: this.entryFile, type: this.reportedType, }; + let publishEnd = () => testChannel.end.publish(channelContext); + let publishError = (err) => testChannel.error.publish({ __proto__: null, ...channelContext, error: err }); + try { const { ctx, args } = this.getRunArgs(); @@ -1762,9 +1769,11 @@ class Suite extends Test { let suiteFn = this.fn; if (testChannel.start.hasSubscribers) { const baseFn = this.fn; - suiteFn = (...fnArgs) => testChannel.start.runStores(channelContext, - () => ReflectApply(baseFn, this, fnArgs), - ); + suiteFn = (...fnArgs) => testChannel.start.runStores(channelContext, () => { + publishEnd = AsyncResource.bind(publishEnd); + publishError = AsyncResource.bind(publishError); + return ReflectApply(baseFn, this, fnArgs); + }); } const runArgs = [suiteFn, ctx]; @@ -1773,12 +1782,12 @@ class Suite extends Test { await ReflectApply(this.runInAsyncScope, this, runArgs); } catch (err) { if (testChannel.error.hasSubscribers) { - testChannel.error.publish({ __proto__: null, ...channelContext, error: err }); + publishError(err); } this.fail(new ERR_TEST_FAILURE(err, kTestCodeFailure)); } finally { if (testChannel.end.hasSubscribers) { - testChannel.end.publish(channelContext); + publishEnd(); } } diff --git a/test/fixtures/test-runner/diagnostics-channel-bindstore-end.js b/test/fixtures/test-runner/diagnostics-channel-bindstore-end.js new file mode 100644 index 00000000000000..0b2d9faea4f998 --- /dev/null +++ b/test/fixtures/test-runner/diagnostics-channel-bindstore-end.js @@ -0,0 +1,27 @@ +'use strict'; +const dc = require('node:diagnostics_channel'); +const { AsyncLocalStorage } = require('node:async_hooks'); +const { test } = require('node:test'); + +const als = new AsyncLocalStorage(); +const ch = dc.tracingChannel('node.test'); + +ch.start.bindStore(als, (data) => data.name); + +const storeAtEnd = {}; +const storeAtError = {}; + +ch.end.subscribe((data) => { + storeAtEnd[data.name] = als.getStore(); +}); + +ch.error.subscribe((data) => { + storeAtError[data.name] = als.getStore(); +}); + +test('passing test', () => {}); +test('failing test', () => { throw new Error('boom'); }); + +process.on('exit', () => { + console.log(JSON.stringify({ storeAtEnd, storeAtError })); +}); diff --git a/test/parallel/test-runner-diagnostics-channel.js b/test/parallel/test-runner-diagnostics-channel.js index b3e6532a1a6318..8f2cdd59a2af93 100644 --- a/test/parallel/test-runner-diagnostics-channel.js +++ b/test/parallel/test-runner-diagnostics-channel.js @@ -119,6 +119,26 @@ test('context is available in async operations within test', async () => { assert.strictEqual(valueInTimeout, testName); }); +test('bindStore propagates store to end and error subscribers', async () => { + // Spawn a fixture that records `als.getStore()` at end/error publish time so + // we can assert subscribers see the bound store, not undefined. + const fixturePath = join(__dirname, '../fixtures/test-runner/diagnostics-channel-bindstore-end.js'); + const result = spawnSync(process.execPath, [fixturePath], { encoding: 'utf8' }); + // The fixture contains an intentionally failing test, so exit is non-zero. + assert.notStrictEqual(result.status, 0); + const line = result.stdout.split('\n').find((l) => l.includes('storeAtEnd')); + assert.ok(line, `expected storeAtEnd line in stdout:\n${result.stdout}`); + const { storeAtEnd, storeAtError } = JSON.parse(line); + assert.deepStrictEqual(storeAtEnd, { + '': '', + 'passing test': 'passing test', + 'failing test': 'failing test', + }); + assert.deepStrictEqual(storeAtError, { + 'failing test': 'failing test', + }); +}); + test('error events fire for failing tests in fixture', async () => { // Run the fixture test that intentionally fails const fixturePath = join(__dirname, '../fixtures/test-runner/diagnostics-channel-error-test.js'); From 57508024c3976380c2ca5152d9df3d7dfbe45988 Mon Sep 17 00:00:00 2001 From: Moshe Atlow Date: Fri, 15 May 2026 13:46:21 +0300 Subject: [PATCH 143/168] test_runner: fix hooks test context Signed-off-by: Moshe Atlow PR-URL: https://github.com/nodejs/node/pull/63285 Reviewed-By: Chemi Atlow Reviewed-By: Benjamin Gruenbaum Reviewed-By: Matteo Collina --- lib/internal/test_runner/harness.js | 13 +--- lib/internal/test_runner/test.js | 21 +++++- test/parallel/test-runner-get-test-context.js | 70 ++++++++++++++++++- tools/eslint-rules/must-call-assert.js | 4 +- 4 files changed, 91 insertions(+), 17 deletions(-) diff --git a/lib/internal/test_runner/harness.js b/lib/internal/test_runner/harness.js index f1d46301b025db..16f9392bf7763b 100644 --- a/lib/internal/test_runner/harness.js +++ b/lib/internal/test_runner/harness.js @@ -21,7 +21,7 @@ const { }, } = require('internal/errors'); const { exitCodes: { kGenericUserError } } = internalBinding('errors'); -const { kCancelledByParent, Test, Suite, TestContext, SuiteContext } = require('internal/test_runner/test'); +const { kCancelledByParent, Test, Suite } = require('internal/test_runner/test'); const { parseCommandLine, reporterScope, @@ -439,16 +439,7 @@ function getTestContext() { if (test === undefined || test === reporterScope) { return undefined; } - // For hooks (hookType is set), return the test/suite being hooked (the parent) - const actualTest = test.hookType !== undefined ? test.parent : test; - if (actualTest === undefined) { - return undefined; - } - // Return SuiteContext for suites, TestContext for tests - if (actualTest instanceof Suite) { - return new SuiteContext(actualTest); - } - return new TestContext(actualTest); + return test.getCtx(); } module.exports = { diff --git a/lib/internal/test_runner/test.js b/lib/internal/test_runner/test.js index 1dcf2bda1e56dc..eb888905798bcd 100644 --- a/lib/internal/test_runner/test.js +++ b/lib/internal/test_runner/test.js @@ -1233,8 +1233,14 @@ class Test extends AsyncResource { } } + #ctx; + getCtx() { + this.#ctx ??= new TestContext(this); + return this.#ctx; + } + getRunArgs() { - const ctx = new TestContext(this); + const ctx = this.getCtx(); return { __proto__: null, ctx, args: [ctx] }; } @@ -1703,6 +1709,11 @@ class TestHook extends Test { this.#args = args; return super.run(); } + + getCtx() { + return this.parentTest.getCtx(); + } + getRunArgs() { return this.#args; } @@ -1794,6 +1805,12 @@ class Suite extends Test { this.buildPhaseFinished = true; } + #ctx; + getCtx() { + this.#ctx ??= new TestContext(this); + return this.#ctx; + } + getRunArgs() { const ctx = new SuiteContext(this); return { __proto__: null, ctx, args: [ctx] }; @@ -1866,6 +1883,4 @@ module.exports = { kUnwrapErrors, Suite, Test, - TestContext, - SuiteContext, }; diff --git a/test/parallel/test-runner-get-test-context.js b/test/parallel/test-runner-get-test-context.js index bc5be4f01cee4a..1e5ef917f9fbac 100644 --- a/test/parallel/test-runner-get-test-context.js +++ b/test/parallel/test-runner-get-test-context.js @@ -1,7 +1,16 @@ 'use strict'; -require('../common'); +const common = require('../common'); const assert = require('node:assert'); -const { test, getTestContext, describe, it } = require('node:test'); +const { + test, + getTestContext, + describe, + it, + before, + after, + beforeEach, + afterEach, +} = require('node:test'); // Outside a test — must return undefined assert.strictEqual(getTestContext(), undefined); @@ -40,6 +49,63 @@ describe('getTestContext returns SuiteContext in suite', () => { }); }); +describe('getTestContext inside hooks', () => { + const suiteName = 'getTestContext inside hooks'; + + before(common.mustCall((t) => { + const ctx = getTestContext(); + assert.ok(ctx !== undefined); + assert.strictEqual(ctx.name, suiteName); + assert.strictEqual(ctx.name, t.name); + })); + + beforeEach(common.mustCall(() => { + const ctx = getTestContext(); + assert.ok(ctx !== undefined); + assert.strictEqual(ctx.name, suiteName); + })); + + afterEach(common.mustCall(() => { + const ctx = getTestContext(); + assert.ok(ctx !== undefined); + assert.strictEqual(ctx.name, suiteName); + })); + + after(common.mustCall((t) => { + const ctx = getTestContext(); + assert.ok(ctx !== undefined); + assert.strictEqual(ctx.name, suiteName); + assert.strictEqual(ctx.name, t.name); + })); + + it('runs inside the suite', () => { + const ctx = getTestContext(); + assert.ok(ctx !== undefined); + assert.strictEqual(ctx.name, 'runs inside the suite'); + }); +}); + +test('getTestContext inside test-level hooks returns the parent test', async (t) => { + const parentName = t.name; + t.beforeEach(common.mustCall(() => { + const ctx = getTestContext(); + assert.ok(ctx !== undefined); + assert.strictEqual(ctx.name, parentName); + })); + + t.afterEach(common.mustCall(() => { + const ctx = getTestContext(); + assert.ok(ctx !== undefined); + assert.strictEqual(ctx.name, parentName); + })); + + await t.test('child', () => { + const ctx = getTestContext(); + assert.ok(ctx !== undefined); + assert.strictEqual(ctx.name, 'child'); + }); +}); + test('getTestContext works in test body during async operations', async (t) => { const ctx = getTestContext(); assert.ok(ctx !== undefined); diff --git a/tools/eslint-rules/must-call-assert.js b/tools/eslint-rules/must-call-assert.js index 7a6f417770bae0..b991e29063aa9c 100644 --- a/tools/eslint-rules/must-call-assert.js +++ b/tools/eslint-rules/must-call-assert.js @@ -63,7 +63,9 @@ function isMustCallOrMustCallAtLeast(str) { } function isMustCallOrTest(str) { - return str === 'test' || str === 'it' || isMustCallOrMustCallAtLeast(str); + return str === 'test' || str === 'it' || str === 'describe' || str === 'suite' || + str === 'before' || str === 'after' || str === 'beforeEach' || str === 'afterEach' || + isMustCallOrMustCallAtLeast(str); } module.exports = { From e9c49ea46f5303c9f3f0860286f08a25caa54851 Mon Sep 17 00:00:00 2001 From: James M Snell Date: Sun, 10 May 2026 13:36:23 -0700 Subject: [PATCH 144/168] quic: fixup quic stream variable chunk len Signed-off-by: James M Snell PR-URL: https://github.com/nodejs/node/pull/63230 Fixes: https://github.com/nodejs/node/issues/63216 Reviewed-By: Tim Perry Reviewed-By: Matteo Collina --- lib/internal/quic/quic.js | 29 +++--- src/quic/streams.cc | 6 +- .../test-quic-stream-bidi-varchunklen.mjs | 91 +++++++++++++++++++ 3 files changed, 110 insertions(+), 16 deletions(-) create mode 100644 test/parallel/test-quic-stream-bidi-varchunklen.mjs diff --git a/lib/internal/quic/quic.js b/lib/internal/quic/quic.js index 6ca59469faf2de..a5ce3d8c14fb23 100644 --- a/lib/internal/quic/quic.js +++ b/lib/internal/quic/quic.js @@ -1279,19 +1279,14 @@ function waitForDrain(stream) { // Writes a batch to the handle, awaiting drain if backpressured. // Returns true if the stream was destroyed during the wait. -// Checks writeDesiredSize before writing to enforce backpressure -// against the outbound DataQueue's uncommitted bytes. +// Only waits when writeDesiredSize is 0 (no capacity at all). +// When there is any capacity, the write proceeds even if the batch +// is larger -- the C++ side buffers the data and writeDesiredSize +// drops toward 0, letting the normal drain mechanism take over. async function writeBatchWithDrain(handle, stream, batch) { const state = getQuicStreamState(stream); - // Calculate total batch size for the capacity check. - let len = 0; - for (const chunk of batch) len += TypedArrayPrototypeGetByteLength(chunk); - - // If insufficient capacity, wait for the C++ drain signal which - // fires when writeDesiredSize transitions from 0 to > 0 (i.e., - // ngtcp2 has consumed data from the outbound DataQueue). - if (len > state.writeDesiredSize) { + if (state.writeDesiredSize === 0) { await waitForDrain(stream); if (stream.destroyed) return true; } @@ -2029,9 +2024,15 @@ class QuicStream { chunk = toUint8Array(chunk); const len = TypedArrayPrototypeGetByteLength(chunk); if (len === 0) return true; - // Refuse the write if the chunk doesn't fit in the available - // buffer capacity. The caller should wait for drain and retry. - if (len > stream.#state.writeDesiredSize) return false; + // Refuse the write only when there is no available capacity at + // all. When writeDesiredSize > 0 we allow the write even if the + // chunk is larger than the remaining capacity -- the C++ side + // will accept the data into the DataQueue and + // UpdateWriteDesiredSize() will drop writeDesiredSize toward 0, + // at which point the standard drain mechanism takes over. + // This follows the Web Streams model where writes beyond the HWM + // succeed and backpressure applies to *subsequent* writes. + if (stream.#state.writeDesiredSize === 0) return false; const result = handle.write([chunk]); if (result === undefined) return false; totalBytesWritten += len; @@ -2070,7 +2071,7 @@ class QuicStream { let len = 0; for (const c of chunks) len += TypedArrayPrototypeGetByteLength(c); if (len === 0) return true; - if (len > stream.#state.writeDesiredSize) return false; + if (stream.#state.writeDesiredSize === 0) return false; const result = handle.write(chunks); if (result === undefined) return false; totalBytesWritten += len; diff --git a/src/quic/streams.cc b/src/quic/streams.cc index dd7f7ecbb3880e..81e619e28d3720 100644 --- a/src/quic/streams.cc +++ b/src/quic/streams.cc @@ -1592,8 +1592,10 @@ void Stream::UpdateWriteDesiredSize() { uint32_t old_size = state_->write_desired_size; state_->write_desired_size = clamped; - // Fire drain when transitioning from 0 to non-zero - if (old_size == 0 && desired > 0) { + // Fire drain when transitioning from 0 to non-zero. + // writeDesiredSize == 0 means the buffer is full or flow control is + // exhausted, so the JS side may be waiting for capacity. + if (old_size == 0 && clamped > 0) { EmitDrain(); } } diff --git a/test/parallel/test-quic-stream-bidi-varchunklen.mjs b/test/parallel/test-quic-stream-bidi-varchunklen.mjs new file mode 100644 index 00000000000000..a8928c7ced34dc --- /dev/null +++ b/test/parallel/test-quic-stream-bidi-varchunklen.mjs @@ -0,0 +1,91 @@ +// Flags: --experimental-quic --experimental-stream-iter --no-warnings + +// Test: bidirectional data transfer with varying chunk sizes. +// This is a regression test for a stall caused by a mismatch between +// writeSync (which rejects when chunk > writeDesiredSize) and +// drainableProtocol (which returned null when writeDesiredSize > 0). +// When chunks don't evenly fill the high water mark, writeDesiredSize +// can be positive but smaller than the next chunk, causing the +// while(!writeSync) { dp(); await } loop to spin without yielding. +// See: https://github.com/nodejs/node/issues/63216 + +import { hasQuic, skip, mustCall } from '../common/index.mjs'; +import assert from 'node:assert'; + +const { strictEqual } = assert; + +if (!hasQuic) { + skip('QUIC is not enabled'); +} + +const { listen, connect } = await import('../common/quic.mjs'); +const { bytes, drainableProtocol: dp } = await import('stream/iter'); + +// Varying chunk sizes — the pattern of alternating large and small +// chunks is effective at triggering the writeDesiredSize gap. +const chunkSizes = [60000, 12, 50000, 1600, 20000, 30000, 0, 100]; +const numChunks = chunkSizes.length; +const byteLength = chunkSizes.reduce((a, b) => a + b, 0); + +// Build a deterministic payload so we can verify integrity. +function buildChunk(index) { + const chunk = new Uint8Array(chunkSizes[index]); + const val = index & 0xff; + for (let i = 0; i < chunkSizes[index]; i++) { + chunk[i] = (val + i) & 0xff; + } + return chunk; +} + +function checksum(data) { + let sum = 0; + for (let i = 0; i < data.byteLength; i++) { + sum = (sum + data[i]) | 0; + } + return sum; +} + +// Compute expected checksum. +let expectedChecksum = 0; +for (let i = 0; i < numChunks; i++) { + const chunk = buildChunk(i); + expectedChecksum = (expectedChecksum + checksum(chunk)) | 0; +} + +const done = Promise.withResolvers(); + +const serverEndpoint = await listen(mustCall((serverSession) => { + serverSession.onstream = mustCall(async (stream) => { + const received = await bytes(stream); + strictEqual(received.byteLength, byteLength); + strictEqual(checksum(received), expectedChecksum); + + stream.writer.endSync(); + await stream.closed; + serverSession.close(); + done.resolve(); + }); +})); + +const clientSession = await connect(serverEndpoint.address); +await clientSession.opened; + +const stream = await clientSession.createBidirectionalStream(); +const w = stream.writer; + +// Write chunks, respecting backpressure via drainableProtocol. +for (let i = 0; i < numChunks; i++) { + const chunk = buildChunk(i); + while (!w.writeSync(chunk)) { + // Flow controlled — wait for drain before retrying. + const drainable = w[dp](); + if (drainable) await drainable; + } +} + +const totalWritten = w.endSync(); +strictEqual(totalWritten, byteLength); + +await Promise.all([stream.closed, done.promise]); +await clientSession.close(); +await serverEndpoint.close(); From 274d799ad1bc3c5abcb1f5c2f3bce51233c51e9c Mon Sep 17 00:00:00 2001 From: Matteo Collina Date: Fri, 15 May 2026 15:37:31 +0100 Subject: [PATCH 145/168] http2: validate non-link headers in writeEarlyHints Validate header names and values for non-link hints passed to writeEarlyHints() in the HTTP/2 compat layer using assertValidHeader() and checkIsHttpToken(), consistent with the HTTP/1.1 validation added in https://github.com/nodejs/node/pull/61897. Previously, hints were forwarded into the headers object without any validation, allowing invalid characters in header names/values to surface as opaque errors deeper in the HTTP/2 stack. Signed-off-by: Matteo Collina PR-URL: https://github.com/nodejs/node/pull/62017 Reviewed-By: Luigi Pinca Reviewed-By: Tim Perry Reviewed-By: Rafael Gonzaga Reviewed-By: James M Snell --- lib/internal/http2/compat.js | 6 +- ...compat-write-early-hints-invalid-header.js | 60 +++++++++++++++++++ 2 files changed, 65 insertions(+), 1 deletion(-) create mode 100644 test/parallel/test-http2-compat-write-early-hints-invalid-header.js diff --git a/lib/internal/http2/compat.js b/lib/internal/http2/compat.js index 86dc7dc047fd78..a85143e90cab0f 100644 --- a/lib/internal/http2/compat.js +++ b/lib/internal/http2/compat.js @@ -921,7 +921,11 @@ class Http2ServerResponse extends Stream { for (const key of ObjectKeys(hints)) { if (key !== 'link') { - headers[key] = hints[key]; + const name = key.trim().toLowerCase(); + assertValidHeader(name, hints[key]); + if (!checkIsHttpToken(name)) + throw new ERR_INVALID_HTTP_TOKEN('Header name', name); + headers[name] = hints[key]; } } diff --git a/test/parallel/test-http2-compat-write-early-hints-invalid-header.js b/test/parallel/test-http2-compat-write-early-hints-invalid-header.js new file mode 100644 index 00000000000000..222c8e997cfb72 --- /dev/null +++ b/test/parallel/test-http2-compat-write-early-hints-invalid-header.js @@ -0,0 +1,60 @@ +'use strict'; + +const common = require('../common'); +if (!common.hasCrypto) common.skip('missing crypto'); + +const assert = require('node:assert'); +const http2 = require('node:http2'); +const debug = require('node:util').debuglog('test'); + +const testResBody = 'response content'; + +{ + const server = http2.createServer(); + + server.on('request', common.mustCall((req, res) => { + debug('Server sending early hints...'); + + assert.throws(() => { + res.writeEarlyHints({ + 'link': '; rel=preload; as=style', + 'x\rbad': 'value', + }); + }, (err) => err.code === 'ERR_INVALID_HTTP_TOKEN'); + + assert.throws(() => { + res.writeEarlyHints({ + 'link': '; rel=preload; as=style', + 'x-custom': undefined, + }); + }, (err) => err.code === 'ERR_HTTP2_INVALID_HEADER_VALUE'); + + debug('Server sending full response...'); + res.end(testResBody); + })); + + server.listen(0); + + server.on('listening', common.mustCall(() => { + const client = http2.connect(`http://localhost:${server.address().port}`); + const req = client.request(); + + debug('Client sending request...'); + + req.on('headers', common.mustNotCall()); + + req.on('response', common.mustCall((headers) => { + assert.strictEqual(headers[':status'], 200); + })); + + let data = ''; + req.on('data', common.mustCallAtLeast((d) => data += d)); + + req.on('end', common.mustCall(() => { + debug('Got full response.'); + assert.strictEqual(data, testResBody); + client.close(); + server.close(); + })); + })); +} From f190a048c34e89151ce5c6ccd9fa8a20d3a5da96 Mon Sep 17 00:00:00 2001 From: Tim Perry <1526883+pimterry@users.noreply.github.com> Date: Fri, 15 May 2026 16:37:45 +0200 Subject: [PATCH 146/168] quic: send correct OpenSSL alert for ALPN mismatches Signed-off-by: Tim Perry PR-URL: https://github.com/nodejs/node/pull/63193 Reviewed-By: James M Snell --- src/quic/tlscontext.cc | 2 +- test/parallel/test-quic-alpn-mismatch.mjs | 32 +++++++++++++---------- 2 files changed, 19 insertions(+), 15 deletions(-) diff --git a/src/quic/tlscontext.cc b/src/quic/tlscontext.cc index b563bae5071e0f..08ce7f9acd1c4c 100644 --- a/src/quic/tlscontext.cc +++ b/src/quic/tlscontext.cc @@ -338,7 +338,7 @@ int TLSContext::OnSelectAlpn(SSL* ssl, in, inlen) == OPENSSL_NPN_NO_OVERLAP) { Debug(&tls_session.session(), "ALPN negotiation failed"); - return SSL_TLSEXT_ERR_NOACK; + return SSL_TLSEXT_ERR_ALERT_FATAL; } // ALPN negotiated successfully. *out/*outlen point to the selected diff --git a/test/parallel/test-quic-alpn-mismatch.mjs b/test/parallel/test-quic-alpn-mismatch.mjs index 5dfff57219e0aa..252095f4d6b3bc 100644 --- a/test/parallel/test-quic-alpn-mismatch.mjs +++ b/test/parallel/test-quic-alpn-mismatch.mjs @@ -2,12 +2,18 @@ // Test: ALPN mismatch causes connection failure. // The server offers 'quic-test' but the client requests 'nonexistent'. -// The handshake should fail. +// The handshake should fail with a `no_application_protocol` alert. +// +// The QUIC transport error code for a CRYPTO_ERROR carrying a TLS alert is +// 0x100 | . For `no_application_protocol` (alert 120 / 0x78) this +// is 0x178 == 376. ERR_QUIC_TRANSPORT_ERROR formats the wire code into its +// message as a bigint, so we match `376n` to assert the specific alert was +// sent rather than some other handshake failure. import { hasQuic, skip, mustCall } from '../common/index.mjs'; import assert from 'node:assert'; -const { rejects, strictEqual } = assert; +const { rejects, strictEqual, match } = assert; if (!hasQuic) { skip('QUIC is not enabled'); @@ -15,18 +21,20 @@ if (!hasQuic) { const { listen, connect } = await import('../common/quic.mjs'); +const expected = { + code: 'ERR_QUIC_TRANSPORT_ERROR', + message: /\b376n\b/, +}; + const onerror = mustCall((err) => { strictEqual(err.code, 'ERR_QUIC_TRANSPORT_ERROR'); + match(err.message, /\b376n\b/); }, 2); const transportParams = { maxIdleTimeout: 1 }; const serverEndpoint = await listen(mustCall(async (serverSession) => { - await rejects(serverSession.opened, { - code: 'ERR_QUIC_TRANSPORT_ERROR', - }); - await rejects(serverSession.closed, { - code: 'ERR_QUIC_TRANSPORT_ERROR', - }); + await rejects(serverSession.opened, expected); + await rejects(serverSession.closed, expected); }), { transportParams, onerror, @@ -39,12 +47,8 @@ const clientSession = await connect(serverEndpoint.address, { onerror, }); -await rejects(clientSession.opened, { - code: 'ERR_QUIC_TRANSPORT_ERROR', -}); +await rejects(clientSession.opened, expected); // The handshake should fail — opened may reject or never resolve. // The session should close with an error. -await rejects(clientSession.closed, { - code: 'ERR_QUIC_TRANSPORT_ERROR', -}); +await rejects(clientSession.closed, expected); From c8206c8080b0b356fd4f7a1c9598bd3fa7d28047 Mon Sep 17 00:00:00 2001 From: "Node.js GitHub Bot" Date: Fri, 15 May 2026 12:16:28 -0400 Subject: [PATCH 147/168] deps: update simdjson to 4.6.4 PR-URL: https://github.com/nodejs/node/pull/62811 Reviewed-By: Antoine du Hamel --- deps/simdjson/simdjson.cpp | 2 +- deps/simdjson/simdjson.h | 2895 ++++++++++++++++++++++++------------ 2 files changed, 1921 insertions(+), 976 deletions(-) diff --git a/deps/simdjson/simdjson.cpp b/deps/simdjson/simdjson.cpp index cbcd9f1e6bc017..6fa9693596be0c 100644 --- a/deps/simdjson/simdjson.cpp +++ b/deps/simdjson/simdjson.cpp @@ -1,4 +1,4 @@ -/* auto-generated on 2026-04-03 15:25:03 -0400. version 4.6.1 Do not edit! */ +/* auto-generated on 2026-05-06 17:28:39 -0400. version 4.6.4 Do not edit! */ /* including simdjson.cpp: */ /* begin file simdjson.cpp */ #define SIMDJSON_SRC_SIMDJSON_CPP diff --git a/deps/simdjson/simdjson.h b/deps/simdjson/simdjson.h index 0a021531346106..b9befc5b17ed3c 100644 --- a/deps/simdjson/simdjson.h +++ b/deps/simdjson/simdjson.h @@ -1,4 +1,4 @@ -/* auto-generated on 2026-04-03 15:25:03 -0400. version 4.6.1 Do not edit! */ +/* auto-generated on 2026-05-06 17:28:39 -0400. version 4.6.4 Do not edit! */ /* including simdjson.h: */ /* begin file simdjson.h */ #ifndef SIMDJSON_H @@ -2538,7 +2538,7 @@ namespace std { #define SIMDJSON_SIMDJSON_VERSION_H /** The version of simdjson being used (major.minor.revision) */ -#define SIMDJSON_VERSION "4.6.1" +#define SIMDJSON_VERSION "4.6.4" namespace simdjson { enum { @@ -2553,7 +2553,7 @@ enum { /** * The revision (major.minor.REVISION) of simdjson being used. */ - SIMDJSON_VERSION_REVISION = 1 + SIMDJSON_VERSION_REVISION = 4 }; } // namespace simdjson @@ -39794,6 +39794,7 @@ simdjson_warn_unused simdjson_result extract_fractured_json( /* begin file simdjson/generic/builder/json_string_builder-inl.h for arm64 */ #include #include +#include #include #ifndef SIMDJSON_GENERIC_STRING_BUILDER_INL_H @@ -40549,6 +40550,11 @@ simdjson_inline void string_builder::append(number_type v) noexcept { simdjson_inline void string_builder::escape_and_append(std::string_view input) noexcept { // escaping might turn a control character into \x00xx so 6 characters. + // Guard against size_t overflow in the multiplication below. + if (input.size() > (std::numeric_limits::max)() / 6) { + set_valid(false); + return; + } if (capacity_check(6 * input.size())) { position += write_string_escaped(input, buffer.get() + position); } @@ -40557,6 +40563,11 @@ string_builder::escape_and_append(std::string_view input) noexcept { simdjson_inline void string_builder::escape_and_append_with_quotes(std::string_view input) noexcept { // escaping might turn a control character into \x00xx so 6 characters. + // Guard against size_t overflow in the arithmetic below. + if (input.size() > ((std::numeric_limits::max)() - 2) / 6) { + set_valid(false); + return; + } if (capacity_check(2 + 6 * input.size())) { buffer.get()[position++] = '"'; position += write_string_escaped(input, buffer.get() + position); @@ -41878,6 +41889,7 @@ simdjson_warn_unused simdjson_result extract_fractured_json( /* begin file simdjson/generic/builder/json_string_builder-inl.h for fallback */ #include #include +#include #include #ifndef SIMDJSON_GENERIC_STRING_BUILDER_INL_H @@ -42633,6 +42645,11 @@ simdjson_inline void string_builder::append(number_type v) noexcept { simdjson_inline void string_builder::escape_and_append(std::string_view input) noexcept { // escaping might turn a control character into \x00xx so 6 characters. + // Guard against size_t overflow in the multiplication below. + if (input.size() > (std::numeric_limits::max)() / 6) { + set_valid(false); + return; + } if (capacity_check(6 * input.size())) { position += write_string_escaped(input, buffer.get() + position); } @@ -42641,6 +42658,11 @@ string_builder::escape_and_append(std::string_view input) noexcept { simdjson_inline void string_builder::escape_and_append_with_quotes(std::string_view input) noexcept { // escaping might turn a control character into \x00xx so 6 characters. + // Guard against size_t overflow in the arithmetic below. + if (input.size() > ((std::numeric_limits::max)() - 2) / 6) { + set_valid(false); + return; + } if (capacity_check(2 + 6 * input.size())) { buffer.get()[position++] = '"'; position += write_string_escaped(input, buffer.get() + position); @@ -44449,6 +44471,7 @@ simdjson_warn_unused simdjson_result extract_fractured_json( /* begin file simdjson/generic/builder/json_string_builder-inl.h for haswell */ #include #include +#include #include #ifndef SIMDJSON_GENERIC_STRING_BUILDER_INL_H @@ -45204,6 +45227,11 @@ simdjson_inline void string_builder::append(number_type v) noexcept { simdjson_inline void string_builder::escape_and_append(std::string_view input) noexcept { // escaping might turn a control character into \x00xx so 6 characters. + // Guard against size_t overflow in the multiplication below. + if (input.size() > (std::numeric_limits::max)() / 6) { + set_valid(false); + return; + } if (capacity_check(6 * input.size())) { position += write_string_escaped(input, buffer.get() + position); } @@ -45212,6 +45240,11 @@ string_builder::escape_and_append(std::string_view input) noexcept { simdjson_inline void string_builder::escape_and_append_with_quotes(std::string_view input) noexcept { // escaping might turn a control character into \x00xx so 6 characters. + // Guard against size_t overflow in the arithmetic below. + if (input.size() > ((std::numeric_limits::max)() - 2) / 6) { + set_valid(false); + return; + } if (capacity_check(2 + 6 * input.size())) { buffer.get()[position++] = '"'; position += write_string_escaped(input, buffer.get() + position); @@ -47020,6 +47053,7 @@ simdjson_warn_unused simdjson_result extract_fractured_json( /* begin file simdjson/generic/builder/json_string_builder-inl.h for icelake */ #include #include +#include #include #ifndef SIMDJSON_GENERIC_STRING_BUILDER_INL_H @@ -47775,6 +47809,11 @@ simdjson_inline void string_builder::append(number_type v) noexcept { simdjson_inline void string_builder::escape_and_append(std::string_view input) noexcept { // escaping might turn a control character into \x00xx so 6 characters. + // Guard against size_t overflow in the multiplication below. + if (input.size() > (std::numeric_limits::max)() / 6) { + set_valid(false); + return; + } if (capacity_check(6 * input.size())) { position += write_string_escaped(input, buffer.get() + position); } @@ -47783,6 +47822,11 @@ string_builder::escape_and_append(std::string_view input) noexcept { simdjson_inline void string_builder::escape_and_append_with_quotes(std::string_view input) noexcept { // escaping might turn a control character into \x00xx so 6 characters. + // Guard against size_t overflow in the arithmetic below. + if (input.size() > ((std::numeric_limits::max)() - 2) / 6) { + set_valid(false); + return; + } if (capacity_check(2 + 6 * input.size())) { buffer.get()[position++] = '"'; position += write_string_escaped(input, buffer.get() + position); @@ -49706,6 +49750,7 @@ simdjson_warn_unused simdjson_result extract_fractured_json( /* begin file simdjson/generic/builder/json_string_builder-inl.h for ppc64 */ #include #include +#include #include #ifndef SIMDJSON_GENERIC_STRING_BUILDER_INL_H @@ -50461,6 +50506,11 @@ simdjson_inline void string_builder::append(number_type v) noexcept { simdjson_inline void string_builder::escape_and_append(std::string_view input) noexcept { // escaping might turn a control character into \x00xx so 6 characters. + // Guard against size_t overflow in the multiplication below. + if (input.size() > (std::numeric_limits::max)() / 6) { + set_valid(false); + return; + } if (capacity_check(6 * input.size())) { position += write_string_escaped(input, buffer.get() + position); } @@ -50469,6 +50519,11 @@ string_builder::escape_and_append(std::string_view input) noexcept { simdjson_inline void string_builder::escape_and_append_with_quotes(std::string_view input) noexcept { // escaping might turn a control character into \x00xx so 6 characters. + // Guard against size_t overflow in the arithmetic below. + if (input.size() > ((std::numeric_limits::max)() - 2) / 6) { + set_valid(false); + return; + } if (capacity_check(2 + 6 * input.size())) { buffer.get()[position++] = '"'; position += write_string_escaped(input, buffer.get() + position); @@ -52709,6 +52764,7 @@ simdjson_warn_unused simdjson_result extract_fractured_json( /* begin file simdjson/generic/builder/json_string_builder-inl.h for westmere */ #include #include +#include #include #ifndef SIMDJSON_GENERIC_STRING_BUILDER_INL_H @@ -53464,6 +53520,11 @@ simdjson_inline void string_builder::append(number_type v) noexcept { simdjson_inline void string_builder::escape_and_append(std::string_view input) noexcept { // escaping might turn a control character into \x00xx so 6 characters. + // Guard against size_t overflow in the multiplication below. + if (input.size() > (std::numeric_limits::max)() / 6) { + set_valid(false); + return; + } if (capacity_check(6 * input.size())) { position += write_string_escaped(input, buffer.get() + position); } @@ -53472,6 +53533,11 @@ string_builder::escape_and_append(std::string_view input) noexcept { simdjson_inline void string_builder::escape_and_append_with_quotes(std::string_view input) noexcept { // escaping might turn a control character into \x00xx so 6 characters. + // Guard against size_t overflow in the arithmetic below. + if (input.size() > ((std::numeric_limits::max)() - 2) / 6) { + set_valid(false); + return; + } if (capacity_check(2 + 6 * input.size())) { buffer.get()[position++] = '"'; position += write_string_escaped(input, buffer.get() + position); @@ -55186,6 +55252,7 @@ simdjson_warn_unused simdjson_result extract_fractured_json( /* begin file simdjson/generic/builder/json_string_builder-inl.h for lsx */ #include #include +#include #include #ifndef SIMDJSON_GENERIC_STRING_BUILDER_INL_H @@ -55941,6 +56008,11 @@ simdjson_inline void string_builder::append(number_type v) noexcept { simdjson_inline void string_builder::escape_and_append(std::string_view input) noexcept { // escaping might turn a control character into \x00xx so 6 characters. + // Guard against size_t overflow in the multiplication below. + if (input.size() > (std::numeric_limits::max)() / 6) { + set_valid(false); + return; + } if (capacity_check(6 * input.size())) { position += write_string_escaped(input, buffer.get() + position); } @@ -55949,6 +56021,11 @@ string_builder::escape_and_append(std::string_view input) noexcept { simdjson_inline void string_builder::escape_and_append_with_quotes(std::string_view input) noexcept { // escaping might turn a control character into \x00xx so 6 characters. + // Guard against size_t overflow in the arithmetic below. + if (input.size() > ((std::numeric_limits::max)() - 2) / 6) { + set_valid(false); + return; + } if (capacity_check(2 + 6 * input.size())) { buffer.get()[position++] = '"'; position += write_string_escaped(input, buffer.get() + position); @@ -57686,6 +57763,7 @@ simdjson_warn_unused simdjson_result extract_fractured_json( /* begin file simdjson/generic/builder/json_string_builder-inl.h for lasx */ #include #include +#include #include #ifndef SIMDJSON_GENERIC_STRING_BUILDER_INL_H @@ -58441,6 +58519,11 @@ simdjson_inline void string_builder::append(number_type v) noexcept { simdjson_inline void string_builder::escape_and_append(std::string_view input) noexcept { // escaping might turn a control character into \x00xx so 6 characters. + // Guard against size_t overflow in the multiplication below. + if (input.size() > (std::numeric_limits::max)() / 6) { + set_valid(false); + return; + } if (capacity_check(6 * input.size())) { position += write_string_escaped(input, buffer.get() + position); } @@ -58449,6 +58532,11 @@ string_builder::escape_and_append(std::string_view input) noexcept { simdjson_inline void string_builder::escape_and_append_with_quotes(std::string_view input) noexcept { // escaping might turn a control character into \x00xx so 6 characters. + // Guard against size_t overflow in the arithmetic below. + if (input.size() > ((std::numeric_limits::max)() - 2) / 6) { + set_valid(false); + return; + } if (capacity_check(2 + 6 * input.size())) { buffer.get()[position++] = '"'; position += write_string_escaped(input, buffer.get() + position); @@ -60190,6 +60278,7 @@ simdjson_warn_unused simdjson_result extract_fractured_json( /* begin file simdjson/generic/builder/json_string_builder-inl.h for rvv_vls */ #include #include +#include #include #ifndef SIMDJSON_GENERIC_STRING_BUILDER_INL_H @@ -60945,6 +61034,11 @@ simdjson_inline void string_builder::append(number_type v) noexcept { simdjson_inline void string_builder::escape_and_append(std::string_view input) noexcept { // escaping might turn a control character into \x00xx so 6 characters. + // Guard against size_t overflow in the multiplication below. + if (input.size() > (std::numeric_limits::max)() / 6) { + set_valid(false); + return; + } if (capacity_check(6 * input.size())) { position += write_string_escaped(input, buffer.get() + position); } @@ -60953,6 +61047,11 @@ string_builder::escape_and_append(std::string_view input) noexcept { simdjson_inline void string_builder::escape_and_append_with_quotes(std::string_view input) noexcept { // escaping might turn a control character into \x00xx so 6 characters. + // Guard against size_t overflow in the arithmetic below. + if (input.size() > ((std::numeric_limits::max)() - 2) / 6) { + set_valid(false); + return; + } if (capacity_check(2 + 6 * input.size())) { buffer.get()[position++] = '"'; position += write_string_escaped(input, buffer.get() + position); @@ -63512,13 +63611,21 @@ class value { simdjson_inline simdjson_result at_path(std::string_view at_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * Supports wildcard character (*) for arrays or ".*" for objects. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; protected: /** @@ -63711,9 +63818,23 @@ struct simdjson_result : public arm64::implementation_si simdjson_inline simdjson_result current_depth() const noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; }; +// Forward-declare explicit specializations so MSVC /permissive- sees them before +// any template instantiation that would resolve element.get(val) to the primary. +template<> simdjson_inline error_code +simdjson_result::get( + arm64::ondemand::value &out) noexcept; +template<> simdjson_inline simdjson_result +simdjson_result::get() noexcept; + } // namespace simdjson #endif // SIMDJSON_GENERIC_ONDEMAND_VALUE_H @@ -65052,8 +65173,6 @@ class parser { static simdjson_inline bool release_parser(); private: - friend bool release_parser(); - friend ondemand::parser& get_parser(); /** Get the thread-local parser instance, allocates it if needed */ static simdjson_inline simdjson_warn_unused std::unique_ptr& get_parser_instance(); /** Get the thread-local parser instance, it might be null */ @@ -65216,13 +65335,21 @@ class array { inline simdjson_result at_path(std::string_view json_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * Supports wildcard patterns like "[*]" to match all array elements. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; /** * Consumes the array and returns a string_view instance corresponding to the @@ -65346,7 +65473,13 @@ struct simdjson_result : public arm64::implementation_si simdjson_inline simdjson_result at(size_t index) noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; simdjson_inline simdjson_result raw_json() noexcept; #if SIMDJSON_SUPPORTS_CONCEPTS // TODO: move this code into object-inl.h @@ -66246,21 +66379,24 @@ class document { simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * * Supports wildcard patterns like "$.array[*]" or "$.object.*" to match multiple elements. * - * This method materializes all matching values into a vector. * The document will be consumed after this call. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern, or: - * - INVALID_JSON_POINTER if the JSONPath cannot be parsed - * - NO_SUCH_FIELD if a field does not exist - * - INDEX_OUT_OF_BOUNDS if an array index is out of bounds - * - INCORRECT_TYPE if path traversal encounters wrong type + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; /** * Consumes the document and returns a string_view instance corresponding to the @@ -66481,7 +66617,13 @@ class document_reference { simdjson_inline simdjson_result raw_json_token() noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; private: document *doc{nullptr}; @@ -66567,7 +66709,13 @@ struct simdjson_result : public arm64::implementation simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; #if SIMDJSON_STATIC_REFLECTION template requires(std::is_class_v && (sizeof...(FieldNames) > 0)) @@ -66652,7 +66800,13 @@ struct simdjson_result : public arm64::impl simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; #if SIMDJSON_STATIC_REFLECTION template requires(std::is_class_v && (sizeof...(FieldNames) > 0)) @@ -67305,13 +67459,21 @@ class object { inline simdjson_result at_path(std::string_view json_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * Supports wildcard patterns like ".*" to match all object fields. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; /** * Reset the iterator so that we are pointing back at the @@ -67461,7 +67623,13 @@ struct simdjson_result : public arm64::implementation_s simdjson_inline simdjson_result operator[](std::string_view key) && noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; inline simdjson_result reset() noexcept; inline simdjson_result is_empty() noexcept; inline simdjson_result count_fields() & noexcept; @@ -68475,46 +68643,34 @@ inline simdjson_result array::at_path(std::string_view json_path) noexcep return at_pointer(json_pointer); } -inline simdjson_result> array::at_path_with_wildcard(std::string_view json_path) noexcept { - std::vector result; - +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code array::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { auto result_pair = get_next_key_and_json_path(json_path); std::string_view key = result_pair.first; std::string_view remaining_path = result_pair.second; // Wildcard case - if(key=="*"){ - for(auto element: *this){ - - if(element.error()){ - return element.error(); - } - - if(remaining_path.empty()){ - // Use value_unsafe() because we've already checked for errors above. - // The 'element' is a simdjson_result wrapper, and we need to extract - // the underlying value. value_unsafe() is safe here because error() returned false. - result.push_back(std::move(element).value_unsafe()); - - }else{ - auto nested_result = element.at_path_with_wildcard(remaining_path); - - if(nested_result.error()){ - return nested_result.error(); - } - // Same logic as above. - std::vector nested_matches = std::move(nested_result).value_unsafe(); - - result.insert(result.end(), - std::make_move_iterator(nested_matches.begin()), - std::make_move_iterator(nested_matches.end())); + if (key=="*"){ + for(auto element: *this) { + value val; + SIMDJSON_TRY(element.get(val)); + if (remaining_path.empty()) { + callback(val); + } else { + error_code err = element.for_each_at_path_with_wildcard(remaining_path, callback); + if(err) { return err; } } } - return result; - }else{ + return SUCCESS; + } else { // Specific index case in which we access the element at the given index - size_t idx=0; + size_t idx = 0; - for(char c:key){ + for (char c : key) { if(c < '0' || c > '9'){ return INVALID_JSON_POINTER; } @@ -68522,16 +68678,13 @@ inline simdjson_result> array::at_path_with_wildcard(std::str } auto element = at(idx); - - if(element.error()){ - return element.error(); - } - - if(remaining_path.empty()){ - result.push_back(std::move(element).value_unsafe()); - return result; - }else{ - return element.at_path_with_wildcard(remaining_path); + value val; + SIMDJSON_TRY(element.get(val)); + if (remaining_path.empty()){ + callback(val); + return SUCCESS; + } else { + return element.for_each_at_path_with_wildcard(remaining_path, callback); } } } @@ -68594,9 +68747,15 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } simdjson_inline simdjson_result simdjson_result::raw_json() noexcept { if (error()) { return error(); } @@ -69017,14 +69176,20 @@ simdjson_inline simdjson_result value::at_path(std::string_view json_path } } -inline simdjson_result> value::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code value::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { json_type t; SIMDJSON_TRY(type().get(t)); switch (t) { case json_type::array: - return (*this).get_array().at_path_with_wildcard(json_path); + return (*this).get_array().for_each_at_path_with_wildcard(json_path, std::forward(callback)); case json_type::object: - return (*this).get_object().at_path_with_wildcard(json_path); + return (*this).get_object().for_each_at_path_with_wildcard(json_path, std::forward(callback)); default: return INVALID_JSON_POINTER; } @@ -69288,12 +69453,18 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard( - std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code simdjson_result::for_each_at_path_with_wildcard( + std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } } // namespace simdjson @@ -69669,8 +69840,14 @@ simdjson_inline simdjson_result document::at_path(std::string_view json_p } } -simdjson_inline simdjson_result> document::at_path_with_wildcard(std::string_view json_path) noexcept { - rewind(); // Rewind the document each time at_path_with_wildcard is called +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code document::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { + rewind(); // Rewind the document each time for_each_at_path_with_wildcard is called if (json_path.empty()) { return INVALID_JSON_POINTER; } @@ -69678,9 +69855,9 @@ simdjson_inline simdjson_result> document::at_path_with_wildc SIMDJSON_TRY(type().get(t)); switch (t) { case json_type::array: - return (*this).get_array().at_path_with_wildcard(json_path); + return (*this).get_array().for_each_at_path_with_wildcard(json_path, std::forward(callback)); case json_type::object: - return (*this).get_object().at_path_with_wildcard(json_path); + return (*this).get_object().for_each_at_path_with_wildcard(json_path, std::forward(callback)); default: return INVALID_JSON_POINTER; } @@ -70017,9 +70194,15 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } #if SIMDJSON_STATIC_REFLECTION @@ -70130,7 +70313,13 @@ simdjson_inline simdjson_result document_reference::get_number() noexcep simdjson_inline simdjson_result document_reference::raw_json_token() noexcept { return doc->raw_json_token(); } simdjson_inline simdjson_result document_reference::at_pointer(std::string_view json_pointer) noexcept { return doc->at_pointer(json_pointer); } simdjson_inline simdjson_result document_reference::at_path(std::string_view json_path) noexcept { return doc->at_path(json_path); } -simdjson_inline simdjson_result> document_reference::at_path_with_wildcard(std::string_view json_path) noexcept { return doc->at_path_with_wildcard(json_path); } +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code document_reference::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { return doc->for_each_at_path_with_wildcard(json_path, std::forward(callback)); } simdjson_inline simdjson_result document_reference::raw_json() noexcept { return doc->raw_json();} simdjson_inline document_reference::operator document&() const noexcept { return *doc; } #if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION @@ -70395,11 +70584,17 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } #if SIMDJSON_STATIC_REFLECTION template @@ -71977,9 +72172,13 @@ inline simdjson_result object::at_path(std::string_view json_path) noexce return at_pointer(json_pointer); } -inline simdjson_result> object::at_path_with_wildcard(std::string_view json_path) noexcept { - std::vector result; - +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code object::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { auto result_pair = get_next_key_and_json_path(json_path); std::string_view key = result_pair.first; std::string_view remaining_path = result_pair.second; @@ -71989,34 +72188,22 @@ inline simdjson_result> object::at_path_with_wildcard(std::st for (auto field : *this) { value val; SIMDJSON_TRY(field.value().get(val)); - if (remaining_path.empty()) { - result.push_back(std::move(val)); + callback(val); } else { - auto nested_result = val.at_path_with_wildcard(remaining_path); - - if (nested_result.error()) { - return nested_result.error(); - } - // Extract and append all nested matches to our result - std::vector nested_vec; - SIMDJSON_TRY(std::move(nested_result).get(nested_vec)); - - result.insert(result.end(), - std::make_move_iterator(nested_vec.begin()), - std::make_move_iterator(nested_vec.end())); + SIMDJSON_TRY(val.for_each_at_path_with_wildcard(remaining_path, callback)); } } - return result; + return SUCCESS; } else { value val; SIMDJSON_TRY(find_field(key).get(val)); if (remaining_path.empty()) { - result.push_back(std::move(val)); - return result; + callback(val); + return SUCCESS; } else { - return val.at_path_with_wildcard(remaining_path); + return val.for_each_at_path_with_wildcard(remaining_path, callback); } } } @@ -72147,9 +72334,15 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } inline simdjson_result simdjson_result::reset() noexcept { @@ -72530,7 +72723,7 @@ simdjson_inline simdjson_warn_unused ondemand::parser& parser::get_parser() { return *parser::get_parser_instance(); } -simdjson_inline bool release_parser() { +simdjson_inline bool parser::release_parser() { auto &parser_instance = parser::get_threadlocal_parser_if_exists(); if (parser_instance) { parser_instance.reset(); @@ -76788,13 +76981,21 @@ class value { simdjson_inline simdjson_result at_path(std::string_view at_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * Supports wildcard character (*) for arrays or ".*" for objects. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; protected: /** @@ -76987,9 +77188,23 @@ struct simdjson_result : public fallback::implementat simdjson_inline simdjson_result current_depth() const noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; }; +// Forward-declare explicit specializations so MSVC /permissive- sees them before +// any template instantiation that would resolve element.get(val) to the primary. +template<> simdjson_inline error_code +simdjson_result::get( + fallback::ondemand::value &out) noexcept; +template<> simdjson_inline simdjson_result +simdjson_result::get() noexcept; + } // namespace simdjson #endif // SIMDJSON_GENERIC_ONDEMAND_VALUE_H @@ -78328,8 +78543,6 @@ class parser { static simdjson_inline bool release_parser(); private: - friend bool release_parser(); - friend ondemand::parser& get_parser(); /** Get the thread-local parser instance, allocates it if needed */ static simdjson_inline simdjson_warn_unused std::unique_ptr& get_parser_instance(); /** Get the thread-local parser instance, it might be null */ @@ -78492,13 +78705,21 @@ class array { inline simdjson_result at_path(std::string_view json_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * Supports wildcard patterns like "[*]" to match all array elements. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; /** * Consumes the array and returns a string_view instance corresponding to the @@ -78622,7 +78843,13 @@ struct simdjson_result : public fallback::implementat simdjson_inline simdjson_result at(size_t index) noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; simdjson_inline simdjson_result raw_json() noexcept; #if SIMDJSON_SUPPORTS_CONCEPTS // TODO: move this code into object-inl.h @@ -79522,21 +79749,24 @@ class document { simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * * Supports wildcard patterns like "$.array[*]" or "$.object.*" to match multiple elements. * - * This method materializes all matching values into a vector. * The document will be consumed after this call. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern, or: - * - INVALID_JSON_POINTER if the JSONPath cannot be parsed - * - NO_SUCH_FIELD if a field does not exist - * - INDEX_OUT_OF_BOUNDS if an array index is out of bounds - * - INCORRECT_TYPE if path traversal encounters wrong type + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; /** * Consumes the document and returns a string_view instance corresponding to the @@ -79757,7 +79987,13 @@ class document_reference { simdjson_inline simdjson_result raw_json_token() noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; private: document *doc{nullptr}; @@ -79843,7 +80079,13 @@ struct simdjson_result : public fallback::implemen simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; #if SIMDJSON_STATIC_REFLECTION template requires(std::is_class_v && (sizeof...(FieldNames) > 0)) @@ -79928,7 +80170,13 @@ struct simdjson_result : public fallback simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; #if SIMDJSON_STATIC_REFLECTION template requires(std::is_class_v && (sizeof...(FieldNames) > 0)) @@ -80581,13 +80829,21 @@ class object { inline simdjson_result at_path(std::string_view json_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * Supports wildcard patterns like ".*" to match all object fields. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; /** * Reset the iterator so that we are pointing back at the @@ -80737,7 +80993,13 @@ struct simdjson_result : public fallback::implementa simdjson_inline simdjson_result operator[](std::string_view key) && noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; inline simdjson_result reset() noexcept; inline simdjson_result is_empty() noexcept; inline simdjson_result count_fields() & noexcept; @@ -81751,46 +82013,34 @@ inline simdjson_result array::at_path(std::string_view json_path) noexcep return at_pointer(json_pointer); } -inline simdjson_result> array::at_path_with_wildcard(std::string_view json_path) noexcept { - std::vector result; - +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code array::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { auto result_pair = get_next_key_and_json_path(json_path); std::string_view key = result_pair.first; std::string_view remaining_path = result_pair.second; // Wildcard case - if(key=="*"){ - for(auto element: *this){ - - if(element.error()){ - return element.error(); - } - - if(remaining_path.empty()){ - // Use value_unsafe() because we've already checked for errors above. - // The 'element' is a simdjson_result wrapper, and we need to extract - // the underlying value. value_unsafe() is safe here because error() returned false. - result.push_back(std::move(element).value_unsafe()); - - }else{ - auto nested_result = element.at_path_with_wildcard(remaining_path); - - if(nested_result.error()){ - return nested_result.error(); - } - // Same logic as above. - std::vector nested_matches = std::move(nested_result).value_unsafe(); - - result.insert(result.end(), - std::make_move_iterator(nested_matches.begin()), - std::make_move_iterator(nested_matches.end())); + if (key=="*"){ + for(auto element: *this) { + value val; + SIMDJSON_TRY(element.get(val)); + if (remaining_path.empty()) { + callback(val); + } else { + error_code err = element.for_each_at_path_with_wildcard(remaining_path, callback); + if(err) { return err; } } } - return result; - }else{ + return SUCCESS; + } else { // Specific index case in which we access the element at the given index - size_t idx=0; + size_t idx = 0; - for(char c:key){ + for (char c : key) { if(c < '0' || c > '9'){ return INVALID_JSON_POINTER; } @@ -81798,16 +82048,13 @@ inline simdjson_result> array::at_path_with_wildcard(std::str } auto element = at(idx); - - if(element.error()){ - return element.error(); - } - - if(remaining_path.empty()){ - result.push_back(std::move(element).value_unsafe()); - return result; - }else{ - return element.at_path_with_wildcard(remaining_path); + value val; + SIMDJSON_TRY(element.get(val)); + if (remaining_path.empty()){ + callback(val); + return SUCCESS; + } else { + return element.for_each_at_path_with_wildcard(remaining_path, callback); } } } @@ -81870,9 +82117,15 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } simdjson_inline simdjson_result simdjson_result::raw_json() noexcept { if (error()) { return error(); } @@ -82293,14 +82546,20 @@ simdjson_inline simdjson_result value::at_path(std::string_view json_path } } -inline simdjson_result> value::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code value::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { json_type t; SIMDJSON_TRY(type().get(t)); switch (t) { case json_type::array: - return (*this).get_array().at_path_with_wildcard(json_path); + return (*this).get_array().for_each_at_path_with_wildcard(json_path, std::forward(callback)); case json_type::object: - return (*this).get_object().at_path_with_wildcard(json_path); + return (*this).get_object().for_each_at_path_with_wildcard(json_path, std::forward(callback)); default: return INVALID_JSON_POINTER; } @@ -82564,12 +82823,18 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard( - std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code simdjson_result::for_each_at_path_with_wildcard( + std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } } // namespace simdjson @@ -82945,8 +83210,14 @@ simdjson_inline simdjson_result document::at_path(std::string_view json_p } } -simdjson_inline simdjson_result> document::at_path_with_wildcard(std::string_view json_path) noexcept { - rewind(); // Rewind the document each time at_path_with_wildcard is called +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code document::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { + rewind(); // Rewind the document each time for_each_at_path_with_wildcard is called if (json_path.empty()) { return INVALID_JSON_POINTER; } @@ -82954,9 +83225,9 @@ simdjson_inline simdjson_result> document::at_path_with_wildc SIMDJSON_TRY(type().get(t)); switch (t) { case json_type::array: - return (*this).get_array().at_path_with_wildcard(json_path); + return (*this).get_array().for_each_at_path_with_wildcard(json_path, std::forward(callback)); case json_type::object: - return (*this).get_object().at_path_with_wildcard(json_path); + return (*this).get_object().for_each_at_path_with_wildcard(json_path, std::forward(callback)); default: return INVALID_JSON_POINTER; } @@ -83293,9 +83564,15 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } #if SIMDJSON_STATIC_REFLECTION @@ -83406,7 +83683,13 @@ simdjson_inline simdjson_result document_reference::get_number() noexcep simdjson_inline simdjson_result document_reference::raw_json_token() noexcept { return doc->raw_json_token(); } simdjson_inline simdjson_result document_reference::at_pointer(std::string_view json_pointer) noexcept { return doc->at_pointer(json_pointer); } simdjson_inline simdjson_result document_reference::at_path(std::string_view json_path) noexcept { return doc->at_path(json_path); } -simdjson_inline simdjson_result> document_reference::at_path_with_wildcard(std::string_view json_path) noexcept { return doc->at_path_with_wildcard(json_path); } +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code document_reference::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { return doc->for_each_at_path_with_wildcard(json_path, std::forward(callback)); } simdjson_inline simdjson_result document_reference::raw_json() noexcept { return doc->raw_json();} simdjson_inline document_reference::operator document&() const noexcept { return *doc; } #if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION @@ -83671,11 +83954,17 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } #if SIMDJSON_STATIC_REFLECTION template @@ -85253,9 +85542,13 @@ inline simdjson_result object::at_path(std::string_view json_path) noexce return at_pointer(json_pointer); } -inline simdjson_result> object::at_path_with_wildcard(std::string_view json_path) noexcept { - std::vector result; - +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code object::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { auto result_pair = get_next_key_and_json_path(json_path); std::string_view key = result_pair.first; std::string_view remaining_path = result_pair.second; @@ -85265,34 +85558,22 @@ inline simdjson_result> object::at_path_with_wildcard(std::st for (auto field : *this) { value val; SIMDJSON_TRY(field.value().get(val)); - if (remaining_path.empty()) { - result.push_back(std::move(val)); + callback(val); } else { - auto nested_result = val.at_path_with_wildcard(remaining_path); - - if (nested_result.error()) { - return nested_result.error(); - } - // Extract and append all nested matches to our result - std::vector nested_vec; - SIMDJSON_TRY(std::move(nested_result).get(nested_vec)); - - result.insert(result.end(), - std::make_move_iterator(nested_vec.begin()), - std::make_move_iterator(nested_vec.end())); + SIMDJSON_TRY(val.for_each_at_path_with_wildcard(remaining_path, callback)); } } - return result; + return SUCCESS; } else { value val; SIMDJSON_TRY(find_field(key).get(val)); if (remaining_path.empty()) { - result.push_back(std::move(val)); - return result; + callback(val); + return SUCCESS; } else { - return val.at_path_with_wildcard(remaining_path); + return val.for_each_at_path_with_wildcard(remaining_path, callback); } } } @@ -85423,9 +85704,15 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } inline simdjson_result simdjson_result::reset() noexcept { @@ -85806,7 +86093,7 @@ simdjson_inline simdjson_warn_unused ondemand::parser& parser::get_parser() { return *parser::get_parser_instance(); } -simdjson_inline bool release_parser() { +simdjson_inline bool parser::release_parser() { auto &parser_instance = parser::get_threadlocal_parser_if_exists(); if (parser_instance) { parser_instance.reset(); @@ -90551,13 +90838,21 @@ class value { simdjson_inline simdjson_result at_path(std::string_view at_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * Supports wildcard character (*) for arrays or ".*" for objects. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; protected: /** @@ -90750,9 +91045,23 @@ struct simdjson_result : public haswell::implementatio simdjson_inline simdjson_result current_depth() const noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; }; +// Forward-declare explicit specializations so MSVC /permissive- sees them before +// any template instantiation that would resolve element.get(val) to the primary. +template<> simdjson_inline error_code +simdjson_result::get( + haswell::ondemand::value &out) noexcept; +template<> simdjson_inline simdjson_result +simdjson_result::get() noexcept; + } // namespace simdjson #endif // SIMDJSON_GENERIC_ONDEMAND_VALUE_H @@ -92091,8 +92400,6 @@ class parser { static simdjson_inline bool release_parser(); private: - friend bool release_parser(); - friend ondemand::parser& get_parser(); /** Get the thread-local parser instance, allocates it if needed */ static simdjson_inline simdjson_warn_unused std::unique_ptr& get_parser_instance(); /** Get the thread-local parser instance, it might be null */ @@ -92255,13 +92562,21 @@ class array { inline simdjson_result at_path(std::string_view json_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * Supports wildcard patterns like "[*]" to match all array elements. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; /** * Consumes the array and returns a string_view instance corresponding to the @@ -92385,7 +92700,13 @@ struct simdjson_result : public haswell::implementatio simdjson_inline simdjson_result at(size_t index) noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; simdjson_inline simdjson_result raw_json() noexcept; #if SIMDJSON_SUPPORTS_CONCEPTS // TODO: move this code into object-inl.h @@ -93285,21 +93606,24 @@ class document { simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * * Supports wildcard patterns like "$.array[*]" or "$.object.*" to match multiple elements. * - * This method materializes all matching values into a vector. * The document will be consumed after this call. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern, or: - * - INVALID_JSON_POINTER if the JSONPath cannot be parsed - * - NO_SUCH_FIELD if a field does not exist - * - INDEX_OUT_OF_BOUNDS if an array index is out of bounds - * - INCORRECT_TYPE if path traversal encounters wrong type + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; /** * Consumes the document and returns a string_view instance corresponding to the @@ -93520,7 +93844,13 @@ class document_reference { simdjson_inline simdjson_result raw_json_token() noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; private: document *doc{nullptr}; @@ -93606,7 +93936,13 @@ struct simdjson_result : public haswell::implementa simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; #if SIMDJSON_STATIC_REFLECTION template requires(std::is_class_v && (sizeof...(FieldNames) > 0)) @@ -93691,7 +94027,13 @@ struct simdjson_result : public haswell:: simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; #if SIMDJSON_STATIC_REFLECTION template requires(std::is_class_v && (sizeof...(FieldNames) > 0)) @@ -94344,13 +94686,21 @@ class object { inline simdjson_result at_path(std::string_view json_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * Supports wildcard patterns like ".*" to match all object fields. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; /** * Reset the iterator so that we are pointing back at the @@ -94500,7 +94850,13 @@ struct simdjson_result : public haswell::implementati simdjson_inline simdjson_result operator[](std::string_view key) && noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; inline simdjson_result reset() noexcept; inline simdjson_result is_empty() noexcept; inline simdjson_result count_fields() & noexcept; @@ -95514,46 +95870,34 @@ inline simdjson_result array::at_path(std::string_view json_path) noexcep return at_pointer(json_pointer); } -inline simdjson_result> array::at_path_with_wildcard(std::string_view json_path) noexcept { - std::vector result; - +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code array::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { auto result_pair = get_next_key_and_json_path(json_path); std::string_view key = result_pair.first; std::string_view remaining_path = result_pair.second; // Wildcard case - if(key=="*"){ - for(auto element: *this){ - - if(element.error()){ - return element.error(); - } - - if(remaining_path.empty()){ - // Use value_unsafe() because we've already checked for errors above. - // The 'element' is a simdjson_result wrapper, and we need to extract - // the underlying value. value_unsafe() is safe here because error() returned false. - result.push_back(std::move(element).value_unsafe()); - - }else{ - auto nested_result = element.at_path_with_wildcard(remaining_path); - - if(nested_result.error()){ - return nested_result.error(); - } - // Same logic as above. - std::vector nested_matches = std::move(nested_result).value_unsafe(); - - result.insert(result.end(), - std::make_move_iterator(nested_matches.begin()), - std::make_move_iterator(nested_matches.end())); + if (key=="*"){ + for(auto element: *this) { + value val; + SIMDJSON_TRY(element.get(val)); + if (remaining_path.empty()) { + callback(val); + } else { + error_code err = element.for_each_at_path_with_wildcard(remaining_path, callback); + if(err) { return err; } } } - return result; - }else{ + return SUCCESS; + } else { // Specific index case in which we access the element at the given index - size_t idx=0; + size_t idx = 0; - for(char c:key){ + for (char c : key) { if(c < '0' || c > '9'){ return INVALID_JSON_POINTER; } @@ -95561,16 +95905,13 @@ inline simdjson_result> array::at_path_with_wildcard(std::str } auto element = at(idx); - - if(element.error()){ - return element.error(); - } - - if(remaining_path.empty()){ - result.push_back(std::move(element).value_unsafe()); - return result; - }else{ - return element.at_path_with_wildcard(remaining_path); + value val; + SIMDJSON_TRY(element.get(val)); + if (remaining_path.empty()){ + callback(val); + return SUCCESS; + } else { + return element.for_each_at_path_with_wildcard(remaining_path, callback); } } } @@ -95633,9 +95974,15 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } simdjson_inline simdjson_result simdjson_result::raw_json() noexcept { if (error()) { return error(); } @@ -96056,14 +96403,20 @@ simdjson_inline simdjson_result value::at_path(std::string_view json_path } } -inline simdjson_result> value::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code value::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { json_type t; SIMDJSON_TRY(type().get(t)); switch (t) { case json_type::array: - return (*this).get_array().at_path_with_wildcard(json_path); + return (*this).get_array().for_each_at_path_with_wildcard(json_path, std::forward(callback)); case json_type::object: - return (*this).get_object().at_path_with_wildcard(json_path); + return (*this).get_object().for_each_at_path_with_wildcard(json_path, std::forward(callback)); default: return INVALID_JSON_POINTER; } @@ -96327,12 +96680,18 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard( - std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code simdjson_result::for_each_at_path_with_wildcard( + std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } } // namespace simdjson @@ -96708,8 +97067,14 @@ simdjson_inline simdjson_result document::at_path(std::string_view json_p } } -simdjson_inline simdjson_result> document::at_path_with_wildcard(std::string_view json_path) noexcept { - rewind(); // Rewind the document each time at_path_with_wildcard is called +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code document::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { + rewind(); // Rewind the document each time for_each_at_path_with_wildcard is called if (json_path.empty()) { return INVALID_JSON_POINTER; } @@ -96717,9 +97082,9 @@ simdjson_inline simdjson_result> document::at_path_with_wildc SIMDJSON_TRY(type().get(t)); switch (t) { case json_type::array: - return (*this).get_array().at_path_with_wildcard(json_path); + return (*this).get_array().for_each_at_path_with_wildcard(json_path, std::forward(callback)); case json_type::object: - return (*this).get_object().at_path_with_wildcard(json_path); + return (*this).get_object().for_each_at_path_with_wildcard(json_path, std::forward(callback)); default: return INVALID_JSON_POINTER; } @@ -97056,9 +97421,15 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } #if SIMDJSON_STATIC_REFLECTION @@ -97169,7 +97540,13 @@ simdjson_inline simdjson_result document_reference::get_number() noexcep simdjson_inline simdjson_result document_reference::raw_json_token() noexcept { return doc->raw_json_token(); } simdjson_inline simdjson_result document_reference::at_pointer(std::string_view json_pointer) noexcept { return doc->at_pointer(json_pointer); } simdjson_inline simdjson_result document_reference::at_path(std::string_view json_path) noexcept { return doc->at_path(json_path); } -simdjson_inline simdjson_result> document_reference::at_path_with_wildcard(std::string_view json_path) noexcept { return doc->at_path_with_wildcard(json_path); } +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code document_reference::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { return doc->for_each_at_path_with_wildcard(json_path, std::forward(callback)); } simdjson_inline simdjson_result document_reference::raw_json() noexcept { return doc->raw_json();} simdjson_inline document_reference::operator document&() const noexcept { return *doc; } #if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION @@ -97434,11 +97811,17 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } #if SIMDJSON_STATIC_REFLECTION template @@ -99016,9 +99399,13 @@ inline simdjson_result object::at_path(std::string_view json_path) noexce return at_pointer(json_pointer); } -inline simdjson_result> object::at_path_with_wildcard(std::string_view json_path) noexcept { - std::vector result; - +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code object::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { auto result_pair = get_next_key_and_json_path(json_path); std::string_view key = result_pair.first; std::string_view remaining_path = result_pair.second; @@ -99028,34 +99415,22 @@ inline simdjson_result> object::at_path_with_wildcard(std::st for (auto field : *this) { value val; SIMDJSON_TRY(field.value().get(val)); - if (remaining_path.empty()) { - result.push_back(std::move(val)); + callback(val); } else { - auto nested_result = val.at_path_with_wildcard(remaining_path); - - if (nested_result.error()) { - return nested_result.error(); - } - // Extract and append all nested matches to our result - std::vector nested_vec; - SIMDJSON_TRY(std::move(nested_result).get(nested_vec)); - - result.insert(result.end(), - std::make_move_iterator(nested_vec.begin()), - std::make_move_iterator(nested_vec.end())); + SIMDJSON_TRY(val.for_each_at_path_with_wildcard(remaining_path, callback)); } } - return result; + return SUCCESS; } else { value val; SIMDJSON_TRY(find_field(key).get(val)); if (remaining_path.empty()) { - result.push_back(std::move(val)); - return result; + callback(val); + return SUCCESS; } else { - return val.at_path_with_wildcard(remaining_path); + return val.for_each_at_path_with_wildcard(remaining_path, callback); } } } @@ -99186,9 +99561,15 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } inline simdjson_result simdjson_result::reset() noexcept { @@ -99569,7 +99950,7 @@ simdjson_inline simdjson_warn_unused ondemand::parser& parser::get_parser() { return *parser::get_parser_instance(); } -simdjson_inline bool release_parser() { +simdjson_inline bool parser::release_parser() { auto &parser_instance = parser::get_threadlocal_parser_if_exists(); if (parser_instance) { parser_instance.reset(); @@ -104314,13 +104695,21 @@ class value { simdjson_inline simdjson_result at_path(std::string_view at_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * Supports wildcard character (*) for arrays or ".*" for objects. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; protected: /** @@ -104513,9 +104902,23 @@ struct simdjson_result : public icelake::implementatio simdjson_inline simdjson_result current_depth() const noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; }; +// Forward-declare explicit specializations so MSVC /permissive- sees them before +// any template instantiation that would resolve element.get(val) to the primary. +template<> simdjson_inline error_code +simdjson_result::get( + icelake::ondemand::value &out) noexcept; +template<> simdjson_inline simdjson_result +simdjson_result::get() noexcept; + } // namespace simdjson #endif // SIMDJSON_GENERIC_ONDEMAND_VALUE_H @@ -105854,8 +106257,6 @@ class parser { static simdjson_inline bool release_parser(); private: - friend bool release_parser(); - friend ondemand::parser& get_parser(); /** Get the thread-local parser instance, allocates it if needed */ static simdjson_inline simdjson_warn_unused std::unique_ptr& get_parser_instance(); /** Get the thread-local parser instance, it might be null */ @@ -106018,13 +106419,21 @@ class array { inline simdjson_result at_path(std::string_view json_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * Supports wildcard patterns like "[*]" to match all array elements. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; /** * Consumes the array and returns a string_view instance corresponding to the @@ -106148,7 +106557,13 @@ struct simdjson_result : public icelake::implementatio simdjson_inline simdjson_result at(size_t index) noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; simdjson_inline simdjson_result raw_json() noexcept; #if SIMDJSON_SUPPORTS_CONCEPTS // TODO: move this code into object-inl.h @@ -107048,21 +107463,24 @@ class document { simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * * Supports wildcard patterns like "$.array[*]" or "$.object.*" to match multiple elements. * - * This method materializes all matching values into a vector. * The document will be consumed after this call. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern, or: - * - INVALID_JSON_POINTER if the JSONPath cannot be parsed - * - NO_SUCH_FIELD if a field does not exist - * - INDEX_OUT_OF_BOUNDS if an array index is out of bounds - * - INCORRECT_TYPE if path traversal encounters wrong type + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; /** * Consumes the document and returns a string_view instance corresponding to the @@ -107283,7 +107701,13 @@ class document_reference { simdjson_inline simdjson_result raw_json_token() noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; private: document *doc{nullptr}; @@ -107369,7 +107793,13 @@ struct simdjson_result : public icelake::implementa simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; #if SIMDJSON_STATIC_REFLECTION template requires(std::is_class_v && (sizeof...(FieldNames) > 0)) @@ -107454,7 +107884,13 @@ struct simdjson_result : public icelake:: simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; #if SIMDJSON_STATIC_REFLECTION template requires(std::is_class_v && (sizeof...(FieldNames) > 0)) @@ -108107,13 +108543,21 @@ class object { inline simdjson_result at_path(std::string_view json_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * Supports wildcard patterns like ".*" to match all object fields. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; /** * Reset the iterator so that we are pointing back at the @@ -108263,7 +108707,13 @@ struct simdjson_result : public icelake::implementati simdjson_inline simdjson_result operator[](std::string_view key) && noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; inline simdjson_result reset() noexcept; inline simdjson_result is_empty() noexcept; inline simdjson_result count_fields() & noexcept; @@ -109277,46 +109727,34 @@ inline simdjson_result array::at_path(std::string_view json_path) noexcep return at_pointer(json_pointer); } -inline simdjson_result> array::at_path_with_wildcard(std::string_view json_path) noexcept { - std::vector result; - +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code array::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { auto result_pair = get_next_key_and_json_path(json_path); std::string_view key = result_pair.first; std::string_view remaining_path = result_pair.second; // Wildcard case - if(key=="*"){ - for(auto element: *this){ - - if(element.error()){ - return element.error(); - } - - if(remaining_path.empty()){ - // Use value_unsafe() because we've already checked for errors above. - // The 'element' is a simdjson_result wrapper, and we need to extract - // the underlying value. value_unsafe() is safe here because error() returned false. - result.push_back(std::move(element).value_unsafe()); - - }else{ - auto nested_result = element.at_path_with_wildcard(remaining_path); - - if(nested_result.error()){ - return nested_result.error(); - } - // Same logic as above. - std::vector nested_matches = std::move(nested_result).value_unsafe(); - - result.insert(result.end(), - std::make_move_iterator(nested_matches.begin()), - std::make_move_iterator(nested_matches.end())); + if (key=="*"){ + for(auto element: *this) { + value val; + SIMDJSON_TRY(element.get(val)); + if (remaining_path.empty()) { + callback(val); + } else { + error_code err = element.for_each_at_path_with_wildcard(remaining_path, callback); + if(err) { return err; } } } - return result; - }else{ + return SUCCESS; + } else { // Specific index case in which we access the element at the given index - size_t idx=0; + size_t idx = 0; - for(char c:key){ + for (char c : key) { if(c < '0' || c > '9'){ return INVALID_JSON_POINTER; } @@ -109324,16 +109762,13 @@ inline simdjson_result> array::at_path_with_wildcard(std::str } auto element = at(idx); - - if(element.error()){ - return element.error(); - } - - if(remaining_path.empty()){ - result.push_back(std::move(element).value_unsafe()); - return result; - }else{ - return element.at_path_with_wildcard(remaining_path); + value val; + SIMDJSON_TRY(element.get(val)); + if (remaining_path.empty()){ + callback(val); + return SUCCESS; + } else { + return element.for_each_at_path_with_wildcard(remaining_path, callback); } } } @@ -109396,9 +109831,15 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } simdjson_inline simdjson_result simdjson_result::raw_json() noexcept { if (error()) { return error(); } @@ -109819,14 +110260,20 @@ simdjson_inline simdjson_result value::at_path(std::string_view json_path } } -inline simdjson_result> value::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code value::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { json_type t; SIMDJSON_TRY(type().get(t)); switch (t) { case json_type::array: - return (*this).get_array().at_path_with_wildcard(json_path); + return (*this).get_array().for_each_at_path_with_wildcard(json_path, std::forward(callback)); case json_type::object: - return (*this).get_object().at_path_with_wildcard(json_path); + return (*this).get_object().for_each_at_path_with_wildcard(json_path, std::forward(callback)); default: return INVALID_JSON_POINTER; } @@ -110090,12 +110537,18 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard( - std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code simdjson_result::for_each_at_path_with_wildcard( + std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } } // namespace simdjson @@ -110471,8 +110924,14 @@ simdjson_inline simdjson_result document::at_path(std::string_view json_p } } -simdjson_inline simdjson_result> document::at_path_with_wildcard(std::string_view json_path) noexcept { - rewind(); // Rewind the document each time at_path_with_wildcard is called +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code document::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { + rewind(); // Rewind the document each time for_each_at_path_with_wildcard is called if (json_path.empty()) { return INVALID_JSON_POINTER; } @@ -110480,9 +110939,9 @@ simdjson_inline simdjson_result> document::at_path_with_wildc SIMDJSON_TRY(type().get(t)); switch (t) { case json_type::array: - return (*this).get_array().at_path_with_wildcard(json_path); + return (*this).get_array().for_each_at_path_with_wildcard(json_path, std::forward(callback)); case json_type::object: - return (*this).get_object().at_path_with_wildcard(json_path); + return (*this).get_object().for_each_at_path_with_wildcard(json_path, std::forward(callback)); default: return INVALID_JSON_POINTER; } @@ -110819,9 +111278,15 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } #if SIMDJSON_STATIC_REFLECTION @@ -110932,7 +111397,13 @@ simdjson_inline simdjson_result document_reference::get_number() noexcep simdjson_inline simdjson_result document_reference::raw_json_token() noexcept { return doc->raw_json_token(); } simdjson_inline simdjson_result document_reference::at_pointer(std::string_view json_pointer) noexcept { return doc->at_pointer(json_pointer); } simdjson_inline simdjson_result document_reference::at_path(std::string_view json_path) noexcept { return doc->at_path(json_path); } -simdjson_inline simdjson_result> document_reference::at_path_with_wildcard(std::string_view json_path) noexcept { return doc->at_path_with_wildcard(json_path); } +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code document_reference::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { return doc->for_each_at_path_with_wildcard(json_path, std::forward(callback)); } simdjson_inline simdjson_result document_reference::raw_json() noexcept { return doc->raw_json();} simdjson_inline document_reference::operator document&() const noexcept { return *doc; } #if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION @@ -111197,11 +111668,17 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } #if SIMDJSON_STATIC_REFLECTION template @@ -112779,9 +113256,13 @@ inline simdjson_result object::at_path(std::string_view json_path) noexce return at_pointer(json_pointer); } -inline simdjson_result> object::at_path_with_wildcard(std::string_view json_path) noexcept { - std::vector result; - +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code object::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { auto result_pair = get_next_key_and_json_path(json_path); std::string_view key = result_pair.first; std::string_view remaining_path = result_pair.second; @@ -112791,34 +113272,22 @@ inline simdjson_result> object::at_path_with_wildcard(std::st for (auto field : *this) { value val; SIMDJSON_TRY(field.value().get(val)); - if (remaining_path.empty()) { - result.push_back(std::move(val)); + callback(val); } else { - auto nested_result = val.at_path_with_wildcard(remaining_path); - - if (nested_result.error()) { - return nested_result.error(); - } - // Extract and append all nested matches to our result - std::vector nested_vec; - SIMDJSON_TRY(std::move(nested_result).get(nested_vec)); - - result.insert(result.end(), - std::make_move_iterator(nested_vec.begin()), - std::make_move_iterator(nested_vec.end())); + SIMDJSON_TRY(val.for_each_at_path_with_wildcard(remaining_path, callback)); } } - return result; + return SUCCESS; } else { value val; SIMDJSON_TRY(find_field(key).get(val)); if (remaining_path.empty()) { - result.push_back(std::move(val)); - return result; + callback(val); + return SUCCESS; } else { - return val.at_path_with_wildcard(remaining_path); + return val.for_each_at_path_with_wildcard(remaining_path, callback); } } } @@ -112949,9 +113418,15 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } inline simdjson_result simdjson_result::reset() noexcept { @@ -113332,7 +113807,7 @@ simdjson_inline simdjson_warn_unused ondemand::parser& parser::get_parser() { return *parser::get_parser_instance(); } -simdjson_inline bool release_parser() { +simdjson_inline bool parser::release_parser() { auto &parser_instance = parser::get_threadlocal_parser_if_exists(); if (parser_instance) { parser_instance.reset(); @@ -118192,13 +118667,21 @@ class value { simdjson_inline simdjson_result at_path(std::string_view at_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * Supports wildcard character (*) for arrays or ".*" for objects. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; protected: /** @@ -118391,9 +118874,23 @@ struct simdjson_result : public ppc64::implementation_si simdjson_inline simdjson_result current_depth() const noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; }; +// Forward-declare explicit specializations so MSVC /permissive- sees them before +// any template instantiation that would resolve element.get(val) to the primary. +template<> simdjson_inline error_code +simdjson_result::get( + ppc64::ondemand::value &out) noexcept; +template<> simdjson_inline simdjson_result +simdjson_result::get() noexcept; + } // namespace simdjson #endif // SIMDJSON_GENERIC_ONDEMAND_VALUE_H @@ -119732,8 +120229,6 @@ class parser { static simdjson_inline bool release_parser(); private: - friend bool release_parser(); - friend ondemand::parser& get_parser(); /** Get the thread-local parser instance, allocates it if needed */ static simdjson_inline simdjson_warn_unused std::unique_ptr& get_parser_instance(); /** Get the thread-local parser instance, it might be null */ @@ -119896,13 +120391,21 @@ class array { inline simdjson_result at_path(std::string_view json_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * Supports wildcard patterns like "[*]" to match all array elements. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; /** * Consumes the array and returns a string_view instance corresponding to the @@ -120026,7 +120529,13 @@ struct simdjson_result : public ppc64::implementation_si simdjson_inline simdjson_result at(size_t index) noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; simdjson_inline simdjson_result raw_json() noexcept; #if SIMDJSON_SUPPORTS_CONCEPTS // TODO: move this code into object-inl.h @@ -120926,21 +121435,24 @@ class document { simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * * Supports wildcard patterns like "$.array[*]" or "$.object.*" to match multiple elements. * - * This method materializes all matching values into a vector. * The document will be consumed after this call. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern, or: - * - INVALID_JSON_POINTER if the JSONPath cannot be parsed - * - NO_SUCH_FIELD if a field does not exist - * - INDEX_OUT_OF_BOUNDS if an array index is out of bounds - * - INCORRECT_TYPE if path traversal encounters wrong type + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; /** * Consumes the document and returns a string_view instance corresponding to the @@ -121161,7 +121673,13 @@ class document_reference { simdjson_inline simdjson_result raw_json_token() noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; private: document *doc{nullptr}; @@ -121247,7 +121765,13 @@ struct simdjson_result : public ppc64::implementation simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; #if SIMDJSON_STATIC_REFLECTION template requires(std::is_class_v && (sizeof...(FieldNames) > 0)) @@ -121332,7 +121856,13 @@ struct simdjson_result : public ppc64::impl simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; #if SIMDJSON_STATIC_REFLECTION template requires(std::is_class_v && (sizeof...(FieldNames) > 0)) @@ -121985,13 +122515,21 @@ class object { inline simdjson_result at_path(std::string_view json_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * Supports wildcard patterns like ".*" to match all object fields. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; /** * Reset the iterator so that we are pointing back at the @@ -122141,7 +122679,13 @@ struct simdjson_result : public ppc64::implementation_s simdjson_inline simdjson_result operator[](std::string_view key) && noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; inline simdjson_result reset() noexcept; inline simdjson_result is_empty() noexcept; inline simdjson_result count_fields() & noexcept; @@ -123155,46 +123699,34 @@ inline simdjson_result array::at_path(std::string_view json_path) noexcep return at_pointer(json_pointer); } -inline simdjson_result> array::at_path_with_wildcard(std::string_view json_path) noexcept { - std::vector result; - +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code array::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { auto result_pair = get_next_key_and_json_path(json_path); std::string_view key = result_pair.first; std::string_view remaining_path = result_pair.second; // Wildcard case - if(key=="*"){ - for(auto element: *this){ - - if(element.error()){ - return element.error(); - } - - if(remaining_path.empty()){ - // Use value_unsafe() because we've already checked for errors above. - // The 'element' is a simdjson_result wrapper, and we need to extract - // the underlying value. value_unsafe() is safe here because error() returned false. - result.push_back(std::move(element).value_unsafe()); - - }else{ - auto nested_result = element.at_path_with_wildcard(remaining_path); - - if(nested_result.error()){ - return nested_result.error(); - } - // Same logic as above. - std::vector nested_matches = std::move(nested_result).value_unsafe(); - - result.insert(result.end(), - std::make_move_iterator(nested_matches.begin()), - std::make_move_iterator(nested_matches.end())); + if (key=="*"){ + for(auto element: *this) { + value val; + SIMDJSON_TRY(element.get(val)); + if (remaining_path.empty()) { + callback(val); + } else { + error_code err = element.for_each_at_path_with_wildcard(remaining_path, callback); + if(err) { return err; } } } - return result; - }else{ + return SUCCESS; + } else { // Specific index case in which we access the element at the given index - size_t idx=0; + size_t idx = 0; - for(char c:key){ + for (char c : key) { if(c < '0' || c > '9'){ return INVALID_JSON_POINTER; } @@ -123202,16 +123734,13 @@ inline simdjson_result> array::at_path_with_wildcard(std::str } auto element = at(idx); - - if(element.error()){ - return element.error(); - } - - if(remaining_path.empty()){ - result.push_back(std::move(element).value_unsafe()); - return result; - }else{ - return element.at_path_with_wildcard(remaining_path); + value val; + SIMDJSON_TRY(element.get(val)); + if (remaining_path.empty()){ + callback(val); + return SUCCESS; + } else { + return element.for_each_at_path_with_wildcard(remaining_path, callback); } } } @@ -123274,9 +123803,15 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } simdjson_inline simdjson_result simdjson_result::raw_json() noexcept { if (error()) { return error(); } @@ -123697,14 +124232,20 @@ simdjson_inline simdjson_result value::at_path(std::string_view json_path } } -inline simdjson_result> value::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code value::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { json_type t; SIMDJSON_TRY(type().get(t)); switch (t) { case json_type::array: - return (*this).get_array().at_path_with_wildcard(json_path); + return (*this).get_array().for_each_at_path_with_wildcard(json_path, std::forward(callback)); case json_type::object: - return (*this).get_object().at_path_with_wildcard(json_path); + return (*this).get_object().for_each_at_path_with_wildcard(json_path, std::forward(callback)); default: return INVALID_JSON_POINTER; } @@ -123968,12 +124509,18 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard( - std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code simdjson_result::for_each_at_path_with_wildcard( + std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } } // namespace simdjson @@ -124349,8 +124896,14 @@ simdjson_inline simdjson_result document::at_path(std::string_view json_p } } -simdjson_inline simdjson_result> document::at_path_with_wildcard(std::string_view json_path) noexcept { - rewind(); // Rewind the document each time at_path_with_wildcard is called +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code document::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { + rewind(); // Rewind the document each time for_each_at_path_with_wildcard is called if (json_path.empty()) { return INVALID_JSON_POINTER; } @@ -124358,9 +124911,9 @@ simdjson_inline simdjson_result> document::at_path_with_wildc SIMDJSON_TRY(type().get(t)); switch (t) { case json_type::array: - return (*this).get_array().at_path_with_wildcard(json_path); + return (*this).get_array().for_each_at_path_with_wildcard(json_path, std::forward(callback)); case json_type::object: - return (*this).get_object().at_path_with_wildcard(json_path); + return (*this).get_object().for_each_at_path_with_wildcard(json_path, std::forward(callback)); default: return INVALID_JSON_POINTER; } @@ -124697,9 +125250,15 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } #if SIMDJSON_STATIC_REFLECTION @@ -124810,7 +125369,13 @@ simdjson_inline simdjson_result document_reference::get_number() noexcep simdjson_inline simdjson_result document_reference::raw_json_token() noexcept { return doc->raw_json_token(); } simdjson_inline simdjson_result document_reference::at_pointer(std::string_view json_pointer) noexcept { return doc->at_pointer(json_pointer); } simdjson_inline simdjson_result document_reference::at_path(std::string_view json_path) noexcept { return doc->at_path(json_path); } -simdjson_inline simdjson_result> document_reference::at_path_with_wildcard(std::string_view json_path) noexcept { return doc->at_path_with_wildcard(json_path); } +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code document_reference::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { return doc->for_each_at_path_with_wildcard(json_path, std::forward(callback)); } simdjson_inline simdjson_result document_reference::raw_json() noexcept { return doc->raw_json();} simdjson_inline document_reference::operator document&() const noexcept { return *doc; } #if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION @@ -125075,11 +125640,17 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } #if SIMDJSON_STATIC_REFLECTION template @@ -126657,9 +127228,13 @@ inline simdjson_result object::at_path(std::string_view json_path) noexce return at_pointer(json_pointer); } -inline simdjson_result> object::at_path_with_wildcard(std::string_view json_path) noexcept { - std::vector result; - +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code object::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { auto result_pair = get_next_key_and_json_path(json_path); std::string_view key = result_pair.first; std::string_view remaining_path = result_pair.second; @@ -126669,34 +127244,22 @@ inline simdjson_result> object::at_path_with_wildcard(std::st for (auto field : *this) { value val; SIMDJSON_TRY(field.value().get(val)); - if (remaining_path.empty()) { - result.push_back(std::move(val)); + callback(val); } else { - auto nested_result = val.at_path_with_wildcard(remaining_path); - - if (nested_result.error()) { - return nested_result.error(); - } - // Extract and append all nested matches to our result - std::vector nested_vec; - SIMDJSON_TRY(std::move(nested_result).get(nested_vec)); - - result.insert(result.end(), - std::make_move_iterator(nested_vec.begin()), - std::make_move_iterator(nested_vec.end())); + SIMDJSON_TRY(val.for_each_at_path_with_wildcard(remaining_path, callback)); } } - return result; + return SUCCESS; } else { value val; SIMDJSON_TRY(find_field(key).get(val)); if (remaining_path.empty()) { - result.push_back(std::move(val)); - return result; + callback(val); + return SUCCESS; } else { - return val.at_path_with_wildcard(remaining_path); + return val.for_each_at_path_with_wildcard(remaining_path, callback); } } } @@ -126827,9 +127390,15 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } inline simdjson_result simdjson_result::reset() noexcept { @@ -127210,7 +127779,7 @@ simdjson_inline simdjson_warn_unused ondemand::parser& parser::get_parser() { return *parser::get_parser_instance(); } -simdjson_inline bool release_parser() { +simdjson_inline bool parser::release_parser() { auto &parser_instance = parser::get_threadlocal_parser_if_exists(); if (parser_instance) { parser_instance.reset(); @@ -132387,13 +132956,21 @@ class value { simdjson_inline simdjson_result at_path(std::string_view at_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * Supports wildcard character (*) for arrays or ".*" for objects. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; protected: /** @@ -132586,9 +133163,23 @@ struct simdjson_result : public westmere::implementat simdjson_inline simdjson_result current_depth() const noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; }; +// Forward-declare explicit specializations so MSVC /permissive- sees them before +// any template instantiation that would resolve element.get(val) to the primary. +template<> simdjson_inline error_code +simdjson_result::get( + westmere::ondemand::value &out) noexcept; +template<> simdjson_inline simdjson_result +simdjson_result::get() noexcept; + } // namespace simdjson #endif // SIMDJSON_GENERIC_ONDEMAND_VALUE_H @@ -133927,8 +134518,6 @@ class parser { static simdjson_inline bool release_parser(); private: - friend bool release_parser(); - friend ondemand::parser& get_parser(); /** Get the thread-local parser instance, allocates it if needed */ static simdjson_inline simdjson_warn_unused std::unique_ptr& get_parser_instance(); /** Get the thread-local parser instance, it might be null */ @@ -134091,13 +134680,21 @@ class array { inline simdjson_result at_path(std::string_view json_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * Supports wildcard patterns like "[*]" to match all array elements. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; /** * Consumes the array and returns a string_view instance corresponding to the @@ -134221,7 +134818,13 @@ struct simdjson_result : public westmere::implementat simdjson_inline simdjson_result at(size_t index) noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; simdjson_inline simdjson_result raw_json() noexcept; #if SIMDJSON_SUPPORTS_CONCEPTS // TODO: move this code into object-inl.h @@ -135121,21 +135724,24 @@ class document { simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * * Supports wildcard patterns like "$.array[*]" or "$.object.*" to match multiple elements. * - * This method materializes all matching values into a vector. * The document will be consumed after this call. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern, or: - * - INVALID_JSON_POINTER if the JSONPath cannot be parsed - * - NO_SUCH_FIELD if a field does not exist - * - INDEX_OUT_OF_BOUNDS if an array index is out of bounds - * - INCORRECT_TYPE if path traversal encounters wrong type + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; /** * Consumes the document and returns a string_view instance corresponding to the @@ -135356,7 +135962,13 @@ class document_reference { simdjson_inline simdjson_result raw_json_token() noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; private: document *doc{nullptr}; @@ -135442,7 +136054,13 @@ struct simdjson_result : public westmere::implemen simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; #if SIMDJSON_STATIC_REFLECTION template requires(std::is_class_v && (sizeof...(FieldNames) > 0)) @@ -135527,7 +136145,13 @@ struct simdjson_result : public westmere simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; #if SIMDJSON_STATIC_REFLECTION template requires(std::is_class_v && (sizeof...(FieldNames) > 0)) @@ -136180,13 +136804,21 @@ class object { inline simdjson_result at_path(std::string_view json_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * Supports wildcard patterns like ".*" to match all object fields. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; /** * Reset the iterator so that we are pointing back at the @@ -136336,7 +136968,13 @@ struct simdjson_result : public westmere::implementa simdjson_inline simdjson_result operator[](std::string_view key) && noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; inline simdjson_result reset() noexcept; inline simdjson_result is_empty() noexcept; inline simdjson_result count_fields() & noexcept; @@ -137350,46 +137988,34 @@ inline simdjson_result array::at_path(std::string_view json_path) noexcep return at_pointer(json_pointer); } -inline simdjson_result> array::at_path_with_wildcard(std::string_view json_path) noexcept { - std::vector result; - +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code array::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { auto result_pair = get_next_key_and_json_path(json_path); std::string_view key = result_pair.first; std::string_view remaining_path = result_pair.second; // Wildcard case - if(key=="*"){ - for(auto element: *this){ - - if(element.error()){ - return element.error(); - } - - if(remaining_path.empty()){ - // Use value_unsafe() because we've already checked for errors above. - // The 'element' is a simdjson_result wrapper, and we need to extract - // the underlying value. value_unsafe() is safe here because error() returned false. - result.push_back(std::move(element).value_unsafe()); - - }else{ - auto nested_result = element.at_path_with_wildcard(remaining_path); - - if(nested_result.error()){ - return nested_result.error(); - } - // Same logic as above. - std::vector nested_matches = std::move(nested_result).value_unsafe(); - - result.insert(result.end(), - std::make_move_iterator(nested_matches.begin()), - std::make_move_iterator(nested_matches.end())); + if (key=="*"){ + for(auto element: *this) { + value val; + SIMDJSON_TRY(element.get(val)); + if (remaining_path.empty()) { + callback(val); + } else { + error_code err = element.for_each_at_path_with_wildcard(remaining_path, callback); + if(err) { return err; } } } - return result; - }else{ + return SUCCESS; + } else { // Specific index case in which we access the element at the given index - size_t idx=0; + size_t idx = 0; - for(char c:key){ + for (char c : key) { if(c < '0' || c > '9'){ return INVALID_JSON_POINTER; } @@ -137397,16 +138023,13 @@ inline simdjson_result> array::at_path_with_wildcard(std::str } auto element = at(idx); - - if(element.error()){ - return element.error(); - } - - if(remaining_path.empty()){ - result.push_back(std::move(element).value_unsafe()); - return result; - }else{ - return element.at_path_with_wildcard(remaining_path); + value val; + SIMDJSON_TRY(element.get(val)); + if (remaining_path.empty()){ + callback(val); + return SUCCESS; + } else { + return element.for_each_at_path_with_wildcard(remaining_path, callback); } } } @@ -137469,9 +138092,15 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } simdjson_inline simdjson_result simdjson_result::raw_json() noexcept { if (error()) { return error(); } @@ -137892,14 +138521,20 @@ simdjson_inline simdjson_result value::at_path(std::string_view json_path } } -inline simdjson_result> value::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code value::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { json_type t; SIMDJSON_TRY(type().get(t)); switch (t) { case json_type::array: - return (*this).get_array().at_path_with_wildcard(json_path); + return (*this).get_array().for_each_at_path_with_wildcard(json_path, std::forward(callback)); case json_type::object: - return (*this).get_object().at_path_with_wildcard(json_path); + return (*this).get_object().for_each_at_path_with_wildcard(json_path, std::forward(callback)); default: return INVALID_JSON_POINTER; } @@ -138163,12 +138798,18 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard( - std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code simdjson_result::for_each_at_path_with_wildcard( + std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } } // namespace simdjson @@ -138544,8 +139185,14 @@ simdjson_inline simdjson_result document::at_path(std::string_view json_p } } -simdjson_inline simdjson_result> document::at_path_with_wildcard(std::string_view json_path) noexcept { - rewind(); // Rewind the document each time at_path_with_wildcard is called +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code document::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { + rewind(); // Rewind the document each time for_each_at_path_with_wildcard is called if (json_path.empty()) { return INVALID_JSON_POINTER; } @@ -138553,9 +139200,9 @@ simdjson_inline simdjson_result> document::at_path_with_wildc SIMDJSON_TRY(type().get(t)); switch (t) { case json_type::array: - return (*this).get_array().at_path_with_wildcard(json_path); + return (*this).get_array().for_each_at_path_with_wildcard(json_path, std::forward(callback)); case json_type::object: - return (*this).get_object().at_path_with_wildcard(json_path); + return (*this).get_object().for_each_at_path_with_wildcard(json_path, std::forward(callback)); default: return INVALID_JSON_POINTER; } @@ -138892,9 +139539,15 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } #if SIMDJSON_STATIC_REFLECTION @@ -139005,7 +139658,13 @@ simdjson_inline simdjson_result document_reference::get_number() noexcep simdjson_inline simdjson_result document_reference::raw_json_token() noexcept { return doc->raw_json_token(); } simdjson_inline simdjson_result document_reference::at_pointer(std::string_view json_pointer) noexcept { return doc->at_pointer(json_pointer); } simdjson_inline simdjson_result document_reference::at_path(std::string_view json_path) noexcept { return doc->at_path(json_path); } -simdjson_inline simdjson_result> document_reference::at_path_with_wildcard(std::string_view json_path) noexcept { return doc->at_path_with_wildcard(json_path); } +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code document_reference::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { return doc->for_each_at_path_with_wildcard(json_path, std::forward(callback)); } simdjson_inline simdjson_result document_reference::raw_json() noexcept { return doc->raw_json();} simdjson_inline document_reference::operator document&() const noexcept { return *doc; } #if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION @@ -139270,11 +139929,17 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } #if SIMDJSON_STATIC_REFLECTION template @@ -140852,9 +141517,13 @@ inline simdjson_result object::at_path(std::string_view json_path) noexce return at_pointer(json_pointer); } -inline simdjson_result> object::at_path_with_wildcard(std::string_view json_path) noexcept { - std::vector result; - +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code object::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { auto result_pair = get_next_key_and_json_path(json_path); std::string_view key = result_pair.first; std::string_view remaining_path = result_pair.second; @@ -140864,34 +141533,22 @@ inline simdjson_result> object::at_path_with_wildcard(std::st for (auto field : *this) { value val; SIMDJSON_TRY(field.value().get(val)); - if (remaining_path.empty()) { - result.push_back(std::move(val)); + callback(val); } else { - auto nested_result = val.at_path_with_wildcard(remaining_path); - - if (nested_result.error()) { - return nested_result.error(); - } - // Extract and append all nested matches to our result - std::vector nested_vec; - SIMDJSON_TRY(std::move(nested_result).get(nested_vec)); - - result.insert(result.end(), - std::make_move_iterator(nested_vec.begin()), - std::make_move_iterator(nested_vec.end())); + SIMDJSON_TRY(val.for_each_at_path_with_wildcard(remaining_path, callback)); } } - return result; + return SUCCESS; } else { value val; SIMDJSON_TRY(find_field(key).get(val)); if (remaining_path.empty()) { - result.push_back(std::move(val)); - return result; + callback(val); + return SUCCESS; } else { - return val.at_path_with_wildcard(remaining_path); + return val.for_each_at_path_with_wildcard(remaining_path, callback); } } } @@ -141022,9 +141679,15 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } inline simdjson_result simdjson_result::reset() noexcept { @@ -141405,7 +142068,7 @@ simdjson_inline simdjson_warn_unused ondemand::parser& parser::get_parser() { return *parser::get_parser_instance(); } -simdjson_inline bool release_parser() { +simdjson_inline bool parser::release_parser() { auto &parser_instance = parser::get_threadlocal_parser_if_exists(); if (parser_instance) { parser_instance.reset(); @@ -146056,13 +146719,21 @@ class value { simdjson_inline simdjson_result at_path(std::string_view at_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * Supports wildcard character (*) for arrays or ".*" for objects. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; protected: /** @@ -146255,9 +146926,23 @@ struct simdjson_result : public lsx::implementation_simdjs simdjson_inline simdjson_result current_depth() const noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; }; +// Forward-declare explicit specializations so MSVC /permissive- sees them before +// any template instantiation that would resolve element.get(val) to the primary. +template<> simdjson_inline error_code +simdjson_result::get( + lsx::ondemand::value &out) noexcept; +template<> simdjson_inline simdjson_result +simdjson_result::get() noexcept; + } // namespace simdjson #endif // SIMDJSON_GENERIC_ONDEMAND_VALUE_H @@ -147596,8 +148281,6 @@ class parser { static simdjson_inline bool release_parser(); private: - friend bool release_parser(); - friend ondemand::parser& get_parser(); /** Get the thread-local parser instance, allocates it if needed */ static simdjson_inline simdjson_warn_unused std::unique_ptr& get_parser_instance(); /** Get the thread-local parser instance, it might be null */ @@ -147760,13 +148443,21 @@ class array { inline simdjson_result at_path(std::string_view json_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * Supports wildcard patterns like "[*]" to match all array elements. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; /** * Consumes the array and returns a string_view instance corresponding to the @@ -147890,7 +148581,13 @@ struct simdjson_result : public lsx::implementation_simdjs simdjson_inline simdjson_result at(size_t index) noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; simdjson_inline simdjson_result raw_json() noexcept; #if SIMDJSON_SUPPORTS_CONCEPTS // TODO: move this code into object-inl.h @@ -148790,21 +149487,24 @@ class document { simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * * Supports wildcard patterns like "$.array[*]" or "$.object.*" to match multiple elements. * - * This method materializes all matching values into a vector. * The document will be consumed after this call. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern, or: - * - INVALID_JSON_POINTER if the JSONPath cannot be parsed - * - NO_SUCH_FIELD if a field does not exist - * - INDEX_OUT_OF_BOUNDS if an array index is out of bounds - * - INCORRECT_TYPE if path traversal encounters wrong type + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; /** * Consumes the document and returns a string_view instance corresponding to the @@ -149025,7 +149725,13 @@ class document_reference { simdjson_inline simdjson_result raw_json_token() noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; private: document *doc{nullptr}; @@ -149111,7 +149817,13 @@ struct simdjson_result : public lsx::implementation_sim simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; #if SIMDJSON_STATIC_REFLECTION template requires(std::is_class_v && (sizeof...(FieldNames) > 0)) @@ -149196,7 +149908,13 @@ struct simdjson_result : public lsx::implemen simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; #if SIMDJSON_STATIC_REFLECTION template requires(std::is_class_v && (sizeof...(FieldNames) > 0)) @@ -149849,13 +150567,21 @@ class object { inline simdjson_result at_path(std::string_view json_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * Supports wildcard patterns like ".*" to match all object fields. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; /** * Reset the iterator so that we are pointing back at the @@ -150005,7 +150731,13 @@ struct simdjson_result : public lsx::implementation_simdj simdjson_inline simdjson_result operator[](std::string_view key) && noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; inline simdjson_result reset() noexcept; inline simdjson_result is_empty() noexcept; inline simdjson_result count_fields() & noexcept; @@ -151019,46 +151751,34 @@ inline simdjson_result array::at_path(std::string_view json_path) noexcep return at_pointer(json_pointer); } -inline simdjson_result> array::at_path_with_wildcard(std::string_view json_path) noexcept { - std::vector result; - +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code array::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { auto result_pair = get_next_key_and_json_path(json_path); std::string_view key = result_pair.first; std::string_view remaining_path = result_pair.second; // Wildcard case - if(key=="*"){ - for(auto element: *this){ - - if(element.error()){ - return element.error(); - } - - if(remaining_path.empty()){ - // Use value_unsafe() because we've already checked for errors above. - // The 'element' is a simdjson_result wrapper, and we need to extract - // the underlying value. value_unsafe() is safe here because error() returned false. - result.push_back(std::move(element).value_unsafe()); - - }else{ - auto nested_result = element.at_path_with_wildcard(remaining_path); - - if(nested_result.error()){ - return nested_result.error(); - } - // Same logic as above. - std::vector nested_matches = std::move(nested_result).value_unsafe(); - - result.insert(result.end(), - std::make_move_iterator(nested_matches.begin()), - std::make_move_iterator(nested_matches.end())); + if (key=="*"){ + for(auto element: *this) { + value val; + SIMDJSON_TRY(element.get(val)); + if (remaining_path.empty()) { + callback(val); + } else { + error_code err = element.for_each_at_path_with_wildcard(remaining_path, callback); + if(err) { return err; } } } - return result; - }else{ + return SUCCESS; + } else { // Specific index case in which we access the element at the given index - size_t idx=0; + size_t idx = 0; - for(char c:key){ + for (char c : key) { if(c < '0' || c > '9'){ return INVALID_JSON_POINTER; } @@ -151066,16 +151786,13 @@ inline simdjson_result> array::at_path_with_wildcard(std::str } auto element = at(idx); - - if(element.error()){ - return element.error(); - } - - if(remaining_path.empty()){ - result.push_back(std::move(element).value_unsafe()); - return result; - }else{ - return element.at_path_with_wildcard(remaining_path); + value val; + SIMDJSON_TRY(element.get(val)); + if (remaining_path.empty()){ + callback(val); + return SUCCESS; + } else { + return element.for_each_at_path_with_wildcard(remaining_path, callback); } } } @@ -151138,9 +151855,15 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } simdjson_inline simdjson_result simdjson_result::raw_json() noexcept { if (error()) { return error(); } @@ -151561,14 +152284,20 @@ simdjson_inline simdjson_result value::at_path(std::string_view json_path } } -inline simdjson_result> value::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code value::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { json_type t; SIMDJSON_TRY(type().get(t)); switch (t) { case json_type::array: - return (*this).get_array().at_path_with_wildcard(json_path); + return (*this).get_array().for_each_at_path_with_wildcard(json_path, std::forward(callback)); case json_type::object: - return (*this).get_object().at_path_with_wildcard(json_path); + return (*this).get_object().for_each_at_path_with_wildcard(json_path, std::forward(callback)); default: return INVALID_JSON_POINTER; } @@ -151832,12 +152561,18 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard( - std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code simdjson_result::for_each_at_path_with_wildcard( + std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } } // namespace simdjson @@ -152213,8 +152948,14 @@ simdjson_inline simdjson_result document::at_path(std::string_view json_p } } -simdjson_inline simdjson_result> document::at_path_with_wildcard(std::string_view json_path) noexcept { - rewind(); // Rewind the document each time at_path_with_wildcard is called +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code document::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { + rewind(); // Rewind the document each time for_each_at_path_with_wildcard is called if (json_path.empty()) { return INVALID_JSON_POINTER; } @@ -152222,9 +152963,9 @@ simdjson_inline simdjson_result> document::at_path_with_wildc SIMDJSON_TRY(type().get(t)); switch (t) { case json_type::array: - return (*this).get_array().at_path_with_wildcard(json_path); + return (*this).get_array().for_each_at_path_with_wildcard(json_path, std::forward(callback)); case json_type::object: - return (*this).get_object().at_path_with_wildcard(json_path); + return (*this).get_object().for_each_at_path_with_wildcard(json_path, std::forward(callback)); default: return INVALID_JSON_POINTER; } @@ -152561,9 +153302,15 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } #if SIMDJSON_STATIC_REFLECTION @@ -152674,7 +153421,13 @@ simdjson_inline simdjson_result document_reference::get_number() noexcep simdjson_inline simdjson_result document_reference::raw_json_token() noexcept { return doc->raw_json_token(); } simdjson_inline simdjson_result document_reference::at_pointer(std::string_view json_pointer) noexcept { return doc->at_pointer(json_pointer); } simdjson_inline simdjson_result document_reference::at_path(std::string_view json_path) noexcept { return doc->at_path(json_path); } -simdjson_inline simdjson_result> document_reference::at_path_with_wildcard(std::string_view json_path) noexcept { return doc->at_path_with_wildcard(json_path); } +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code document_reference::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { return doc->for_each_at_path_with_wildcard(json_path, std::forward(callback)); } simdjson_inline simdjson_result document_reference::raw_json() noexcept { return doc->raw_json();} simdjson_inline document_reference::operator document&() const noexcept { return *doc; } #if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION @@ -152939,11 +153692,17 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } #if SIMDJSON_STATIC_REFLECTION template @@ -154521,9 +155280,13 @@ inline simdjson_result object::at_path(std::string_view json_path) noexce return at_pointer(json_pointer); } -inline simdjson_result> object::at_path_with_wildcard(std::string_view json_path) noexcept { - std::vector result; - +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code object::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { auto result_pair = get_next_key_and_json_path(json_path); std::string_view key = result_pair.first; std::string_view remaining_path = result_pair.second; @@ -154533,34 +155296,22 @@ inline simdjson_result> object::at_path_with_wildcard(std::st for (auto field : *this) { value val; SIMDJSON_TRY(field.value().get(val)); - if (remaining_path.empty()) { - result.push_back(std::move(val)); + callback(val); } else { - auto nested_result = val.at_path_with_wildcard(remaining_path); - - if (nested_result.error()) { - return nested_result.error(); - } - // Extract and append all nested matches to our result - std::vector nested_vec; - SIMDJSON_TRY(std::move(nested_result).get(nested_vec)); - - result.insert(result.end(), - std::make_move_iterator(nested_vec.begin()), - std::make_move_iterator(nested_vec.end())); + SIMDJSON_TRY(val.for_each_at_path_with_wildcard(remaining_path, callback)); } } - return result; + return SUCCESS; } else { value val; SIMDJSON_TRY(find_field(key).get(val)); if (remaining_path.empty()) { - result.push_back(std::move(val)); - return result; + callback(val); + return SUCCESS; } else { - return val.at_path_with_wildcard(remaining_path); + return val.for_each_at_path_with_wildcard(remaining_path, callback); } } } @@ -154691,9 +155442,15 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } inline simdjson_result simdjson_result::reset() noexcept { @@ -155074,7 +155831,7 @@ simdjson_inline simdjson_warn_unused ondemand::parser& parser::get_parser() { return *parser::get_parser_instance(); } -simdjson_inline bool release_parser() { +simdjson_inline bool parser::release_parser() { auto &parser_instance = parser::get_threadlocal_parser_if_exists(); if (parser_instance) { parser_instance.reset(); @@ -159748,13 +160505,21 @@ class value { simdjson_inline simdjson_result at_path(std::string_view at_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * Supports wildcard character (*) for arrays or ".*" for objects. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; protected: /** @@ -159947,9 +160712,23 @@ struct simdjson_result : public lasx::implementation_simd simdjson_inline simdjson_result current_depth() const noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; }; +// Forward-declare explicit specializations so MSVC /permissive- sees them before +// any template instantiation that would resolve element.get(val) to the primary. +template<> simdjson_inline error_code +simdjson_result::get( + lasx::ondemand::value &out) noexcept; +template<> simdjson_inline simdjson_result +simdjson_result::get() noexcept; + } // namespace simdjson #endif // SIMDJSON_GENERIC_ONDEMAND_VALUE_H @@ -161288,8 +162067,6 @@ class parser { static simdjson_inline bool release_parser(); private: - friend bool release_parser(); - friend ondemand::parser& get_parser(); /** Get the thread-local parser instance, allocates it if needed */ static simdjson_inline simdjson_warn_unused std::unique_ptr& get_parser_instance(); /** Get the thread-local parser instance, it might be null */ @@ -161452,13 +162229,21 @@ class array { inline simdjson_result at_path(std::string_view json_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * Supports wildcard patterns like "[*]" to match all array elements. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; /** * Consumes the array and returns a string_view instance corresponding to the @@ -161582,7 +162367,13 @@ struct simdjson_result : public lasx::implementation_simd simdjson_inline simdjson_result at(size_t index) noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; simdjson_inline simdjson_result raw_json() noexcept; #if SIMDJSON_SUPPORTS_CONCEPTS // TODO: move this code into object-inl.h @@ -162482,21 +163273,24 @@ class document { simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * * Supports wildcard patterns like "$.array[*]" or "$.object.*" to match multiple elements. * - * This method materializes all matching values into a vector. * The document will be consumed after this call. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern, or: - * - INVALID_JSON_POINTER if the JSONPath cannot be parsed - * - NO_SUCH_FIELD if a field does not exist - * - INDEX_OUT_OF_BOUNDS if an array index is out of bounds - * - INCORRECT_TYPE if path traversal encounters wrong type + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; /** * Consumes the document and returns a string_view instance corresponding to the @@ -162717,7 +163511,13 @@ class document_reference { simdjson_inline simdjson_result raw_json_token() noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; private: document *doc{nullptr}; @@ -162803,7 +163603,13 @@ struct simdjson_result : public lasx::implementation_s simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; #if SIMDJSON_STATIC_REFLECTION template requires(std::is_class_v && (sizeof...(FieldNames) > 0)) @@ -162888,7 +163694,13 @@ struct simdjson_result : public lasx::implem simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; #if SIMDJSON_STATIC_REFLECTION template requires(std::is_class_v && (sizeof...(FieldNames) > 0)) @@ -163541,13 +164353,21 @@ class object { inline simdjson_result at_path(std::string_view json_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * Supports wildcard patterns like ".*" to match all object fields. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; /** * Reset the iterator so that we are pointing back at the @@ -163697,7 +164517,13 @@ struct simdjson_result : public lasx::implementation_sim simdjson_inline simdjson_result operator[](std::string_view key) && noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; inline simdjson_result reset() noexcept; inline simdjson_result is_empty() noexcept; inline simdjson_result count_fields() & noexcept; @@ -164711,46 +165537,34 @@ inline simdjson_result array::at_path(std::string_view json_path) noexcep return at_pointer(json_pointer); } -inline simdjson_result> array::at_path_with_wildcard(std::string_view json_path) noexcept { - std::vector result; - +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code array::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { auto result_pair = get_next_key_and_json_path(json_path); std::string_view key = result_pair.first; std::string_view remaining_path = result_pair.second; // Wildcard case - if(key=="*"){ - for(auto element: *this){ - - if(element.error()){ - return element.error(); - } - - if(remaining_path.empty()){ - // Use value_unsafe() because we've already checked for errors above. - // The 'element' is a simdjson_result wrapper, and we need to extract - // the underlying value. value_unsafe() is safe here because error() returned false. - result.push_back(std::move(element).value_unsafe()); - - }else{ - auto nested_result = element.at_path_with_wildcard(remaining_path); - - if(nested_result.error()){ - return nested_result.error(); - } - // Same logic as above. - std::vector nested_matches = std::move(nested_result).value_unsafe(); - - result.insert(result.end(), - std::make_move_iterator(nested_matches.begin()), - std::make_move_iterator(nested_matches.end())); + if (key=="*"){ + for(auto element: *this) { + value val; + SIMDJSON_TRY(element.get(val)); + if (remaining_path.empty()) { + callback(val); + } else { + error_code err = element.for_each_at_path_with_wildcard(remaining_path, callback); + if(err) { return err; } } } - return result; - }else{ + return SUCCESS; + } else { // Specific index case in which we access the element at the given index - size_t idx=0; + size_t idx = 0; - for(char c:key){ + for (char c : key) { if(c < '0' || c > '9'){ return INVALID_JSON_POINTER; } @@ -164758,16 +165572,13 @@ inline simdjson_result> array::at_path_with_wildcard(std::str } auto element = at(idx); - - if(element.error()){ - return element.error(); - } - - if(remaining_path.empty()){ - result.push_back(std::move(element).value_unsafe()); - return result; - }else{ - return element.at_path_with_wildcard(remaining_path); + value val; + SIMDJSON_TRY(element.get(val)); + if (remaining_path.empty()){ + callback(val); + return SUCCESS; + } else { + return element.for_each_at_path_with_wildcard(remaining_path, callback); } } } @@ -164830,9 +165641,15 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } simdjson_inline simdjson_result simdjson_result::raw_json() noexcept { if (error()) { return error(); } @@ -165253,14 +166070,20 @@ simdjson_inline simdjson_result value::at_path(std::string_view json_path } } -inline simdjson_result> value::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code value::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { json_type t; SIMDJSON_TRY(type().get(t)); switch (t) { case json_type::array: - return (*this).get_array().at_path_with_wildcard(json_path); + return (*this).get_array().for_each_at_path_with_wildcard(json_path, std::forward(callback)); case json_type::object: - return (*this).get_object().at_path_with_wildcard(json_path); + return (*this).get_object().for_each_at_path_with_wildcard(json_path, std::forward(callback)); default: return INVALID_JSON_POINTER; } @@ -165524,12 +166347,18 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard( - std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code simdjson_result::for_each_at_path_with_wildcard( + std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } } // namespace simdjson @@ -165905,8 +166734,14 @@ simdjson_inline simdjson_result document::at_path(std::string_view json_p } } -simdjson_inline simdjson_result> document::at_path_with_wildcard(std::string_view json_path) noexcept { - rewind(); // Rewind the document each time at_path_with_wildcard is called +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code document::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { + rewind(); // Rewind the document each time for_each_at_path_with_wildcard is called if (json_path.empty()) { return INVALID_JSON_POINTER; } @@ -165914,9 +166749,9 @@ simdjson_inline simdjson_result> document::at_path_with_wildc SIMDJSON_TRY(type().get(t)); switch (t) { case json_type::array: - return (*this).get_array().at_path_with_wildcard(json_path); + return (*this).get_array().for_each_at_path_with_wildcard(json_path, std::forward(callback)); case json_type::object: - return (*this).get_object().at_path_with_wildcard(json_path); + return (*this).get_object().for_each_at_path_with_wildcard(json_path, std::forward(callback)); default: return INVALID_JSON_POINTER; } @@ -166253,9 +167088,15 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } #if SIMDJSON_STATIC_REFLECTION @@ -166366,7 +167207,13 @@ simdjson_inline simdjson_result document_reference::get_number() noexcep simdjson_inline simdjson_result document_reference::raw_json_token() noexcept { return doc->raw_json_token(); } simdjson_inline simdjson_result document_reference::at_pointer(std::string_view json_pointer) noexcept { return doc->at_pointer(json_pointer); } simdjson_inline simdjson_result document_reference::at_path(std::string_view json_path) noexcept { return doc->at_path(json_path); } -simdjson_inline simdjson_result> document_reference::at_path_with_wildcard(std::string_view json_path) noexcept { return doc->at_path_with_wildcard(json_path); } +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code document_reference::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { return doc->for_each_at_path_with_wildcard(json_path, std::forward(callback)); } simdjson_inline simdjson_result document_reference::raw_json() noexcept { return doc->raw_json();} simdjson_inline document_reference::operator document&() const noexcept { return *doc; } #if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION @@ -166631,11 +167478,17 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } #if SIMDJSON_STATIC_REFLECTION template @@ -168213,9 +169066,13 @@ inline simdjson_result object::at_path(std::string_view json_path) noexce return at_pointer(json_pointer); } -inline simdjson_result> object::at_path_with_wildcard(std::string_view json_path) noexcept { - std::vector result; - +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code object::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { auto result_pair = get_next_key_and_json_path(json_path); std::string_view key = result_pair.first; std::string_view remaining_path = result_pair.second; @@ -168225,34 +169082,22 @@ inline simdjson_result> object::at_path_with_wildcard(std::st for (auto field : *this) { value val; SIMDJSON_TRY(field.value().get(val)); - if (remaining_path.empty()) { - result.push_back(std::move(val)); + callback(val); } else { - auto nested_result = val.at_path_with_wildcard(remaining_path); - - if (nested_result.error()) { - return nested_result.error(); - } - // Extract and append all nested matches to our result - std::vector nested_vec; - SIMDJSON_TRY(std::move(nested_result).get(nested_vec)); - - result.insert(result.end(), - std::make_move_iterator(nested_vec.begin()), - std::make_move_iterator(nested_vec.end())); + SIMDJSON_TRY(val.for_each_at_path_with_wildcard(remaining_path, callback)); } } - return result; + return SUCCESS; } else { value val; SIMDJSON_TRY(find_field(key).get(val)); if (remaining_path.empty()) { - result.push_back(std::move(val)); - return result; + callback(val); + return SUCCESS; } else { - return val.at_path_with_wildcard(remaining_path); + return val.for_each_at_path_with_wildcard(remaining_path, callback); } } } @@ -168383,9 +169228,15 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } inline simdjson_result simdjson_result::reset() noexcept { @@ -168766,7 +169617,7 @@ simdjson_inline simdjson_warn_unused ondemand::parser& parser::get_parser() { return *parser::get_parser_instance(); } -simdjson_inline bool release_parser() { +simdjson_inline bool parser::release_parser() { auto &parser_instance = parser::get_threadlocal_parser_if_exists(); if (parser_instance) { parser_instance.reset(); @@ -173444,13 +174295,21 @@ class value { simdjson_inline simdjson_result at_path(std::string_view at_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * Supports wildcard character (*) for arrays or ".*" for objects. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; protected: /** @@ -173643,9 +174502,23 @@ struct simdjson_result : public rvv_vls::implementatio simdjson_inline simdjson_result current_depth() const noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; }; +// Forward-declare explicit specializations so MSVC /permissive- sees them before +// any template instantiation that would resolve element.get(val) to the primary. +template<> simdjson_inline error_code +simdjson_result::get( + rvv_vls::ondemand::value &out) noexcept; +template<> simdjson_inline simdjson_result +simdjson_result::get() noexcept; + } // namespace simdjson #endif // SIMDJSON_GENERIC_ONDEMAND_VALUE_H @@ -174984,8 +175857,6 @@ class parser { static simdjson_inline bool release_parser(); private: - friend bool release_parser(); - friend ondemand::parser& get_parser(); /** Get the thread-local parser instance, allocates it if needed */ static simdjson_inline simdjson_warn_unused std::unique_ptr& get_parser_instance(); /** Get the thread-local parser instance, it might be null */ @@ -175148,13 +176019,21 @@ class array { inline simdjson_result at_path(std::string_view json_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * Supports wildcard patterns like "[*]" to match all array elements. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; /** * Consumes the array and returns a string_view instance corresponding to the @@ -175278,7 +176157,13 @@ struct simdjson_result : public rvv_vls::implementatio simdjson_inline simdjson_result at(size_t index) noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; simdjson_inline simdjson_result raw_json() noexcept; #if SIMDJSON_SUPPORTS_CONCEPTS // TODO: move this code into object-inl.h @@ -176178,21 +177063,24 @@ class document { simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * * Supports wildcard patterns like "$.array[*]" or "$.object.*" to match multiple elements. * - * This method materializes all matching values into a vector. * The document will be consumed after this call. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern, or: - * - INVALID_JSON_POINTER if the JSONPath cannot be parsed - * - NO_SUCH_FIELD if a field does not exist - * - INDEX_OUT_OF_BOUNDS if an array index is out of bounds - * - INCORRECT_TYPE if path traversal encounters wrong type + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; /** * Consumes the document and returns a string_view instance corresponding to the @@ -176413,7 +177301,13 @@ class document_reference { simdjson_inline simdjson_result raw_json_token() noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; private: document *doc{nullptr}; @@ -176499,7 +177393,13 @@ struct simdjson_result : public rvv_vls::implementa simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; #if SIMDJSON_STATIC_REFLECTION template requires(std::is_class_v && (sizeof...(FieldNames) > 0)) @@ -176584,7 +177484,13 @@ struct simdjson_result : public rvv_vls:: simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; #if SIMDJSON_STATIC_REFLECTION template requires(std::is_class_v && (sizeof...(FieldNames) > 0)) @@ -177237,13 +178143,21 @@ class object { inline simdjson_result at_path(std::string_view json_path) noexcept; /** - * Get all values matching the given JSONPath expression with wildcard support. + * Call the provided callback for each value matching the given JSONPath + * expression with wildcard support. * Supports wildcard patterns like ".*" to match all object fields. * * @param json_path JSONPath expression with wildcards - * @return Vector of values matching the wildcard pattern + * @param callback Function called for each matching value + * @return error_code indicating success or failure */ - inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; /** * Reset the iterator so that we are pointing back at the @@ -177393,7 +178307,13 @@ struct simdjson_result : public rvv_vls::implementati simdjson_inline simdjson_result operator[](std::string_view key) && noexcept; simdjson_inline simdjson_result at_pointer(std::string_view json_pointer) noexcept; simdjson_inline simdjson_result at_path(std::string_view json_path) noexcept; - simdjson_inline simdjson_result> at_path_with_wildcard(std::string_view json_path) noexcept; +#if SIMDJSON_SUPPORTS_CONCEPTS + template + requires std::invocable +#else + template +#endif + simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept; inline simdjson_result reset() noexcept; inline simdjson_result is_empty() noexcept; inline simdjson_result count_fields() & noexcept; @@ -178407,46 +179327,34 @@ inline simdjson_result array::at_path(std::string_view json_path) noexcep return at_pointer(json_pointer); } -inline simdjson_result> array::at_path_with_wildcard(std::string_view json_path) noexcept { - std::vector result; - +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code array::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { auto result_pair = get_next_key_and_json_path(json_path); std::string_view key = result_pair.first; std::string_view remaining_path = result_pair.second; // Wildcard case - if(key=="*"){ - for(auto element: *this){ - - if(element.error()){ - return element.error(); - } - - if(remaining_path.empty()){ - // Use value_unsafe() because we've already checked for errors above. - // The 'element' is a simdjson_result wrapper, and we need to extract - // the underlying value. value_unsafe() is safe here because error() returned false. - result.push_back(std::move(element).value_unsafe()); - - }else{ - auto nested_result = element.at_path_with_wildcard(remaining_path); - - if(nested_result.error()){ - return nested_result.error(); - } - // Same logic as above. - std::vector nested_matches = std::move(nested_result).value_unsafe(); - - result.insert(result.end(), - std::make_move_iterator(nested_matches.begin()), - std::make_move_iterator(nested_matches.end())); + if (key=="*"){ + for(auto element: *this) { + value val; + SIMDJSON_TRY(element.get(val)); + if (remaining_path.empty()) { + callback(val); + } else { + error_code err = element.for_each_at_path_with_wildcard(remaining_path, callback); + if(err) { return err; } } } - return result; - }else{ + return SUCCESS; + } else { // Specific index case in which we access the element at the given index - size_t idx=0; + size_t idx = 0; - for(char c:key){ + for (char c : key) { if(c < '0' || c > '9'){ return INVALID_JSON_POINTER; } @@ -178454,16 +179362,13 @@ inline simdjson_result> array::at_path_with_wildcard(std::str } auto element = at(idx); - - if(element.error()){ - return element.error(); - } - - if(remaining_path.empty()){ - result.push_back(std::move(element).value_unsafe()); - return result; - }else{ - return element.at_path_with_wildcard(remaining_path); + value val; + SIMDJSON_TRY(element.get(val)); + if (remaining_path.empty()){ + callback(val); + return SUCCESS; + } else { + return element.for_each_at_path_with_wildcard(remaining_path, callback); } } } @@ -178526,9 +179431,15 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } simdjson_inline simdjson_result simdjson_result::raw_json() noexcept { if (error()) { return error(); } @@ -178949,14 +179860,20 @@ simdjson_inline simdjson_result value::at_path(std::string_view json_path } } -inline simdjson_result> value::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code value::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { json_type t; SIMDJSON_TRY(type().get(t)); switch (t) { case json_type::array: - return (*this).get_array().at_path_with_wildcard(json_path); + return (*this).get_array().for_each_at_path_with_wildcard(json_path, std::forward(callback)); case json_type::object: - return (*this).get_object().at_path_with_wildcard(json_path); + return (*this).get_object().for_each_at_path_with_wildcard(json_path, std::forward(callback)); default: return INVALID_JSON_POINTER; } @@ -179220,12 +180137,18 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard( - std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code simdjson_result::for_each_at_path_with_wildcard( + std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } } // namespace simdjson @@ -179601,8 +180524,14 @@ simdjson_inline simdjson_result document::at_path(std::string_view json_p } } -simdjson_inline simdjson_result> document::at_path_with_wildcard(std::string_view json_path) noexcept { - rewind(); // Rewind the document each time at_path_with_wildcard is called +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code document::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { + rewind(); // Rewind the document each time for_each_at_path_with_wildcard is called if (json_path.empty()) { return INVALID_JSON_POINTER; } @@ -179610,9 +180539,9 @@ simdjson_inline simdjson_result> document::at_path_with_wildc SIMDJSON_TRY(type().get(t)); switch (t) { case json_type::array: - return (*this).get_array().at_path_with_wildcard(json_path); + return (*this).get_array().for_each_at_path_with_wildcard(json_path, std::forward(callback)); case json_type::object: - return (*this).get_object().at_path_with_wildcard(json_path); + return (*this).get_object().for_each_at_path_with_wildcard(json_path, std::forward(callback)); default: return INVALID_JSON_POINTER; } @@ -179949,9 +180878,15 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } #if SIMDJSON_STATIC_REFLECTION @@ -180062,7 +180997,13 @@ simdjson_inline simdjson_result document_reference::get_number() noexcep simdjson_inline simdjson_result document_reference::raw_json_token() noexcept { return doc->raw_json_token(); } simdjson_inline simdjson_result document_reference::at_pointer(std::string_view json_pointer) noexcept { return doc->at_pointer(json_pointer); } simdjson_inline simdjson_result document_reference::at_path(std::string_view json_path) noexcept { return doc->at_path(json_path); } -simdjson_inline simdjson_result> document_reference::at_path_with_wildcard(std::string_view json_path) noexcept { return doc->at_path_with_wildcard(json_path); } +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code document_reference::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { return doc->for_each_at_path_with_wildcard(json_path, std::forward(callback)); } simdjson_inline simdjson_result document_reference::raw_json() noexcept { return doc->raw_json();} simdjson_inline document_reference::operator document&() const noexcept { return *doc; } #if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION @@ -180327,11 +181268,17 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } #if SIMDJSON_STATIC_REFLECTION template @@ -181909,9 +182856,13 @@ inline simdjson_result object::at_path(std::string_view json_path) noexce return at_pointer(json_pointer); } -inline simdjson_result> object::at_path_with_wildcard(std::string_view json_path) noexcept { - std::vector result; - +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +inline error_code object::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { auto result_pair = get_next_key_and_json_path(json_path); std::string_view key = result_pair.first; std::string_view remaining_path = result_pair.second; @@ -181921,34 +182872,22 @@ inline simdjson_result> object::at_path_with_wildcard(std::st for (auto field : *this) { value val; SIMDJSON_TRY(field.value().get(val)); - if (remaining_path.empty()) { - result.push_back(std::move(val)); + callback(val); } else { - auto nested_result = val.at_path_with_wildcard(remaining_path); - - if (nested_result.error()) { - return nested_result.error(); - } - // Extract and append all nested matches to our result - std::vector nested_vec; - SIMDJSON_TRY(std::move(nested_result).get(nested_vec)); - - result.insert(result.end(), - std::make_move_iterator(nested_vec.begin()), - std::make_move_iterator(nested_vec.end())); + SIMDJSON_TRY(val.for_each_at_path_with_wildcard(remaining_path, callback)); } } - return result; + return SUCCESS; } else { value val; SIMDJSON_TRY(find_field(key).get(val)); if (remaining_path.empty()) { - result.push_back(std::move(val)); - return result; + callback(val); + return SUCCESS; } else { - return val.at_path_with_wildcard(remaining_path); + return val.for_each_at_path_with_wildcard(remaining_path, callback); } } } @@ -182079,9 +183018,15 @@ simdjson_inline simdjson_result simdjson_result> simdjson_result::at_path_with_wildcard(std::string_view json_path) noexcept { +#if SIMDJSON_SUPPORTS_CONCEPTS +template + requires std::invocable +#else +template +#endif +simdjson_inline error_code simdjson_result::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { if (error()) { return error(); } - return first.at_path_with_wildcard(json_path); + return first.for_each_at_path_with_wildcard(json_path, std::forward(callback)); } inline simdjson_result simdjson_result::reset() noexcept { @@ -182462,7 +183407,7 @@ simdjson_inline simdjson_warn_unused ondemand::parser& parser::get_parser() { return *parser::get_parser_instance(); } -simdjson_inline bool release_parser() { +simdjson_inline bool parser::release_parser() { auto &parser_instance = parser::get_threadlocal_parser_if_exists(); if (parser_instance) { parser_instance.reset(); From 03f27fef16a526a4fc6df36ec284ed20db9e9fab Mon Sep 17 00:00:00 2001 From: Tim Perry <1526883+pimterry@users.noreply.github.com> Date: Fri, 15 May 2026 18:16:41 +0200 Subject: [PATCH 148/168] http: add writeInformation to send arbitrary 1xx status codes Signed-off-by: Tim Perry PR-URL: https://github.com/nodejs/node/pull/63155 Reviewed-By: Matteo Collina Reviewed-By: James M Snell Reviewed-By: Ethan Arrowood --- doc/api/http.md | 32 +++++++ doc/api/http2.md | 25 +++++ lib/_http_server.js | 68 +++++++++++--- lib/internal/http2/compat.js | 45 +++++---- .../parallel/test-http-information-headers.js | 6 +- test/parallel/test-http-write-information.js | 94 +++++++++++++++++++ .../test-http2-compat-write-information.js | 70 ++++++++++++++ 7 files changed, 306 insertions(+), 34 deletions(-) create mode 100644 test/parallel/test-http-write-information.js create mode 100644 test/parallel/test-http2-compat-write-information.js diff --git a/doc/api/http.md b/doc/api/http.md index 65ed90bca83b48..a916337287e109 100644 --- a/doc/api/http.md +++ b/doc/api/http.md @@ -2700,6 +2700,35 @@ been transmitted are equal or not. Attempting to set a header field name or value that contains invalid characters will result in a [`TypeError`][] being thrown. +### `response.writeInformation(statusCode[, headers][, callback])` + + + +* `statusCode` {number} An HTTP 1xx informational status code, between `100` + and `199` inclusive, excluding `101` (Switching Protocols) which is only + available through the [`'upgrade'`][] event. +* `headers` {Object|Array} An optional set of headers to send with the + informational response. Accepts the same shapes as + [`response.writeHead()`][]. +* `callback` {Function} Optional, called once the message has been written + to the socket. + +Sends an arbitrary HTTP/1.1 1xx informational response to the client. This +is a generic equivalent of [`response.writeContinue()`][], +[`response.writeProcessing()`][] and [`response.writeEarlyHints()`][], and +can be called multiple times before the final response. After the final +response headers have been sent (via [`response.writeHead()`][] or an +implicit header), calling this method throws `ERR_HTTP_HEADERS_SENT`. + +Clients receive these responses via the [`'information'`][information event] +event on `http.ClientRequest`. + +```js +response.writeInformation(110, { 'X-Progress': '50%' }); +``` + ### `response.writeProcessing()` + +* `statusCode` {number} An HTTP 1xx informational status code, between `100` + and `199` inclusive, excluding `101` (Switching Protocols) which is not + allowed in HTTP/2. +* `headers` {Object} An optional object of headers to send with the + informational response. + +Sends an arbitrary HTTP 1xx informational response, equivalent in HTTP/2 to a +`HEADERS` frame whose `:status` pseudo-header is a 1xx code. May be called +multiple times before the final response. After the final response headers +have been sent, this method is a no-op and returns `false`. + +This is the generic equivalent of [`response.writeContinue()`][] and +[`response.writeEarlyHints()`][]. + +```js +response.writeInformation(110, { 'X-Progress': '50%' }); +``` + #### `response.writeHead(statusCode[, statusMessage][, headers])` > Stability: 1 - Experimental @@ -261,7 +268,9 @@ $ node inspect --probe :[:] --expr * `--probe :[:]`: Source location of the probe. When execution reaches the location, the provided expressions are evaluated and printed in - the output. Line and column numbers are 1-based. When omitted, column defaults to 1. + the output. `` matches the URL suffix of the script to probe. + `` and `` numbers are 1-based. When `` is omitted, the probe + binds to the first executable column on the line. * `--expr `: JavaScript expression to evaluate whenever execution reaches the location specified by the preceding `--probe`. Must immediately follow the `--probe` it belongs to. @@ -313,13 +322,17 @@ Without `--json`, by default the output is printed in a human-readable text form ```console $ node inspect --probe cli.js:5 --expr 'rss' cli.js -Hit 1 at cli.js:5 +Hit 1 at file:///path/to/cli.js:5:3 rss = 54935552 -Hit 2 at cli.js:5 +Hit 2 at file:///path/to/cli.js:5:3 rss = 55083008 Completed ``` +The original `:[:]` passed to `--probe` may be resolved to a different +location to ensure it's pausable, or it can match multiple loaded scripts, so the actual +evaluation location helps disambiguate the results. + Primitive results are printed directly, while objects and arrays use Chrome DevTools Protocol preview data when available. Other non-primitive values fall back to the Chrome DevTools Protocol `description` string. @@ -331,16 +344,24 @@ When `--json` is used, the output shape looks like this: ```console $ node inspect --json --probe cli.js:5 --expr 'rss' cli.js -{"v":1,"probes":[{"expr":"rss","target":["cli.js",5]}],"results":[{"probe":0,"event":"hit","hit":1,"result":{"type":"number","value":55443456,"description":"55443456"}},{"probe":0,"event":"hit","hit":2,"result":{"type":"number","value":55574528,"description":"55574528"}},{"event":"completed"}]} +{"v":2,"probes":[{"expr":"rss","target":{"suffix":"cli.js","line":5}}],"results":[{"probe":0,"event":"hit","hit":1,"location":{"url":"file:///path/to/cli.js","line":5,"column":3},"result":{"type":"number","value":55443456,"description":"55443456"}},{"probe":0,"event":"hit","hit":2,"location":{"url":"file:///path/to/cli.js","line":5,"column":3},"result":{"type":"number","value":55574528,"description":"55574528"}},{"event":"completed"}]} ``` ```json { - "v": 1, // Probe JSON schema version. + "v": 2, // Probe JSON schema version. "probes": [ { "expr": "rss", // The expression paired with --probe. - "target": ["cli.js", 5] // [file, line] or [file, line, col]. + "target": { + // The user's probe specification. `suffix` is the raw passed + // to --probe and is matched as a path-separator-anchored suffix + // against every loaded script's URL. `column` is present only if the + // user supplied `:col`. The actual evaluation location may differ + // from the target and will be reported in each hit's `location` field. + "suffix": "cli.js", + "line": 5 + } } ], "results": [ @@ -348,6 +369,14 @@ $ node inspect --json --probe cli.js:5 --expr 'rss' cli.js "probe": 0, // Index into probes[]. "event": "hit", // Hit events are recorded in observation order. "hit": 1, // 1-based hit count for this probe. + "location": { + // The actual location where the execution is paused to evaluate + // the expression of the probe. This may differ from the probe's + // target due to pausability adjustments or multiple matches. + "url": "file:///path/to/cli.js", + "line": 5, + "column": 3 + }, "result": { "type": "number", "value": 55443456, @@ -359,6 +388,7 @@ $ node inspect --json --probe cli.js:5 --expr 'rss' cli.js "probe": 0, "event": "hit", "hit": 2, + "location": { "url": "file:///path/to/cli.js", "line": 5, "column": 3 }, "result": { "type": "number", "value": 55574528, @@ -427,9 +457,9 @@ $ node inspect --probe app.js:4 --expr 'x' --probe app.js:4 --expr 'y' -- app.js Prints ```text -Hit 1 at app.js:4 +Hit 1 at file:///path/to/app.js:4:1 x = {x: 42} -Hit 1 at app.js:4 +Hit 1 at file:///path/to/app.js:4:1 y = {y: 35} Completed ``` @@ -441,7 +471,7 @@ $ node inspect --probe app.js:4 --expr 'x' --probe app.js:4 --expr 'y' --json -- Prints ```json -{"v":1,"probes":[{"expr":"x","target":["app.js",4]},{"expr":"y","target":["app.js",4]}],"results":[{"probe":0,"event":"hit","hit":1,"result":{"type":"object","description":"Object","preview":{"type":"object","description":"Object","overflow":false,"properties":[{"name":"x","type":"number","value":"42"}]}}},{"probe":1,"event":"hit","hit":1,"result":{"type":"object","description":"Object","preview":{"type":"object","description":"Object","overflow":false,"properties":[{"name":"y","type":"number","value":"35"}]}}},{"event":"completed"}]} +{"v":2,"probes":[{"expr":"x","target":{"suffix":"app.js","line":4}},{"expr":"y","target":{"suffix":"app.js","line":4}}],"results":[{"probe":0,"event":"hit","hit":1,"location":{"url":"file:///path/to/app.js","line":4,"column":1},"result":{"type":"object","description":"Object","preview":{"type":"object","description":"Object","overflow":false,"properties":[{"name":"x","type":"number","value":"42"}]}}},{"probe":1,"event":"hit","hit":1,"location":{"url":"file:///path/to/app.js","line":4,"column":1},"result":{"type":"object","description":"Object","preview":{"type":"object","description":"Object","overflow":false,"properties":[{"name":"y","type":"number","value":"35"}]}}},{"event":"completed"}]} ``` ### Selecting the probe location @@ -459,7 +489,7 @@ console.log(x); // line 3 ```console $ node inspect --probe app.js:1 --expr 'x' app.js -Hit 1 at app.js:1 +Hit 1 at file:///path/to/app.js:1:1 [error] x = ReferenceError: Cannot access 'x' from debugger ... Completed @@ -469,13 +499,16 @@ Instead, probe at a location where the variable is already initialized: ```console $ node inspect --probe app.js:3 --expr 'x' app.js -Hit 1 at app.js:3 +Hit 1 at file:///path/to/app.js:3:1 x = 42 Completed ``` -Probe paths are matched against loaded script URLs by basename, similar to how -native debuggers typically match breakpoints. Given: +The `` argument is matched as a path suffix of every loaded +script URL, anchored on a path separator. Passing only a basename +matches every loaded script with that basename, similar to how native +debuggers typically match breakpoints, while passing a partial path +narrows the match. Given: ```text project/ @@ -484,7 +517,10 @@ project/ ``` `--probe utils.js:10` binds to _both_ files and produces one hit per match. -To disambiguate, specify a fuller path that only matches the intended file: +Each hit carries its own `location` field identifying where the expression +was actually executed, so consumers can attribute the result to one of the +two files accurately. To disambiguate at bind time, specify a fuller path +that only matches the intended file: ```console $ node inspect --probe src/utils.js:10 --expr 'x' main.js # matches only src/utils.js diff --git a/lib/internal/debugger/inspect_helpers.js b/lib/internal/debugger/inspect_helpers.js index 0511f06f5176a5..d0049acc06cd22 100644 --- a/lib/internal/debugger/inspect_helpers.js +++ b/lib/internal/debugger/inspect_helpers.js @@ -99,9 +99,12 @@ Example: Options: --probe :[:] - Source location of the probe (1-based, col defaults - to 1). Matches by file basename, use a fuller path to - disambiguate. Must be immediately followed by --expr. + Source location of the probe. is matched as a + path suffix of every loaded script URL, anchored on + a path separator. and the optional are + 1-based. If is omitted, the probe binds to + the first executable column on the line. This option + must be immediately followed by a pairing --expr. --expr Expression to evaluate in the lexical scope of the preceding --probe each time execution reaches it. Avoid probing let/const-bound variables at their @@ -114,6 +117,8 @@ Options: Semantics: * Multiple --probe/--expr pairs are allowed. Same-location --probes share a pause and scope, their --exprs are evaluated in command-line order. +* --probe utils.js:[:] matches every loaded utils.js. Pass a + fuller path e.g. src/utils.js to narrow the match. * Use -- before any Node.js flags intended for the child process. * Target errors are surfaced in the report as a terminal 'error' event. The probing process exits 0 unless it encounters an error itself. diff --git a/lib/internal/debugger/inspect_probe.js b/lib/internal/debugger/inspect_probe.js index c872202f1876f7..4600d8eb10ee3b 100644 --- a/lib/internal/debugger/inspect_probe.js +++ b/lib/internal/debugger/inspect_probe.js @@ -40,11 +40,41 @@ const { } = internalBinding('errors'); const kProbeDefaultTimeout = 30000; -const kProbeVersion = 1; +const kProbeVersion = 2; const kProbeDisconnectSentinel = 'Waiting for the debugger to disconnect...'; const kDigitsRegex = /^\d+$/; const kInspectPortRegex = /^--inspect-port=(\d+)$/; +/** + * The probe request specified by --probe, serialized into the public report. + * @typedef {object} ProbeTarget + * @property {string} suffix The raw suffix supplied by the user. + * @property {number} line 1-based line number. + * @property {number} [column] 1-based column number. + */ + +/** + * Location where the probe was evaluated, serialized into the public report. + * @typedef {object} Location + * @property {string} url V8-reported script URL. + * @property {number} line 1-based line number. + * @property {number} column 1-based column number. + */ + +/** + * Per-breakpoint state keyed by V8 `breakpointId` from `Debugger.setBreakpointByUrl`. + * @typedef {object} BreakpointDefinition + * @property {number[]} probeIndices Indices into probes that bound to this breakpoint. + */ + +/** + * Per-probe state corresponds to each --probe --expr pair. + * @typedef {object} Probe + * @property {string} expr Expression to evaluate on hit. + * @property {ProbeTarget} target User's original --probe request shape. + * @property {number} hits Count of hits observed. + */ + function parseUnsignedInteger(value, name, allowZero = false) { if (typeof value !== 'string' || RegExpPrototypeExec(kDigitsRegex, value) === null) { throw new ERR_DEBUGGER_STARTUP_ERROR(`Invalid ${name}: ${value}`); @@ -56,32 +86,34 @@ function parseUnsignedInteger(value, name, allowZero = false) { return parsed; } -// Accepts file:line or file:line:column formats. -// Non-greedy (.+?) allows Windows drive-letter paths like C:\foo.js:10. -function parseProbeLocation(text) { +/** + * @param {string} text Raw `--probe` argument. + * @returns {ProbeTarget} + */ +function parseProbeTarget(text) { + // Accepts file:line or file:line:column formats. + // Non-greedy (.+?) allows Windows drive-letter paths like C:\foo.js:10. const match = RegExpPrototypeExec(/^(.+?):(\d+)(?::(\d+))?$/, text); if (match === null) { throw new ERR_DEBUGGER_STARTUP_ERROR(`Invalid probe location: ${text}`); } - const file = match[1]; + const suffix = match[1]; const line = parseUnsignedInteger(match[2], 'probe location'); - const column = match[3] !== undefined ? - parseUnsignedInteger(match[3], 'probe location') : undefined; - const target = column === undefined ? [file, line] : [file, line, column]; + // Column is left as undefined if the user does not supply one. + const column = match[3] !== undefined ? parseUnsignedInteger(match[3], 'probe location') : undefined; + return { suffix, line, column }; +} - return { - file, - lineNumber: line - 1, - columnNumber: column === undefined ? undefined : column - 1, - target, - }; +function formatTargetText(target) { + const { suffix, line, column } = target; + return column === undefined ? `${suffix}:${line}` : `${suffix}:${line}:${column}`; } function formatPendingProbeLocations(probes, pending) { const seen = new SafeSet(); for (const probeIndex of pending) { - seen.add(ArrayPrototypeJoin(probes[probeIndex].target, ':')); + seen.add(formatTargetText(probes[probeIndex].target)); } return ArrayPrototypeJoin(ArrayFrom(seen), ', '); } @@ -202,6 +234,10 @@ function formatRemoteObject(result) { } } +function formatHitLocation(location) { + return `${location.url}:${location.line}:${location.column}`; +} + // Built human-readable text output for probe reports. function buildProbeTextReport(report) { const lines = []; @@ -209,8 +245,11 @@ function buildProbeTextReport(report) { for (const result of report.results) { if (result.event === 'hit') { const probe = report.probes[result.probe]; - const location = ArrayPrototypeJoin(probe.target, ':'); - ArrayPrototypePush(lines, `Hit ${result.hit} at ${location}`); + // If Debugger.scriptParsed was missed and the URL is unknown, fall back to the user's + // probe target text for readability. This is unlikely unless there's a bug in V8. + const locText = (result.location.url !== undefined) ? + formatHitLocation(result.location) : formatTargetText(probe.target); + ArrayPrototypePush(lines, `Hit ${result.hit} at ${locText}`); if (result.error !== undefined) { ArrayPrototypePush(lines, ` [error] ${probe.expr} = ` + @@ -268,7 +307,7 @@ function parseProbeTokens(tokens, args) { let json = false; let sawSeparator = false; let childStartIndex = args.length; - let pendingLocation; + let pendingTarget; let expectedExprIndex = -1; const probes = []; @@ -279,16 +318,16 @@ function parseProbeTokens(tokens, args) { break; } - if (pendingLocation !== undefined) { + if (pendingTarget !== undefined) { if (token.kind === 'option' && token.name === 'expr' && token.index === expectedExprIndex && token.value !== undefined) { ArrayPrototypePush(probes, { expr: token.value, - location: pendingLocation, + target: pendingTarget, }); - pendingLocation = undefined; + pendingTarget = undefined; continue; } @@ -321,7 +360,7 @@ function parseProbeTokens(tokens, args) { preview = true; break; case 'probe': - pendingLocation = parseProbeLocation(token.value); + pendingTarget = parseProbeTarget(token.value); expectedExprIndex = token.index + (token.inlineValue ? 1 : 2); break; case 'expr': @@ -335,7 +374,7 @@ function parseProbeTokens(tokens, args) { } } - if (pendingLocation !== undefined) { + if (pendingTarget !== undefined) { throw new ERR_DEBUGGER_STARTUP_ERROR( 'Each --probe must be followed immediately by --expr '); } @@ -391,24 +430,23 @@ class ProbeInspectorSession { this.finished = false; this.started = false; this.stderrBuffer = ''; + /** @type {Map} keyed by V8 breakpointId. */ this.breakpointDefinitions = new SafeMap(); + /** @type {Map} scriptId -> URL. */ + this.scriptIdToUrl = new SafeMap(); this.results = []; this.timeout = null; this.resolveCompletion = null; this.completionPromise = new Promise((resolve) => { this.resolveCompletion = resolve; }); - this.probes = ArrayPrototypeMap(options.probes, (probe) => ({ - expr: probe.expr, - target: probe.location.target, - location: probe.location, - hits: 0, - })); - + /** @type {Probe[]} */ + this.probes = ArrayPrototypeMap(options.probes, ({ expr, target }) => ({ expr, target, hits: 0 })); this.onChildOutput = FunctionPrototypeBind(this.onChildOutput, this); this.onChildExit = FunctionPrototypeBind(this.onChildExit, this); this.onClientClose = FunctionPrototypeBind(this.onClientClose, this); this.onPaused = FunctionPrototypeBind(this.onPaused, this); + this.onScriptParsed = FunctionPrototypeBind(this.onScriptParsed, this); } finish(state) { @@ -498,24 +536,38 @@ class ProbeInspectorSession { return; } - const callFrameId = params.callFrames?.[0]?.callFrameId; + const topFrame = params.callFrames?.[0]; + const callFrameId = topFrame?.callFrameId; if (callFrameId === undefined) { await this.resume(); return; } + const { scriptId, lineNumber, columnNumber } = topFrame.location; + // `Debugger.scriptParsed` should always precede a pause for the same script. + // It should only be undefined if there's a bug (even in that case, just omit it). + const location = { + url: this.scriptIdToUrl.get(scriptId), + // CDP locations are 0-based, locations in public report are 1-based. + line: lineNumber + 1, + column: columnNumber + 1, + }; for (const breakpointId of hitBreakpoints) { + // The breakpoint ID is stable even for scripts parsed after the initial resolution + // so we can count on it here. const definition = this.breakpointDefinitions.get(breakpointId); if (definition === undefined) { continue; } + + // Evaluate the expressions in the order they appear on the command line. for (const probeIndex of definition.probeIndices) { - await this.evaluateProbe(callFrameId, probeIndex); + await this.evaluateProbe(callFrameId, probeIndex, location); } } await this.resume(); } - async evaluateProbe(callFrameId, probeIndex) { + async evaluateProbe(callFrameId, probeIndex, location) { const probe = this.probes[probeIndex]; const evaluation = await this.client.callMethod('Debugger.evaluateOnCallFrame', { callFrameId, @@ -524,8 +576,7 @@ class ProbeInspectorSession { }); probe.hits++; - const result = { probe: probeIndex, event: 'hit', hit: probe.hits }; - + const result = { probe: probeIndex, event: 'hit', hit: probe.hits, location }; if (evaluation.exceptionDetails !== undefined) { result.error = evaluation.result === undefined ? { type: 'object', @@ -553,31 +604,35 @@ class ProbeInspectorSession { this.child.on('exit', this.onChildExit); this.client.on('close', this.onClientClose); this.client.on('Debugger.paused', this.onPaused); + this.client.on('Debugger.scriptParsed', this.onScriptParsed); + } + + onScriptParsed(params) { + // This map grows by the number of scripts parsed, which is limited, and is just a + // small string -> string map. The lifetime is bounded by probe timeout etc. so cleanup is overkill. + this.scriptIdToUrl.set(params.scriptId, params.url); } async bindBreakpoints() { - const uniqueLocations = new SafeMap(); + const uniqueTargets = new SafeMap(); for (let probeIndex = 0; probeIndex < this.probes.length; probeIndex++) { - const probe = this.probes[probeIndex]; - const key = `${probe.location.file}\n${probe.location.lineNumber}\n` + - `${probe.location.columnNumber === undefined ? '' : probe.location.columnNumber}`; - let entry = uniqueLocations.get(key); + const { target } = this.probes[probeIndex]; + const key = `${target.suffix}\n${target.line}\n${target.column ?? ''}`; + let entry = uniqueTargets.get(key); if (entry === undefined) { - entry = { location: probe.location, probeIndices: [] }; - uniqueLocations.set(key, entry); + entry = { target, probeIndices: [] }; + uniqueTargets.set(key, entry); } ArrayPrototypePush(entry.probeIndices, probeIndex); } - for (const { location, probeIndices } of uniqueLocations.values()) { - // TODO(joyeecheung): Normalize relative probe paths and avoid suffix matches that can - // bind unrelated loaded scripts with the same basename. + for (const { target, probeIndices } of uniqueTargets.values()) { // On Windows, normalize backslashes to forward slashes so the regex matches // V8 script URLs which always use forward slashes. const normalizedFile = process.platform === 'win32' ? - SideEffectFreeRegExpPrototypeSymbolReplace(/\\/g, location.file, '/') : - location.file; + SideEffectFreeRegExpPrototypeSymbolReplace(/\\/g, target.suffix, '/') : + target.suffix; const escapedPath = SideEffectFreeRegExpPrototypeSymbolReplace( /([/\\.?*()^${}|[\]])/g, normalizedFile, @@ -585,10 +640,13 @@ class ProbeInspectorSession { ); const params = { urlRegex: `^(.*[\\/\\\\])?${escapedPath}$`, - lineNumber: location.lineNumber, + // CDP locations are 0-based, the probe target from CLI is 1-based. + lineNumber: target.line - 1, }; - if (location.columnNumber !== undefined) { - params.columnNumber = location.columnNumber; + if (target.column !== undefined) { + // Only pass columnNumber to CDP when the user specifies one, otherwise let + // the inspector bind to the first executable column. + params.columnNumber = target.column - 1; } const result = await this.client.callMethod('Debugger.setBreakpointByUrl', params); @@ -610,9 +668,7 @@ class ProbeInspectorSession { const pending = this.getPendingProbeIndices(); const report = { v: kProbeVersion, - probes: ArrayPrototypeMap(this.probes, (probe) => { - return { expr: probe.expr, target: probe.target }; - }), + probes: ArrayPrototypeMap(this.probes, ({ expr, target }) => ({ expr, target })), results: ArrayPrototypeSlice(this.results), }; @@ -685,6 +741,8 @@ class ProbeInspectorSession { this.onChildOutput, { skipPortPreflight }); this.child = child; + // On Debugger.enable, V8 emits Debugger.scriptParsed for all existing scripts. + // Attach the listener early to make sure we don't miss any events. this.attachListeners(); await this.client.connect(actualPort, actualHost); diff --git a/test/common/debugger-probe.js b/test/common/debugger-probe.js index e4c7f831bab7cc..c9e67931ee4573 100644 --- a/test/common/debugger-probe.js +++ b/test/common/debugger-probe.js @@ -1,12 +1,6 @@ 'use strict'; const assert = require('assert'); -const fixtures = require('./fixtures'); -const path = require('path'); - -function debuggerFixturePath(name) { - return path.relative(process.cwd(), fixtures.path('debugger', name)); -} // Work around a pre-existing inspector issue: if the debuggee exits too quickly // the inspector can segfault while tearing down. For now normalize the segfault @@ -49,9 +43,4 @@ function assertProbeText(output, expected) { module.exports = { assertProbeJson, assertProbeText, - missScript: debuggerFixturePath('probe-miss.js'), - probeScript: debuggerFixturePath('probe.js'), - throwScript: debuggerFixturePath('probe-throw.js'), - probeTypesScript: debuggerFixturePath('probe-types.js'), - timeoutScript: debuggerFixturePath('probe-timeout.js'), }; diff --git a/test/fixtures/debugger/probe-bound-never-hit.js b/test/fixtures/debugger/probe-bound-never-hit.js new file mode 100644 index 00000000000000..65277d09c8f5c9 --- /dev/null +++ b/test/fixtures/debugger/probe-bound-never-hit.js @@ -0,0 +1,10 @@ +'use strict'; + +function neverCalled() { + console.log('unreachable'); + console.log('also unreachable'); + console.log('still unreachable'); +} + +console.log('reached'); +module.exports = neverCalled; // Keep the function alive. diff --git a/test/fixtures/debugger/probe-indented.js b/test/fixtures/debugger/probe-indented.js new file mode 100644 index 00000000000000..3d05242a3ba62e --- /dev/null +++ b/test/fixtures/debugger/probe-indented.js @@ -0,0 +1,10 @@ +'use strict'; + +function run() { + let x = 0; + // The first executable column is past column 1. + x = 42; + return x; +} + +run(); diff --git a/test/fixtures/debugger/probe-late-entry.js b/test/fixtures/debugger/probe-late-entry.js new file mode 100644 index 00000000000000..2e8350bd7a28a1 --- /dev/null +++ b/test/fixtures/debugger/probe-late-entry.js @@ -0,0 +1,7 @@ +'use strict'; + +import('./probe-late-target.cjs').then(({ add }) => { + const result = add(3, 2); + const { multiply } = require('./probe-late-target.mjs'); + console.log(multiply(result, 4)); +}); diff --git a/test/fixtures/debugger/probe-late-target.cjs b/test/fixtures/debugger/probe-late-target.cjs new file mode 100644 index 00000000000000..0e324b1a7daf95 --- /dev/null +++ b/test/fixtures/debugger/probe-late-target.cjs @@ -0,0 +1,7 @@ +'use strict'; + +exports.add = function(a, b) { + let value = a; + value += b; + return value; +}; diff --git a/test/fixtures/debugger/probe-late-target.mjs b/test/fixtures/debugger/probe-late-target.mjs new file mode 100644 index 00000000000000..832a16e8fcbf60 --- /dev/null +++ b/test/fixtures/debugger/probe-late-target.mjs @@ -0,0 +1,5 @@ +export function multiply(a, b) { + let value = a; + value *= b; + return value; +} diff --git a/test/fixtures/debugger/probe-multi-a/utils.js b/test/fixtures/debugger/probe-multi-a/utils.js new file mode 100644 index 00000000000000..0e324b1a7daf95 --- /dev/null +++ b/test/fixtures/debugger/probe-multi-a/utils.js @@ -0,0 +1,7 @@ +'use strict'; + +exports.add = function(a, b) { + let value = a; + value += b; + return value; +}; diff --git a/test/fixtures/debugger/probe-multi-b/utils.js b/test/fixtures/debugger/probe-multi-b/utils.js new file mode 100644 index 00000000000000..786ddaef1a794f --- /dev/null +++ b/test/fixtures/debugger/probe-multi-b/utils.js @@ -0,0 +1,7 @@ +'use strict'; + +exports.multiply = function(a, b) { + let value = a; + value *= b; + return value; +}; diff --git a/test/fixtures/debugger/probe-multi-entry.js b/test/fixtures/debugger/probe-multi-entry.js new file mode 100644 index 00000000000000..3eef08774e980b --- /dev/null +++ b/test/fixtures/debugger/probe-multi-entry.js @@ -0,0 +1,6 @@ +'use strict'; + +const { add } = require('./probe-multi-a/utils'); +const { multiply } = require('./probe-multi-b/utils'); + +multiply(add(1, 2), 3); diff --git a/test/fixtures/debugger/probe-multi-statement.js b/test/fixtures/debugger/probe-multi-statement.js new file mode 100644 index 00000000000000..e014edbe1119a8 --- /dev/null +++ b/test/fixtures/debugger/probe-multi-statement.js @@ -0,0 +1,7 @@ +'use strict'; + +const acc = []; +function fill() { + acc.push(1); acc.push(2); acc.push(3); +} +fill(); diff --git a/test/parallel/test-debugger-probe-bound-never-hit.js b/test/parallel/test-debugger-probe-bound-never-hit.js new file mode 100644 index 00000000000000..2dc8b5a5e9d921 --- /dev/null +++ b/test/parallel/test-debugger-probe-bound-never-hit.js @@ -0,0 +1,34 @@ +// Tests that probing an unreachable line produces a `miss` with no hit events. +'use strict'; + +const common = require('../common'); +common.skipIfInspectorDisabled(); + +const fixtures = require('../common/fixtures'); +const { spawnSyncAndAssert } = require('../common/child_process'); +const { assertProbeJson } = require('../common/debugger-probe'); + +const cwd = fixtures.path('debugger'); + +spawnSyncAndAssert(process.execPath, [ + 'inspect', + '--json', + '--probe', 'probe-bound-never-hit.js:4', + '--expr', '1', + 'probe-bound-never-hit.js', +], { cwd }, { + stdout(output) { + assertProbeJson(output, { + v: 2, + probes: [{ + expr: '1', + target: { suffix: 'probe-bound-never-hit.js', line: 4 }, + }], + results: [{ + event: 'miss', + pending: [0], + }], + }); + }, + trim: true, +}); diff --git a/test/parallel/test-debugger-probe-child-inspect-port-zero.js b/test/parallel/test-debugger-probe-child-inspect-port-zero.js index 2abc81441edeb1..468f7fdccba83a 100644 --- a/test/parallel/test-debugger-probe-child-inspect-port-zero.js +++ b/test/parallel/test-debugger-probe-child-inspect-port-zero.js @@ -4,29 +4,34 @@ const common = require('../common'); common.skipIfInspectorDisabled(); +const fixtures = require('../common/fixtures'); const { spawnSyncAndAssert } = require('../common/child_process'); -const { assertProbeJson, probeScript } = require('../common/debugger-probe'); +const { assertProbeJson } = require('../common/debugger-probe'); + +const cwd = fixtures.path('debugger'); +const probeUrl = fixtures.fileURL('debugger', 'probe.js').href; spawnSyncAndAssert(process.execPath, [ 'inspect', '--json', - '--probe', `${probeScript}:12`, + '--probe', 'probe.js:12', '--expr', 'finalValue', '--', '--inspect-port=0', - probeScript, -], { + 'probe.js', +], { cwd }, { stdout(output) { assertProbeJson(output, { - v: 1, + v: 2, probes: [{ expr: 'finalValue', - target: [probeScript, 12], + target: { suffix: 'probe.js', line: 12 }, }], results: [{ probe: 0, event: 'hit', hit: 1, + location: { url: probeUrl, line: 12, column: 1 }, result: { type: 'number', value: 81, description: '81' }, }, { event: 'completed', diff --git a/test/parallel/test-debugger-probe-explicit-column.js b/test/parallel/test-debugger-probe-explicit-column.js new file mode 100644 index 00000000000000..ac65b572a37847 --- /dev/null +++ b/test/parallel/test-debugger-probe-explicit-column.js @@ -0,0 +1,72 @@ +// Tests that probes on the same line but different columns are hit separately. +'use strict'; + +const common = require('../common'); +common.skipIfInspectorDisabled(); + +const fixtures = require('../common/fixtures'); +const { spawnSyncAndAssert } = require('../common/child_process'); +const { assertProbeJson } = require('../common/debugger-probe'); + +const cwd = fixtures.path('debugger'); +const fixtureUrl = fixtures.fileURL('debugger', 'probe-multi-statement.js').href; + +// col 3: acc === [] +// col 16: acc === [1] +// col 29: acc === [1, 2] +spawnSyncAndAssert(process.execPath, [ + 'inspect', + '--json', + '--probe', 'probe-multi-statement.js:5:3', + '--expr', 'acc.length', + '--probe', 'probe-multi-statement.js:5:16', + '--expr', 'acc.length', + '--probe', 'probe-multi-statement.js:5:29', + '--expr', 'acc.length', + 'probe-multi-statement.js', +], { cwd }, { + stdout(output) { + assertProbeJson(output, { + v: 2, + probes: [ + { + expr: 'acc.length', + target: { suffix: 'probe-multi-statement.js', line: 5, column: 3 }, + }, + { + expr: 'acc.length', + target: { suffix: 'probe-multi-statement.js', line: 5, column: 16 }, + }, + { + expr: 'acc.length', + target: { suffix: 'probe-multi-statement.js', line: 5, column: 29 }, + }, + ], + results: [ + { + probe: 0, + event: 'hit', + hit: 1, + location: { url: fixtureUrl, line: 5, column: 3 }, + result: { type: 'number', value: 0, description: '0' }, + }, + { + probe: 1, + event: 'hit', + hit: 1, + location: { url: fixtureUrl, line: 5, column: 16 }, + result: { type: 'number', value: 1, description: '1' }, + }, + { + probe: 2, + event: 'hit', + hit: 1, + location: { url: fixtureUrl, line: 5, column: 29 }, + result: { type: 'number', value: 2, description: '2' }, + }, + { event: 'completed' }, + ], + }); + }, + trim: true, +}); diff --git a/test/parallel/test-debugger-probe-global-option-order.js b/test/parallel/test-debugger-probe-global-option-order.js index 19487c8f623795..33e9b688f2e0d8 100644 --- a/test/parallel/test-debugger-probe-global-option-order.js +++ b/test/parallel/test-debugger-probe-global-option-order.js @@ -4,27 +4,32 @@ const common = require('../common'); common.skipIfInspectorDisabled(); +const fixtures = require('../common/fixtures'); const { spawnSyncAndAssert } = require('../common/child_process'); -const { assertProbeJson, probeScript } = require('../common/debugger-probe'); +const { assertProbeJson } = require('../common/debugger-probe'); + +const cwd = fixtures.path('debugger'); +const probeUrl = fixtures.fileURL('debugger', 'probe.js').href; spawnSyncAndAssert(process.execPath, [ 'inspect', - '--probe', `${probeScript}:12`, + '--probe', 'probe.js:12', '--expr', 'finalValue', '--json', - probeScript, -], { + 'probe.js', +], { cwd }, { stdout(output) { assertProbeJson(output, { - v: 1, + v: 2, probes: [{ expr: 'finalValue', - target: [probeScript, 12], + target: { suffix: 'probe.js', line: 12 }, }], results: [{ probe: 0, event: 'hit', hit: 1, + location: { url: probeUrl, line: 12, column: 1 }, result: { type: 'number', value: 81, description: '81' }, }, { event: 'completed', diff --git a/test/parallel/test-debugger-probe-json-preview.js b/test/parallel/test-debugger-probe-json-preview.js index 853939075aa326..acfd5bbbc7804b 100644 --- a/test/parallel/test-debugger-probe-json-preview.js +++ b/test/parallel/test-debugger-probe-json-preview.js @@ -4,39 +4,41 @@ const common = require('../common'); common.skipIfInspectorDisabled(); +const fixtures = require('../common/fixtures'); const { spawnSyncAndAssert } = require('../common/child_process'); -const { - assertProbeJson, - probeTypesScript, -} = require('../common/debugger-probe'); +const { assertProbeJson } = require('../common/debugger-probe'); -const location = `${probeTypesScript}:17`; +const cwd = fixtures.path('debugger'); +const probeArg = 'probe-types.js:17'; +const target = { suffix: 'probe-types.js', line: 17 }; +const location = { url: fixtures.fileURL('debugger', 'probe-types.js').href, line: 17, column: 1 }; spawnSyncAndAssert(process.execPath, [ 'inspect', '--json', '--preview', - '--probe', location, + '--probe', probeArg, '--expr', 'objectValue', - '--probe', location, + '--probe', probeArg, '--expr', 'arrayValue', - '--probe', location, + '--probe', probeArg, '--expr', 'errorValue', - probeTypesScript, -], { + 'probe-types.js', +], { cwd }, { stdout(output) { assertProbeJson(output, { - v: 1, + v: 2, probes: [ - { expr: 'objectValue', target: [probeTypesScript, 17] }, - { expr: 'arrayValue', target: [probeTypesScript, 17] }, - { expr: 'errorValue', target: [probeTypesScript, 17] }, + { expr: 'objectValue', target }, + { expr: 'arrayValue', target }, + { expr: 'errorValue', target }, ], results: [ { probe: 0, event: 'hit', hit: 1, + location, result: { type: 'object', description: 'Object', @@ -55,6 +57,7 @@ spawnSyncAndAssert(process.execPath, [ probe: 1, event: 'hit', hit: 1, + location, result: { type: 'object', subtype: 'array', @@ -76,6 +79,7 @@ spawnSyncAndAssert(process.execPath, [ probe: 2, event: 'hit', hit: 1, + location, result: { type: 'object', subtype: 'error', diff --git a/test/parallel/test-debugger-probe-json-special-values.js b/test/parallel/test-debugger-probe-json-special-values.js index 97782c9e314e3d..e24ea5b3080b8b 100644 --- a/test/parallel/test-debugger-probe-json-special-values.js +++ b/test/parallel/test-debugger-probe-json-special-values.js @@ -4,104 +4,113 @@ const common = require('../common'); common.skipIfInspectorDisabled(); +const fixtures = require('../common/fixtures'); const { spawnSyncAndAssert } = require('../common/child_process'); -const { - assertProbeJson, - probeTypesScript, -} = require('../common/debugger-probe'); +const { assertProbeJson } = require('../common/debugger-probe'); -const location = `${probeTypesScript}:17`; +const cwd = fixtures.path('debugger'); +const probeArg = 'probe-types.js:17'; +const target = { suffix: 'probe-types.js', line: 17 }; +const location = { url: fixtures.fileURL('debugger', 'probe-types.js').href, line: 17, column: 1 }; spawnSyncAndAssert(process.execPath, [ 'inspect', '--json', - '--probe', location, + '--probe', probeArg, '--expr', 'stringValue', - '--probe', location, + '--probe', probeArg, '--expr', 'booleanValue', - '--probe', location, + '--probe', probeArg, '--expr', 'undefinedValue', - '--probe', location, + '--probe', probeArg, '--expr', 'nullValue', - '--probe', location, + '--probe', probeArg, '--expr', 'nanValue', - '--probe', location, + '--probe', probeArg, '--expr', 'bigintValue', - '--probe', location, + '--probe', probeArg, '--expr', 'symbolValue', - '--probe', location, + '--probe', probeArg, '--expr', 'functionValue', - '--probe', location, + '--probe', probeArg, '--expr', 'objectValue', - '--probe', location, + '--probe', probeArg, '--expr', 'arrayValue', - '--probe', location, + '--probe', probeArg, '--expr', 'errorValue', - probeTypesScript, -], { + 'probe-types.js', +], { cwd }, { stdout(output) { assertProbeJson(output, { - v: 1, + v: 2, probes: [ - { expr: 'stringValue', target: [probeTypesScript, 17] }, - { expr: 'booleanValue', target: [probeTypesScript, 17] }, - { expr: 'undefinedValue', target: [probeTypesScript, 17] }, - { expr: 'nullValue', target: [probeTypesScript, 17] }, - { expr: 'nanValue', target: [probeTypesScript, 17] }, - { expr: 'bigintValue', target: [probeTypesScript, 17] }, - { expr: 'symbolValue', target: [probeTypesScript, 17] }, - { expr: 'functionValue', target: [probeTypesScript, 17] }, - { expr: 'objectValue', target: [probeTypesScript, 17] }, - { expr: 'arrayValue', target: [probeTypesScript, 17] }, - { expr: 'errorValue', target: [probeTypesScript, 17] }, + { expr: 'stringValue', target }, + { expr: 'booleanValue', target }, + { expr: 'undefinedValue', target }, + { expr: 'nullValue', target }, + { expr: 'nanValue', target }, + { expr: 'bigintValue', target }, + { expr: 'symbolValue', target }, + { expr: 'functionValue', target }, + { expr: 'objectValue', target }, + { expr: 'arrayValue', target }, + { expr: 'errorValue', target }, ], results: [ { probe: 0, event: 'hit', hit: 1, + location, result: { type: 'string', value: 'hello' }, }, { probe: 1, event: 'hit', hit: 1, + location, result: { type: 'boolean', value: true }, }, { probe: 2, event: 'hit', hit: 1, + location, result: { type: 'undefined' }, }, { probe: 3, event: 'hit', hit: 1, + location, result: { type: 'object', subtype: 'null', value: null }, }, { probe: 4, event: 'hit', hit: 1, + location, result: { type: 'number', unserializableValue: 'NaN', description: 'NaN' }, }, { probe: 5, event: 'hit', hit: 1, + location, result: { type: 'bigint', unserializableValue: '1n', description: '1n' }, }, { probe: 6, event: 'hit', hit: 1, + location, result: { type: 'symbol', description: 'Symbol(tag)' }, }, { probe: 7, event: 'hit', hit: 1, + location, result: { type: 'function', description: '() => 1', @@ -111,6 +120,7 @@ spawnSyncAndAssert(process.execPath, [ probe: 8, event: 'hit', hit: 1, + location, result: { type: 'object', description: 'Object', @@ -120,6 +130,7 @@ spawnSyncAndAssert(process.execPath, [ probe: 9, event: 'hit', hit: 1, + location, result: { type: 'object', subtype: 'array', @@ -130,6 +141,7 @@ spawnSyncAndAssert(process.execPath, [ probe: 10, event: 'hit', hit: 1, + location, result: { type: 'object', subtype: 'error', diff --git a/test/parallel/test-debugger-probe-json.js b/test/parallel/test-debugger-probe-json.js index be2288ee78ddac..559392cc69d9b5 100644 --- a/test/parallel/test-debugger-probe-json.js +++ b/test/parallel/test-debugger-probe-json.js @@ -4,57 +4,68 @@ const common = require('../common'); common.skipIfInspectorDisabled(); +const fixtures = require('../common/fixtures'); const { spawnSyncAndAssert } = require('../common/child_process'); -const { assertProbeJson, probeScript } = require('../common/debugger-probe'); +const { assertProbeJson } = require('../common/debugger-probe'); + +const cwd = fixtures.path('debugger'); +const probeUrl = fixtures.fileURL('debugger', 'probe.js').href; +const locationAt8 = { url: probeUrl, line: 8, column: 3 }; +const locationAt12 = { url: probeUrl, line: 12, column: 1 }; spawnSyncAndAssert(process.execPath, [ 'inspect', '--json', - '--probe', `${probeScript}:8`, + '--probe', 'probe.js:8', '--expr', 'index', - '--probe', `${probeScript}:8`, + '--probe', 'probe.js:8', '--expr', 'total', - '--probe', `${probeScript}:12`, + '--probe', 'probe.js:12', '--expr', 'finalValue', - probeScript, -], { + 'probe.js', +], { cwd }, { stdout(output) { assertProbeJson(output, { - v: 1, + v: 2, probes: [ - { expr: 'index', target: [probeScript, 8] }, - { expr: 'total', target: [probeScript, 8] }, - { expr: 'finalValue', target: [probeScript, 12] }, + { expr: 'index', target: { suffix: 'probe.js', line: 8 } }, + { expr: 'total', target: { suffix: 'probe.js', line: 8 } }, + { expr: 'finalValue', target: { suffix: 'probe.js', line: 12 } }, ], results: [ { probe: 0, event: 'hit', hit: 1, + location: locationAt8, result: { type: 'number', value: 0, description: '0' }, }, { probe: 1, event: 'hit', hit: 1, + location: locationAt8, result: { type: 'number', value: 0, description: '0' }, }, { probe: 0, event: 'hit', hit: 2, + location: locationAt8, result: { type: 'number', value: 1, description: '1' }, }, { probe: 1, event: 'hit', hit: 2, + location: locationAt8, result: { type: 'number', value: 40, description: '40' }, }, { probe: 2, event: 'hit', hit: 1, + location: locationAt12, result: { type: 'number', value: 81, description: '81' }, }, { event: 'completed' }, diff --git a/test/parallel/test-debugger-probe-late-resolution.js b/test/parallel/test-debugger-probe-late-resolution.js new file mode 100644 index 00000000000000..202019122c45b8 --- /dev/null +++ b/test/parallel/test-debugger-probe-late-resolution.js @@ -0,0 +1,52 @@ +// Tests that probing scripts loaded mid-session via require(esm) and import(cjs) +// still resolves and hits correctly. +'use strict'; + +const common = require('../common'); +common.skipIfInspectorDisabled(); + +const fixtures = require('../common/fixtures'); +const { spawnSyncAndAssert } = require('../common/child_process'); +const { assertProbeJson } = require('../common/debugger-probe'); + +const cwd = fixtures.path('debugger'); +const esmUrl = fixtures.fileURL('debugger', 'probe-late-target.mjs').href; +const cjsUrl = fixtures.fileURL('debugger', 'probe-late-target.cjs').href; + +spawnSyncAndAssert(process.execPath, [ + 'inspect', + '--json', + '--probe', 'probe-late-target.mjs:3', + '--expr', 'value', + '--probe', 'probe-late-target.cjs:5', + '--expr', 'value', + 'probe-late-entry.js', +], { cwd }, { + stdout(output) { + assertProbeJson(output, { + v: 2, + probes: [ + { expr: 'value', target: { suffix: 'probe-late-target.mjs', line: 3 } }, + { expr: 'value', target: { suffix: 'probe-late-target.cjs', line: 5 } }, + ], + results: [ + { + probe: 1, + event: 'hit', + hit: 1, + location: { url: cjsUrl, line: 5, column: 3 }, + result: { type: 'number', value: 3, description: '3' }, + }, + { + probe: 0, + event: 'hit', + hit: 1, + location: { url: esmUrl, line: 3, column: 3 }, + result: { type: 'number', value: 5, description: '5' }, + }, + { event: 'completed' }, + ], + }); + }, + trim: true, +}); diff --git a/test/parallel/test-debugger-probe-launch.js b/test/parallel/test-debugger-probe-launch.js index 09511fabf2caaf..24b299ac227453 100644 --- a/test/parallel/test-debugger-probe-launch.js +++ b/test/parallel/test-debugger-probe-launch.js @@ -5,17 +5,19 @@ const common = require('../common'); common.skipIfInspectorDisabled(); const assert = require('assert'); +const fixtures = require('../common/fixtures'); const { spawnSyncAndExit } = require('../common/child_process'); -const { probeScript } = require('../common/debugger-probe'); + +const cwd = fixtures.path('debugger'); spawnSyncAndExit(process.execPath, [ 'inspect', - '--probe', `${probeScript}:12`, + '--probe', 'probe.js:12', '--expr', 'finalValue', '--', '--not-a-real-node-flag', - probeScript, -], { + 'probe.js', +], { cwd }, { signal: null, status: 1, stderr(output) { diff --git a/test/parallel/test-debugger-probe-miss.js b/test/parallel/test-debugger-probe-miss.js index 2908b8092aeb7d..4fd4824ed0c1d3 100644 --- a/test/parallel/test-debugger-probe-miss.js +++ b/test/parallel/test-debugger-probe-miss.js @@ -4,20 +4,25 @@ const common = require('../common'); common.skipIfInspectorDisabled(); +const fixtures = require('../common/fixtures'); const { spawnSyncAndAssert } = require('../common/child_process'); -const { assertProbeJson, missScript } = require('../common/debugger-probe'); +const { assertProbeJson } = require('../common/debugger-probe'); +const cwd = fixtures.path('debugger'); spawnSyncAndAssert(process.execPath, [ 'inspect', '--json', - '--probe', `${missScript}:99`, + '--probe', 'probe-miss.js:99', '--expr', '42', - missScript, -], { + 'probe-miss.js', +], { cwd }, { stdout(output) { assertProbeJson(output, { - v: 1, - probes: [{ expr: '42', target: [missScript, 99] }], + v: 2, + probes: [{ + expr: '42', + target: { suffix: 'probe-miss.js', line: 99 }, + }], results: [{ event: 'miss', pending: [0], diff --git a/test/parallel/test-debugger-probe-missing-expr.js b/test/parallel/test-debugger-probe-missing-expr.js index 57adb70b1b7f35..3011bc51f587e4 100644 --- a/test/parallel/test-debugger-probe-missing-expr.js +++ b/test/parallel/test-debugger-probe-missing-expr.js @@ -4,14 +4,16 @@ const common = require('../common'); common.skipIfInspectorDisabled(); +const fixtures = require('../common/fixtures'); const { spawnSyncAndExit } = require('../common/child_process'); -const { probeScript } = require('../common/debugger-probe'); + +const cwd = fixtures.path('debugger'); spawnSyncAndExit(process.execPath, [ 'inspect', - '--probe', `${probeScript}:12`, - probeScript, -], { + '--probe', 'probe.js:12', + 'probe.js', +], { cwd }, { signal: null, status: 9, stderr: /Each --probe must be followed immediately by --expr/, diff --git a/test/parallel/test-debugger-probe-multi-location.js b/test/parallel/test-debugger-probe-multi-location.js new file mode 100644 index 00000000000000..15638f880ed421 --- /dev/null +++ b/test/parallel/test-debugger-probe-multi-location.js @@ -0,0 +1,49 @@ +// Tests that when probing a suffix that resolves to two files, +// both are probed and each hit is attributed to the right script. +'use strict'; + +const common = require('../common'); +common.skipIfInspectorDisabled(); + +const fixtures = require('../common/fixtures'); +const { spawnSyncAndAssert } = require('../common/child_process'); +const { assertProbeJson } = require('../common/debugger-probe'); + +const cwd = fixtures.path('debugger'); +const urlA = fixtures.fileURL('debugger', 'probe-multi-a', 'utils.js').href; +const urlB = fixtures.fileURL('debugger', 'probe-multi-b', 'utils.js').href; + +spawnSyncAndAssert(process.execPath, [ + 'inspect', + '--json', + '--probe', 'utils.js:5', + '--expr', 'b', + 'probe-multi-entry.js', +], { cwd }, { + stdout(output) { + assertProbeJson(output, { + v: 2, + probes: [ + { expr: 'b', target: { suffix: 'utils.js', line: 5 } }, + ], + results: [ + { + probe: 0, + event: 'hit', + hit: 1, + location: { url: urlA, line: 5, column: 3 }, + result: { type: 'number', value: 2, description: '2' }, + }, + { + probe: 0, + event: 'hit', + hit: 2, + location: { url: urlB, line: 5, column: 3 }, + result: { type: 'number', value: 3, description: '3' }, + }, + { event: 'completed' }, + ], + }); + }, + trim: true, +}); diff --git a/test/parallel/test-debugger-probe-narrow-suffix.js b/test/parallel/test-debugger-probe-narrow-suffix.js new file mode 100644 index 00000000000000..194ddfbdc5d4f7 --- /dev/null +++ b/test/parallel/test-debugger-probe-narrow-suffix.js @@ -0,0 +1,40 @@ +// Tests that a path-qualified suffix narrows the match to a single script. +'use strict'; + +const common = require('../common'); +common.skipIfInspectorDisabled(); + +const fixtures = require('../common/fixtures'); +const { spawnSyncAndAssert } = require('../common/child_process'); +const { assertProbeJson } = require('../common/debugger-probe'); + +const cwd = fixtures.path('debugger'); +const urlA = fixtures.fileURL('debugger', 'probe-multi-a', 'utils.js').href; + +spawnSyncAndAssert(process.execPath, [ + 'inspect', + '--json', + '--probe', 'probe-multi-a/utils.js:5', + '--expr', 'b', + 'probe-multi-entry.js', +], { cwd }, { + stdout(output) { + assertProbeJson(output, { + v: 2, + probes: [ + { expr: 'b', target: { suffix: 'probe-multi-a/utils.js', line: 5 } }, + ], + results: [ + { + probe: 0, + event: 'hit', + hit: 1, + location: { url: urlA, line: 5, column: 3 }, + result: { type: 'number', value: 2, description: '2' }, + }, + { event: 'completed' }, + ], + }); + }, + trim: true, +}); diff --git a/test/parallel/test-debugger-probe-no-column-indent.js b/test/parallel/test-debugger-probe-no-column-indent.js new file mode 100644 index 00000000000000..351f1b89e79a3f --- /dev/null +++ b/test/parallel/test-debugger-probe-no-column-indent.js @@ -0,0 +1,43 @@ +// Tests probing an indented line without specifying a column should relocate +// the breakpoint to the first executable column. +'use strict'; + +const common = require('../common'); +common.skipIfInspectorDisabled(); + +const fixtures = require('../common/fixtures'); +const { spawnSyncAndAssert } = require('../common/child_process'); +const { assertProbeJson } = require('../common/debugger-probe'); +const cwd = fixtures.path('debugger'); +const fixtureUrl = fixtures.fileURL('debugger', 'probe-indented.js').href; + +spawnSyncAndAssert(process.execPath, [ + 'inspect', + '--json', + '--probe', 'probe-indented.js:6', // No `:col` + '--expr', 'x', + 'probe-indented.js', +], { cwd }, { + stdout(output) { + assertProbeJson(output, { + v: 2, + probes: [{ + expr: 'x', + // No `:col` in `target`, reflecting the user spec. + target: { suffix: 'probe-indented.js', line: 6 }, + }], + results: [{ + probe: 0, + event: 'hit', + hit: 1, + // V8 should relocate the breakpoint to the first executable column (3). + location: { url: fixtureUrl, line: 6, column: 3 }, + // Pauses *before* the assignment runs, so `x` still holds the value from line 4. + result: { type: 'number', value: 0, description: '0' }, + }, { + event: 'completed', + }], + }); + }, + trim: true, +}); diff --git a/test/parallel/test-debugger-probe-requires-separator.js b/test/parallel/test-debugger-probe-requires-separator.js index bbbefb0069805f..efc81fda4d69fd 100644 --- a/test/parallel/test-debugger-probe-requires-separator.js +++ b/test/parallel/test-debugger-probe-requires-separator.js @@ -4,16 +4,18 @@ const common = require('../common'); common.skipIfInspectorDisabled(); +const fixtures = require('../common/fixtures'); const { spawnSyncAndExit } = require('../common/child_process'); -const { probeScript } = require('../common/debugger-probe'); + +const cwd = fixtures.path('debugger'); spawnSyncAndExit(process.execPath, [ 'inspect', - '--probe', `${probeScript}:12`, + '--probe', 'probe.js:12', '--expr', 'finalValue', '--inspect-port=0', - probeScript, -], { + 'probe.js', +], { cwd }, { signal: null, status: 9, stderr: /Use -- before child Node\.js flags in probe mode/, diff --git a/test/parallel/test-debugger-probe-text-special-values.js b/test/parallel/test-debugger-probe-text-special-values.js index 3886eb66daed8b..ea62c45970a1e4 100644 --- a/test/parallel/test-debugger-probe-text-special-values.js +++ b/test/parallel/test-debugger-probe-text-special-values.js @@ -4,63 +4,62 @@ const common = require('../common'); common.skipIfInspectorDisabled(); +const fixtures = require('../common/fixtures'); const { spawnSyncAndAssert } = require('../common/child_process'); -const { - assertProbeText, - probeTypesScript, -} = require('../common/debugger-probe'); - -const location = `${probeTypesScript}:17`; +const { assertProbeText } = require('../common/debugger-probe'); +const cwd = fixtures.path('debugger'); +const probeArg = 'probe-types.js:17'; +const hitText = `${fixtures.fileURL('debugger', 'probe-types.js').href}:17:1`; spawnSyncAndAssert(process.execPath, [ 'inspect', - '--probe', location, + '--probe', probeArg, '--expr', 'stringValue', - '--probe', location, + '--probe', probeArg, '--expr', 'booleanValue', - '--probe', location, + '--probe', probeArg, '--expr', 'undefinedValue', - '--probe', location, + '--probe', probeArg, '--expr', 'nullValue', - '--probe', location, + '--probe', probeArg, '--expr', 'nanValue', - '--probe', location, + '--probe', probeArg, '--expr', 'bigintValue', - '--probe', location, + '--probe', probeArg, '--expr', 'symbolValue', - '--probe', location, + '--probe', probeArg, '--expr', 'functionValue', - '--probe', location, + '--probe', probeArg, '--expr', 'objectValue', - '--probe', location, + '--probe', probeArg, '--expr', 'arrayValue', - '--probe', location, + '--probe', probeArg, '--expr', 'errorValue', - probeTypesScript, -], { + 'probe-types.js', +], { cwd }, { stdout(output) { assertProbeText(output, [ - `Hit 1 at ${location}`, + `Hit 1 at ${hitText}`, ' stringValue = "hello"', - `Hit 1 at ${location}`, + `Hit 1 at ${hitText}`, ' booleanValue = true', - `Hit 1 at ${location}`, + `Hit 1 at ${hitText}`, ' undefinedValue = undefined', - `Hit 1 at ${location}`, + `Hit 1 at ${hitText}`, ' nullValue = null', - `Hit 1 at ${location}`, + `Hit 1 at ${hitText}`, ' nanValue = NaN', - `Hit 1 at ${location}`, + `Hit 1 at ${hitText}`, ' bigintValue = 1n', - `Hit 1 at ${location}`, + `Hit 1 at ${hitText}`, ' symbolValue = Symbol(tag)', - `Hit 1 at ${location}`, + `Hit 1 at ${hitText}`, ' functionValue = () => 1', - `Hit 1 at ${location}`, + `Hit 1 at ${hitText}`, ' objectValue = {alpha: 1, beta: "two"}', - `Hit 1 at ${location}`, + `Hit 1 at ${hitText}`, ' arrayValue = [1, "two", 3]', - `Hit 1 at ${location}`, + `Hit 1 at ${hitText}`, ' errorValue = Error: boom', 'Completed', ].join('\n')); diff --git a/test/parallel/test-debugger-probe-text.js b/test/parallel/test-debugger-probe-text.js index 30e77b25985d16..f6752741a223d6 100644 --- a/test/parallel/test-debugger-probe-text.js +++ b/test/parallel/test-debugger-probe-text.js @@ -4,18 +4,21 @@ const common = require('../common'); common.skipIfInspectorDisabled(); +const fixtures = require('../common/fixtures'); const { spawnSyncAndAssert } = require('../common/child_process'); -const { assertProbeText, probeScript } = require('../common/debugger-probe'); +const { assertProbeText } = require('../common/debugger-probe'); +const cwd = fixtures.path('debugger'); +const probeUrl = fixtures.fileURL('debugger', 'probe.js').href; spawnSyncAndAssert(process.execPath, [ 'inspect', - '--probe', `${probeScript}:12`, + '--probe', 'probe.js:12', '--expr', 'finalValue', - probeScript, -], { + 'probe.js', +], { cwd }, { stdout(output) { assertProbeText(output, - `Hit 1 at ${probeScript}:12\n` + + `Hit 1 at ${probeUrl}:12:1\n` + ' finalValue = 81\n' + 'Completed'); }, diff --git a/test/parallel/test-debugger-probe-timeout.js b/test/parallel/test-debugger-probe-timeout.js index fe641f31943af0..da877741ca0cb1 100644 --- a/test/parallel/test-debugger-probe-timeout.js +++ b/test/parallel/test-debugger-probe-timeout.js @@ -4,29 +4,34 @@ const common = require('../common'); common.skipIfInspectorDisabled(); +const fixtures = require('../common/fixtures'); const { spawnSyncAndExit } = require('../common/child_process'); -const { assertProbeJson, timeoutScript } = require('../common/debugger-probe'); +const { assertProbeJson } = require('../common/debugger-probe'); +const cwd = fixtures.path('debugger'); spawnSyncAndExit(process.execPath, [ 'inspect', '--json', '--timeout=200', - '--probe', `${timeoutScript}:99`, + '--probe', 'probe-timeout.js:99', '--expr', '1', - timeoutScript, -], { + 'probe-timeout.js', +], { cwd }, { signal: null, status: 1, stdout(output) { assertProbeJson(output, { - v: 1, - probes: [{ expr: '1', target: [timeoutScript, 99] }], + v: 2, + probes: [{ + expr: '1', + target: { suffix: 'probe-timeout.js', line: 99 }, + }], results: [{ event: 'timeout', pending: [0], error: { code: 'probe_timeout', - message: `Timed out after 200ms waiting for probes: ${timeoutScript}:99`, + message: 'Timed out after 200ms waiting for probes: probe-timeout.js:99', }, }], }); From e5686734eed9e48d9a4efcaef147e0576f1e3815 Mon Sep 17 00:00:00 2001 From: Richard Lau Date: Fri, 15 May 2026 20:26:17 +0100 Subject: [PATCH 150/168] doc: fix CHANGELOG MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Remove Node.js 23 column. Mark Node.js 20 as End-of-Life and remove the corresponding column. Signed-off-by: Richard Lau PR-URL: https://github.com/nodejs/node/pull/63292 Fixes: https://github.com/nodejs/node/issues/63291 Reviewed-By: Marco Ippolito Reviewed-By: Juan José Arboleda Reviewed-By: Luigi Pinca --- CHANGELOG.md | 63 ++-------------------------------------------------- 1 file changed, 2 insertions(+), 61 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 0edb03a399f5ca..984419475dbd2e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,12 +3,12 @@ Select a Node.js version below to view the changelog history: * [Node.js 26](doc/changelogs/CHANGELOG_V26.md) **Current** -* [Node.js 25](doc/changelogs/CHANGELOG_V25.md) **Current** +* [Node.js 25](doc/changelogs/CHANGELOG_V25.md) Current * [Node.js 24](doc/changelogs/CHANGELOG_V24.md) **Long Term Support** * [Node.js 23](doc/changelogs/CHANGELOG_V23.md) End-of-Life * [Node.js 22](doc/changelogs/CHANGELOG_V22.md) Long Term Support * [Node.js 21](doc/changelogs/CHANGELOG_V21.md) End-of-Life -* [Node.js 20](doc/changelogs/CHANGELOG_V20.md) Long Term Support +* [Node.js 20](doc/changelogs/CHANGELOG_V20.md) End-of-Life * [Node.js 19](doc/changelogs/CHANGELOG_V19.md) End-of-Life * [Node.js 18](doc/changelogs/CHANGELOG_V18.md) End-of-Life * [Node.js 17](doc/changelogs/CHANGELOG_V17.md) End-of-Life @@ -39,7 +39,6 @@ release. 25 (Current) 24 (LTS) 22 (LTS) - 20 (LTS) @@ -87,21 +86,6 @@ release. 24.0.0
-23.11.0
-23.10.0
-23.9.0
-23.8.0
-23.7.0
-23.6.1
-23.6.0
-23.5.0
-23.4.0
-23.3.0
-23.2.0
-23.1.0
-23.0.0
- - 22.22.3
22.22.2
22.22.1
@@ -135,49 +119,6 @@ release. 22.1.0
22.0.0
- -20.20.2
-20.20.1
-20.20.0
-20.19.6
-20.19.5
-20.19.4
-20.19.3
-20.19.2
-20.19.1
-20.19.0
-20.18.3
-20.18.2
-20.18.1
-20.18.0
-20.17.0
-20.16.0
-20.15.1
-20.15.0
-20.14.0
-20.13.1
-20.13.0
-20.12.2
-20.12.1
-20.12.0
-20.11.1
-20.11.0
-20.10.0
-20.9.0
-20.8.1
-20.8.0
-20.7.0
-20.6.1
-20.6.0
-20.5.1
-20.5.0
-20.4.0
-20.3.1
-20.3.0
-20.2.0
-20.1.0
-20.0.0
- From be7ded16933ab22f8a65193ddb1159d97f292c23 Mon Sep 17 00:00:00 2001 From: Trivikram Kamat <16024985+trivikr@users.noreply.github.com> Date: Fri, 15 May 2026 13:03:17 -0700 Subject: [PATCH 151/168] stream: optimize single-slot push queue drain Avoid allocating a new result array when PushQueue drains a single queued slot. Return that slot directly and keep the existing flattening path for multiple queued slots. Signed-off-by: Kamat, Trivikram <16024985+trivikr@users.noreply.github.com> Assisted-by: openai:gpt-5.5 PR-URL: https://github.com/nodejs/node/pull/63274 Reviewed-By: James M Snell Reviewed-By: Ethan Arrowood --- lib/internal/streams/iter/push.js | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/lib/internal/streams/iter/push.js b/lib/internal/streams/iter/push.js index 4c0b3240d45fdb..36da35912c951d 100644 --- a/lib/internal/streams/iter/push.js +++ b/lib/internal/streams/iter/push.js @@ -448,6 +448,10 @@ class PushQueue { // =========================================================================== #drain() { + if (this.#slots.length === 1) { + return this.#slots.shift(); + } + const result = []; for (let i = 0; i < this.#slots.length; i++) { const slot = this.#slots.get(i); From 2d6cbea73aade6dfd9eda2157af6fb6140355805 Mon Sep 17 00:00:00 2001 From: Trivikram Kamat <16024985+trivikr@users.noreply.github.com> Date: Fri, 15 May 2026 13:03:31 -0700 Subject: [PATCH 152/168] stream: validate fromWritable() options before cache Validate options before returning a cached fromWritable() adapter so invalid later options still throw. Cache adapters by backpressure policy as well as Writable instance, since the policy changes write behavior. Fixes: https://github.com/nodejs/node/issues/63277 Signed-off-by: Kamat, Trivikram <16024985+trivikr@users.noreply.github.com> Assisted-by: openai:gpt-5.5 PR-URL: https://github.com/nodejs/node/pull/63278 Fixes: https://github.com/nodejs/node/issues/63277 Reviewed-By: James M Snell Reviewed-By: Ethan Arrowood --- doc/api/stream_iter.md | 5 ++- lib/internal/streams/iter/classic.js | 18 +++++--- ...stream-iter-from-writable-cache-options.js | 45 +++++++++++++++++++ 3 files changed, 61 insertions(+), 7 deletions(-) create mode 100644 test/parallel/test-stream-iter-from-writable-cache-options.js diff --git a/doc/api/stream_iter.md b/doc/api/stream_iter.md index 04d416e5b1b855..611f1bf88c7c02 100644 --- a/doc/api/stream_iter.md +++ b/doc/api/stream_iter.md @@ -1543,8 +1543,9 @@ the synchronous Writer methods (`writeSync`, `writevSync`, `endSync`) always return `false` or `-1`, deferring to the async path. The per-write `options.signal` parameter from the Writer interface is also ignored. -The result is cached per instance -- calling `fromWritable()` twice with the -same stream returns the same Writer. +The result is cached per instance and backpressure policy -- calling +`fromWritable()` twice with the same stream and `backpressure` option returns +the same Writer. For duck-typed streams that do not expose `writableHighWaterMark`, `writableLength`, or similar properties, sensible defaults are used. diff --git a/lib/internal/streams/iter/classic.js b/lib/internal/streams/iter/classic.js index 854f761d071b1c..533bc3e00580ae 100644 --- a/lib/internal/streams/iter/classic.js +++ b/lib/internal/streams/iter/classic.js @@ -21,6 +21,7 @@ const { PromiseReject, PromiseResolve, PromiseWithResolvers, + SafeMap, SafeWeakMap, SymbolAsyncDispose, SymbolAsyncIterator, @@ -427,10 +428,6 @@ function fromWritable(writable, options = kNullPrototype) { throw new ERR_INVALID_ARG_TYPE('writable', 'Writable', writable); } - // Return cached adapter if available. - const cached = fromWritableCache.get(writable); - if (cached !== undefined) return cached; - validateObject(options, 'options'); const { backpressure = 'strict', @@ -459,6 +456,17 @@ function fromWritable(writable, options = kNullPrototype) { 'drop-oldest is not supported for classic stream.Writable'); } + // Return cached adapter if available. Backpressure policy changes writer + // behavior, so cache one adapter per policy. + let cachedByBackpressure = fromWritableCache.get(writable); + if (cachedByBackpressure !== undefined) { + const cached = cachedByBackpressure.get(backpressure); + if (cached !== undefined) return cached; + } else { + cachedByBackpressure = new SafeMap(); + fromWritableCache.set(writable, cachedByBackpressure); + } + // Fall back to sensible defaults for duck-typed streams that may not // expose the full stream.Writable property set. const hwm = writable.writableHighWaterMark ?? 16384; @@ -710,7 +718,7 @@ function fromWritable(writable, options = kNullPrototype) { return promise; }; - fromWritableCache.set(writable, writer); + cachedByBackpressure.set(backpressure, writer); return writer; } diff --git a/test/parallel/test-stream-iter-from-writable-cache-options.js b/test/parallel/test-stream-iter-from-writable-cache-options.js new file mode 100644 index 00000000000000..67e673c36f6f2f --- /dev/null +++ b/test/parallel/test-stream-iter-from-writable-cache-options.js @@ -0,0 +1,45 @@ +// Flags: --experimental-stream-iter +'use strict'; + +const common = require('../common'); +const assert = require('assert'); +const { Writable } = require('stream'); +const { fromWritable } = require('stream/iter'); + +{ + const writable = new Writable({ write() {} }); + + fromWritable(writable); + + assert.throws( + () => fromWritable(writable, { backpressure: 'invalid' }), + { code: 'ERR_INVALID_ARG_VALUE' }, + ); + + writable.destroy(); +} + +async function testCachedWritableUsesLaterBackpressureOptions() { + const chunks = []; + const writable = new Writable({ + highWaterMark: 1, + write(chunk, encoding, callback) { + chunks.push(Buffer.from(chunk)); + }, + }); + + fromWritable(writable); + const writer = fromWritable(writable, { backpressure: 'drop-newest' }); + + await writer.write('a'); + await writer.write('b'); + + assert.deepStrictEqual( + chunks.map((chunk) => chunk.toString()), + ['a'], + ); + + writable.destroy(); +} + +testCachedWritableUsesLaterBackpressureOptions().then(common.mustCall()); From a91d859506be3e84055457ff5c08eb12e5b44bd0 Mon Sep 17 00:00:00 2001 From: "Node.js GitHub Bot" Date: Fri, 15 May 2026 19:09:28 -0400 Subject: [PATCH 153/168] deps: update sqlite to 3.53.1 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit PR-URL: https://github.com/nodejs/node/pull/63217 Reviewed-By: Chemi Atlow Reviewed-By: Michaël Zasso Reviewed-By: Colin Ihrig Reviewed-By: Edy Silva Reviewed-By: Jithil P Ponnan --- deps/sqlite/sqlite3.c | 176 +++++++++++++++++++++++++----------------- deps/sqlite/sqlite3.h | 12 +-- 2 files changed, 111 insertions(+), 77 deletions(-) diff --git a/deps/sqlite/sqlite3.c b/deps/sqlite/sqlite3.c index 91db04a9ecdc54..dfd557adeda581 100644 --- a/deps/sqlite/sqlite3.c +++ b/deps/sqlite/sqlite3.c @@ -1,6 +1,6 @@ /****************************************************************************** ** This file is an amalgamation of many separate C source files from SQLite -** version 3.53.0. By combining all the individual C code files into this +** version 3.53.1. By combining all the individual C code files into this ** single large file, the entire code can be compiled as a single translation ** unit. This allows many compilers to do optimizations that would not be ** possible if the files were compiled separately. Performance improvements @@ -18,7 +18,7 @@ ** separate file. This file contains only code for the core SQLite library. ** ** The content in this amalgamation comes from Fossil check-in -** 4525003a53a7fc63ca75c59b22c79608659c with changes in files: +** c88b22011a54b4f6fbd149e9f8e4de77658c with changes in files: ** ** */ @@ -467,12 +467,12 @@ extern "C" { ** [sqlite3_libversion_number()], [sqlite3_sourceid()], ** [sqlite_version()] and [sqlite_source_id()]. */ -#define SQLITE_VERSION "3.53.0" -#define SQLITE_VERSION_NUMBER 3053000 -#define SQLITE_SOURCE_ID "2026-04-09 11:41:38 4525003a53a7fc63ca75c59b22c79608659ca12f0131f52c18637f829977f20b" -#define SQLITE_SCM_BRANCH "trunk" -#define SQLITE_SCM_TAGS "release major-release version-3.53.0" -#define SQLITE_SCM_DATETIME "2026-04-09T11:41:38.498Z" +#define SQLITE_VERSION "3.53.1" +#define SQLITE_VERSION_NUMBER 3053001 +#define SQLITE_SOURCE_ID "2026-05-05 10:34:17 c88b22011a54b4f6fbd149e9f8e4de77658ce58143a1af0e3785e4e6475127e9" +#define SQLITE_SCM_BRANCH "branch-3.53" +#define SQLITE_SCM_TAGS "release version-3.53.1" +#define SQLITE_SCM_DATETIME "2026-05-05T10:34:17.344Z" /* ** CAPI3REF: Run-Time Library Version Numbers @@ -32513,7 +32513,7 @@ static char *printfTempBuf(sqlite3_str *pAccum, sqlite3_int64 n){ sqlite3StrAccumSetError(pAccum, SQLITE_TOOBIG); return 0; } - z = sqlite3DbMallocRaw(pAccum->db, n); + z = sqlite3_malloc(n); if( z==0 ){ sqlite3StrAccumSetError(pAccum, SQLITE_NOMEM); } @@ -32971,11 +32971,27 @@ SQLITE_API void sqlite3_str_vappendf( szBufNeeded = MAX(e2,0)+(i64)precision+(i64)width+10; if( cThousand && e2>0 ) szBufNeeded += (e2+2)/3; - if( sqlite3StrAccumEnlargeIfNeeded(pAccum, szBufNeeded) ){ - width = length = 0; - break; + if( szBufNeeded + pAccum->nChar >= pAccum->nAlloc ){ + if( pAccum->mxAlloc==0 && pAccum->accError==0 ){ + /* Unable to allocate space in pAccum, perhaps because it + ** is coming from sqlite3_snprintf() or similar. We'll have + ** to render into temporary space and the memcpy() it over. */ + bufpt = sqlite3_malloc(szBufNeeded); + if( bufpt==0 ){ + sqlite3StrAccumSetError(pAccum, SQLITE_NOMEM); + return; + } + zExtra = bufpt; + }else if( sqlite3StrAccumEnlarge(pAccum, szBufNeeded)zText + pAccum->nChar; + } + }else{ + bufpt = pAccum->zText + pAccum->nChar; } - bufpt = zOut = pAccum->zText + pAccum->nChar; + zOut = bufpt; flag_dp = (precision>0 ?1:0) | flag_alternateform | flag_altform2; /* The sign in front of the number */ @@ -33076,14 +33092,22 @@ SQLITE_API void sqlite3_str_vappendf( } length = width; } - pAccum->nChar += length; - zOut[length] = 0; - /* Floating point conversions render directly into the output - ** buffer. Hence, don't just break out of the switch(). Bypass the - ** output buffer writing that occurs after the switch() by continuing - ** to the next character in the format string. */ - continue; + if( zExtra==0 ){ + /* The result is being rendered directory into pAccum. This + ** is the command and fast case */ + pAccum->nChar += length; + zOut[length] = 0; + continue; + }else{ + /* We were unable to render directly into pAccum because we + ** couldn't allocate sufficient memory. We need to memcpy() + ** the rendering (or some prefix thereof) into the output + ** buffer. */ + bufpt[0] = 0; + bufpt = zExtra; + break; + } } case etSIZE: if( !bArgList ){ @@ -33130,7 +33154,7 @@ SQLITE_API void sqlite3_str_vappendf( if( sqlite3StrAccumEnlargeIfNeeded(pAccum, nCopyBytes) ){ break; } - sqlite3_str_append(pAccum, + sqlite3_str_append(pAccum, &pAccum->zText[pAccum->nChar-nCopyBytes], nCopyBytes); precision -= nPrior; nPrior *= 2; @@ -33646,7 +33670,7 @@ SQLITE_API void sqlite3_str_reset(StrAccum *p){ ** of its content, all in one call. */ SQLITE_API void sqlite3_str_free(sqlite3_str *p){ - if( p ){ + if( p!=0 && p!=&sqlite3OomStr ){ sqlite3_str_reset(p); sqlite3_free(p); } @@ -36792,15 +36816,20 @@ SQLITE_PRIVATE u8 sqlite3StrIHash(const char *z){ return h; } +#if !defined(SQLITE_DISABLE_INTRINSIC) \ + && (defined(__GNUC__) || defined(__clang__)) \ + && (defined(__x86_64__) || defined(__aarch64__) || \ + (defined(__riscv) && defined(__riscv_xlen) && (__riscv_xlen>32))) +#define SQLITE_USE_UINT128 +#endif + /* ** Two inputs are multiplied to get a 128-bit result. Write the ** lower 64-bits of the result into *pLo, and return the high-order ** 64 bits. */ static u64 sqlite3Multiply128(u64 a, u64 b, u64 *pLo){ -#if (defined(__GNUC__) || defined(__clang__)) \ - && (defined(__x86_64__) || defined(__aarch64__) || defined(__riscv)) \ - && !defined(SQLITE_DISABLE_INTRINSIC) +#if defined(SQLITE_USE_UINT128) __uint128_t r = (__uint128_t)a * b; *pLo = (u64)r; return (u64)(r>>64); @@ -36834,9 +36863,7 @@ static u64 sqlite3Multiply128(u64 a, u64 b, u64 *pLo){ ** The lower 64 bits of A*B are discarded. */ static u64 sqlite3Multiply160(u64 a, u32 aLo, u64 b, u32 *pLo){ -#if (defined(__GNUC__) || defined(__clang__)) \ - && (defined(__x86_64__) || defined(__aarch64__) || defined(__riscv)) \ - && !defined(SQLITE_DISABLE_INTRINSIC) +#if defined(SQLITE_USE_UINT128) __uint128_t r = (__uint128_t)a * b; r += ((__uint128_t)aLo * b) >> 32; *pLo = (r>>32)&0xffffffff; @@ -36874,6 +36901,8 @@ static u64 sqlite3Multiply160(u64 a, u32 aLo, u64 b, u32 *pLo){ #endif } +#undef SQLITE_USE_UINT128 + /* ** Return a u64 with the N-th bit set. */ @@ -56108,10 +56137,10 @@ SQLITE_API int sqlite3_deserialize( if( rc ) goto end_deserialize; db->init.iDb = (u8)iDb; db->init.reopenMemdb = 1; - rc = sqlite3_step(pStmt); + sqlite3_step(pStmt); db->init.reopenMemdb = 0; - if( rc!=SQLITE_DONE ){ - rc = SQLITE_ERROR; + rc = sqlite3_finalize(pStmt); + if( rc!=SQLITE_OK ){ goto end_deserialize; } p = memdbFromDbSchema(db, zSchema); @@ -56132,7 +56161,6 @@ SQLITE_API int sqlite3_deserialize( } end_deserialize: - sqlite3_finalize(pStmt); if( pData && (mFlags & SQLITE_DESERIALIZE_FREEONCLOSE)!=0 ){ sqlite3_free(pData); } @@ -123122,7 +123150,9 @@ SQLITE_PRIVATE void sqlite3AlterDropConstraint( if( !pTab ) return; if( pCons ){ - zArg = sqlite3MPrintf(db, "%.*Q", pCons->n, pCons->z); + char *z = sqlite3NameFromToken(db, pCons); + zArg = sqlite3MPrintf(db, "%Q", z); + sqlite3DbFree(db, z); }else{ int iCol; if( alterFindCol(pParse, pTab, pCol, &iCol) ) return; @@ -125504,6 +125534,16 @@ static void attachFunc( ** from sqlite3_deserialize() to close database db->init.iDb and ** reopen it as a MemDB */ Btree *pNewBt = 0; + + pNew = &db->aDb[db->init.iDb]; + assert( pNew->pBt!=0 ); + if( sqlite3BtreeTxnState(pNew->pBt)!=SQLITE_TXN_NONE + || sqlite3BtreeIsInBackup(pNew->pBt) + ){ + rc = SQLITE_BUSY; + goto attach_error; + } + pVfs = sqlite3_vfs_find("memdb"); if( pVfs==0 ) return; rc = sqlite3BtreeOpen(pVfs, "x\0", db, &pNewBt, 0, SQLITE_OPEN_MAIN_DB); @@ -125513,8 +125553,7 @@ static void attachFunc( /* Both the Btree and the new Schema were allocated successfully. ** Close the old db and update the aDb[] slot with the new memdb ** values. */ - pNew = &db->aDb[db->init.iDb]; - if( ALWAYS(pNew->pBt) ) sqlite3BtreeClose(pNew->pBt); + sqlite3BtreeClose(pNew->pBt); pNew->pBt = pNewBt; pNew->pSchema = pNewSchema; }else{ @@ -156057,6 +156096,7 @@ static SQLITE_NOINLINE void existsToJoin( && !ExprHasProperty(pWhere, EP_OuterON|EP_InnerON) && ALWAYS(p->pSrc!=0) && p->pSrc->nSrcpLimit==0 || p->pLimit->pRight==0) ){ if( pWhere->op==TK_AND ){ Expr *pRight = pWhere->pRight; @@ -156104,7 +156144,6 @@ static SQLITE_NOINLINE void existsToJoin( sqlite3TreeViewSelect(0, p, 0); } #endif - existsToJoin(pParse, p, pSubWhere); } } } @@ -165946,7 +165985,7 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart( ** by this loop in the a[0] slot and all notReady tables in a[1..] slots. ** This becomes the SrcList in the recursive call to sqlite3WhereBegin(). */ - if( pWInfo->nLevel>1 ){ + if( pWInfo->nLevel>1 || pTabItem->fg.fromExists ){ int nNotReady; /* The number of notReady tables */ SrcItem *origSrc; /* Original list of tables */ nNotReady = pWInfo->nLevel - iLevel - 1; @@ -165959,6 +165998,13 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart( for(k=1; k<=nNotReady; k++){ memcpy(&pOrTab->a[k], &origSrc[pLevel[k].iFrom], sizeof(pOrTab->a[k])); } + + /* Clear the fromExists flag on the OR-optimized table entry so that + ** the calls to sqlite3WhereEnd() do not code early-exits after the + ** first row is visited. The early exit applies to this table's + ** overall loop - including the multiple OR branches and any WHERE + ** conditions not passed to the sub-loops - not to the sub-loops. */ + pOrTab->a[0].fg.fromExists = 0; }else{ pOrTab = pWInfo->pTabList; } @@ -166202,7 +166248,7 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart( assert( pLevel->op==OP_Return ); pLevel->p2 = sqlite3VdbeCurrentAddr(v); - if( pWInfo->nLevel>1 ){ sqlite3DbFreeNN(db, pOrTab); } + if( pWInfo->pTabList!=pOrTab ){ sqlite3DbFreeNN(db, pOrTab); } if( !untestedTerms ) disableTerm(pLevel, pTerm); }else #endif /* SQLITE_OMIT_OR_OPTIMIZATION */ @@ -176127,27 +176173,11 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){ } #endif /* SQLITE_DISABLE_SKIPAHEAD_DISTINCT */ } - if( pTabList->a[pLevel->iFrom].fg.fromExists - && (i==pWInfo->nLevel-1 - || pTabList->a[pWInfo->a[i+1].iFrom].fg.fromExists==0) - ){ - /* This is an EXISTS-to-JOIN optimization which is either the - ** inner-most loop, or the inner-most of a group of nested - ** EXISTS-to-JOIN optimization loops. If this loop sees a successful - ** row, it should break out of itself as well as other EXISTS-to-JOIN - ** loops in which is is directly nested. */ - int nOuter = 0; /* Nr of outer EXISTS that this one is nested within */ - while( nOutera[pLevel[-nOuter-1].iFrom].fg.fromExists ) break; - nOuter++; - } - testcase( nOuter>0 ); - sqlite3VdbeAddOp2(v, OP_Goto, 0, pLevel[-nOuter].addrBrk); - if( nOuter ){ - VdbeComment((v, "EXISTS break %d..%d", i-nOuter, i)); - }else{ - VdbeComment((v, "EXISTS break %d", i)); - } + if( pTabList->a[pLevel->iFrom].fg.fromExists ){ + /* This is an EXISTS-to-JOIN optimization loop. If this loop sees a + ** successful row, it should break out of itself. */ + sqlite3VdbeAddOp2(v, OP_Goto, 0, pLevel->addrBrk); + VdbeComment((v, "EXISTS break %d", i)); } sqlite3VdbeResolveLabel(v, pLevel->addrCont); if( pLevel->op!=OP_Noop ){ @@ -184334,6 +184364,7 @@ static YYACTIONTYPE yy_reduce( yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy454, 0); if( yymsp[-4].minor.yy454 ){ yymsp[-4].minor.yy454->x.pList = pList; + sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy454); }else{ sqlite3ExprListDelete(pParse->db, pList); } @@ -233951,10 +233982,11 @@ static int sessionSerialLen(const u8 *a){ int n; assert( a!=0 ); e = *a; - if( e==0 || e==0xFF ) return 1; - if( e==SQLITE_NULL ) return 1; if( e==SQLITE_INTEGER || e==SQLITE_FLOAT ) return 9; - return sessionVarintGet(&a[1], &n) + 1 + n; + if( e==SQLITE_TEXT || e==SQLITE_BLOB ){ + return sessionVarintGet(&a[1], &n) + 1 + n; + } + return 1; } /* @@ -233977,17 +234009,17 @@ static unsigned int sessionChangeHash( u8 *a = aRecord; /* Used to iterate through change record */ for(i=0; inCol; i++){ - int eType = *a; int isPK = pTab->abPK[i]; if( bPkOnly && isPK==0 ) continue; - assert( eType==SQLITE_INTEGER || eType==SQLITE_FLOAT - || eType==SQLITE_TEXT || eType==SQLITE_BLOB - || eType==SQLITE_NULL || eType==0 - ); - if( isPK ){ - a++; + int eType = *a++; + + assert( eType==SQLITE_INTEGER || eType==SQLITE_FLOAT + || eType==SQLITE_TEXT || eType==SQLITE_BLOB + || eType==SQLITE_NULL || eType==0 + ); + h = sessionHashAppendType(h, eType); if( eType==SQLITE_INTEGER || eType==SQLITE_FLOAT ){ h = sessionHashAppendI64(h, sessionGetI64(a)); @@ -237015,9 +237047,11 @@ static int sessionChangesetBufferRecord( rc = sessionInputBuffer(pIn, nByte); }else if( eType==SQLITE_INTEGER || eType==SQLITE_FLOAT ){ nByte += 8; + }else if( eType!=0 && eType!=SQLITE_NULL ){ + rc = SQLITE_CORRUPT_BKPT; } } - if( (pIn->iNext+nByte)>pIn->nData ){ + if( rc==SQLITE_OK && (pIn->iNext+nByte)>pIn->nData ){ rc = SQLITE_CORRUPT_BKPT; } } @@ -263222,7 +263256,7 @@ static void fts5SourceIdFunc( ){ assert( nArg==0 ); UNUSED_PARAM2(nArg, apUnused); - sqlite3_result_text(pCtx, "fts5: 2026-04-09 11:41:38 4525003a53a7fc63ca75c59b22c79608659ca12f0131f52c18637f829977f20b", -1, SQLITE_TRANSIENT); + sqlite3_result_text(pCtx, "fts5: 2026-05-05 10:34:17 c88b22011a54b4f6fbd149e9f8e4de77658ce58143a1af0e3785e4e6475127e9", -1, SQLITE_TRANSIENT); } /* diff --git a/deps/sqlite/sqlite3.h b/deps/sqlite/sqlite3.h index 5d7f82b659140b..8ee26c99d86e6e 100644 --- a/deps/sqlite/sqlite3.h +++ b/deps/sqlite/sqlite3.h @@ -146,12 +146,12 @@ extern "C" { ** [sqlite3_libversion_number()], [sqlite3_sourceid()], ** [sqlite_version()] and [sqlite_source_id()]. */ -#define SQLITE_VERSION "3.53.0" -#define SQLITE_VERSION_NUMBER 3053000 -#define SQLITE_SOURCE_ID "2026-04-09 11:41:38 4525003a53a7fc63ca75c59b22c79608659ca12f0131f52c18637f829977f20b" -#define SQLITE_SCM_BRANCH "trunk" -#define SQLITE_SCM_TAGS "release major-release version-3.53.0" -#define SQLITE_SCM_DATETIME "2026-04-09T11:41:38.498Z" +#define SQLITE_VERSION "3.53.1" +#define SQLITE_VERSION_NUMBER 3053001 +#define SQLITE_SOURCE_ID "2026-05-05 10:34:17 c88b22011a54b4f6fbd149e9f8e4de77658ce58143a1af0e3785e4e6475127e9" +#define SQLITE_SCM_BRANCH "branch-3.53" +#define SQLITE_SCM_TAGS "release version-3.53.1" +#define SQLITE_SCM_DATETIME "2026-05-05T10:34:17.344Z" /* ** CAPI3REF: Run-Time Library Version Numbers From c0327d3cbb982c75cb2233e9f4ed483e39c03c73 Mon Sep 17 00:00:00 2001 From: Trivikram Kamat <16024985+trivikr@users.noreply.github.com> Date: Fri, 15 May 2026 16:31:12 -0700 Subject: [PATCH 154/168] stream: uncork fromWritable writev on chunk error Ensure fromWritable().writev() uncorks the wrapped Writable when converting a later chunk throws. This prevents an internal cork from leaking after ERR_INVALID_ARG_TYPE. Fixes: https://github.com/nodejs/node/issues/63294 Signed-off-by: Kamat, Trivikram <16024985+trivikr@users.noreply.github.com> Assisted-by: openai:gpt-5.5 PR-URL: https://github.com/nodejs/node/pull/63295 Fixes: https://github.com/nodejs/node/issues/63294 Reviewed-By: James M Snell Reviewed-By: Ethan Arrowood --- lib/internal/streams/iter/classic.js | 26 ++++++++++++++----- .../test-stream-iter-writable-interop.js | 16 ++++++++++++ 2 files changed, 36 insertions(+), 6 deletions(-) diff --git a/lib/internal/streams/iter/classic.js b/lib/internal/streams/iter/classic.js index 533bc3e00580ae..fd5f811ea52d97 100644 --- a/lib/internal/streams/iter/classic.js +++ b/lib/internal/streams/iter/classic.js @@ -535,6 +535,16 @@ function fromWritable(writable, options = kNullPrototype) { return (writable.writableLength ?? 0) >= hwm; } + function writeChunks(chunks) { + let ok = true; + for (let i = 0; i < chunks.length; i++) { + const bytes = toUint8Array(chunks[i]); + totalBytes += TypedArrayPrototypeGetByteLength(bytes); + ok = writable.write(bytes); + } + return ok; + } + const writer = { __proto__: null, @@ -630,14 +640,18 @@ function fromWritable(writable, options = kNullPrototype) { return PromiseResolve(); } - if (typeof writable.cork === 'function') writable.cork(); let ok = true; - for (let i = 0; i < chunks.length; i++) { - const bytes = toUint8Array(chunks[i]); - totalBytes += TypedArrayPrototypeGetByteLength(bytes); - ok = writable.write(bytes); + if (typeof writable.cork === 'function' && + typeof writable.uncork === 'function') { + writable.cork(); + try { + ok = writeChunks(chunks); + } finally { + writable.uncork(); + } + } else { + ok = writeChunks(chunks); } - if (typeof writable.uncork === 'function') writable.uncork(); if (ok) return PromiseResolve(); diff --git a/test/parallel/test-stream-iter-writable-interop.js b/test/parallel/test-stream-iter-writable-interop.js index 8a2ead0d0ee579..e7b83ac22841ce 100644 --- a/test/parallel/test-stream-iter-writable-interop.js +++ b/test/parallel/test-stream-iter-writable-interop.js @@ -550,6 +550,21 @@ function testWritevInvalidChunksType() { ); } +// ============================================================================= +// writev() uncorks when chunk validation throws +// ============================================================================= + +function testWritevInvalidChunkUncorks() { + const writable = new Writable({ write(chunk, enc, cb) { cb(); } }); + const writer = fromWritable(writable); + + assert.throws( + () => writer.writev([new Uint8Array([1]), 42]), + { code: 'ERR_INVALID_ARG_TYPE' }, + ); + assert.strictEqual(writable.writableCorked, 0); +} + // ============================================================================= // Cached writer: second call returns same instance // ============================================================================= @@ -638,6 +653,7 @@ testDrainableNull(); testDropOldestThrows(); testInvalidBackpressureThrows(); testWritevInvalidChunksType(); +testWritevInvalidChunkUncorks(); testCachedWriter(); testObjectModeThrows(); From a6696e280b54b60ccf1afc85e68c2285a3a96b87 Mon Sep 17 00:00:00 2001 From: Trivikram Kamat <16024985+trivikr@users.noreply.github.com> Date: Fri, 15 May 2026 21:21:29 -0700 Subject: [PATCH 155/168] stream: validate broadcast writer writev chunks Validate BroadcastWriter writev() and writevSync() inputs before converting chunks so non-array values throw ERR_INVALID_ARG_TYPE. Fixes: https://github.com/nodejs/node/issues/63299 Signed-off-by: Kamat, Trivikram <16024985+trivikr@users.noreply.github.com> Assisted-by: openai:gpt-5.5 PR-URL: https://github.com/nodejs/node/pull/63300 Fixes: https://github.com/nodejs/node/issues/63299 Reviewed-By: James M Snell Reviewed-By: Matteo Collina Reviewed-By: Ethan Arrowood --- lib/internal/streams/iter/broadcast.js | 6 ++++++ test/parallel/test-stream-iter-validation.js | 10 ++++++++++ 2 files changed, 16 insertions(+) diff --git a/lib/internal/streams/iter/broadcast.js b/lib/internal/streams/iter/broadcast.js index 9b3ccebff9ac89..71da0d95be8821 100644 --- a/lib/internal/streams/iter/broadcast.js +++ b/lib/internal/streams/iter/broadcast.js @@ -463,6 +463,9 @@ class BroadcastWriter { } writev(chunks, options) { + if (!ArrayIsArray(chunks)) { + throw new ERR_INVALID_ARG_TYPE('chunks', 'Array', chunks); + } // Fast path: no signal, writer open, buffer has space if (this.#canUseWriteFastPath(options)) { const converted = convertChunks(chunks); @@ -523,6 +526,9 @@ class BroadcastWriter { } writevSync(chunks) { + if (!ArrayIsArray(chunks)) { + throw new ERR_INVALID_ARG_TYPE('chunks', 'Array', chunks); + } if (this.#isClosedOrAborted()) return false; if (!this.#broadcast[kCanWrite]()) return false; const converted = convertChunks(chunks); diff --git a/test/parallel/test-stream-iter-validation.js b/test/parallel/test-stream-iter-validation.js index d58eca4e63ac3b..19cde169d6f496 100644 --- a/test/parallel/test-stream-iter-validation.js +++ b/test/parallel/test-stream-iter-validation.js @@ -147,6 +147,16 @@ assert.throws(() => broadcast({ highWaterMark: Number.MAX_SAFE_INTEGER + 1 }), assert.throws(() => broadcast({ signal: {} }), { code: 'ERR_INVALID_ARG_TYPE' }); assert.throws(() => broadcast({ backpressure: 'bad' }), { code: 'ERR_INVALID_ARG_VALUE' }); +// BroadcastWriter.writev requires array +{ + const { writer } = broadcast(); + assert.throws(() => writer.writev('bad'), { code: 'ERR_INVALID_ARG_TYPE' }); + assert.throws(() => writer.writev(42), { code: 'ERR_INVALID_ARG_TYPE' }); + assert.throws(() => writer.writevSync('bad'), { code: 'ERR_INVALID_ARG_TYPE' }); + assert.throws(() => writer.writevSync(42), { code: 'ERR_INVALID_ARG_TYPE' }); + writer.endSync(); +} + // Broadcast.from rejects non-iterable input assert.throws(() => Broadcast.from(42), { code: 'ERR_INVALID_ARG_TYPE' }); assert.throws(() => Broadcast.from('bad'), { code: 'ERR_INVALID_ARG_TYPE' }); From 19dd555e9d199960e92e8fd212bc7b6f83a982d8 Mon Sep 17 00:00:00 2001 From: Matteo Collina Date: Sat, 16 May 2026 12:33:55 +0200 Subject: [PATCH 156/168] doc: mark stream.compose stable Signed-off-by: Matteo Collina PR-URL: https://github.com/nodejs/node/pull/62562 Reviewed-By: James M Snell --- doc/api/stream.md | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/doc/api/stream.md b/doc/api/stream.md index 5e30121673b7a1..95c1ab1e2dc8f5 100644 --- a/doc/api/stream.md +++ b/doc/api/stream.md @@ -3013,6 +3013,9 @@ const server = http.createServer((req, res) => { -> Stability: 1 - `stream.compose` is experimental. +> Stability: 2 - Stable * `streams` {Stream\[]|Iterable\[]|AsyncIterable\[]|Function\[]| ReadableStream\[]|WritableStream\[]|TransformStream\[]|Duplex\[]|Function} From 8c6e39e459e9b4f9a30a7333bbf3f8d22b97a47d Mon Sep 17 00:00:00 2001 From: Trivikram Kamat <16024985+trivikr@users.noreply.github.com> Date: Sat, 16 May 2026 07:44:46 -0700 Subject: [PATCH 157/168] stream: avoid retrying accepted pipeTo writes PushWriter in block backpressure mode can return false from writeSync() and writevSync() after accepting data. Treat that false return as backpressure and wait for drain instead of retrying the same chunks asynchronously. Fixes: https://github.com/nodejs/node/issues/63296 Signed-off-by: Kamat, Trivikram <16024985+trivikr@users.noreply.github.com> Assisted-by: openai:gpt-5.5 PR-URL: https://github.com/nodejs/node/pull/63297 Fixes: https://github.com/nodejs/node/issues/63296 Reviewed-By: James M Snell Reviewed-By: Ethan Arrowood --- lib/internal/streams/iter/pull.js | 32 ++++++++++++++++++ lib/internal/streams/iter/push.js | 11 +++++-- lib/internal/streams/iter/types.js | 3 ++ .../test-stream-iter-pipeto-writev.js | 33 ++++++++++++++++++- 4 files changed, 76 insertions(+), 3 deletions(-) diff --git a/lib/internal/streams/iter/pull.js b/lib/internal/streams/iter/pull.js index b4a7678237f465..5b004c58a5e995 100644 --- a/lib/internal/streams/iter/pull.js +++ b/lib/internal/streams/iter/pull.js @@ -51,6 +51,8 @@ const { } = require('internal/streams/iter/utils'); const { + drainableProtocol, + kSyncWriteAcceptedOnFalse, kValidatedTransform, } = require('internal/streams/iter/types'); @@ -828,6 +830,22 @@ async function pipeTo(source, ...args) { const hasWriteSync = typeof writer.writeSync === 'function'; const hasWritevSync = typeof writer.writevSync === 'function'; const hasEndSync = typeof writer.endSync === 'function'; + const syncFalseCanBeAccepted = writer[kSyncWriteAcceptedOnFalse] === true; + + function syncFalseWasAccepted() { + return syncFalseCanBeAccepted && writer.desiredSize === 0; + } + + function waitForSyncBackpressure() { + const ondrain = writer[drainableProtocol]; + return ondrain?.call(writer); + } + + async function writeBatchAfterAcceptedBackpressure(batch, startIndex) { + await waitForSyncBackpressure(); + await writeBatchAsyncFallback(batch, startIndex); + } + // Async fallback for writeBatch when sync write fails partway through. // Continues writing from batch[startIndex] using async write(). async function writeBatchAsyncFallback(batch, startIndex) { @@ -835,6 +853,10 @@ async function pipeTo(source, ...args) { const chunk = batch[i]; if (hasWriteSync && writer.writeSync(chunk)) { // Sync retry succeeded + } else if (syncFalseWasAccepted()) { + totalBytes += TypedArrayPrototypeGetByteLength(chunk); + await waitForSyncBackpressure(); + continue; } else { const result = writer.write( chunk, signal ? { __proto__: null, signal } : undefined); @@ -852,6 +874,12 @@ async function pipeTo(source, ...args) { function writeBatch(batch) { if (hasWritev && batch.length > 1) { if (!hasWritevSync || !writer.writevSync(batch)) { + if (hasWritevSync && syncFalseWasAccepted()) { + for (let i = 0; i < batch.length; i++) { + totalBytes += TypedArrayPrototypeGetByteLength(batch[i]); + } + return waitForSyncBackpressure(); + } const opts = signal ? { __proto__: null, signal } : undefined; return PromisePrototypeThen(writer.writev(batch, opts), () => { for (let i = 0; i < batch.length; i++) { @@ -867,6 +895,10 @@ async function pipeTo(source, ...args) { for (let i = 0; i < batch.length; i++) { const chunk = batch[i]; if (!hasWriteSync || !writer.writeSync(chunk)) { + if (hasWriteSync && syncFalseWasAccepted()) { + totalBytes += TypedArrayPrototypeGetByteLength(chunk); + return writeBatchAfterAcceptedBackpressure(batch, i + 1); + } // Sync path failed at index i - fall back to async for the rest. // Count bytes for chunks already written synchronously (0..i-1). return writeBatchAsyncFallback(batch, i); diff --git a/lib/internal/streams/iter/push.js b/lib/internal/streams/iter/push.js index 36da35912c951d..c5b12663f83c24 100644 --- a/lib/internal/streams/iter/push.js +++ b/lib/internal/streams/iter/push.js @@ -32,6 +32,7 @@ const { const { drainableProtocol, + kSyncWriteAcceptedOnFalse, } = require('internal/streams/iter/types'); const { @@ -560,6 +561,10 @@ class PushWriter { return this.#queue.desiredSize; } + get [kSyncWriteAcceptedOnFalse]() { + return this.#queue.backpressurePolicy === 'block'; + } + write(chunk, options) { if (!options?.signal && this.#queue.canWriteSync()) { const bytes = toUint8Array(chunk); @@ -586,7 +591,8 @@ class PushWriter { writeSync(chunk) { const bytes = toUint8Array(chunk); const result = this.#queue.writeSync([bytes]); - if (!result && this.#queue.backpressurePolicy === 'block') { + if (!result && this.#queue.backpressurePolicy === 'block' && + this.#queue.desiredSize === 0) { // Block policy: force-enqueue and return false as backpressure signal. // Data IS accepted; false tells caller to slow down. this.#queue.forceEnqueue([bytes]); @@ -601,7 +607,8 @@ class PushWriter { } const bytes = convertChunks(chunks); const result = this.#queue.writeSync(bytes); - if (!result && this.#queue.backpressurePolicy === 'block') { + if (!result && this.#queue.backpressurePolicy === 'block' && + this.#queue.desiredSize === 0) { this.#queue.forceEnqueue(bytes); return false; } diff --git a/lib/internal/streams/iter/types.js b/lib/internal/streams/iter/types.js index 99ddc8fd582770..71112b1515c081 100644 --- a/lib/internal/streams/iter/types.js +++ b/lib/internal/streams/iter/types.js @@ -64,9 +64,12 @@ const kValidatedTransform = Symbol('kValidatedTransform'); */ const kValidatedSource = Symbol('kValidatedSource'); +const kSyncWriteAcceptedOnFalse = Symbol('kSyncWriteAcceptedOnFalse'); + module.exports = { broadcastProtocol, drainableProtocol, + kSyncWriteAcceptedOnFalse, kValidatedSource, kValidatedTransform, shareProtocol, diff --git a/test/parallel/test-stream-iter-pipeto-writev.js b/test/parallel/test-stream-iter-pipeto-writev.js index 505bdd6d2b2ced..893ab09b85d1f4 100644 --- a/test/parallel/test-stream-iter-pipeto-writev.js +++ b/test/parallel/test-stream-iter-pipeto-writev.js @@ -5,7 +5,8 @@ const common = require('../common'); const assert = require('assert'); -const { pipeTo, pipeToSync } = require('stream/iter'); +const { setImmediate: setImmediatePromise } = require('timers/promises'); +const { pipeTo, pipeToSync, push, text } = require('stream/iter'); // Multi-chunk batch with writevSync (sync success path) async function testWritevSyncSuccess() { @@ -104,6 +105,35 @@ async function testWriteSyncAlwaysFails() { assert.strictEqual(total, 2); } +// PushWriter block mode accepts sync writes even when returning false for +// backpressure. pipeTo must wait for drain, not retry the same write. +async function assertPushWriterBlockPipeTo(source, expected, expectedTotal) { + const { writer, readable } = push({ + highWaterMark: 1, + backpressure: 'block', + }); + + const pipe = pipeTo(source, writer); + await setImmediatePromise(); + const data = await text(readable); + const total = await pipe; + + assert.strictEqual(data, expected); + assert.strictEqual(total, expectedTotal); +} + +async function testPushWriterBlockSyncFalseAccepted() { + await assertPushWriterBlockPipeTo((async function*() { + yield [new Uint8Array([97])]; + yield [new Uint8Array([98])]; + })(), 'ab', 2); + + await assertPushWriterBlockPipeTo((async function*() { + yield [new Uint8Array([97, 98])]; + yield [new Uint8Array([99]), new Uint8Array([100])]; + })(), 'abcd', 4); +} + // pipeToSync with writevSync async function testPipeToSyncWritev() { const batches = []; @@ -142,6 +172,7 @@ Promise.all([ testWritevSyncFails(), testWriteSyncFailsMidBatch(), testWriteSyncAlwaysFails(), + testPushWriterBlockSyncFalseAccepted(), testPipeToSyncWritev(), testPipeToSyncWriteFallback(), ]).then(common.mustCall()); From 3163d8aaf4df11ad43487655d05965bed63b97f6 Mon Sep 17 00:00:00 2001 From: inoway46 Date: Wed, 13 May 2026 21:08:36 +0900 Subject: [PATCH 158/168] test: avoid initial-break wait in restart-message Signed-off-by: inoway46 PR-URL: https://github.com/nodejs/node/pull/62060 Refs: https://github.com/nodejs/node/issues/61762 Reviewed-By: Luigi Pinca Reviewed-By: Kohei Ueno --- test/parallel/test-debugger-restart-message.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/parallel/test-debugger-restart-message.js b/test/parallel/test-debugger-restart-message.js index 5803d0ad262058..3f19e22f550eeb 100644 --- a/test/parallel/test-debugger-restart-message.js +++ b/test/parallel/test-debugger-restart-message.js @@ -20,7 +20,7 @@ const startCLI = require('../common/debugger'); async function onWaitForInitialBreak() { try { - await cli.waitForInitialBreak(); + await cli.waitFor(/ ok\n/); await cli.waitForPrompt(); assert.strictEqual(cli.output.match(listeningRegExp).length, 1); From 9de9b9f88e5de9a64b1c1c341f1a955cca3c27ec Mon Sep 17 00:00:00 2001 From: Yuya Inoue <65857152+inoway46@users.noreply.github.com> Date: Sun, 17 May 2026 00:10:48 +0900 Subject: [PATCH 159/168] test: avoid flaky restart sync in debugger exceptions test MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: inoway46 PR-URL: https://github.com/nodejs/node/pull/62055 Refs: https://github.com/nodejs/node/issues/61762 Reviewed-By: Luigi Pinca Reviewed-By: James M Snell Reviewed-By: Gürgün Dayıoğlu --- test/parallel/test-debugger-exceptions.js | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/test/parallel/test-debugger-exceptions.js b/test/parallel/test-debugger-exceptions.js index 3f75161a6b6e3d..27818612301163 100644 --- a/test/parallel/test-debugger-exceptions.js +++ b/test/parallel/test-debugger-exceptions.js @@ -27,8 +27,10 @@ const path = require('path'); await cli.waitFor(/disconnect/); // Next run: With `breakOnException` it pauses in both places. - await cli.stepCommand('r'); + await cli.command('r'); + await cli.waitFor(/ ok\n/); await cli.waitForInitialBreak(); + await cli.waitForPrompt(); assert.deepStrictEqual(cli.breakInfo, { filename: script, line: 1 }); await cli.command('breakOnException'); await cli.stepCommand('c'); @@ -38,16 +40,20 @@ const path = require('path'); // Next run: With `breakOnUncaught` it only pauses on the 2nd exception. await cli.command('breakOnUncaught'); - await cli.stepCommand('r'); // Also, the setting survives the restart. + await cli.command('r'); // Also, the setting survives the restart. + await cli.waitFor(/ ok\n/); await cli.waitForInitialBreak(); + await cli.waitForPrompt(); assert.deepStrictEqual(cli.breakInfo, { filename: script, line: 1 }); await cli.stepCommand('c'); assert.ok(cli.output.includes(`exception in ${script}:9`)); // Next run: Back to the initial state! It should die again. await cli.command('breakOnNone'); - await cli.stepCommand('r'); + await cli.command('r'); + await cli.waitFor(/ ok\n/); await cli.waitForInitialBreak(); + await cli.waitForPrompt(); assert.deepStrictEqual(cli.breakInfo, { filename: script, line: 1 }); await cli.command('c'); await cli.waitFor(/disconnect/); From 13c2374d0b9471162a9c70d17da12a541295042d Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Sat, 16 May 2026 21:27:02 +0200 Subject: [PATCH 160/168] stream: remove unnecessary check MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/63030 Reviewed-By: Luigi Pinca Reviewed-By: Matteo Collina Reviewed-By: James M Snell Reviewed-By: Trivikram Kamat Reviewed-By: Gürgün Dayıoğlu Reviewed-By: Yagiz Nizipli --- lib/internal/webstreams/util.js | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/lib/internal/webstreams/util.js b/lib/internal/webstreams/util.js index 4bb4522e55c042..808b0b069e57f7 100644 --- a/lib/internal/webstreams/util.js +++ b/lib/internal/webstreams/util.js @@ -62,12 +62,11 @@ const getNonWritablePropertyDescriptor = (value) => { function extractHighWaterMark(value, defaultHWM) { if (value === undefined) return defaultHWM; - value = +value; - if (typeof value !== 'number' || - NumberIsNaN(value) || - value < 0) + const coercedValue = +value; + if (NumberIsNaN(coercedValue) || + coercedValue < 0) throw new ERR_INVALID_ARG_VALUE.RangeError('strategy.highWaterMark', value); - return value; + return coercedValue; } function extractSizeAlgorithm(size) { @@ -159,13 +158,13 @@ function peekQueueValue(controller) { function enqueueValueWithSize(controller, value, size) { assert(controller[kState].queue !== undefined); assert(controller[kState].queueTotalSize !== undefined); - size = +size; - if (typeof size !== 'number' || - size < 0 || - NumberIsNaN(size) || - size === Infinity) { + const coercedSize = +size; + if (NumberIsNaN(coercedSize) || + coercedSize < 0 || + coercedSize === Infinity) { throw new ERR_INVALID_ARG_VALUE.RangeError('size', size); } + size = coercedSize; ArrayPrototypePush(controller[kState].queue, { value, size }); controller[kState].queueTotalSize += size; } From f8e8eb871091d92eaff8c813c4db622001d280ad Mon Sep 17 00:00:00 2001 From: Trivikram Kamat <16024985+trivikr@users.noreply.github.com> Date: Sat, 16 May 2026 23:03:20 -0700 Subject: [PATCH 161/168] stream: cache minimum cursor count in broadcast MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Track how many broadcast consumers share the cached minimum cursor, matching the share implementation. This lets buffer trimming avoid calling getMinCursor() until the last minimum-cursor consumer advances or detaches. Add coverage for fan-out trimming behavior. Signed-off-by: Kamat, Trivikram <16024985+trivikr@users.noreply.github.com> Assisted-by: openai:gpt-5.5 PR-URL: https://github.com/nodejs/node/pull/63322 Reviewed-By: James M Snell Reviewed-By: Ethan Arrowood Reviewed-By: Gürgün Dayıoğlu --- lib/internal/streams/iter/broadcast.js | 66 +++++++++++++------ .../test-stream-iter-broadcast-coverage.js | 28 ++++++++ 2 files changed, 74 insertions(+), 20 deletions(-) diff --git a/lib/internal/streams/iter/broadcast.js b/lib/internal/streams/iter/broadcast.js index 71da0d95be8821..7b6fc3525d122f 100644 --- a/lib/internal/streams/iter/broadcast.js +++ b/lib/internal/streams/iter/broadcast.js @@ -92,7 +92,7 @@ class BroadcastImpl { #options; #writer = null; #cachedMinCursor = 0; - #minCursorDirty = false; + #cachedMinCursorConsumers = 0; constructor(options) { this.#options = options; @@ -150,13 +150,13 @@ class BroadcastImpl { }; this.#consumers.add(state); - // New consumer starts at buffer start; recalculate min cursor - // since this consumer may now be the slowest. if (this.#consumers.size === 1) { this.#cachedMinCursor = state.cursor; - this.#minCursorDirty = false; + this.#cachedMinCursorConsumers = 1; + } else if (state.cursor === this.#cachedMinCursor) { + this.#cachedMinCursorConsumers++; } else { - this.#minCursorDirty = true; + this.#recomputeMinCursor(); } const self = this; @@ -167,9 +167,9 @@ class BroadcastImpl { state.detached = true; state.resolve = null; state.reject = null; - self.#consumers.delete(state); - self.#minCursorDirty = true; - self.#tryTrimBuffer(); + if (self.#deleteConsumer(state)) { + self.#tryTrimBuffer(); + } } return { @@ -186,19 +186,19 @@ class BroadcastImpl { const bufferIndex = state.cursor - self.#bufferStart; if (bufferIndex < self.#buffer.length) { const chunk = self.#buffer.get(bufferIndex); - // If this consumer was at the min cursor, mark dirty - if (state.cursor <= self.#cachedMinCursor) { - self.#minCursorDirty = true; - } + const cursor = state.cursor; state.cursor++; - self.#tryTrimBuffer(); + if (cursor === self.#cachedMinCursor && + --self.#cachedMinCursorConsumers === 0) { + self.#tryTrimBuffer(); + } return PromiseResolve( { __proto__: null, done: false, value: chunk }); } if (self.#error) { state.detached = true; - self.#consumers.delete(state); + self.#deleteConsumer(state); return PromiseReject(self.#error); } @@ -253,6 +253,7 @@ class BroadcastImpl { consumer.detached = true; } this.#consumers.clear(); + this.#cachedMinCursorConsumers = 0; } [SymbolDispose]() { @@ -274,9 +275,11 @@ class BroadcastImpl { this.#bufferStart++; for (const consumer of this.#consumers) { if (consumer.cursor < this.#bufferStart) { + this.#deleteConsumerFromMin(consumer); consumer.cursor = this.#bufferStart; } } + this.#recomputeMinCursor(); break; case 'drop-newest': return true; @@ -297,7 +300,12 @@ class BroadcastImpl { const bufferIndex = consumer.cursor - this.#bufferStart; if (bufferIndex < this.#buffer.length) { const chunk = this.#buffer.get(bufferIndex); + const cursor = consumer.cursor; consumer.cursor++; + if (cursor === this.#cachedMinCursor && + --this.#cachedMinCursorConsumers === 0) { + this.#tryTrimBuffer(); + } consumer.resolve({ __proto__: null, done: false, value: chunk }); } else { consumer.resolve({ __proto__: null, done: true, value: undefined }); @@ -323,6 +331,7 @@ class BroadcastImpl { consumer.detached = true; } this.#consumers.clear(); + this.#cachedMinCursorConsumers = 0; } [kGetDesiredSize]() { @@ -343,14 +352,14 @@ class BroadcastImpl { // Private methods #recomputeMinCursor() { - const { minCursor } = getMinCursor( + const { minCursor, minCursorConsumers } = getMinCursor( this.#consumers, this.#bufferStart + this.#buffer.length); this.#cachedMinCursor = minCursor; - this.#minCursorDirty = false; + this.#cachedMinCursorConsumers = minCursorConsumers; } #tryTrimBuffer() { - if (this.#minCursorDirty) { + if (this.#cachedMinCursorConsumers === 0) { this.#recomputeMinCursor(); } const trimCount = this.#cachedMinCursor - this.#bufferStart; @@ -377,10 +386,12 @@ class BroadcastImpl { const bufferIndex = consumer.cursor - this.#bufferStart; if (bufferIndex < this.#buffer.length) { const chunk = this.#buffer.get(bufferIndex); - if (consumer.cursor <= this.#cachedMinCursor) { - this.#minCursorDirty = true; - } + const cursor = consumer.cursor; consumer.cursor++; + if (cursor === this.#cachedMinCursor && + --this.#cachedMinCursorConsumers === 0) { + this.#tryTrimBuffer(); + } const resolve = consumer.resolve; consumer.resolve = null; consumer.reject = null; @@ -392,6 +403,21 @@ class BroadcastImpl { } } } + + #deleteConsumerFromMin(consumer) { + if (consumer.cursor === this.#cachedMinCursor) { + this.#cachedMinCursorConsumers--; + return this.#cachedMinCursorConsumers === 0; + } + return false; + } + + #deleteConsumer(consumer) { + if (this.#consumers.delete(consumer)) { + return this.#deleteConsumerFromMin(consumer); + } + return false; + } } // ============================================================================= diff --git a/test/parallel/test-stream-iter-broadcast-coverage.js b/test/parallel/test-stream-iter-broadcast-coverage.js index bc86f44867dcc5..7aa71062ab197b 100644 --- a/test/parallel/test-stream-iter-broadcast-coverage.js +++ b/test/parallel/test-stream-iter-broadcast-coverage.js @@ -96,6 +96,33 @@ async function testRingbufferGrow() { } } +// Multiple consumers at the minimum cursor should trim only after the last +// one advances or detaches. +async function testFanOutMinCursorTrimming() { + const { writer, broadcast: bc } = broadcast({ highWaterMark: 4 }); + const iter1 = bc.push()[Symbol.asyncIterator](); + const iter2 = bc.push()[Symbol.asyncIterator](); + + writer.writeSync(new Uint8Array([1])); + writer.writeSync(new Uint8Array([2])); + assert.strictEqual(bc.bufferSize, 2); + + assert.strictEqual((await iter1.next()).done, false); + assert.strictEqual(bc.bufferSize, 2); + + assert.strictEqual((await iter2.next()).done, false); + assert.strictEqual(bc.bufferSize, 1); + + await iter1.return(); + assert.strictEqual(bc.bufferSize, 1); + + assert.strictEqual((await iter2.next()).done, false); + assert.strictEqual(bc.bufferSize, 0); + + writer.endSync(); + assert.strictEqual((await iter2.next()).done, true); +} + // Broadcast drainableProtocol after close returns null async function testDrainableAfterClose() { const { drainableProtocol } = require('stream/iter'); @@ -111,5 +138,6 @@ Promise.all([ testBroadcastFromSyncIterable(), testBroadcastFromSyncIterableStrings(), testRingbufferGrow(), + testFanOutMinCursorTrimming(), testDrainableAfterClose(), ]).then(common.mustCall()); From 265679b5ac36b03b2b039b5eed02ef6582d1fd34 Mon Sep 17 00:00:00 2001 From: Trivikram Kamat <16024985+trivikr@users.noreply.github.com> Date: Sun, 17 May 2026 01:04:30 -0700 Subject: [PATCH 162/168] stream: limit iter from sync iterable batches Bound sync iterable normalization in from() and fromSync() to FROM_BATCH_SIZE. This avoids unbounded batches for from() sync iterable fallbacks and lets fromSync() coalesce plain Uint8Array values for writev paths. Signed-off-by: Kamat, Trivikram <16024985+trivikr@users.noreply.github.com> Assisted-by: openai:gpt-5.5 PR-URL: https://github.com/nodejs/node/pull/63324 Reviewed-By: James M Snell Reviewed-By: Ethan Arrowood --- benchmark/streams/iter-from-batching.js | 100 ++++++++++++++++++ lib/internal/streams/iter/from.js | 75 +++++++++---- .../test-stream-iter-from-coverage.js | 34 ++++++ test/parallel/test-stream-iter-from-sync.js | 5 +- .../test-stream-iter-pipeto-writev.js | 22 ++++ 5 files changed, 216 insertions(+), 20 deletions(-) create mode 100644 benchmark/streams/iter-from-batching.js diff --git a/benchmark/streams/iter-from-batching.js b/benchmark/streams/iter-from-batching.js new file mode 100644 index 00000000000000..0e09537b9eae11 --- /dev/null +++ b/benchmark/streams/iter-from-batching.js @@ -0,0 +1,100 @@ +// Measures batching behavior for stream/iter from() and fromSync() +// with plain synchronous Uint8Array iterables. +'use strict'; + +const common = require('../common.js'); +const { closeSync, openSync, writeSync, writevSync } = require('fs'); +const { devNull } = require('os'); + +const bench = common.createBenchmark(main, { + method: ['from-first-batch', 'from-sync-writev'], + chunks: [256, 4096, 16384], + chunkSize: [16], + n: [100, 1000], +}, { + flags: ['--experimental-stream-iter'], + combinationFilter({ method, chunks, n }) { + if (n === 1) { + return true; + } + if (method === 'from-first-batch') { + return n === 1000; + } + return n === 100 && chunks !== 16384; + }, + test: { + chunks: 256, + chunkSize: 16, + n: 1, + }, +}); + +function main({ method, chunks, chunkSize, n }) { + switch (method) { + case 'from-first-batch': + return benchFromFirstBatch(chunks, chunkSize, n); + case 'from-sync-writev': + return benchFromSyncWritev(chunks, chunkSize, n); + } +} + +function* source(chunks, chunk) { + for (let i = 0; i < chunks; i++) { + yield chunk; + } +} + +function benchFromFirstBatch(chunks, chunkSize, n) { + const { from } = require('stream/iter'); + const chunk = new Uint8Array(chunkSize); + let seen = 0; + + (async () => { + bench.start(); + for (let i = 0; i < n; i++) { + const iterator = from(source(chunks, chunk))[Symbol.asyncIterator](); + const { value, done } = await iterator.next(); + if (done || value.length === 0) { + throw new Error('expected a batch'); + } + seen += value.length; + } + bench.end(n); + if (seen === 0) { + throw new Error('expected chunks'); + } + })(); +} + +function benchFromSyncWritev(chunks, chunkSize, n) { + const { pipeToSync } = require('stream/iter'); + const chunk = new Uint8Array(chunkSize); + const expected = chunks * chunkSize * n; + let seen = 0; + let total = 0; + const fd = openSync(devNull, 'w'); + const writer = { + writeSync(chunk) { + writeSync(fd, chunk); + seen++; + }, + writevSync(batch) { + writevSync(fd, batch); + seen += batch.length; + }, + }; + + try { + bench.start(); + for (let i = 0; i < n; i++) { + total += pipeToSync(source(chunks, chunk), writer); + } + bench.end(chunks * n); + } finally { + closeSync(fd); + } + + if (total !== expected || seen !== chunks * n) { + throw new Error('unexpected chunk count'); + } +} diff --git a/lib/internal/streams/iter/from.js b/lib/internal/streams/iter/from.js index 5ac802a00f2d08..1efe83e9a04162 100644 --- a/lib/internal/streams/iter/from.js +++ b/lib/internal/streams/iter/from.js @@ -47,7 +47,7 @@ const { toUint8Array, } = require('internal/streams/iter/utils'); -// Maximum number of chunks to yield per batch from from(Uint8Array[]). +// Maximum number of chunks to yield per batch from from()/fromSync(). // Bounds peak memory when arrays flow through transforms, which must // allocate output for the entire batch at once. const FROM_BATCH_SIZE = 128; @@ -190,33 +190,66 @@ function isUint8ArrayBatch(value) { return true; } +function* yieldBoundedBatch(batch) { + if (batch.length === 0) { + return; + } + if (batch.length <= FROM_BATCH_SIZE) { + yield batch; + return; + } + for (let i = 0; i < batch.length; i += FROM_BATCH_SIZE) { + yield ArrayPrototypeSlice(batch, i, i + FROM_BATCH_SIZE); + } +} + /** * Normalize a sync streamable source, yielding batches of Uint8Array. * @param {Iterable} source * @yields {Uint8Array[]} */ function* normalizeSyncSource(source) { + let batch = []; + for (const value of source) { // Fast path 1: value is already a Uint8Array[] batch if (isUint8ArrayBatch(value)) { - if (value.length > 0) { - yield value; + if (batch.length > 0) { + yield batch; + batch = []; } + yield* yieldBoundedBatch(value); continue; } // Fast path 2: value is a single Uint8Array (very common) if (isUint8Array(value)) { - yield [value]; + ArrayPrototypePush(batch, value); + if (batch.length === FROM_BATCH_SIZE) { + yield batch; + batch = []; + } continue; } // Slow path: normalize the value - const batch = []; - for (const chunk of normalizeSyncValue(value)) { - ArrayPrototypePush(batch, chunk); - } if (batch.length > 0) { yield batch; + batch = []; + } + let valueBatch = []; + for (const chunk of normalizeSyncValue(value)) { + ArrayPrototypePush(valueBatch, chunk); + if (valueBatch.length === FROM_BATCH_SIZE) { + yield valueBatch; + valueBatch = []; + } } + if (valueBatch.length > 0) { + yield valueBatch; + } + } + + if (batch.length > 0) { + yield batch; } } @@ -329,36 +362,42 @@ async function* normalizeAsyncSource(source) { return; } - // Fall back to sync iteration - batch all sync values together + // Fall back to sync iteration - batch sync values together with a bound. if (isSyncIterable(source)) { - const batch = []; + let batch = []; for (const value of source) { // Fast path 1: value is already a Uint8Array[] batch if (isUint8ArrayBatch(value)) { // Flush any accumulated batch first if (batch.length > 0) { - yield ArrayPrototypeSlice(batch); - batch.length = 0; - } - if (value.length > 0) { - yield value; + yield batch; + batch = []; } + yield* yieldBoundedBatch(value); continue; } // Fast path 2: value is a single Uint8Array (very common) if (isUint8Array(value)) { ArrayPrototypePush(batch, value); + if (batch.length === FROM_BATCH_SIZE) { + yield batch; + batch = []; + } continue; } // Slow path: normalize the value - must flush and yield individually if (batch.length > 0) { - yield ArrayPrototypeSlice(batch); - batch.length = 0; + yield batch; + batch = []; } - const asyncBatch = []; + let asyncBatch = []; for await (const chunk of normalizeAsyncValue(value)) { ArrayPrototypePush(asyncBatch, chunk); + if (asyncBatch.length === FROM_BATCH_SIZE) { + yield asyncBatch; + asyncBatch = []; + } } if (asyncBatch.length > 0) { yield asyncBatch; diff --git a/test/parallel/test-stream-iter-from-coverage.js b/test/parallel/test-stream-iter-from-coverage.js index c4f622a56bd7fa..eb75bec4826206 100644 --- a/test/parallel/test-stream-iter-from-coverage.js +++ b/test/parallel/test-stream-iter-from-coverage.js @@ -31,6 +31,22 @@ async function testFromSyncSubBatching() { assert.strictEqual(totalChunks, 200); } +// fromSync: generic sync iterables of Uint8Array use bounded batches +async function testFromSyncIterableSubBatching() { + function* gen() { + for (let i = 0; i < 200; i++) { + yield new Uint8Array([i & 0xFF]); + } + } + const batches = []; + for (const batch of fromSync(gen())) { + batches.push(batch); + } + assert.strictEqual(batches.length, 2); + assert.strictEqual(batches[0].length, 128); + assert.strictEqual(batches[1].length, 72); +} + // from: Uint8Array[] with > 128 elements triggers sub-batching (async) async function testFromAsyncSubBatching() { const bigBatch = Array.from({ length: 200 }, @@ -44,6 +60,22 @@ async function testFromAsyncSubBatching() { assert.strictEqual(batches[1].length, 72); } +// from: sync iterables use bounded batches instead of one unbounded batch +async function testFromAsyncSyncIterableSubBatching() { + function* gen() { + for (let i = 0; i < 200; i++) { + yield new Uint8Array([i & 0xFF]); + } + } + const batches = []; + for await (const batch of from(gen())) { + batches.push(batch); + } + assert.strictEqual(batches.length, 2); + assert.strictEqual(batches[0].length, 128); + assert.strictEqual(batches[1].length, 72); +} + // Exact boundary: 128 elements → single batch (no split) async function testFromSubBatchingBoundary() { const exactBatch = Array.from({ length: 128 }, @@ -133,7 +165,9 @@ async function testFromSyncInvalidYield() { Promise.all([ testFromSyncSubBatching(), + testFromSyncIterableSubBatching(), testFromAsyncSubBatching(), + testFromAsyncSyncIterableSubBatching(), testFromSubBatchingBoundary(), testFromSubBatchingBoundaryPlus1(), testFromSyncDataViewInGenerator(), diff --git a/test/parallel/test-stream-iter-from-sync.js b/test/parallel/test-stream-iter-from-sync.js index a9ce0bd575abdc..d3a5cf671e10d8 100644 --- a/test/parallel/test-stream-iter-from-sync.js +++ b/test/parallel/test-stream-iter-from-sync.js @@ -66,9 +66,10 @@ function testFromSyncGenerator() { for (const batch of readable) { batches.push(batch); } - assert.strictEqual(batches.length, 2); + assert.strictEqual(batches.length, 1); + assert.strictEqual(batches[0].length, 2); assert.deepStrictEqual(batches[0][0], new Uint8Array([1, 2])); - assert.deepStrictEqual(batches[1][0], new Uint8Array([3, 4])); + assert.deepStrictEqual(batches[0][1], new Uint8Array([3, 4])); } function testFromSyncNestedIterables() { diff --git a/test/parallel/test-stream-iter-pipeto-writev.js b/test/parallel/test-stream-iter-pipeto-writev.js index 893ab09b85d1f4..71a691dd6627b7 100644 --- a/test/parallel/test-stream-iter-pipeto-writev.js +++ b/test/parallel/test-stream-iter-pipeto-writev.js @@ -151,6 +151,27 @@ async function testPipeToSyncWritev() { assert.ok(batches.some((b) => b.length > 1)); } +// pipeToSync batches plain Uint8Array chunks for writevSync +async function testPipeToSyncPlainChunksWritev() { + const batches = []; + const writes = []; + const writer = { + writevSync(chunks) { batches.push(chunks); }, + writeSync(chunk) { writes.push(chunk); return true; }, + endSync() { return 0; }, + }; + function* source() { + yield new Uint8Array([1]); + yield new Uint8Array([2]); + yield new Uint8Array([3]); + } + const total = pipeToSync(source(), writer); + assert.strictEqual(total, 3); + assert.strictEqual(batches.length, 1); + assert.strictEqual(batches[0].length, 3); + assert.strictEqual(writes.length, 0); +} + // pipeToSync with writer that has write() and writeSync() — writeSync preferred async function testPipeToSyncWriteFallback() { const syncWrites = []; @@ -174,5 +195,6 @@ Promise.all([ testWriteSyncAlwaysFails(), testPushWriterBlockSyncFalseAccepted(), testPipeToSyncWritev(), + testPipeToSyncPlainChunksWritev(), testPipeToSyncWriteFallback(), ]).then(common.mustCall()); From a9b0a83e82e4a91f8b86b134858af559696ad24c Mon Sep 17 00:00:00 2001 From: LiviaMedeiros Date: Fri, 15 May 2026 18:25:20 +0800 Subject: [PATCH 163/168] fs: make `Date` properties on `Stats` enumerable MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: LiviaMedeiros PR-URL: https://github.com/nodejs/node/pull/63328 Reviewed-By: René Reviewed-By: Anna Henningsen Reviewed-By: James M Snell Reviewed-By: Luigi Pinca --- lib/internal/fs/utils.js | 18 +++++++++--------- lib/internal/util.js | 3 ++- test/parallel/test-fs-stat-date.mjs | 11 +++++++++++ 3 files changed, 22 insertions(+), 10 deletions(-) diff --git a/lib/internal/fs/utils.js b/lib/internal/fs/utils.js index 98e7b303e1091e..eaa9bd145b14cd 100644 --- a/lib/internal/fs/utils.js +++ b/lib/internal/fs/utils.js @@ -13,7 +13,6 @@ const { Number, NumberIsFinite, ObjectDefineProperties, - ObjectDefineProperty, ObjectIs, ObjectSetPrototypeOf, ReflectOwnKeys, @@ -48,6 +47,7 @@ const { once, deprecate, isWindows, + setOwnProperty, } = require('internal/util'); const { toPathIfFileURL } = require('internal/url'); const { @@ -449,10 +449,10 @@ const lazyDateFields = { enumerable: true, configurable: true, get() { - return this.atime = dateFromMs(this.atimeMs); + return setOwnProperty(this, 'atime', dateFromMs(this.atimeMs)); }, set(value) { - ObjectDefineProperty(this, 'atime', { __proto__: null, value, writable: true }); + setOwnProperty(this, 'atime', value); }, }, mtime: { @@ -460,10 +460,10 @@ const lazyDateFields = { enumerable: true, configurable: true, get() { - return this.mtime = dateFromMs(this.mtimeMs); + return setOwnProperty(this, 'mtime', dateFromMs(this.mtimeMs)); }, set(value) { - ObjectDefineProperty(this, 'mtime', { __proto__: null, value, writable: true }); + setOwnProperty(this, 'mtime', value); }, }, ctime: { @@ -471,10 +471,10 @@ const lazyDateFields = { enumerable: true, configurable: true, get() { - return this.ctime = dateFromMs(this.ctimeMs); + return setOwnProperty(this, 'ctime', dateFromMs(this.ctimeMs)); }, set(value) { - ObjectDefineProperty(this, 'ctime', { __proto__: null, value, writable: true }); + setOwnProperty(this, 'ctime', value); }, }, birthtime: { @@ -482,10 +482,10 @@ const lazyDateFields = { enumerable: true, configurable: true, get() { - return this.birthtime = dateFromMs(this.birthtimeMs); + return setOwnProperty(this, 'birthtime', dateFromMs(this.birthtimeMs)); }, set(value) { - ObjectDefineProperty(this, 'birthtime', { __proto__: null, value, writable: true }); + setOwnProperty(this, 'birthtime', value); }, }, }; diff --git a/lib/internal/util.js b/lib/internal/util.js index 28bb83e558c426..34af9ca6f61a6f 100644 --- a/lib/internal/util.js +++ b/lib/internal/util.js @@ -752,13 +752,14 @@ function filterOwnProperties(source, keys) { * @returns {any} */ function setOwnProperty(obj, key, value) { - return ObjectDefineProperty(obj, key, { + ObjectDefineProperty(obj, key, { __proto__: null, configurable: true, enumerable: true, value, writable: true, }); + return value; } let internalGlobal; diff --git a/test/parallel/test-fs-stat-date.mjs b/test/parallel/test-fs-stat-date.mjs index 5f85bff2731e86..489cd4fc20fd9c 100644 --- a/test/parallel/test-fs-stat-date.mjs +++ b/test/parallel/test-fs-stat-date.mjs @@ -42,6 +42,13 @@ function closeEnough(actual, expected, margin) { `expected ${expected} ± ${margin}, got ${actual}`); } +// Ensure that accessed atime and mtime are enumerable +function validateEnumerability(stats) { + const keys = Object.keys(stats); + assert.ok(keys.includes('atime')); + assert.ok(keys.includes('mtime')); +} + async function runTest(atime, mtime, margin = 0) { margin += Number.EPSILON; try { @@ -56,24 +63,28 @@ async function runTest(atime, mtime, margin = 0) { closeEnough(stats.mtimeMs, mtime, margin); closeEnough(stats.atime.getTime(), new Date(atime).getTime(), margin); closeEnough(stats.mtime.getTime(), new Date(mtime).getTime(), margin); + validateEnumerability(stats); const statsBigint = await fsPromises.stat(filepath, { bigint: true }); closeEnough(statsBigint.atimeMs, BigInt(atime), margin); closeEnough(statsBigint.mtimeMs, BigInt(mtime), margin); closeEnough(statsBigint.atime.getTime(), new Date(atime).getTime(), margin); closeEnough(statsBigint.mtime.getTime(), new Date(mtime).getTime(), margin); + validateEnumerability(statsBigint); const statsSync = fs.statSync(filepath); closeEnough(statsSync.atimeMs, atime, margin); closeEnough(statsSync.mtimeMs, mtime, margin); closeEnough(statsSync.atime.getTime(), new Date(atime).getTime(), margin); closeEnough(statsSync.mtime.getTime(), new Date(mtime).getTime(), margin); + validateEnumerability(statsSync); const statsSyncBigint = fs.statSync(filepath, { bigint: true }); closeEnough(statsSyncBigint.atimeMs, BigInt(atime), margin); closeEnough(statsSyncBigint.mtimeMs, BigInt(mtime), margin); closeEnough(statsSyncBigint.atime.getTime(), new Date(atime).getTime(), margin); closeEnough(statsSyncBigint.mtime.getTime(), new Date(mtime).getTime(), margin); + validateEnumerability(statsSyncBigint); } // Too high/low numbers produce too different results on different platforms From 5a8882a375ed9555c8f50c7f3ee9d03576d5cdb8 Mon Sep 17 00:00:00 2001 From: Antoine du Hamel Date: Sun, 17 May 2026 15:42:58 +0200 Subject: [PATCH 164/168] doc: remove inactive members from Triagers list Signed-off-by: Antoine du Hamel PR-URL: https://github.com/nodejs/node/pull/63329 Fixes: https://github.com/nodejs/admin/issues/1058 Reviewed-By: James M Snell Reviewed-By: Luigi Pinca Reviewed-By: Moshe Atlow --- README.md | 14 -------------- 1 file changed, 14 deletions(-) diff --git a/README.md b/README.md index b5dbf8ea68e92c..55f15c5a8045dc 100644 --- a/README.md +++ b/README.md @@ -745,38 +745,24 @@ maintaining the Node.js project. * [1ilsang](https://github.com/1ilsang) - **Sangchul Lee** <<1ilsang.dev@gmail.com>> (he/him) -* [atlowChemi](https://github.com/atlowChemi) - - **Chemi Atlow** <> (he/him) * [bjohansebas](https://github.com/bjohansebas) - **Sebastian Beltran** <> * [bmuenzenmeyer](https://github.com/bmuenzenmeyer) - **Brian Muenzenmeyer** <> (he/him) -* [CanadaHonk](https://github.com/CanadaHonk) - - **Oliver Medhurst** <> (they/them) -* [daeyeon](https://github.com/daeyeon) - - **Daeyeon Jeong** <> (he/him) * [efekrskl](https://github.com/efekrskl) - **Efe Karasakal** <> (he/him) * [gireeshpunathil](https://github.com/gireeshpunathil) - **Gireesh Punathil** <> (he/him) -* [gurgunday](https://github.com/gurgunday) - - **Gürgün Dayıoğlu** <> * [haramj](https://github.com/haramj) - **Haram Jeong** <> * [HBSPS](https://github.com/HBSPS) - **Wiyeong Seo** <> * [iam-frankqiu](https://github.com/iam-frankqiu) - **Frank Qiu** <> (he/him) -* [KevinEady](https://github.com/KevinEady) - - **Kevin Eady** <> (he/him) -* [marsonya](https://github.com/marsonya) - - **Akhil Marsonya** <> (he/him) * [milesguicent](https://github.com/milesguicent) - **Miles Guicent** <> (he/him) * [preveen-stack](https://github.com/preveen-stack) - **Preveen Padmanabhan** <> (he/him) -* [RaisinTen](https://github.com/RaisinTen) - - **Darshan Sen** <> (he/him) Triagers follow the [Triage Guide](./doc/contributing/issues.md#triaging-a-bug-report) when responding to new issues. From 0ed1d94aff7e6420096ca7b7bc8ab6078e065fe3 Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Tue, 5 May 2026 10:35:51 +0200 Subject: [PATCH 165/168] src: simplify OpenSSL feature gates Add OPENSSL_WITH_* feature macros for crypto capabilities that vary by OpenSSL version and use those instead of repeating version checks. Signed-off-by: Filip Skokan PR-URL: https://github.com/nodejs/node/pull/63255 Refs: https://github.com/electron/electron/issues/36256 Refs: https://github.com/electron/electron/issues/41720 Refs: https://github.com/electron/electron/pull/51127 Reviewed-By: James M Snell Reviewed-By: Yagiz Nizipli --- deps/ncrypto/ncrypto.cc | 22 ++++++------ deps/ncrypto/ncrypto.h | 69 ++++++++++++++++++++++++++++++------- src/crypto/crypto_aes.h | 2 +- src/crypto/crypto_argon2.cc | 4 +-- src/crypto/crypto_argon2.h | 2 +- src/crypto/crypto_cipher.cc | 2 +- src/crypto/crypto_kem.cc | 2 +- src/crypto/crypto_kem.h | 2 +- src/crypto/crypto_kmac.cc | 4 +-- src/crypto/crypto_kmac.h | 5 ++- src/crypto/crypto_sig.cc | 6 ++-- src/node_crypto.cc | 15 ++++---- src/node_crypto.h | 4 ++- 13 files changed, 91 insertions(+), 48 deletions(-) diff --git a/deps/ncrypto/ncrypto.cc b/deps/ncrypto/ncrypto.cc index ae7a343fe49767..e79706105e3d4e 100644 --- a/deps/ncrypto/ncrypto.cc +++ b/deps/ncrypto/ncrypto.cc @@ -20,7 +20,7 @@ #include #include #include -#if OPENSSL_VERSION_NUMBER >= 0x30200000L +#if OPENSSL_WITH_ARGON2 #include #endif #endif @@ -1955,8 +1955,7 @@ DataPointer pbkdf2(const Digest& md, return {}; } -#if OPENSSL_VERSION_NUMBER >= 0x30200000L -#ifndef OPENSSL_NO_ARGON2 +#if OPENSSL_WITH_ARGON2 DataPointer argon2(const Buffer& pass, const Buffer& salt, uint32_t lanes, @@ -2049,7 +2048,6 @@ DataPointer argon2(const Buffer& pass, return {}; } #endif -#endif // ============================================================================ @@ -4614,7 +4612,7 @@ HMACCtxPointer HMACCtxPointer::New() { return HMACCtxPointer(HMAC_CTX_new()); } -#if OPENSSL_VERSION_MAJOR >= 3 +#if OPENSSL_WITH_KMAC EVPMacPointer::EVPMacPointer(EVP_MAC* mac) : mac_(mac) {} EVPMacPointer::EVPMacPointer(EVPMacPointer&& other) noexcept @@ -4702,7 +4700,7 @@ EVPMacCtxPointer EVPMacCtxPointer::New(EVP_MAC* mac) { if (!mac) return EVPMacCtxPointer(); return EVPMacCtxPointer(EVP_MAC_CTX_new(mac)); } -#endif // OPENSSL_VERSION_MAJOR >= 3 +#endif // OPENSSL_WITH_KMAC DataPointer hashDigest(const Buffer& buf, const EVP_MD* md) { @@ -4849,8 +4847,8 @@ const Digest Digest::FromName(const char* name) { // ============================================================================ // KEM Implementation -#if OPENSSL_VERSION_MAJOR >= 3 -#if !OPENSSL_VERSION_PREREQ(3, 5) +#if OPENSSL_WITH_KEM +#if OPENSSL_WITH_KEM_OPERATION_PARAM bool KEM::SetOperationParameter(EVP_PKEY_CTX* ctx, const EVPKeyPointer& key) { const char* operation = nullptr; @@ -4858,7 +4856,7 @@ bool KEM::SetOperationParameter(EVP_PKEY_CTX* ctx, const EVPKeyPointer& key) { case EVP_PKEY_RSA: operation = OSSL_KEM_PARAM_OPERATION_RSASVE; break; -#if OPENSSL_VERSION_PREREQ(3, 2) +#if OPENSSL_WITH_OPENSSL_DHKEM case EVP_PKEY_EC: case EVP_PKEY_X25519: case EVP_PKEY_X448: @@ -4895,7 +4893,7 @@ std::optional KEM::Encapsulate( return std::nullopt; } -#if !OPENSSL_VERSION_PREREQ(3, 5) +#if OPENSSL_WITH_KEM_OPERATION_PARAM if (!SetOperationParameter(ctx.get(), public_key)) { return std::nullopt; } @@ -4936,7 +4934,7 @@ DataPointer KEM::Decapsulate(const EVPKeyPointer& private_key, return {}; } -#if !OPENSSL_VERSION_PREREQ(3, 5) +#if OPENSSL_WITH_KEM_OPERATION_PARAM if (!SetOperationParameter(ctx.get(), private_key)) { return {}; } @@ -4966,6 +4964,6 @@ DataPointer KEM::Decapsulate(const EVPKeyPointer& private_key, return shared_key; } -#endif // OPENSSL_VERSION_MAJOR >= 3 +#endif // OPENSSL_WITH_KEM } // namespace ncrypto diff --git a/deps/ncrypto/ncrypto.h b/deps/ncrypto/ncrypto.h index d3b0762f3313bb..7f9612c01a56ee 100644 --- a/deps/ncrypto/ncrypto.h +++ b/deps/ncrypto/ncrypto.h @@ -42,20 +42,67 @@ // The FIPS-related functions are only available // when the OpenSSL itself was compiled with FIPS support. -#if defined(OPENSSL_FIPS) && OPENSSL_VERSION_MAJOR < 3 +#if defined(OPENSSL_FIPS) && !OPENSSL_VERSION_PREREQ(3, 0) #include #endif // OPENSSL_FIPS -// Define OPENSSL_WITH_PQC for post-quantum cryptography support -#if OPENSSL_VERSION_NUMBER >= 0x30500000L +#if OPENSSL_VERSION_PREREQ(3, 0) +#define OPENSSL_WITH_AES_OCB 1 +#else +#define OPENSSL_WITH_AES_OCB 0 +#endif + +#if !defined(OPENSSL_NO_ARGON2) && OPENSSL_VERSION_PREREQ(3, 2) +#define OPENSSL_WITH_ARGON2 1 +#else +#define OPENSSL_WITH_ARGON2 0 +#endif + +#if OPENSSL_VERSION_PREREQ(3, 0) +#define OPENSSL_WITH_KEM 1 +#else +#define OPENSSL_WITH_KEM 0 +#endif + +#if OPENSSL_VERSION_PREREQ(3, 0) +#define OPENSSL_WITH_KMAC 1 +#else +#define OPENSSL_WITH_KMAC 0 +#endif + +#if OPENSSL_VERSION_PREREQ(3, 2) +#define OPENSSL_WITH_SIGNATURE_CONTEXT_STRING 1 +#else +#define OPENSSL_WITH_SIGNATURE_CONTEXT_STRING 0 +#endif + +#if !defined(OPENSSL_IS_BORINGSSL) && OPENSSL_VERSION_PREREQ(3, 2) +#define OPENSSL_WITH_OPENSSL_DHKEM 1 +#else +#define OPENSSL_WITH_OPENSSL_DHKEM 0 +#endif + +#if OPENSSL_WITH_KEM && !OPENSSL_VERSION_PREREQ(3, 5) +#define OPENSSL_WITH_KEM_OPERATION_PARAM 1 +#else +#define OPENSSL_WITH_KEM_OPERATION_PARAM 0 +#endif + +// Define OPENSSL_WITH_PQC for post-quantum cryptography support. +#if OPENSSL_VERSION_PREREQ(3, 5) #define OPENSSL_WITH_PQC 1 +#else +#define OPENSSL_WITH_PQC 0 +#endif + +#if OPENSSL_WITH_PQC #define EVP_PKEY_ML_KEM_512 NID_ML_KEM_512 #define EVP_PKEY_ML_KEM_768 NID_ML_KEM_768 #define EVP_PKEY_ML_KEM_1024 NID_ML_KEM_1024 #include #endif -#if OPENSSL_VERSION_MAJOR >= 3 +#if OPENSSL_VERSION_PREREQ(3, 0) #define OSSL3_CONST const #else #define OSSL3_CONST @@ -1492,7 +1539,7 @@ class HMACCtxPointer final { DeleteFnPtr ctx_; }; -#if OPENSSL_VERSION_MAJOR >= 3 +#if OPENSSL_WITH_KMAC class EVPMacPointer final { public: EVPMacPointer() = default; @@ -1540,7 +1587,7 @@ class EVPMacCtxPointer final { private: DeleteFnPtr ctx_; }; -#endif // OPENSSL_VERSION_MAJOR >= 3 +#endif // OPENSSL_WITH_KMAC #ifndef OPENSSL_NO_ENGINE class EnginePointer final { @@ -1653,8 +1700,7 @@ DataPointer pbkdf2(const Digest& md, uint32_t iterations, size_t length); -#if OPENSSL_VERSION_NUMBER >= 0x30200000L -#ifndef OPENSSL_NO_ARGON2 +#if OPENSSL_WITH_ARGON2 enum class Argon2Type { ARGON2D, ARGON2I, ARGON2ID }; DataPointer argon2(const Buffer& pass, @@ -1668,11 +1714,10 @@ DataPointer argon2(const Buffer& pass, const Buffer& ad, Argon2Type type); #endif -#endif // ============================================================================ // KEM (Key Encapsulation Mechanism) -#if OPENSSL_VERSION_MAJOR >= 3 +#if OPENSSL_WITH_KEM class KEM final { public: @@ -1696,13 +1741,13 @@ class KEM final { const Buffer& ciphertext); private: -#if !OPENSSL_VERSION_PREREQ(3, 5) +#if OPENSSL_WITH_KEM_OPERATION_PARAM static bool SetOperationParameter(EVP_PKEY_CTX* ctx, const EVPKeyPointer& key); #endif }; -#endif // OPENSSL_VERSION_MAJOR >= 3 +#endif // OPENSSL_WITH_KEM // ============================================================================ // Version metadata diff --git a/src/crypto/crypto_aes.h b/src/crypto/crypto_aes.h index 5627f9020bad54..427ac253408a19 100644 --- a/src/crypto/crypto_aes.h +++ b/src/crypto/crypto_aes.h @@ -26,7 +26,7 @@ constexpr unsigned kNoAuthTagLength = static_cast(-1); V(KW_192, AES_Cipher, ncrypto::Cipher::AES_192_KW) \ V(KW_256, AES_Cipher, ncrypto::Cipher::AES_256_KW) -#if OPENSSL_VERSION_MAJOR >= 3 +#if OPENSSL_WITH_AES_OCB #define VARIANTS_OCB(V) \ V(OCB_128, AES_Cipher, ncrypto::Cipher::AES_128_OCB) \ V(OCB_192, AES_Cipher, ncrypto::Cipher::AES_192_OCB) \ diff --git a/src/crypto/crypto_argon2.cc b/src/crypto/crypto_argon2.cc index 7bb995ca51c0df..d5207f4be57bb2 100644 --- a/src/crypto/crypto_argon2.cc +++ b/src/crypto/crypto_argon2.cc @@ -2,8 +2,7 @@ #include "async_wrap-inl.h" #include "threadpoolwork-inl.h" -#if OPENSSL_VERSION_NUMBER >= 0x30200000L -#ifndef OPENSSL_NO_ARGON2 +#if OPENSSL_WITH_ARGON2 #include namespace node::crypto { @@ -159,4 +158,3 @@ void Argon2::RegisterExternalReferences(ExternalReferenceRegistry* registry) { } // namespace node::crypto #endif -#endif diff --git a/src/crypto/crypto_argon2.h b/src/crypto/crypto_argon2.h index 73e8460d204dd3..354d0a4be6f392 100644 --- a/src/crypto/crypto_argon2.h +++ b/src/crypto/crypto_argon2.h @@ -6,7 +6,7 @@ #include "crypto/crypto_util.h" namespace node::crypto { -#if !defined(OPENSSL_NO_ARGON2) && OPENSSL_VERSION_NUMBER >= 0x30200000L +#if OPENSSL_WITH_ARGON2 // Argon2 is a password-based key derivation algorithm // defined in https://datatracker.ietf.org/doc/html/rfc9106 diff --git a/src/crypto/crypto_cipher.cc b/src/crypto/crypto_cipher.cc index 2e9acf86099ee8..dec72c20412e4e 100644 --- a/src/crypto/crypto_cipher.cc +++ b/src/crypto/crypto_cipher.cc @@ -711,7 +711,7 @@ bool CipherBase::Final(std::unique_ptr* out) { static_cast(ctx_.getBlockSize()), BackingStoreInitializationMode::kUninitialized); -#if (OPENSSL_VERSION_NUMBER < 0x30000000L) +#if !OPENSSL_VERSION_PREREQ(3, 0) // OpenSSL v1.x doesn't verify the presence of the auth tag so do // it ourselves, see https://github.com/nodejs/node/issues/45874. if (kind_ == kDecipher && ctx_.isChaCha20Poly1305() && diff --git a/src/crypto/crypto_kem.cc b/src/crypto/crypto_kem.cc index dff69f2e18f947..d30c6aaef6253f 100644 --- a/src/crypto/crypto_kem.cc +++ b/src/crypto/crypto_kem.cc @@ -1,6 +1,6 @@ #include "crypto/crypto_kem.h" -#if OPENSSL_VERSION_MAJOR >= 3 +#if OPENSSL_WITH_KEM #include "async_wrap-inl.h" #include "base_object-inl.h" diff --git a/src/crypto/crypto_kem.h b/src/crypto/crypto_kem.h index 2b4671cfc7a0ec..e00aa04baa897e 100644 --- a/src/crypto/crypto_kem.h +++ b/src/crypto/crypto_kem.h @@ -10,7 +10,7 @@ #include "memory_tracker.h" #include "node_external_reference.h" -#if OPENSSL_VERSION_MAJOR >= 3 +#if OPENSSL_WITH_KEM namespace node { namespace crypto { diff --git a/src/crypto/crypto_kmac.cc b/src/crypto/crypto_kmac.cc index fd431ffc1b47b7..ed4a8e9d526983 100644 --- a/src/crypto/crypto_kmac.cc +++ b/src/crypto/crypto_kmac.cc @@ -3,7 +3,7 @@ #include "node_internals.h" #include "threadpoolwork-inl.h" -#if OPENSSL_VERSION_MAJOR >= 3 +#if OPENSSL_WITH_KMAC #include #include #include "crypto/crypto_keys.h" @@ -220,4 +220,4 @@ void Kmac::RegisterExternalReferences(ExternalReferenceRegistry* registry) { } // namespace node::crypto -#endif +#endif // OPENSSL_WITH_KMAC diff --git a/src/crypto/crypto_kmac.h b/src/crypto/crypto_kmac.h index 9ee6192ee3dd17..5a8c9e5039f22b 100644 --- a/src/crypto/crypto_kmac.h +++ b/src/crypto/crypto_kmac.h @@ -10,8 +10,7 @@ namespace node::crypto { -// KMAC (Keccak Message Authentication Code) is available since OpenSSL 3.0. -#if OPENSSL_VERSION_MAJOR >= 3 +#if OPENSSL_WITH_KMAC enum class KmacVariant { KMAC128, KMAC256 }; @@ -72,7 +71,7 @@ namespace Kmac { void Initialize(Environment* env, v8::Local target) {} void RegisterExternalReferences(ExternalReferenceRegistry* registry) {} } // namespace Kmac -#endif +#endif // OPENSSL_WITH_KMAC } // namespace node::crypto diff --git a/src/crypto/crypto_sig.cc b/src/crypto/crypto_sig.cc index bd3c9f538c5de5..ad5e2038339d12 100644 --- a/src/crypto/crypto_sig.cc +++ b/src/crypto/crypto_sig.cc @@ -237,9 +237,8 @@ bool UseP1363Encoding(const EVPKeyPointer& key, const DSASigEnc dsa_encoding) { } bool SupportsContextString(const EVPKeyPointer& key) { -#if OPENSSL_VERSION_NUMBER < 0x3020000fL - return false; -#else + if (!OPENSSL_WITH_SIGNATURE_CONTEXT_STRING) return false; + switch (key.id()) { case EVP_PKEY_ED25519: case EVP_PKEY_ED448: @@ -264,7 +263,6 @@ bool SupportsContextString(const EVPKeyPointer& key) { default: return false; } -#endif } } // namespace diff --git a/src/node_crypto.cc b/src/node_crypto.cc index c0869f40e0410d..91d80e0dd379ba 100644 --- a/src/node_crypto.cc +++ b/src/node_crypto.cc @@ -61,21 +61,24 @@ namespace crypto { V(Verify) \ V(X509Certificate) -#if !defined(OPENSSL_NO_ARGON2) && OPENSSL_VERSION_NUMBER >= 0x30200000L +#if OPENSSL_WITH_ARGON2 #define ARGON2_NAMESPACE_LIST(V) V(Argon2) #else #define ARGON2_NAMESPACE_LIST(V) -#endif // !OPENSSL_NO_ARGON2 && OpenSSL >= 3.2 +#endif // OPENSSL_WITH_ARGON2 -// KEM and KMAC functionality requires OpenSSL 3.0.0 or later -#if OPENSSL_VERSION_MAJOR >= 3 +#if OPENSSL_WITH_KEM #define KEM_NAMESPACE_LIST(V) V(KEM) -#define KMAC_NAMESPACE_LIST(V) V(Kmac) #else #define KEM_NAMESPACE_LIST(V) -#define KMAC_NAMESPACE_LIST(V) #endif +#if OPENSSL_WITH_KMAC +#define KMAC_NAMESPACE_LIST(V) V(Kmac) +#else +#define KMAC_NAMESPACE_LIST(V) +#endif // OPENSSL_WITH_KMAC + #define TURBOSHAKE_NAMESPACE_LIST(V) V(TurboShake) #ifdef OPENSSL_NO_SCRYPT diff --git a/src/node_crypto.h b/src/node_crypto.h index 80657431a791db..ecc2b8c6a358c8 100644 --- a/src/node_crypto.h +++ b/src/node_crypto.h @@ -40,8 +40,10 @@ #include "crypto/crypto_hash.h" #include "crypto/crypto_hkdf.h" #include "crypto/crypto_hmac.h" -#if OPENSSL_VERSION_MAJOR >= 3 +#if OPENSSL_WITH_KEM #include "crypto/crypto_kem.h" +#endif +#if OPENSSL_WITH_KMAC #include "crypto/crypto_kmac.h" #endif #include "crypto/crypto_keygen.h" From 07431982bb70a859632c702418f129d9daaf477e Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Wed, 22 Apr 2026 22:39:29 +0200 Subject: [PATCH 166/168] crypto: wire AES-KW in Web Cryptography when using BoringSSL Signed-off-by: Filip Skokan PR-URL: https://github.com/nodejs/node/pull/63255 Refs: https://github.com/electron/electron/issues/36256 Refs: https://github.com/electron/electron/issues/41720 Refs: https://github.com/electron/electron/pull/51127 Reviewed-By: James M Snell Reviewed-By: Yagiz Nizipli --- lib/internal/crypto/util.js | 1 - src/crypto/crypto_aes.cc | 75 +++++++++++++++++++ src/crypto/crypto_aes.h | 12 +++ test/fixtures/webcrypto/supports-level-2.mjs | 12 +-- .../test-crypto-key-objects-to-crypto-key.js | 4 +- .../test-webcrypto-deduplicate-usages.js | 39 +++------- .../test-webcrypto-derivebits-hkdf.js | 4 +- test/parallel/test-webcrypto-keygen.js | 27 +++---- ...-webcrypto-promise-prototype-pollution.mjs | 20 ++--- test/parallel/test-webcrypto-wrap-unwrap.js | 24 +++--- .../test-webcrypto-derivebits-pbkdf2.js | 11 +-- test/wpt/status/WebCryptoAPI.cjs | 7 -- 12 files changed, 136 insertions(+), 100 deletions(-) diff --git a/lib/internal/crypto/util.js b/lib/internal/crypto/util.js index 67b5f66e4c3320..366d994fa4b2d7 100644 --- a/lib/internal/crypto/util.js +++ b/lib/internal/crypto/util.js @@ -396,7 +396,6 @@ const kAlgorithmDefinitions = { // Conditionally supported algorithms const conditionalAlgorithms = { - 'AES-KW': !process.features.openssl_is_boringssl, 'AES-OCB': !!hasAesOcbMode, 'Argon2d': !!Argon2Job, 'Argon2i': !!Argon2Job, diff --git a/src/crypto/crypto_aes.cc b/src/crypto/crypto_aes.cc index fa619696ffd5b2..815c972837049a 100644 --- a/src/crypto/crypto_aes.cc +++ b/src/crypto/crypto_aes.cc @@ -181,6 +181,68 @@ WebCryptoCipherStatus AES_Cipher(Environment* env, return WebCryptoCipherStatus::OK; } +#ifdef OPENSSL_IS_BORINGSSL +// AES Key Wrap using BoringSSL's low-level AES_wrap_key / AES_unwrap_key. +// BoringSSL does not expose EVP_aes_*_wrap via the +// EVP_CIPHER registry, so the EVP-based AES_Cipher path is unusable for +// AES-KW. This matches Chromium's WebCrypto AES-KW implementation. +WebCryptoCipherStatus AES_KW_Cipher(Environment* env, + const KeyObjectData& key_data, + WebCryptoCipherMode cipher_mode, + const AESCipherConfig& params, + const ByteSource& in, + ByteSource* out) { + CHECK_EQ(key_data.GetKeyType(), kKeyTypeSecret); + + const unsigned key_bits = + static_cast(key_data.GetSymmetricKeySize()) * 8; + const auto key_bytes = + reinterpret_cast(key_data.GetSymmetricKey()); + const bool encrypt = cipher_mode == kWebCryptoCipherEncrypt; + + AES_KEY aes_key; + if (encrypt) { + // Input must be a multiple of 8 bytes and at least 16 bytes. + if (in.size() < 16 || in.size() % 8 != 0) { + return WebCryptoCipherStatus::FAILED; + } + if (AES_set_encrypt_key(key_bytes, key_bits, &aes_key) != 0) { + return WebCryptoCipherStatus::FAILED; + } + auto buf = DataPointer::Alloc(in.size() + 8); + int len = AES_wrap_key(&aes_key, + nullptr, + static_cast(buf.get()), + in.data(), + in.size()); + if (len < 0 || static_cast(len) != in.size() + 8) { + return WebCryptoCipherStatus::FAILED; + } + *out = ByteSource::Allocated(buf.release()); + } else { + // Input must be a multiple of 8 bytes and at least 24 bytes. + if (in.size() < 24 || in.size() % 8 != 0) { + return WebCryptoCipherStatus::FAILED; + } + if (AES_set_decrypt_key(key_bytes, key_bits, &aes_key) != 0) { + return WebCryptoCipherStatus::FAILED; + } + auto buf = DataPointer::Alloc(in.size() - 8); + int len = AES_unwrap_key(&aes_key, + nullptr, + static_cast(buf.get()), + in.data(), + in.size()); + if (len < 0 || static_cast(len) != in.size() - 8) { + return WebCryptoCipherStatus::FAILED; + } + *out = ByteSource::Allocated(buf.release()); + } + + return WebCryptoCipherStatus::OK; +} +#endif // OPENSSL_IS_BORINGSSL + // The AES_CTR implementation here takes it's inspiration from the chromium // implementation here: // https://github.com/chromium/chromium/blob/7af6cfd/components/webcrypto/algorithms/aes_ctr.cc @@ -465,6 +527,19 @@ Maybe AESCipherTraits::AdditionalConfig( } #undef V +#ifdef OPENSSL_IS_BORINGSSL + // On BoringSSL the KW variants have no backing EVP_CIPHER; they use + // low-level AES_wrap_key / AES_unwrap_key instead. + const bool is_kw = params->variant == AESKeyVariant::KW_128 || + params->variant == AESKeyVariant::KW_192 || + params->variant == AESKeyVariant::KW_256; + + if (is_kw) { + UseDefaultIV(params); + return JustVoid(); + } +#endif + if (!params->cipher) { THROW_ERR_CRYPTO_UNKNOWN_CIPHER(env); return Nothing(); diff --git a/src/crypto/crypto_aes.h b/src/crypto/crypto_aes.h index 427ac253408a19..401e7b2c338a1b 100644 --- a/src/crypto/crypto_aes.h +++ b/src/crypto/crypto_aes.h @@ -22,9 +22,21 @@ constexpr unsigned kNoAuthTagLength = static_cast(-1); V(GCM_128, AES_Cipher, ncrypto::Cipher::AES_128_GCM) \ V(GCM_192, AES_Cipher, ncrypto::Cipher::AES_192_GCM) \ V(GCM_256, AES_Cipher, ncrypto::Cipher::AES_256_GCM) \ + VARIANTS_KW(V) + +#ifdef OPENSSL_IS_BORINGSSL +// BoringSSL does not expose EVP_aes_*_wrap via the EVP_CIPHER registry. +// Route AES-KW through low-level AES_wrap_key / AES_unwrap_key instead. +#define VARIANTS_KW(V) \ + V(KW_128, AES_KW_Cipher, static_cast(nullptr)) \ + V(KW_192, AES_KW_Cipher, static_cast(nullptr)) \ + V(KW_256, AES_KW_Cipher, static_cast(nullptr)) +#else +#define VARIANTS_KW(V) \ V(KW_128, AES_Cipher, ncrypto::Cipher::AES_128_KW) \ V(KW_192, AES_Cipher, ncrypto::Cipher::AES_192_KW) \ V(KW_256, AES_Cipher, ncrypto::Cipher::AES_256_KW) +#endif #if OPENSSL_WITH_AES_OCB #define VARIANTS_OCB(V) \ diff --git a/test/fixtures/webcrypto/supports-level-2.mjs b/test/fixtures/webcrypto/supports-level-2.mjs index 931be98a824032..1850acacdc22e9 100644 --- a/test/fixtures/webcrypto/supports-level-2.mjs +++ b/test/fixtures/webcrypto/supports-level-2.mjs @@ -74,7 +74,7 @@ export const vectors = { [false, { name: 'AES-CBC', length: 25 }], [true, { name: 'AES-GCM', length: 128 }], [false, { name: 'AES-GCM', length: 25 }], - [!boringSSL, { name: 'AES-KW', length: 128 }], + [true, { name: 'AES-KW', length: 128 }], [false, { name: 'AES-KW', length: 25 }], [true, { name: 'HMAC', hash: 'SHA-256' }], [true, { name: 'HMAC', hash: 'SHA-256', length: 256 }], @@ -192,7 +192,7 @@ export const vectors = { [true, 'AES-CTR'], [true, 'AES-CBC'], [true, 'AES-GCM'], - [!boringSSL, 'AES-KW'], + [true, 'AES-KW'], [true, { name: 'HMAC', hash: 'SHA-256' }], [true, { name: 'HMAC', hash: 'SHA-256', length: 256 }], [false, { name: 'HMAC', hash: 'SHA-256', length: 25 }], @@ -214,18 +214,18 @@ export const vectors = { [true, 'AES-CTR'], [true, 'AES-CBC'], [true, 'AES-GCM'], - [!boringSSL, 'AES-KW'], + [true, 'AES-KW'], [true, 'Ed25519'], [true, 'X25519'], ], 'wrapKey': [ [false, 'AES-KW'], - [!boringSSL, 'AES-KW', 'AES-CTR'], - [!boringSSL, 'AES-KW', 'HMAC'], + [true, 'AES-KW', 'AES-CTR'], + [true, 'AES-KW', 'HMAC'], ], 'unwrapKey': [ [false, 'AES-KW'], - [!boringSSL, 'AES-KW', 'AES-CTR'], + [true, 'AES-KW', 'AES-CTR'], ], 'unsupported operation': [ [false, ''], diff --git a/test/parallel/test-crypto-key-objects-to-crypto-key.js b/test/parallel/test-crypto-key-objects-to-crypto-key.js index 54449329cb551a..6089a22c510892 100644 --- a/test/parallel/test-crypto-key-objects-to-crypto-key.js +++ b/test/parallel/test-crypto-key-objects-to-crypto-key.js @@ -31,8 +31,8 @@ function assertCryptoKey(cryptoKey, keyObject, algorithm, extractable, usages) { algorithms.push('ChaCha20-Poly1305'); if (process.features.openssl_is_boringssl) { - algorithms = algorithms.filter((a) => a !== 'AES-KW' && a !== 'ChaCha20-Poly1305'); - common.printSkipMessage('Skipping unsupported AES-KW/ChaCha20-Poly1305 test cases'); + algorithms = algorithms.filter((a) => a !== 'ChaCha20-Poly1305'); + common.printSkipMessage('Skipping unsupported ChaCha20-Poly1305 test case'); } for (const algorithm of algorithms) { diff --git a/test/parallel/test-webcrypto-deduplicate-usages.js b/test/parallel/test-webcrypto-deduplicate-usages.js index e30dbe7887166e..6af5146e1b82ed 100644 --- a/test/parallel/test-webcrypto-deduplicate-usages.js +++ b/test/parallel/test-webcrypto-deduplicate-usages.js @@ -42,17 +42,10 @@ function assertSameSet(actual, expected, msg) { { algorithm: { name: 'AES-GCM', length: 128 }, usages: ['decrypt', 'encrypt', 'decrypt'], expected: ['encrypt', 'decrypt'] }, - ]; - - if (!process.features.openssl_is_boringssl) { - symmetric.push({ - algorithm: { name: 'AES-KW', length: 128 }, + { algorithm: { name: 'AES-KW', length: 128 }, usages: ['wrapKey', 'unwrapKey', 'wrapKey', 'unwrapKey'], - expected: ['wrapKey', 'unwrapKey'], - }); - } else { - common.printSkipMessage('AES-KW is not supported in BoringSSL'); - } + expected: ['wrapKey', 'unwrapKey'] }, + ]; if (hasOpenSSL(3)) { symmetric.push({ @@ -172,17 +165,10 @@ function assertSameSet(actual, expected, msg) { { algorithm: { name: 'HMAC', hash: 'SHA-256' }, keyData: new Uint8Array(32), usages: ['verify', 'sign', 'verify', 'sign'], expected: ['sign', 'verify'] }, - ]; - - if (!process.features.openssl_is_boringssl) { - rawSymmetric.push({ - algorithm: { name: 'AES-KW' }, keyData: new Uint8Array(16), + { algorithm: { name: 'AES-KW' }, keyData: new Uint8Array(16), usages: ['wrapKey', 'unwrapKey', 'wrapKey'], - expected: ['wrapKey', 'unwrapKey'], - }); - } else { - common.printSkipMessage('AES-KW is not supported in BoringSSL'); - } + expected: ['wrapKey', 'unwrapKey'] }, + ]; if (hasOpenSSL(3)) { // KMAC does not support `raw` format, only `raw-secret` and `jwk`. @@ -455,17 +441,10 @@ function assertSameSet(actual, expected, msg) { { algorithm: { name: 'AES-GCM', length: 128 }, usages: ['decrypt', 'encrypt', 'decrypt'], expected: ['encrypt', 'decrypt'] }, - ]; - - if (!process.features.openssl_is_boringssl) { - jwkVectors.push({ - algorithm: { name: 'AES-KW', length: 128 }, + { algorithm: { name: 'AES-KW', length: 128 }, usages: ['wrapKey', 'unwrapKey', 'wrapKey', 'unwrapKey'], - expected: ['wrapKey', 'unwrapKey'], - }); - } else { - common.printSkipMessage('AES-KW is not supported in BoringSSL'); - } + expected: ['wrapKey', 'unwrapKey'] }, + ]; if (hasOpenSSL(3)) { jwkVectors.push({ diff --git a/test/parallel/test-webcrypto-derivebits-hkdf.js b/test/parallel/test-webcrypto-derivebits-hkdf.js index 689eaeb38fd66f..d2057d1f782e7f 100644 --- a/test/parallel/test-webcrypto-derivebits-hkdf.js +++ b/test/parallel/test-webcrypto-derivebits-hkdf.js @@ -24,12 +24,12 @@ const kDerivedKeyTypes = [ ['HMAC', 256, 'SHA-256', 'sign', 'verify'], ['HMAC', 256, 'SHA-384', 'sign', 'verify'], ['HMAC', 256, 'SHA-512', 'sign', 'verify'], + ['AES-KW', 128, undefined, 'wrapKey', 'unwrapKey'], + ['AES-KW', 256, undefined, 'wrapKey', 'unwrapKey'], ]; if (!process.features.openssl_is_boringssl) { kDerivedKeyTypes.push( - ['AES-KW', 128, undefined, 'wrapKey', 'unwrapKey'], - ['AES-KW', 256, undefined, 'wrapKey', 'unwrapKey'], ['HMAC', 256, 'SHA3-256', 'sign', 'verify'], ['HMAC', 256, 'SHA3-384', 'sign', 'verify'], ['HMAC', 256, 'SHA3-512', 'sign', 'verify'], diff --git a/test/parallel/test-webcrypto-keygen.js b/test/parallel/test-webcrypto-keygen.js index e57c34436578ab..520f8a15b1f60e 100644 --- a/test/parallel/test-webcrypto-keygen.js +++ b/test/parallel/test-webcrypto-keygen.js @@ -135,6 +135,14 @@ const vectors = { 'deriveBits', ], }, + 'AES-KW': { + algorithm: { length: 256 }, + result: 'CryptoKey', + usages: [ + 'wrapKey', + 'unwrapKey', + ], + } }; if (!process.features.openssl_is_boringssl) { @@ -152,14 +160,6 @@ if (!process.features.openssl_is_boringssl) { 'deriveBits', ], }; - vectors['AES-KW'] = { - algorithm: { length: 256 }, - result: 'CryptoKey', - usages: [ - 'wrapKey', - 'unwrapKey', - ], - }; vectors['ChaCha20-Poly1305'] = { result: 'CryptoKey', usages: [ @@ -606,17 +606,10 @@ if (hasOpenSSL(3, 5)) { [ 'AES-CBC', 256, ['encrypt', 'decrypt']], [ 'AES-GCM', 128, ['encrypt', 'decrypt']], [ 'AES-GCM', 256, ['encrypt', 'decrypt']], + [ 'AES-KW', 128, ['wrapKey', 'unwrapKey']], + [ 'AES-KW', 256, ['wrapKey', 'unwrapKey']], ]; - if (!process.features.openssl_is_boringssl) { - kTests.push( - [ 'AES-KW', 128, ['wrapKey', 'unwrapKey']], - [ 'AES-KW', 256, ['wrapKey', 'unwrapKey']], - ); - } else { - common.printSkipMessage('Skipping unsupported AES-KW test cases'); - } - const tests = Promise.all(kTests.map((args) => test(...args))); tests.then(common.mustCall()); diff --git a/test/parallel/test-webcrypto-promise-prototype-pollution.mjs b/test/parallel/test-webcrypto-promise-prototype-pollution.mjs index 3ea0a961f41b90..b4fbedba5e3242 100644 --- a/test/parallel/test-webcrypto-promise-prototype-pollution.mjs +++ b/test/parallel/test-webcrypto-promise-prototype-pollution.mjs @@ -59,21 +59,17 @@ await subtle.deriveKey( true, ['encrypt', 'decrypt']); -if (!process.features.openssl_is_boringssl) { - const wrappingKey = await subtle.generateKey( - { name: 'AES-KW', length: 256 }, true, ['wrapKey', 'unwrapKey']); +const wrappingKey = await subtle.generateKey( + { name: 'AES-KW', length: 256 }, true, ['wrapKey', 'unwrapKey']); - const keyToWrap = await subtle.generateKey( - { name: 'AES-CBC', length: 256 }, true, ['encrypt', 'decrypt']); +const keyToWrap = await subtle.generateKey( + { name: 'AES-CBC', length: 256 }, true, ['encrypt', 'decrypt']); - const wrapped = await subtle.wrapKey('raw', keyToWrap, wrappingKey, 'AES-KW'); +const wrapped = await subtle.wrapKey('raw', keyToWrap, wrappingKey, 'AES-KW'); - await subtle.unwrapKey( - 'raw', wrapped, wrappingKey, 'AES-KW', - { name: 'AES-CBC', length: 256 }, true, ['encrypt', 'decrypt']); -} else { - common.printSkipMessage('Skipping unsupported AES-KW test case'); -} +await subtle.unwrapKey( + 'raw', wrapped, wrappingKey, 'AES-KW', + { name: 'AES-CBC', length: 256 }, true, ['encrypt', 'decrypt']); const { privateKey } = await subtle.generateKey( { name: 'ECDSA', namedCurve: 'P-256' }, true, ['sign', 'verify']); diff --git a/test/parallel/test-webcrypto-wrap-unwrap.js b/test/parallel/test-webcrypto-wrap-unwrap.js index 8c57111daebca6..8039eae1f764b3 100644 --- a/test/parallel/test-webcrypto-wrap-unwrap.js +++ b/test/parallel/test-webcrypto-wrap-unwrap.js @@ -39,14 +39,15 @@ const kWrappingData = { }, pair: false }, -}; - -if (!process.features.openssl_is_boringssl) { - kWrappingData['AES-KW'] = { + 'AES-KW': { generate: { length: 128 }, wrap: { }, pair: false - }; + }, +}; + + +if (!process.features.openssl_is_boringssl) { kWrappingData['ChaCha20-Poly1305'] = { wrap: { iv: new Uint8Array(12), @@ -56,7 +57,7 @@ if (!process.features.openssl_is_boringssl) { pair: false }; } else { - common.printSkipMessage('Skipping unsupported AES-KW test case'); + common.printSkipMessage('Skipping unsupported ChaCha20-Poly1305 test case'); } if (hasOpenSSL(3)) { @@ -188,20 +189,15 @@ async function generateKeysToWrap() { usages: ['sign', 'verify'], pair: false, }, - ]; - - if (!process.features.openssl_is_boringssl) { - parameters.push({ + { algorithm: { name: 'AES-KW', length: 128 }, usages: ['wrapKey', 'unwrapKey'], pair: false, - }); - } else { - common.printSkipMessage('Skipping unsupported AES-KW test case'); - } + }, + ]; if (!process.features.openssl_is_boringssl) { parameters.push({ diff --git a/test/pummel/test-webcrypto-derivebits-pbkdf2.js b/test/pummel/test-webcrypto-derivebits-pbkdf2.js index cbe64bff77505c..bfb01ac0c94fe0 100644 --- a/test/pummel/test-webcrypto-derivebits-pbkdf2.js +++ b/test/pummel/test-webcrypto-derivebits-pbkdf2.js @@ -28,17 +28,10 @@ const kDerivedKeyTypes = [ ['HMAC', 256, 'SHA-256', 'sign', 'verify'], ['HMAC', 256, 'SHA-384', 'sign', 'verify'], ['HMAC', 256, 'SHA-512', 'sign', 'verify'], + ['AES-KW', 128, undefined, 'wrapKey', 'unwrapKey'], + ['AES-KW', 256, undefined, 'wrapKey', 'unwrapKey'], ]; -if (!process.features.openssl_is_boringssl) { - kDerivedKeyTypes.push( - ['AES-KW', 128, undefined, 'wrapKey', 'unwrapKey'], - ['AES-KW', 256, undefined, 'wrapKey', 'unwrapKey'], - ); -} else { - common.printSkipMessage('Skipping unsupported AES-KW test cases'); -} - const kPasswords = { short: '5040737377307264', long: '55736572732073686f756c64207069636b206c6f6' + diff --git a/test/wpt/status/WebCryptoAPI.cjs b/test/wpt/status/WebCryptoAPI.cjs index 93ec24557e2701..9e41793127aef5 100644 --- a/test/wpt/status/WebCryptoAPI.cjs +++ b/test/wpt/status/WebCryptoAPI.cjs @@ -68,11 +68,9 @@ if (process.features.openssl_is_boringssl) { 'digest/cshake.tentative.https.any.js', 'digest/sha3.tentative.https.any.js', 'encrypt_decrypt/chacha20_poly1305.tentative.https.any.js', - 'generateKey/failures_AES-KW.https.any.js', 'generateKey/failures_Ed448.tentative.https.any.js', 'generateKey/failures_X448.tentative.https.any.js', 'generateKey/failures_chacha20_poly1305.tentative.https.any.js', - 'generateKey/successes_AES-KW.https.any.js', 'generateKey/successes_Ed448.tentative.https.any.js', 'generateKey/successes_X448.tentative.https.any.js', 'generateKey/successes_chacha20_poly1305.tentative.https.any.js', @@ -84,11 +82,6 @@ if (process.features.openssl_is_boringssl) { 'sign_verify/eddsa_curve448.tentative.https.any.js'); skipSubtests( - ['derive_bits_keys/hkdf.https.any.js', /AES-KW/], - ['derive_bits_keys/pbkdf2.https.any.js', /AES-KW/], - ['import_export/raw_format_aliases.tentative.https.any.js', /AES-KW/], - ['import_export/symmetric_importKey.https.any.js', /AES-KW/], - ['supports.tentative.https.any.js', /AES-KW/], ['supports-modern.tentative.https.any.js', /ChaCha20-Poly1305/], ['supports-modern.tentative.https.any.js', /^supports returns true for algorithm objects with valid parameters$/]); } From be9f78f0dc8159e39d30cb1267e6ba1c2ac12d63 Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Wed, 22 Apr 2026 23:48:26 +0200 Subject: [PATCH 167/168] crypto: wire ChaCha20-Poly1305 in Web Cryptography when using BoringSSL Signed-off-by: Filip Skokan PR-URL: https://github.com/nodejs/node/pull/63255 Refs: https://github.com/electron/electron/issues/36256 Refs: https://github.com/electron/electron/issues/41720 Refs: https://github.com/electron/electron/pull/51127 Reviewed-By: James M Snell Reviewed-By: Yagiz Nizipli --- lib/internal/crypto/util.js | 2 +- src/crypto/crypto_chacha20_poly1305.cc | 78 +++++++++++++++++++ .../webcrypto/supports-modern-algorithms.mjs | 11 ++- .../test-crypto-key-objects-to-crypto-key.js | 7 +- ...-webcrypto-aead-decrypt-detached-buffer.js | 5 +- .../test-webcrypto-deduplicate-usages.js | 37 ++++----- ...rypto-encrypt-decrypt-chacha20-poly1305.js | 3 - test/parallel/test-webcrypto-keygen.js | 20 ++--- test/parallel/test-webcrypto-wrap-unwrap.js | 23 ++---- test/wpt/status/WebCryptoAPI.cjs | 7 -- 10 files changed, 115 insertions(+), 78 deletions(-) diff --git a/lib/internal/crypto/util.js b/lib/internal/crypto/util.js index 366d994fa4b2d7..663375b9e155d2 100644 --- a/lib/internal/crypto/util.js +++ b/lib/internal/crypto/util.js @@ -400,7 +400,7 @@ const conditionalAlgorithms = { 'Argon2d': !!Argon2Job, 'Argon2i': !!Argon2Job, 'Argon2id': !!Argon2Job, - 'ChaCha20-Poly1305': !process.features.openssl_is_boringssl || + 'ChaCha20-Poly1305': process.features.openssl_is_boringssl || ArrayPrototypeIncludes(getCiphers(), 'chacha20-poly1305'), 'cSHAKE128': !process.features.openssl_is_boringssl || ArrayPrototypeIncludes(getHashes(), 'shake128'), diff --git a/src/crypto/crypto_chacha20_poly1305.cc b/src/crypto/crypto_chacha20_poly1305.cc index 0fd3e0517317ca..43d63fa8c5e409 100644 --- a/src/crypto/crypto_chacha20_poly1305.cc +++ b/src/crypto/crypto_chacha20_poly1305.cc @@ -10,6 +10,9 @@ #include "v8.h" #include +#ifdef OPENSSL_IS_BORINGSSL +#include +#endif namespace node { @@ -110,10 +113,15 @@ Maybe ChaCha20Poly1305CipherTraits::AdditionalConfig( params->mode = mode; params->cipher = ncrypto::Cipher::CHACHA20_POLY1305; +#ifndef OPENSSL_IS_BORINGSSL + // On BoringSSL, ChaCha20-Poly1305 is not exposed via the EVP_CIPHER registry + // so FromNid() returns a null Cipher. We use EVP_AEAD directly in DoCipher + // instead. if (!params->cipher) { THROW_ERR_CRYPTO_UNKNOWN_CIPHER(env); return Nothing(); } +#endif // IV parameter (required) if (!ValidateIV(env, mode, args[offset], params)) { @@ -144,6 +152,75 @@ WebCryptoCipherStatus ChaCha20Poly1305CipherTraits::DoCipher( return WebCryptoCipherStatus::INVALID_KEY_TYPE; } +#ifdef OPENSSL_IS_BORINGSSL + // BoringSSL does not expose ChaCha20-Poly1305 via the EVP_CIPHER registry; + // it is only available through the EVP_AEAD API. Matches Chromium's + // WebCrypto ChaCha20-Poly1305 implementation. + const auto key_bytes = + reinterpret_cast(key_data.GetSymmetricKey()); + const auto ad_bytes = params.additional_data.data(); + const auto ad_len = params.additional_data.size(); + const auto iv_bytes = params.iv.data(); + const auto iv_len = params.iv.size(); + + bssl::ScopedEVP_AEAD_CTX ctx; + if (!EVP_AEAD_CTX_init(ctx.get(), + EVP_aead_chacha20_poly1305(), + key_bytes, + key_data.GetSymmetricKeySize(), + kChaCha20Poly1305TagSize, + nullptr)) { + return WebCryptoCipherStatus::FAILED; + } + + if (cipher_mode == kWebCryptoCipherEncrypt) { + size_t out_len = 0; + const size_t max_out_len = in.size() + kChaCha20Poly1305TagSize; + auto buf = DataPointer::Alloc(max_out_len); + if (!EVP_AEAD_CTX_seal(ctx.get(), + static_cast(buf.get()), + &out_len, + max_out_len, + iv_bytes, + iv_len, + in.data(), + in.size(), + ad_bytes, + ad_len)) { + return WebCryptoCipherStatus::FAILED; + } + buf = buf.resize(out_len); + *out = ByteSource::Allocated(buf.release()); + return WebCryptoCipherStatus::OK; + } + + // Decrypt + if (in.size() < kChaCha20Poly1305TagSize) { + return WebCryptoCipherStatus::FAILED; + } + size_t out_len = 0; + const size_t max_out_len = in.size(); // at most |in_len| bytes written + auto buf = DataPointer::Alloc(max_out_len == 0 ? 1 : max_out_len); + if (!EVP_AEAD_CTX_open(ctx.get(), + static_cast(buf.get()), + &out_len, + max_out_len, + iv_bytes, + iv_len, + in.data(), + in.size(), + ad_bytes, + ad_len)) { + return WebCryptoCipherStatus::FAILED; + } + if (out_len == 0) { + *out = ByteSource(); + } else { + buf = buf.resize(out_len); + *out = ByteSource::Allocated(buf.release()); + } + return WebCryptoCipherStatus::OK; +#else auto ctx = CipherCtxPointer::New(); CHECK(ctx); @@ -242,6 +319,7 @@ WebCryptoCipherStatus ChaCha20Poly1305CipherTraits::DoCipher( *out = ByteSource::Allocated(buf.release()); return WebCryptoCipherStatus::OK; +#endif // OPENSSL_IS_BORINGSSL } void ChaCha20Poly1305::Initialize(Environment* env, Local target) { diff --git a/test/fixtures/webcrypto/supports-modern-algorithms.mjs b/test/fixtures/webcrypto/supports-modern-algorithms.mjs index 0572107e9f492e..956a94b191d266 100644 --- a/test/fixtures/webcrypto/supports-modern-algorithms.mjs +++ b/test/fixtures/webcrypto/supports-modern-algorithms.mjs @@ -6,7 +6,6 @@ const pqc = hasOpenSSL(3, 5); const argon2 = hasOpenSSL(3, 2); const shake128 = crypto.getHashes().includes('shake128'); const shake256 = crypto.getHashes().includes('shake256'); -const chacha = crypto.getCiphers().includes('chacha20-poly1305'); const ocb = hasOpenSSL(3); const kmac = hasOpenSSL(3); const boringSSL = process.features.openssl_is_boringssl; @@ -78,7 +77,7 @@ export const vectors = { [pqc, 'ML-KEM-512'], [pqc, 'ML-KEM-768'], [pqc, 'ML-KEM-1024'], - [chacha, 'ChaCha20-Poly1305'], + [true, 'ChaCha20-Poly1305'], [ocb, { name: 'AES-OCB', length: 128 }], [false, 'Argon2d'], [false, 'Argon2i'], @@ -99,7 +98,7 @@ export const vectors = { [pqc, 'ML-KEM-512'], [pqc, 'ML-KEM-768'], [pqc, 'ML-KEM-1024'], - [chacha, 'ChaCha20-Poly1305'], + [true, 'ChaCha20-Poly1305'], [ocb, { name: 'AES-OCB', length: 128 }], [argon2, 'Argon2d'], [argon2, 'Argon2i'], @@ -120,7 +119,7 @@ export const vectors = { [pqc, 'ML-KEM-512'], [pqc, 'ML-KEM-768'], [pqc, 'ML-KEM-1024'], - [chacha, 'ChaCha20-Poly1305'], + [true, 'ChaCha20-Poly1305'], [ocb, 'AES-OCB'], [false, 'Argon2d'], [false, 'Argon2i'], @@ -186,9 +185,9 @@ export const vectors = { [false, { name: 'Argon2d', nonce: Buffer.alloc(8), parallelism: 16777215, memory: 8, passes: 1 }, 32], ], 'encrypt': [ - [chacha, { name: 'ChaCha20-Poly1305', iv: Buffer.alloc(12) }], + [true, { name: 'ChaCha20-Poly1305', iv: Buffer.alloc(12) }], [false, { name: 'ChaCha20-Poly1305', iv: Buffer.alloc(16) }], - [chacha, { name: 'ChaCha20-Poly1305', iv: Buffer.alloc(12), tagLength: 128 }], + [true, { name: 'ChaCha20-Poly1305', iv: Buffer.alloc(12), tagLength: 128 }], [false, { name: 'ChaCha20-Poly1305', iv: Buffer.alloc(12), tagLength: 64 }], [false, 'ChaCha20-Poly1305'], [ocb, { name: 'AES-OCB', iv: Buffer.alloc(15) }], diff --git a/test/parallel/test-crypto-key-objects-to-crypto-key.js b/test/parallel/test-crypto-key-objects-to-crypto-key.js index 6089a22c510892..e3bea9948708dd 100644 --- a/test/parallel/test-crypto-key-objects-to-crypto-key.js +++ b/test/parallel/test-crypto-key-objects-to-crypto-key.js @@ -26,15 +26,10 @@ function assertCryptoKey(cryptoKey, keyObject, algorithm, extractable, usages) { { for (const length of [128, 192, 256]) { const key = createSecretKey(randomBytes(length >> 3)); - let algorithms = ['AES-CTR', 'AES-CBC', 'AES-GCM', 'AES-KW']; + const algorithms = ['AES-CTR', 'AES-CBC', 'AES-GCM', 'AES-KW']; if (length === 256) algorithms.push('ChaCha20-Poly1305'); - if (process.features.openssl_is_boringssl) { - algorithms = algorithms.filter((a) => a !== 'ChaCha20-Poly1305'); - common.printSkipMessage('Skipping unsupported ChaCha20-Poly1305 test case'); - } - for (const algorithm of algorithms) { const usages = algorithm === 'AES-KW' ? ['wrapKey', 'unwrapKey'] : ['encrypt', 'decrypt']; for (const extractable of [true, false]) { diff --git a/test/parallel/test-webcrypto-aead-decrypt-detached-buffer.js b/test/parallel/test-webcrypto-aead-decrypt-detached-buffer.js index a96e709095430f..316d706e7b7948 100644 --- a/test/parallel/test-webcrypto-aead-decrypt-detached-buffer.js +++ b/test/parallel/test-webcrypto-aead-decrypt-detached-buffer.js @@ -29,14 +29,11 @@ async function test(algorithmName, keyLength, ivLength, format = 'raw') { const tests = [ test('AES-GCM', 32, 12), + test('ChaCha20-Poly1305', 32, 12, 'raw-secret'), ]; if (hasOpenSSL(3)) { tests.push(test('AES-OCB', 32, 12, 'raw-secret')); } -if (!process.features.openssl_is_boringssl) { - tests.push(test('ChaCha20-Poly1305', 32, 12, 'raw-secret')); -} - Promise.all(tests).then(common.mustCall()); diff --git a/test/parallel/test-webcrypto-deduplicate-usages.js b/test/parallel/test-webcrypto-deduplicate-usages.js index 6af5146e1b82ed..e9ce750a9487f1 100644 --- a/test/parallel/test-webcrypto-deduplicate-usages.js +++ b/test/parallel/test-webcrypto-deduplicate-usages.js @@ -45,6 +45,9 @@ function assertSameSet(actual, expected, msg) { { algorithm: { name: 'AES-KW', length: 128 }, usages: ['wrapKey', 'unwrapKey', 'wrapKey', 'unwrapKey'], expected: ['wrapKey', 'unwrapKey'] }, + { algorithm: { name: 'ChaCha20-Poly1305' }, + usages: ['wrapKey', 'decrypt', 'encrypt', 'unwrapKey', 'wrapKey', 'encrypt'], + expected: ['encrypt', 'decrypt', 'wrapKey', 'unwrapKey'] }, ]; if (hasOpenSSL(3)) { @@ -62,16 +65,6 @@ function assertSameSet(actual, expected, msg) { common.printSkipMessage('AES-OCB and KMAC require OpenSSL >= 3'); } - if (!process.features.openssl_is_boringssl) { - symmetric.push({ - algorithm: { name: 'ChaCha20-Poly1305' }, - usages: ['wrapKey', 'decrypt', 'encrypt', 'unwrapKey', 'wrapKey', 'encrypt'], - expected: ['encrypt', 'decrypt', 'wrapKey', 'unwrapKey'], - }); - } else { - common.printSkipMessage('ChaCha20-Poly1305 is not supported in BoringSSL'); - } - for (const { algorithm, usages, expected } of symmetric) { tests.push((async () => { const key = await subtle.generateKey(algorithm, true, usages); @@ -342,20 +335,16 @@ function assertSameSet(actual, expected, msg) { })()); // ChaCha20-Poly1305 raw-secret import. - if (!process.features.openssl_is_boringssl) { - tests.push((async () => { - const key = await subtle.importKey( - 'raw-secret', - new Uint8Array(32), - { name: 'ChaCha20-Poly1305' }, - true, - ['decrypt', 'encrypt', 'decrypt', 'encrypt']); - assertSameSet(key.usages, ['encrypt', 'decrypt']); - assert.strictEqual(key.usages.length, 2); - })()); - } else { - common.printSkipMessage('ChaCha20-Poly1305 is not supported in BoringSSL'); - } + tests.push((async () => { + const key = await subtle.importKey( + 'raw-secret', + new Uint8Array(32), + { name: 'ChaCha20-Poly1305' }, + true, + ['decrypt', 'encrypt', 'decrypt', 'encrypt']); + assertSameSet(key.usages, ['encrypt', 'decrypt']); + assert.strictEqual(key.usages.length, 2); + })()); // AES-OCB raw-secret import. if (hasOpenSSL(3)) { diff --git a/test/parallel/test-webcrypto-encrypt-decrypt-chacha20-poly1305.js b/test/parallel/test-webcrypto-encrypt-decrypt-chacha20-poly1305.js index 0f930a356712ed..723fd26ea5708b 100644 --- a/test/parallel/test-webcrypto-encrypt-decrypt-chacha20-poly1305.js +++ b/test/parallel/test-webcrypto-encrypt-decrypt-chacha20-poly1305.js @@ -5,9 +5,6 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); -if (process.features.openssl_is_boringssl) - common.skip('Skipping unsupported ChaCha20-Poly1305 test case'); - const assert = require('assert'); const { subtle } = globalThis.crypto; diff --git a/test/parallel/test-webcrypto-keygen.js b/test/parallel/test-webcrypto-keygen.js index 520f8a15b1f60e..323bb638c57d86 100644 --- a/test/parallel/test-webcrypto-keygen.js +++ b/test/parallel/test-webcrypto-keygen.js @@ -142,7 +142,16 @@ const vectors = { 'wrapKey', 'unwrapKey', ], - } + }, + 'ChaCha20-Poly1305': { + result: 'CryptoKey', + usages: [ + 'encrypt', + 'decrypt', + 'wrapKey', + 'unwrapKey', + ], + }, }; if (!process.features.openssl_is_boringssl) { @@ -160,15 +169,6 @@ if (!process.features.openssl_is_boringssl) { 'deriveBits', ], }; - vectors['ChaCha20-Poly1305'] = { - result: 'CryptoKey', - usages: [ - 'encrypt', - 'decrypt', - 'wrapKey', - 'unwrapKey', - ], - }; } else { common.printSkipMessage('Skipping unsupported test cases'); } diff --git a/test/parallel/test-webcrypto-wrap-unwrap.js b/test/parallel/test-webcrypto-wrap-unwrap.js index 8039eae1f764b3..a8450df571b47e 100644 --- a/test/parallel/test-webcrypto-wrap-unwrap.js +++ b/test/parallel/test-webcrypto-wrap-unwrap.js @@ -44,21 +44,15 @@ const kWrappingData = { wrap: { }, pair: false }, -}; - - -if (!process.features.openssl_is_boringssl) { - kWrappingData['ChaCha20-Poly1305'] = { + 'ChaCha20-Poly1305': { wrap: { iv: new Uint8Array(12), additionalData: new Uint8Array(16), tagLength: 128 }, pair: false - }; -} else { - common.printSkipMessage('Skipping unsupported ChaCha20-Poly1305 test case'); -} + } +}; if (hasOpenSSL(3)) { kWrappingData['AES-OCB'] = { @@ -197,19 +191,14 @@ async function generateKeysToWrap() { usages: ['wrapKey', 'unwrapKey'], pair: false, }, - ]; - - if (!process.features.openssl_is_boringssl) { - parameters.push({ + { algorithm: { name: 'ChaCha20-Poly1305' }, usages: ['encrypt', 'decrypt'], pair: false, - }); - } else { - common.printSkipMessage('Skipping unsupported ChaCha20-Poly1305 test case'); - } + }, + ]; if (hasOpenSSL(3, 5)) { for (const name of ['ML-DSA-44', 'ML-DSA-65', 'ML-DSA-87']) { diff --git a/test/wpt/status/WebCryptoAPI.cjs b/test/wpt/status/WebCryptoAPI.cjs index 9e41793127aef5..316652d0730626 100644 --- a/test/wpt/status/WebCryptoAPI.cjs +++ b/test/wpt/status/WebCryptoAPI.cjs @@ -67,23 +67,16 @@ if (process.features.openssl_is_boringssl) { 'derive_bits_keys/cfrg_curves_keys_curve448.tentative.https.any.js', 'digest/cshake.tentative.https.any.js', 'digest/sha3.tentative.https.any.js', - 'encrypt_decrypt/chacha20_poly1305.tentative.https.any.js', 'generateKey/failures_Ed448.tentative.https.any.js', 'generateKey/failures_X448.tentative.https.any.js', - 'generateKey/failures_chacha20_poly1305.tentative.https.any.js', 'generateKey/successes_Ed448.tentative.https.any.js', 'generateKey/successes_X448.tentative.https.any.js', - 'generateKey/successes_chacha20_poly1305.tentative.https.any.js', - 'import_export/ChaCha20-Poly1305_importKey.tentative.https.any.js', 'import_export/okp_importKey_Ed448.tentative.https.any.js', 'import_export/okp_importKey_failures_Ed448.tentative.https.any.js', 'import_export/okp_importKey_failures_X448.tentative.https.any.js', 'import_export/okp_importKey_X448.tentative.https.any.js', 'sign_verify/eddsa_curve448.tentative.https.any.js'); - skipSubtests( - ['supports-modern.tentative.https.any.js', /ChaCha20-Poly1305/], - ['supports-modern.tentative.https.any.js', /^supports returns true for algorithm objects with valid parameters$/]); } function assertNoOverlap(fileSkips, subtestSkips) { From 550f195277eebff9fa6ed940ae7ea4563d8b3f5c Mon Sep 17 00:00:00 2001 From: Filip Skokan Date: Fri, 8 May 2026 20:03:33 +0200 Subject: [PATCH 168/168] crypto: wire ML-DSA and ML-KEM for use when using BoringSSL Signed-off-by: Filip Skokan PR-URL: https://github.com/nodejs/node/pull/63255 Refs: https://github.com/electron/electron/issues/36256 Refs: https://github.com/electron/electron/issues/41720 Refs: https://github.com/electron/electron/pull/51127 Reviewed-By: James M Snell Reviewed-By: Yagiz Nizipli --- benchmark/crypto/create-keyobject.js | 2 + benchmark/crypto/kem.js | 3 + benchmark/crypto/oneshot-sign.js | 2 + benchmark/crypto/oneshot-verify.js | 2 + deps/ncrypto/ncrypto.cc | 155 ++++++--- deps/ncrypto/ncrypto.h | 32 +- lib/internal/crypto/webidl.js | 16 +- src/crypto/crypto_keys.cc | 314 ++++-------------- src/crypto/crypto_pqc.cc | 156 +++++++-- src/crypto/crypto_pqc.h | 9 + src/crypto/crypto_sig.cc | 29 +- src/crypto/crypto_util.cc | 2 +- test/fixtures/keys/Makefile | 16 + .../keys/ml_dsa_44_private_encrypted.der | Bin 0 -> 166 bytes .../keys/ml_dsa_44_private_encrypted.pem | 6 + .../keys/ml_kem_768_private_encrypted.der | Bin 0 -> 198 bytes .../keys/ml_kem_768_private_encrypted.pem | 7 + .../webcrypto/supports-modern-algorithms.mjs | 58 ++-- test/parallel/test-crypto-encap-decap.js | 20 +- test/parallel/test-crypto-key-objects-raw.js | 47 +-- .../test-crypto-key-objects-to-crypto-key.js | 2 +- test/parallel/test-crypto-keygen-raw.js | 16 +- .../test-crypto-pqc-encrypted-pkcs8.js | 134 ++++++++ .../test-crypto-pqc-key-objects-ml-dsa.js | 18 +- .../test-crypto-pqc-key-objects-ml-kem.js | 28 +- .../parallel/test-crypto-pqc-keygen-ml-dsa.js | 2 +- .../parallel/test-crypto-pqc-keygen-ml-kem.js | 17 +- .../test-crypto-pqc-sign-verify-ml-dsa.js | 25 +- .../test-webcrypto-deduplicate-usages.js | 12 +- .../test-webcrypto-encap-decap-ml-kem.js | 12 +- .../test-webcrypto-export-import-ml-dsa.js | 53 +-- .../test-webcrypto-export-import-ml-kem.js | 70 ++-- test/parallel/test-webcrypto-keygen.js | 14 +- ...-webcrypto-promise-prototype-pollution.mjs | 2 +- .../test-webcrypto-sign-verify-ml-dsa.js | 4 +- test/parallel/test-webcrypto-sign-verify.js | 2 +- test/parallel/test-webcrypto-wrap-unwrap.js | 2 +- test/wpt/status/WebCryptoAPI.cjs | 9 +- 38 files changed, 792 insertions(+), 506 deletions(-) create mode 100644 test/fixtures/keys/ml_dsa_44_private_encrypted.der create mode 100644 test/fixtures/keys/ml_dsa_44_private_encrypted.pem create mode 100644 test/fixtures/keys/ml_kem_768_private_encrypted.der create mode 100644 test/fixtures/keys/ml_kem_768_private_encrypted.pem create mode 100644 test/parallel/test-crypto-pqc-encrypted-pkcs8.js diff --git a/benchmark/crypto/create-keyobject.js b/benchmark/crypto/create-keyobject.js index 30f8213175df69..7cd6db2d567ad6 100644 --- a/benchmark/crypto/create-keyobject.js +++ b/benchmark/crypto/create-keyobject.js @@ -26,6 +26,8 @@ const keyFixtures = { if (hasOpenSSL(3, 5)) { keyFixtures['ml-dsa-44'] = readKeyPair('ml_dsa_44_public', 'ml_dsa_44_private'); +} else if (process.features.openssl_is_boringssl) { + keyFixtures['ml-dsa-44'] = readKeyPair('ml_dsa_44_public', 'ml_dsa_44_private_seed_only'); } const bench = common.createBenchmark(main, { diff --git a/benchmark/crypto/kem.js b/benchmark/crypto/kem.js index ffdcac6d7fcb0d..a544fc2124afe9 100644 --- a/benchmark/crypto/kem.js +++ b/benchmark/crypto/kem.js @@ -24,6 +24,9 @@ if (hasOpenSSL(3, 5)) { keyFixtures['ml-kem-512'] = readKeyPair('ml_kem_512_public', 'ml_kem_512_private'); keyFixtures['ml-kem-768'] = readKeyPair('ml_kem_768_public', 'ml_kem_768_private'); keyFixtures['ml-kem-1024'] = readKeyPair('ml_kem_1024_public', 'ml_kem_1024_private'); +} else if (process.features.openssl_is_boringssl) { + keyFixtures['ml-kem-768'] = readKeyPair('ml_kem_768_public', 'ml_kem_768_private_seed_only'); + keyFixtures['ml-kem-1024'] = readKeyPair('ml_kem_1024_public', 'ml_kem_1024_private_seed_only'); } if (hasOpenSSL(3, 2)) { keyFixtures['p-256'] = readKeyPair('ec_p256_public', 'ec_p256_private'); diff --git a/benchmark/crypto/oneshot-sign.js b/benchmark/crypto/oneshot-sign.js index d0abc7b5412e60..72e3726d9a5349 100644 --- a/benchmark/crypto/oneshot-sign.js +++ b/benchmark/crypto/oneshot-sign.js @@ -19,6 +19,8 @@ const keyFixtures = { if (hasOpenSSL(3, 5)) { keyFixtures['ml-dsa-44'] = readKey('ml_dsa_44_private'); +} else if (process.features.openssl_is_boringssl) { + keyFixtures['ml-dsa-44'] = readKey('ml_dsa_44_private_seed_only'); } const data = crypto.randomBytes(256); diff --git a/benchmark/crypto/oneshot-verify.js b/benchmark/crypto/oneshot-verify.js index c6a24f52126eb2..8b397b02dbf285 100644 --- a/benchmark/crypto/oneshot-verify.js +++ b/benchmark/crypto/oneshot-verify.js @@ -26,6 +26,8 @@ const keyFixtures = { if (hasOpenSSL(3, 5)) { keyFixtures['ml-dsa-44'] = readKeyPair('ml_dsa_44_public', 'ml_dsa_44_private'); +} else if (process.features.openssl_is_boringssl) { + keyFixtures['ml-dsa-44'] = readKeyPair('ml_dsa_44_public', 'ml_dsa_44_private_seed_only'); } const data = crypto.randomBytes(256); diff --git a/deps/ncrypto/ncrypto.cc b/deps/ncrypto/ncrypto.cc index e79706105e3d4e..38378b730aca66 100644 --- a/deps/ncrypto/ncrypto.cc +++ b/deps/ncrypto/ncrypto.cc @@ -34,9 +34,13 @@ constexpr static PQCMapping pqc_mappings[] = { {"ML-DSA-44", EVP_PKEY_ML_DSA_44}, {"ML-DSA-65", EVP_PKEY_ML_DSA_65}, {"ML-DSA-87", EVP_PKEY_ML_DSA_87}, - {"ML-KEM-512", EVP_PKEY_ML_KEM_512}, {"ML-KEM-768", EVP_PKEY_ML_KEM_768}, {"ML-KEM-1024", EVP_PKEY_ML_KEM_1024}, + +#if OPENSSL_WITH_PQC_ML_KEM_512 + {"ML-KEM-512", EVP_PKEY_ML_KEM_512}, +#endif +#if OPENSSL_WITH_PQC_SLH_DSA {"SLH-DSA-SHA2-128f", EVP_PKEY_SLH_DSA_SHA2_128F}, {"SLH-DSA-SHA2-128s", EVP_PKEY_SLH_DSA_SHA2_128S}, {"SLH-DSA-SHA2-192f", EVP_PKEY_SLH_DSA_SHA2_192F}, @@ -49,6 +53,7 @@ constexpr static PQCMapping pqc_mappings[] = { {"SLH-DSA-SHAKE-192s", EVP_PKEY_SLH_DSA_SHAKE_192S}, {"SLH-DSA-SHAKE-256f", EVP_PKEY_SLH_DSA_SHAKE_256F}, {"SLH-DSA-SHAKE-256s", EVP_PKEY_SLH_DSA_SHAKE_256S}, +#endif }; #endif @@ -2095,27 +2100,99 @@ EVPKeyPointer EVPKeyPointer::NewRawPrivate( } #if OPENSSL_WITH_PQC -EVPKeyPointer EVPKeyPointer::NewRawSeed( - int id, const Buffer& data) { - if (id == 0) return {}; +namespace { +constexpr size_t kPqcMlDsaSeedSize = 32; +constexpr size_t kPqcMlKemSeedSize = 64; + +size_t GetPqcSeedSize(int id) { + switch (id) { + case EVP_PKEY_ML_DSA_44: + case EVP_PKEY_ML_DSA_65: + case EVP_PKEY_ML_DSA_87: + return kPqcMlDsaSeedSize; +#if OPENSSL_WITH_PQC_ML_KEM_512 + case EVP_PKEY_ML_KEM_512: +#endif + case EVP_PKEY_ML_KEM_768: + case EVP_PKEY_ML_KEM_1024: + return kPqcMlKemSeedSize; + default: + unreachable(); + } +} + +#if OPENSSL_WITH_BORINGSSL_PQC +const EVP_PKEY_ALG* GetPqcSeedAlg(int id) { + switch (id) { + case EVP_PKEY_ML_DSA_44: + return EVP_pkey_ml_dsa_44(); + case EVP_PKEY_ML_DSA_65: + return EVP_pkey_ml_dsa_65(); + case EVP_PKEY_ML_DSA_87: + return EVP_pkey_ml_dsa_87(); + case EVP_PKEY_ML_KEM_768: + return EVP_pkey_ml_kem_768(); + case EVP_PKEY_ML_KEM_1024: + return EVP_pkey_ml_kem_1024(); + default: + unreachable(); + } +} +#else +const char* GetPqcSeedParamName(int id) { + switch (id) { + case EVP_PKEY_ML_DSA_44: + case EVP_PKEY_ML_DSA_65: + case EVP_PKEY_ML_DSA_87: + return OSSL_PKEY_PARAM_ML_DSA_SEED; + case EVP_PKEY_ML_KEM_512: + case EVP_PKEY_ML_KEM_768: + case EVP_PKEY_ML_KEM_1024: + return OSSL_PKEY_PARAM_ML_KEM_SEED; + default: + unreachable(); + } +} +#endif +EVPKeyPointer NewPqcKeyFromSeed(int id, + const Buffer& data) { +#if OPENSSL_WITH_BORINGSSL_PQC + return EVPKeyPointer( + EVP_PKEY_from_private_seed(GetPqcSeedAlg(id), data.data, data.len)); +#else OSSL_PARAM params[] = { - OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_ML_DSA_SEED, + OSSL_PARAM_construct_octet_string(GetPqcSeedParamName(id), const_cast(data.data), data.len), OSSL_PARAM_END}; - EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new_id(id, nullptr); - if (ctx == nullptr) return {}; + auto ctx = EVPKeyCtxPointer::NewFromID(id); + if (!ctx) return {}; EVP_PKEY* pkey = nullptr; - if (ctx == nullptr || EVP_PKEY_fromdata_init(ctx) <= 0 || - EVP_PKEY_fromdata(ctx, &pkey, EVP_PKEY_KEYPAIR, params) <= 0) { - EVP_PKEY_CTX_free(ctx); + if (EVP_PKEY_fromdata_init(ctx.get()) <= 0 || + EVP_PKEY_fromdata(ctx.get(), &pkey, EVP_PKEY_KEYPAIR, params) <= 0) { return {}; } - return EVPKeyPointer(pkey); +#endif +} + +bool GetPqcSeed(EVP_PKEY* pkey, int id, const Buffer& out) { + size_t len = out.len; +#if OPENSSL_WITH_BORINGSSL_PQC + return EVP_PKEY_get_private_seed(pkey, out.data, &len) == 1; +#else + return EVP_PKEY_get_octet_string_param( + pkey, GetPqcSeedParamName(id), out.data, out.len, &len) == 1; +#endif +} +} // namespace + +EVPKeyPointer EVPKeyPointer::NewRawSeed( + int id, const Buffer& data) { + return NewPqcKeyFromSeed(id, data); } #endif @@ -2165,7 +2242,7 @@ EVP_PKEY* EVPKeyPointer::release() { int EVPKeyPointer::id(const EVP_PKEY* key) { if (key == nullptr) return 0; int type = EVP_PKEY_id(key); -#if OPENSSL_WITH_PQC +#if OPENSSL_WITH_OPENSSL_PQC // EVP_PKEY_id returns -1 when EVP_PKEY_* is only implemented in a provider // which is the case for all post-quantum NIST algorithms // one suggested way would be to use a chain of `EVP_PKEY_is_a` @@ -2243,34 +2320,11 @@ DataPointer EVPKeyPointer::rawPublicKey() const { DataPointer EVPKeyPointer::rawSeed() const { if (!pkey_) return {}; - // Determine seed length and parameter name based on key type - size_t seed_len; - const char* param_name; - - switch (id()) { - case EVP_PKEY_ML_DSA_44: - case EVP_PKEY_ML_DSA_65: - case EVP_PKEY_ML_DSA_87: - seed_len = 32; // ML-DSA uses 32-byte seeds - param_name = OSSL_PKEY_PARAM_ML_DSA_SEED; - break; - case EVP_PKEY_ML_KEM_512: - case EVP_PKEY_ML_KEM_768: - case EVP_PKEY_ML_KEM_1024: - seed_len = 64; // ML-KEM uses 64-byte seeds - param_name = OSSL_PKEY_PARAM_ML_KEM_SEED; - break; - default: - unreachable(); - } + const size_t seed_len = GetPqcSeedSize(id()); if (auto data = DataPointer::Alloc(seed_len)) { const Buffer buf = data; - size_t len = data.size(); - - if (EVP_PKEY_get_octet_string_param( - get(), param_name, buf.data, len, &seed_len) != 1) - return {}; + if (!GetPqcSeed(get(), id(), buf)) return {}; return data; } return {}; @@ -2312,6 +2366,7 @@ EVPKeyPointer::operator const EC_KEY*() const { } namespace { + EVPKeyPointer::ParseKeyResult TryParsePublicKeyInner(const BIOPointer& bp, const char* name, auto&& parse) { @@ -2739,6 +2794,7 @@ bool EVPKeyPointer::isOneShotVariant() const { case EVP_PKEY_ML_DSA_44: case EVP_PKEY_ML_DSA_65: case EVP_PKEY_ML_DSA_87: +#if OPENSSL_WITH_PQC_SLH_DSA case EVP_PKEY_SLH_DSA_SHA2_128F: case EVP_PKEY_SLH_DSA_SHA2_128S: case EVP_PKEY_SLH_DSA_SHA2_192F: @@ -2751,6 +2807,7 @@ bool EVPKeyPointer::isOneShotVariant() const { case EVP_PKEY_SLH_DSA_SHAKE_192S: case EVP_PKEY_SLH_DSA_SHAKE_256F: case EVP_PKEY_SLH_DSA_SHAKE_256S: +#endif #endif return true; default: @@ -4401,7 +4458,17 @@ std::optional EVPMDCtxPointer::signInitWithContext( const EVPKeyPointer& key, const Digest& digest, const Buffer& context_string) { -#ifdef OSSL_SIGNATURE_PARAM_CONTEXT_STRING +#ifdef OPENSSL_IS_BORINGSSL + EVP_PKEY_CTX* ctx = nullptr; + if (!EVP_DigestSignInit(ctx_.get(), &ctx, digest, nullptr, key.get())) { + return std::nullopt; + } + if (EVP_PKEY_CTX_set1_signature_context_string( + ctx, context_string.data, context_string.len) <= 0) { + return std::nullopt; + } + return ctx; +#elif defined(OSSL_SIGNATURE_PARAM_CONTEXT_STRING) EVP_PKEY_CTX* ctx = nullptr; #ifdef OSSL_SIGNATURE_PARAM_INSTANCE @@ -4446,7 +4513,17 @@ std::optional EVPMDCtxPointer::verifyInitWithContext( const EVPKeyPointer& key, const Digest& digest, const Buffer& context_string) { -#ifdef OSSL_SIGNATURE_PARAM_CONTEXT_STRING +#ifdef OPENSSL_IS_BORINGSSL + EVP_PKEY_CTX* ctx = nullptr; + if (!EVP_DigestVerifyInit(ctx_.get(), &ctx, digest, nullptr, key.get())) { + return std::nullopt; + } + if (EVP_PKEY_CTX_set1_signature_context_string( + ctx, context_string.data, context_string.len) <= 0) { + return std::nullopt; + } + return ctx; +#elif defined(OSSL_SIGNATURE_PARAM_CONTEXT_STRING) EVP_PKEY_CTX* ctx = nullptr; #ifdef OSSL_SIGNATURE_PARAM_INSTANCE diff --git a/deps/ncrypto/ncrypto.h b/deps/ncrypto/ncrypto.h index 7f9612c01a56ee..b27e2e76c3dcfc 100644 --- a/deps/ncrypto/ncrypto.h +++ b/deps/ncrypto/ncrypto.h @@ -58,7 +58,7 @@ #define OPENSSL_WITH_ARGON2 0 #endif -#if OPENSSL_VERSION_PREREQ(3, 0) +#if OPENSSL_VERSION_PREREQ(3, 0) || defined(OPENSSL_IS_BORINGSSL) #define OPENSSL_WITH_KEM 1 #else #define OPENSSL_WITH_KEM 0 @@ -70,7 +70,7 @@ #define OPENSSL_WITH_KMAC 0 #endif -#if OPENSSL_VERSION_PREREQ(3, 2) +#if defined(OPENSSL_IS_BORINGSSL) || OPENSSL_VERSION_PREREQ(3, 2) #define OPENSSL_WITH_SIGNATURE_CONTEXT_STRING 1 #else #define OPENSSL_WITH_SIGNATURE_CONTEXT_STRING 0 @@ -82,24 +82,40 @@ #define OPENSSL_WITH_OPENSSL_DHKEM 0 #endif -#if OPENSSL_WITH_KEM && !OPENSSL_VERSION_PREREQ(3, 5) +#if OPENSSL_WITH_KEM && !defined(OPENSSL_IS_BORINGSSL) && \ + !OPENSSL_VERSION_PREREQ(3, 5) #define OPENSSL_WITH_KEM_OPERATION_PARAM 1 #else #define OPENSSL_WITH_KEM_OPERATION_PARAM 0 #endif -// Define OPENSSL_WITH_PQC for post-quantum cryptography support. -#if OPENSSL_VERSION_PREREQ(3, 5) -#define OPENSSL_WITH_PQC 1 +// Post-quantum cryptography support. Keep these explicit so code can +// distinguish provider API shape from the available algorithm set. +#if !defined(OPENSSL_IS_BORINGSSL) && OPENSSL_VERSION_PREREQ(3, 5) +#define OPENSSL_WITH_OPENSSL_PQC 1 #else -#define OPENSSL_WITH_PQC 0 +#define OPENSSL_WITH_OPENSSL_PQC 0 #endif -#if OPENSSL_WITH_PQC +#ifdef OPENSSL_IS_BORINGSSL +#define OPENSSL_WITH_BORINGSSL_PQC 1 +#else +#define OPENSSL_WITH_BORINGSSL_PQC 0 +#endif + +#define OPENSSL_WITH_PQC \ + (OPENSSL_WITH_OPENSSL_PQC || OPENSSL_WITH_BORINGSSL_PQC) +#define OPENSSL_WITH_PQC_ML_KEM_512 OPENSSL_WITH_OPENSSL_PQC +#define OPENSSL_WITH_PQC_SLH_DSA OPENSSL_WITH_OPENSSL_PQC + +#if OPENSSL_WITH_OPENSSL_PQC #define EVP_PKEY_ML_KEM_512 NID_ML_KEM_512 #define EVP_PKEY_ML_KEM_768 NID_ML_KEM_768 #define EVP_PKEY_ML_KEM_1024 NID_ML_KEM_1024 #include +#elif OPENSSL_WITH_BORINGSSL_PQC +#define EVP_PKEY_ML_KEM_768 NID_ML_KEM_768 +#define EVP_PKEY_ML_KEM_1024 NID_ML_KEM_1024 #endif #if OPENSSL_VERSION_PREREQ(3, 0) diff --git a/lib/internal/crypto/webidl.js b/lib/internal/crypto/webidl.js index 18bea7df03880d..cca3a5fb044d92 100644 --- a/lib/internal/crypto/webidl.js +++ b/lib/internal/crypto/webidl.js @@ -588,14 +588,18 @@ converters.ContextParams = createDictionaryConverter( key: 'context', converter: converters.BufferSource, validator(V, dict) { - let { 0: major, 1: minor } = process.versions.openssl.split('.'); - major = NumberParseInt(major, 10); - minor = NumberParseInt(minor, 10); - if (major > 3 || (major === 3 && minor >= 2)) { + if (process.features.openssl_is_boringssl) { this.validator = undefined; } else { - this.validator = validateZeroLength('ContextParams.context'); - this.validator(V, dict); + let { 0: major, 1: minor } = process.versions.openssl.split('.'); + major = NumberParseInt(major, 10); + minor = NumberParseInt(minor, 10); + if (major > 3 || (major === 3 && minor >= 2)) { + this.validator = undefined; + } else { + this.validator = validateZeroLength('ContextParams.context'); + this.validator(V, dict); + } } }, }, diff --git a/src/crypto/crypto_keys.cc b/src/crypto/crypto_keys.cc index 0ca1d536c16582..aac059696596e4 100644 --- a/src/crypto/crypto_keys.cc +++ b/src/crypto/crypto_keys.cc @@ -177,7 +177,11 @@ bool ExportJWKAsymmetricKey(Environment* env, const KeyObjectData& key, Local target, bool handleRsaPss) { - switch (key.GetAsymmetricKey().id()) { + const int id = key.GetAsymmetricKey().id(); +#if OPENSSL_WITH_PQC + if (IsPqcKeyId(id)) return ExportJwkPqcKey(env, key, target); +#endif + switch (id) { case EVP_PKEY_RSA_PSS: { if (handleRsaPss) return ExportJWKRsaKey(env, key, target); break; @@ -187,51 +191,10 @@ bool ExportJWKAsymmetricKey(Environment* env, case EVP_PKEY_EC: return ExportJWKEcKey(env, key, target); case EVP_PKEY_ED25519: - // Fall through case EVP_PKEY_ED448: - // Fall through case EVP_PKEY_X25519: - // Fall through case EVP_PKEY_X448: return ExportJWKEdKey(env, key, target); -#if OPENSSL_WITH_PQC - case EVP_PKEY_ML_DSA_44: - // Fall through - case EVP_PKEY_ML_DSA_65: - // Fall through - case EVP_PKEY_ML_DSA_87: - // Fall through - case EVP_PKEY_SLH_DSA_SHA2_128F: - // Fall through - case EVP_PKEY_SLH_DSA_SHA2_128S: - // Fall through - case EVP_PKEY_SLH_DSA_SHA2_192F: - // Fall through - case EVP_PKEY_SLH_DSA_SHA2_192S: - // Fall through - case EVP_PKEY_SLH_DSA_SHA2_256F: - // Fall through - case EVP_PKEY_SLH_DSA_SHA2_256S: - // Fall through - case EVP_PKEY_SLH_DSA_SHAKE_128F: - // Fall through - case EVP_PKEY_SLH_DSA_SHAKE_128S: - // Fall through - case EVP_PKEY_SLH_DSA_SHAKE_192F: - // Fall through - case EVP_PKEY_SLH_DSA_SHAKE_192S: - // Fall through - case EVP_PKEY_SLH_DSA_SHAKE_256F: - // Fall through - case EVP_PKEY_SLH_DSA_SHAKE_256S: - // Fall through - case EVP_PKEY_ML_KEM_512: - // Fall through - case EVP_PKEY_ML_KEM_768: - // Fall through - case EVP_PKEY_ML_KEM_1024: - return ExportJwkPqcKey(env, key, target); -#endif } THROW_ERR_CRYPTO_JWK_UNSUPPORTED_KEY_TYPE(env); return false; @@ -306,35 +269,19 @@ int GetNidFromName(const char* name) { const char* name; int nid; } kNameToNid[] = { - {"Ed25519", EVP_PKEY_ED25519}, - {"Ed448", EVP_PKEY_ED448}, - {"X25519", EVP_PKEY_X25519}, - {"X448", EVP_PKEY_X448}, -#if OPENSSL_WITH_PQC - {"ML-DSA-44", EVP_PKEY_ML_DSA_44}, - {"ML-DSA-65", EVP_PKEY_ML_DSA_65}, - {"ML-DSA-87", EVP_PKEY_ML_DSA_87}, - {"ML-KEM-512", EVP_PKEY_ML_KEM_512}, - {"ML-KEM-768", EVP_PKEY_ML_KEM_768}, - {"ML-KEM-1024", EVP_PKEY_ML_KEM_1024}, - {"SLH-DSA-SHA2-128f", EVP_PKEY_SLH_DSA_SHA2_128F}, - {"SLH-DSA-SHA2-128s", EVP_PKEY_SLH_DSA_SHA2_128S}, - {"SLH-DSA-SHA2-192f", EVP_PKEY_SLH_DSA_SHA2_192F}, - {"SLH-DSA-SHA2-192s", EVP_PKEY_SLH_DSA_SHA2_192S}, - {"SLH-DSA-SHA2-256f", EVP_PKEY_SLH_DSA_SHA2_256F}, - {"SLH-DSA-SHA2-256s", EVP_PKEY_SLH_DSA_SHA2_256S}, - {"SLH-DSA-SHAKE-128f", EVP_PKEY_SLH_DSA_SHAKE_128F}, - {"SLH-DSA-SHAKE-128s", EVP_PKEY_SLH_DSA_SHAKE_128S}, - {"SLH-DSA-SHAKE-192f", EVP_PKEY_SLH_DSA_SHAKE_192F}, - {"SLH-DSA-SHAKE-192s", EVP_PKEY_SLH_DSA_SHAKE_192S}, - {"SLH-DSA-SHAKE-256f", EVP_PKEY_SLH_DSA_SHAKE_256F}, - {"SLH-DSA-SHAKE-256s", EVP_PKEY_SLH_DSA_SHAKE_256S}, -#endif + {"Ed25519", EVP_PKEY_ED25519}, + {"Ed448", EVP_PKEY_ED448}, + {"X25519", EVP_PKEY_X25519}, + {"X448", EVP_PKEY_X448}, }; for (const auto& entry : kNameToNid) { if (StringEqualNoCase(name, entry.name)) return entry.nid; } +#if OPENSSL_WITH_PQC + return GetPqcNidFromName(name); +#else return NID_undef; +#endif } bool IsUnavailablePqcKeyType(Environment* env, Local key_type) { @@ -442,35 +389,15 @@ bool KeyObjectData::ToEncodedPublicKey( const auto point = ECKeyPointer::GetPublicKey(ec_key); return ECPointToBuffer(env, group, point, form).ToLocal(out); } - switch (pkey.id()) { - case EVP_PKEY_ED25519: - case EVP_PKEY_ED448: - case EVP_PKEY_X25519: - case EVP_PKEY_X448: + const int id = pkey.id(); + bool is_raw_supported = id == EVP_PKEY_ED25519 || id == EVP_PKEY_ED448 || + id == EVP_PKEY_X25519 || id == EVP_PKEY_X448; #if OPENSSL_WITH_PQC - case EVP_PKEY_ML_DSA_44: - case EVP_PKEY_ML_DSA_65: - case EVP_PKEY_ML_DSA_87: - case EVP_PKEY_ML_KEM_512: - case EVP_PKEY_ML_KEM_768: - case EVP_PKEY_ML_KEM_1024: - case EVP_PKEY_SLH_DSA_SHA2_128F: - case EVP_PKEY_SLH_DSA_SHA2_128S: - case EVP_PKEY_SLH_DSA_SHA2_192F: - case EVP_PKEY_SLH_DSA_SHA2_192S: - case EVP_PKEY_SLH_DSA_SHA2_256F: - case EVP_PKEY_SLH_DSA_SHA2_256S: - case EVP_PKEY_SLH_DSA_SHAKE_128F: - case EVP_PKEY_SLH_DSA_SHAKE_128S: - case EVP_PKEY_SLH_DSA_SHAKE_192F: - case EVP_PKEY_SLH_DSA_SHAKE_192S: - case EVP_PKEY_SLH_DSA_SHAKE_256F: - case EVP_PKEY_SLH_DSA_SHAKE_256S: + is_raw_supported = is_raw_supported || IsPqcKeyId(id); #endif - break; - default: - THROW_ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS(env); - return false; + if (!is_raw_supported) { + THROW_ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS(env); + return false; } auto raw_data = pkey.rawPublicKey(); if (!raw_data) { @@ -517,29 +444,15 @@ bool KeyObjectData::ToEncodedPrivateKey( } return Buffer::Copy(env, buf.get(), buf.size()).ToLocal(out); } - switch (pkey.id()) { - case EVP_PKEY_ED25519: - case EVP_PKEY_ED448: - case EVP_PKEY_X25519: - case EVP_PKEY_X448: + const int id = pkey.id(); + bool is_raw_supported = id == EVP_PKEY_ED25519 || id == EVP_PKEY_ED448 || + id == EVP_PKEY_X25519 || id == EVP_PKEY_X448; #if OPENSSL_WITH_PQC - case EVP_PKEY_SLH_DSA_SHA2_128F: - case EVP_PKEY_SLH_DSA_SHA2_128S: - case EVP_PKEY_SLH_DSA_SHA2_192F: - case EVP_PKEY_SLH_DSA_SHA2_192S: - case EVP_PKEY_SLH_DSA_SHA2_256F: - case EVP_PKEY_SLH_DSA_SHA2_256S: - case EVP_PKEY_SLH_DSA_SHAKE_128F: - case EVP_PKEY_SLH_DSA_SHAKE_128S: - case EVP_PKEY_SLH_DSA_SHAKE_192F: - case EVP_PKEY_SLH_DSA_SHAKE_192S: - case EVP_PKEY_SLH_DSA_SHAKE_256F: - case EVP_PKEY_SLH_DSA_SHAKE_256S: + is_raw_supported = is_raw_supported || IsPqcRawPrivateKeyId(id); #endif - break; - default: - THROW_ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS(env); - return false; + if (!is_raw_supported) { + THROW_ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS(env); + return false; } auto raw_data = pkey.rawPrivateKey(); if (!raw_data) { @@ -549,23 +462,13 @@ bool KeyObjectData::ToEncodedPrivateKey( return Buffer::Copy(env, raw_data.get(), raw_data.size()) .ToLocal(out); } else if (config.format == EVPKeyPointer::PKFormatType::RAW_SEED) { +#if OPENSSL_WITH_PQC Mutex::ScopedLock lock(mutex()); const auto& pkey = GetAsymmetricKey(); - switch (pkey.id()) { -#if OPENSSL_WITH_PQC - case EVP_PKEY_ML_DSA_44: - case EVP_PKEY_ML_DSA_65: - case EVP_PKEY_ML_DSA_87: - case EVP_PKEY_ML_KEM_512: - case EVP_PKEY_ML_KEM_768: - case EVP_PKEY_ML_KEM_1024: - break; -#endif - default: - THROW_ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS(env); - return false; + if (!IsPqcSeedKeyId(pkey.id())) { + THROW_ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS(env); + return false; } -#if OPENSSL_WITH_PQC auto raw_data = pkey.rawSeed(); if (!raw_data) { THROW_ERR_CRYPTO_OPERATION_FAILED(env, "Failed to get raw seed"); @@ -738,33 +641,17 @@ static KeyObjectData ImportRawKey(Environment* env, fn = target_type == kKeyTypePrivate ? EVPKeyPointer::NewRawPrivate : EVPKeyPointer::NewRawPublic; break; + default: #if OPENSSL_WITH_PQC - case EVP_PKEY_ML_DSA_44: - case EVP_PKEY_ML_DSA_65: - case EVP_PKEY_ML_DSA_87: - case EVP_PKEY_ML_KEM_512: - case EVP_PKEY_ML_KEM_768: - case EVP_PKEY_ML_KEM_1024: - fn = target_type == kKeyTypePrivate ? EVPKeyPointer::NewRawSeed - : EVPKeyPointer::NewRawPublic; - break; - case EVP_PKEY_SLH_DSA_SHA2_128F: - case EVP_PKEY_SLH_DSA_SHA2_128S: - case EVP_PKEY_SLH_DSA_SHA2_192F: - case EVP_PKEY_SLH_DSA_SHA2_192S: - case EVP_PKEY_SLH_DSA_SHA2_256F: - case EVP_PKEY_SLH_DSA_SHA2_256S: - case EVP_PKEY_SLH_DSA_SHAKE_128F: - case EVP_PKEY_SLH_DSA_SHAKE_128S: - case EVP_PKEY_SLH_DSA_SHAKE_192F: - case EVP_PKEY_SLH_DSA_SHAKE_192S: - case EVP_PKEY_SLH_DSA_SHAKE_256F: - case EVP_PKEY_SLH_DSA_SHAKE_256S: - fn = target_type == kKeyTypePrivate ? EVPKeyPointer::NewRawPrivate - : EVPKeyPointer::NewRawPublic; - break; + if (IsPqcKeyId(id)) { + if (target_type == kKeyTypePrivate) { + fn = IsPqcSeedKeyId(id) ? EVPKeyPointer::NewRawSeed + : EVPKeyPointer::NewRawPrivate; + } else { + fn = EVPKeyPointer::NewRawPublic; + } + } #endif - default: break; } @@ -1377,45 +1264,12 @@ Local KeyObjectHandle::GetAsymmetricKeyType() const { case EVP_PKEY_X448: return env()->crypto_x448_string(); #if OPENSSL_WITH_PQC - case EVP_PKEY_ML_DSA_44: - return env()->crypto_ml_dsa_44_string(); - case EVP_PKEY_ML_DSA_65: - return env()->crypto_ml_dsa_65_string(); - case EVP_PKEY_ML_DSA_87: - return env()->crypto_ml_dsa_87_string(); - case EVP_PKEY_ML_KEM_512: - return env()->crypto_ml_kem_512_string(); - case EVP_PKEY_ML_KEM_768: - return env()->crypto_ml_kem_768_string(); - case EVP_PKEY_ML_KEM_1024: - return env()->crypto_ml_kem_1024_string(); - case EVP_PKEY_SLH_DSA_SHA2_128F: - return env()->crypto_slh_dsa_sha2_128f_string(); - case EVP_PKEY_SLH_DSA_SHA2_128S: - return env()->crypto_slh_dsa_sha2_128s_string(); - case EVP_PKEY_SLH_DSA_SHA2_192F: - return env()->crypto_slh_dsa_sha2_192f_string(); - case EVP_PKEY_SLH_DSA_SHA2_192S: - return env()->crypto_slh_dsa_sha2_192s_string(); - case EVP_PKEY_SLH_DSA_SHA2_256F: - return env()->crypto_slh_dsa_sha2_256f_string(); - case EVP_PKEY_SLH_DSA_SHA2_256S: - return env()->crypto_slh_dsa_sha2_256s_string(); - case EVP_PKEY_SLH_DSA_SHAKE_128F: - return env()->crypto_slh_dsa_shake_128f_string(); - case EVP_PKEY_SLH_DSA_SHAKE_128S: - return env()->crypto_slh_dsa_shake_128s_string(); - case EVP_PKEY_SLH_DSA_SHAKE_192F: - return env()->crypto_slh_dsa_shake_192f_string(); - case EVP_PKEY_SLH_DSA_SHAKE_192S: - return env()->crypto_slh_dsa_shake_192s_string(); - case EVP_PKEY_SLH_DSA_SHAKE_256F: - return env()->crypto_slh_dsa_shake_256f_string(); - case EVP_PKEY_SLH_DSA_SHAKE_256S: - return env()->crypto_slh_dsa_shake_256s_string(); -#endif + default: + return GetPqcAsymmetricKeyType(env(), data_.GetAsymmetricKey().id()); +#else default: return Undefined(env()->isolate()); +#endif } } @@ -1524,34 +1378,14 @@ void KeyObjectHandle::RawPublicKey( Mutex::ScopedLock lock(data.mutex()); const auto& pkey = data.GetAsymmetricKey(); - switch (pkey.id()) { - case EVP_PKEY_ED25519: - case EVP_PKEY_ED448: - case EVP_PKEY_X25519: - case EVP_PKEY_X448: + const int id = pkey.id(); + bool is_raw_supported = id == EVP_PKEY_ED25519 || id == EVP_PKEY_ED448 || + id == EVP_PKEY_X25519 || id == EVP_PKEY_X448; #if OPENSSL_WITH_PQC - case EVP_PKEY_ML_DSA_44: - case EVP_PKEY_ML_DSA_65: - case EVP_PKEY_ML_DSA_87: - case EVP_PKEY_ML_KEM_512: - case EVP_PKEY_ML_KEM_768: - case EVP_PKEY_ML_KEM_1024: - case EVP_PKEY_SLH_DSA_SHA2_128F: - case EVP_PKEY_SLH_DSA_SHA2_128S: - case EVP_PKEY_SLH_DSA_SHA2_192F: - case EVP_PKEY_SLH_DSA_SHA2_192S: - case EVP_PKEY_SLH_DSA_SHA2_256F: - case EVP_PKEY_SLH_DSA_SHA2_256S: - case EVP_PKEY_SLH_DSA_SHAKE_128F: - case EVP_PKEY_SLH_DSA_SHAKE_128S: - case EVP_PKEY_SLH_DSA_SHAKE_192F: - case EVP_PKEY_SLH_DSA_SHAKE_192S: - case EVP_PKEY_SLH_DSA_SHAKE_256F: - case EVP_PKEY_SLH_DSA_SHAKE_256S: + is_raw_supported = is_raw_supported || IsPqcKeyId(id); #endif - break; - default: - return THROW_ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS(env); + if (!is_raw_supported) { + return THROW_ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS(env); } auto raw_data = pkey.rawPublicKey(); @@ -1577,28 +1411,14 @@ void KeyObjectHandle::RawPrivateKey( Mutex::ScopedLock lock(data.mutex()); const auto& pkey = data.GetAsymmetricKey(); - switch (pkey.id()) { - case EVP_PKEY_ED25519: - case EVP_PKEY_ED448: - case EVP_PKEY_X25519: - case EVP_PKEY_X448: + const int id = pkey.id(); + bool is_raw_supported = id == EVP_PKEY_ED25519 || id == EVP_PKEY_ED448 || + id == EVP_PKEY_X25519 || id == EVP_PKEY_X448; #if OPENSSL_WITH_PQC - case EVP_PKEY_SLH_DSA_SHA2_128F: - case EVP_PKEY_SLH_DSA_SHA2_128S: - case EVP_PKEY_SLH_DSA_SHA2_192F: - case EVP_PKEY_SLH_DSA_SHA2_192S: - case EVP_PKEY_SLH_DSA_SHA2_256F: - case EVP_PKEY_SLH_DSA_SHA2_256S: - case EVP_PKEY_SLH_DSA_SHAKE_128F: - case EVP_PKEY_SLH_DSA_SHAKE_128S: - case EVP_PKEY_SLH_DSA_SHAKE_192F: - case EVP_PKEY_SLH_DSA_SHAKE_192S: - case EVP_PKEY_SLH_DSA_SHAKE_256F: - case EVP_PKEY_SLH_DSA_SHAKE_256S: + is_raw_supported = is_raw_supported || IsPqcRawPrivateKeyId(id); #endif - break; - default: - return THROW_ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS(env); + if (!is_raw_supported) { + return THROW_ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS(env); } auto raw_data = pkey.rawPrivateKey(); @@ -1687,24 +1507,14 @@ void KeyObjectHandle::RawSeed(const v8::FunctionCallbackInfo& args) { const KeyObjectData& data = key->Data(); CHECK_EQ(data.GetKeyType(), kKeyTypePrivate); +#if OPENSSL_WITH_PQC Mutex::ScopedLock lock(data.mutex()); const auto& pkey = data.GetAsymmetricKey(); - switch (pkey.id()) { -#if OPENSSL_WITH_PQC - case EVP_PKEY_ML_DSA_44: - case EVP_PKEY_ML_DSA_65: - case EVP_PKEY_ML_DSA_87: - case EVP_PKEY_ML_KEM_512: - case EVP_PKEY_ML_KEM_768: - case EVP_PKEY_ML_KEM_1024: - break; -#endif - default: - return THROW_ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS(env); + if (!IsPqcSeedKeyId(pkey.id())) { + return THROW_ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS(env); } -#if OPENSSL_WITH_PQC auto raw_data = pkey.rawSeed(); if (!raw_data) { return THROW_ERR_CRYPTO_OPERATION_FAILED(env, "Failed to get raw seed"); @@ -1713,6 +1523,8 @@ void KeyObjectHandle::RawSeed(const v8::FunctionCallbackInfo& args) { args.GetReturnValue().Set( Buffer::Copy(env, raw_data.get(), raw_data.size()) .FromMaybe(Local())); +#else + return THROW_ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS(env); #endif } @@ -2180,9 +1992,12 @@ void Initialize(Environment* env, Local target) { NODE_DEFINE_CONSTANT(target, EVP_PKEY_ML_DSA_44); NODE_DEFINE_CONSTANT(target, EVP_PKEY_ML_DSA_65); NODE_DEFINE_CONSTANT(target, EVP_PKEY_ML_DSA_87); +#if OPENSSL_WITH_PQC_ML_KEM_512 NODE_DEFINE_CONSTANT(target, EVP_PKEY_ML_KEM_512); +#endif NODE_DEFINE_CONSTANT(target, EVP_PKEY_ML_KEM_768); NODE_DEFINE_CONSTANT(target, EVP_PKEY_ML_KEM_1024); +#if OPENSSL_WITH_PQC_SLH_DSA NODE_DEFINE_CONSTANT(target, EVP_PKEY_SLH_DSA_SHA2_128F); NODE_DEFINE_CONSTANT(target, EVP_PKEY_SLH_DSA_SHA2_128S); NODE_DEFINE_CONSTANT(target, EVP_PKEY_SLH_DSA_SHA2_192F); @@ -2195,6 +2010,7 @@ void Initialize(Environment* env, Local target) { NODE_DEFINE_CONSTANT(target, EVP_PKEY_SLH_DSA_SHAKE_192S); NODE_DEFINE_CONSTANT(target, EVP_PKEY_SLH_DSA_SHAKE_256F); NODE_DEFINE_CONSTANT(target, EVP_PKEY_SLH_DSA_SHAKE_256S); +#endif #endif NODE_DEFINE_CONSTANT(target, EVP_PKEY_X25519); NODE_DEFINE_CONSTANT(target, EVP_PKEY_X448); diff --git a/src/crypto/crypto_pqc.cc b/src/crypto/crypto_pqc.cc index bf40052fb6ea1e..8d4af1e7801180 100644 --- a/src/crypto/crypto_pqc.cc +++ b/src/crypto/crypto_pqc.cc @@ -17,32 +17,105 @@ namespace crypto { #if OPENSSL_WITH_PQC namespace { +using PqcKeyTypeGetter = Local (Environment::*)() const; + +enum PqcAlgorithmFlag { + kPqcRawPrivate = 1 << 0, + kPqcRawSeed = 1 << 1, + kPqcSignature = 1 << 2, +}; + struct PqcAlgorithm { int id; const char* name; - bool - use_seed; // true: rawSeed/NewRawSeed, false: rawPrivateKey/NewRawPrivate + PqcKeyTypeGetter key_type; + int flags; }; +// ML-DSA and ML-KEM carry private material as a seed. SLH-DSA uses the +// expanded private key and is only exposed by OpenSSL. +constexpr int kPqcMlDsaFlags = kPqcRawSeed | kPqcSignature; +constexpr int kPqcMlKemFlags = kPqcRawSeed; +constexpr int kPqcSlhDsaFlags = kPqcRawPrivate | kPqcSignature; + constexpr PqcAlgorithm kPqcAlgorithms[] = { - {EVP_PKEY_ML_DSA_44, "ML-DSA-44", true}, - {EVP_PKEY_ML_DSA_65, "ML-DSA-65", true}, - {EVP_PKEY_ML_DSA_87, "ML-DSA-87", true}, - {EVP_PKEY_ML_KEM_512, "ML-KEM-512", true}, - {EVP_PKEY_ML_KEM_768, "ML-KEM-768", true}, - {EVP_PKEY_ML_KEM_1024, "ML-KEM-1024", true}, - {EVP_PKEY_SLH_DSA_SHA2_128F, "SLH-DSA-SHA2-128f", false}, - {EVP_PKEY_SLH_DSA_SHA2_128S, "SLH-DSA-SHA2-128s", false}, - {EVP_PKEY_SLH_DSA_SHA2_192F, "SLH-DSA-SHA2-192f", false}, - {EVP_PKEY_SLH_DSA_SHA2_192S, "SLH-DSA-SHA2-192s", false}, - {EVP_PKEY_SLH_DSA_SHA2_256F, "SLH-DSA-SHA2-256f", false}, - {EVP_PKEY_SLH_DSA_SHA2_256S, "SLH-DSA-SHA2-256s", false}, - {EVP_PKEY_SLH_DSA_SHAKE_128F, "SLH-DSA-SHAKE-128f", false}, - {EVP_PKEY_SLH_DSA_SHAKE_128S, "SLH-DSA-SHAKE-128s", false}, - {EVP_PKEY_SLH_DSA_SHAKE_192F, "SLH-DSA-SHAKE-192f", false}, - {EVP_PKEY_SLH_DSA_SHAKE_192S, "SLH-DSA-SHAKE-192s", false}, - {EVP_PKEY_SLH_DSA_SHAKE_256F, "SLH-DSA-SHAKE-256f", false}, - {EVP_PKEY_SLH_DSA_SHAKE_256S, "SLH-DSA-SHAKE-256s", false}, + {EVP_PKEY_ML_DSA_44, + "ML-DSA-44", + &Environment::crypto_ml_dsa_44_string, + kPqcMlDsaFlags}, + {EVP_PKEY_ML_DSA_65, + "ML-DSA-65", + &Environment::crypto_ml_dsa_65_string, + kPqcMlDsaFlags}, + {EVP_PKEY_ML_DSA_87, + "ML-DSA-87", + &Environment::crypto_ml_dsa_87_string, + kPqcMlDsaFlags}, + {EVP_PKEY_ML_KEM_768, + "ML-KEM-768", + &Environment::crypto_ml_kem_768_string, + kPqcMlKemFlags}, + {EVP_PKEY_ML_KEM_1024, + "ML-KEM-1024", + &Environment::crypto_ml_kem_1024_string, + kPqcMlKemFlags}, + +#if OPENSSL_WITH_PQC_ML_KEM_512 + {EVP_PKEY_ML_KEM_512, + "ML-KEM-512", + &Environment::crypto_ml_kem_512_string, + kPqcMlKemFlags}, +#endif +#if OPENSSL_WITH_PQC_SLH_DSA + {EVP_PKEY_SLH_DSA_SHA2_128F, + "SLH-DSA-SHA2-128f", + &Environment::crypto_slh_dsa_sha2_128f_string, + kPqcSlhDsaFlags}, + {EVP_PKEY_SLH_DSA_SHA2_128S, + "SLH-DSA-SHA2-128s", + &Environment::crypto_slh_dsa_sha2_128s_string, + kPqcSlhDsaFlags}, + {EVP_PKEY_SLH_DSA_SHA2_192F, + "SLH-DSA-SHA2-192f", + &Environment::crypto_slh_dsa_sha2_192f_string, + kPqcSlhDsaFlags}, + {EVP_PKEY_SLH_DSA_SHA2_192S, + "SLH-DSA-SHA2-192s", + &Environment::crypto_slh_dsa_sha2_192s_string, + kPqcSlhDsaFlags}, + {EVP_PKEY_SLH_DSA_SHA2_256F, + "SLH-DSA-SHA2-256f", + &Environment::crypto_slh_dsa_sha2_256f_string, + kPqcSlhDsaFlags}, + {EVP_PKEY_SLH_DSA_SHA2_256S, + "SLH-DSA-SHA2-256s", + &Environment::crypto_slh_dsa_sha2_256s_string, + kPqcSlhDsaFlags}, + {EVP_PKEY_SLH_DSA_SHAKE_128F, + "SLH-DSA-SHAKE-128f", + &Environment::crypto_slh_dsa_shake_128f_string, + kPqcSlhDsaFlags}, + {EVP_PKEY_SLH_DSA_SHAKE_128S, + "SLH-DSA-SHAKE-128s", + &Environment::crypto_slh_dsa_shake_128s_string, + kPqcSlhDsaFlags}, + {EVP_PKEY_SLH_DSA_SHAKE_192F, + "SLH-DSA-SHAKE-192f", + &Environment::crypto_slh_dsa_shake_192f_string, + kPqcSlhDsaFlags}, + {EVP_PKEY_SLH_DSA_SHAKE_192S, + "SLH-DSA-SHAKE-192s", + &Environment::crypto_slh_dsa_shake_192s_string, + kPqcSlhDsaFlags}, + {EVP_PKEY_SLH_DSA_SHAKE_256F, + "SLH-DSA-SHAKE-256f", + &Environment::crypto_slh_dsa_shake_256f_string, + kPqcSlhDsaFlags}, + {EVP_PKEY_SLH_DSA_SHAKE_256S, + "SLH-DSA-SHAKE-256s", + &Environment::crypto_slh_dsa_shake_256s_string, + kPqcSlhDsaFlags}, +#endif }; const PqcAlgorithm* FindPqcAlgorithmById(int id) { @@ -59,6 +132,10 @@ const PqcAlgorithm* FindPqcAlgorithmByName(const char* name) { return nullptr; } +bool HasPqcAlgorithmFlag(const PqcAlgorithm* alg, PqcAlgorithmFlag flag) { + return alg != nullptr && (alg->flags & flag) != 0; +} + bool TrySetEncodedKey(Environment* env, DataPointer data, Local target, @@ -82,9 +159,9 @@ bool ExportJwkPqcKey(Environment* env, CHECK(alg); if (key.GetKeyType() == kKeyTypePrivate) { - DataPointer priv_data = - alg->use_seed ? pkey.rawSeed() : pkey.rawPrivateKey(); - if (alg->use_seed && !priv_data) { + const bool uses_seed = HasPqcAlgorithmFlag(alg, kPqcRawSeed); + DataPointer priv_data = uses_seed ? pkey.rawSeed() : pkey.rawPrivateKey(); + if (uses_seed && !priv_data) { THROW_ERR_CRYPTO_OPERATION_FAILED(env, "key does not have an available seed"); return false; @@ -144,8 +221,9 @@ KeyObjectData ImportJWKPqcKey(Environment* env, Local jwk) { .data = priv.data(), .len = priv.size(), }; - pkey = alg->use_seed ? EVPKeyPointer::NewRawSeed(alg->id, buf) - : EVPKeyPointer::NewRawPrivate(alg->id, buf); + pkey = HasPqcAlgorithmFlag(alg, kPqcRawSeed) + ? EVPKeyPointer::NewRawSeed(alg->id, buf) + : EVPKeyPointer::NewRawPrivate(alg->id, buf); } else { ByteSource pub = ByteSource::FromEncodedString(env, pub_value.As()); pkey = @@ -176,14 +254,38 @@ KeyObjectData ImportJWKPqcKey(Environment* env, Local jwk) { return KeyObjectData::CreateAsymmetric(type, std::move(pkey)); } +bool IsPqcKeyId(int id) { + return FindPqcAlgorithmById(id) != nullptr; +} + bool IsPqcRawPrivateKeyId(int id) { const PqcAlgorithm* alg = FindPqcAlgorithmById(id); - return alg != nullptr && !alg->use_seed; + return HasPqcAlgorithmFlag(alg, kPqcRawPrivate); } bool IsPqcSeedKeyId(int id) { const PqcAlgorithm* alg = FindPqcAlgorithmById(id); - return alg != nullptr && alg->use_seed; + return HasPqcAlgorithmFlag(alg, kPqcRawSeed); +} + +bool IsPqcSignatureKeyId(int id) { + const PqcAlgorithm* alg = FindPqcAlgorithmById(id); + return HasPqcAlgorithmFlag(alg, kPqcSignature); +} + +int GetPqcNidFromName(const char* name) { + for (const auto& alg : kPqcAlgorithms) { + if (StringEqualNoCase(name, alg.name)) return alg.id; + } + return NID_undef; +} + +Local GetPqcAsymmetricKeyType(Environment* env, int id) { + const PqcAlgorithm* alg = FindPqcAlgorithmById(id); + if (alg == nullptr) return v8::Undefined(env->isolate()); + + Local key_type = (env->*(alg->key_type))(); + return key_type.As(); } #endif } // namespace crypto diff --git a/src/crypto/crypto_pqc.h b/src/crypto/crypto_pqc.h index 156066097bbfb9..14f919d94c6f8a 100644 --- a/src/crypto/crypto_pqc.h +++ b/src/crypto/crypto_pqc.h @@ -18,10 +18,19 @@ KeyObjectData ImportJWKPqcKey(Environment* env, v8::Local jwk); // Returns true for PQC algorithms that support raw private key export/import. bool IsPqcRawPrivateKeyId(int id); +// Returns true if the given EVP_PKEY id is a PQC algorithm known to Node. +bool IsPqcKeyId(int id); // Returns true for PQC algorithms that carry the private key as a seed // (ML-DSA, ML-KEM). Returns false for algorithms that use the expanded // private key (SLH-DSA), or for non-PQC ids. bool IsPqcSeedKeyId(int id); +// Returns true for PQC signature algorithms (ML-DSA, SLH-DSA). Returns false +// for ML-KEM or for non-PQC ids. +bool IsPqcSignatureKeyId(int id); +// Returns the EVP_PKEY id for the given PQC algorithm name, or NID_undef. +int GetPqcNidFromName(const char* name); +// Returns the JS asymmetricKeyType string for a PQC id, or undefined. +v8::Local GetPqcAsymmetricKeyType(Environment* env, int id); #endif } // namespace crypto } // namespace node diff --git a/src/crypto/crypto_sig.cc b/src/crypto/crypto_sig.cc index ad5e2038339d12..d8a4fe395a5f47 100644 --- a/src/crypto/crypto_sig.cc +++ b/src/crypto/crypto_sig.cc @@ -3,6 +3,7 @@ #include "base_object-inl.h" #include "crypto/crypto_ec.h" #include "crypto/crypto_keys.h" +#include "crypto/crypto_pqc.h" #include "crypto/crypto_util.h" #include "env-inl.h" #include "memory_tracker-inl.h" @@ -239,30 +240,14 @@ bool UseP1363Encoding(const EVPKeyPointer& key, const DSASigEnc dsa_encoding) { bool SupportsContextString(const EVPKeyPointer& key) { if (!OPENSSL_WITH_SIGNATURE_CONTEXT_STRING) return false; - switch (key.id()) { - case EVP_PKEY_ED25519: - case EVP_PKEY_ED448: + const int id = key.id(); #if OPENSSL_WITH_PQC - case EVP_PKEY_ML_DSA_44: - case EVP_PKEY_ML_DSA_65: - case EVP_PKEY_ML_DSA_87: - case EVP_PKEY_SLH_DSA_SHA2_128F: - case EVP_PKEY_SLH_DSA_SHA2_128S: - case EVP_PKEY_SLH_DSA_SHA2_192F: - case EVP_PKEY_SLH_DSA_SHA2_192S: - case EVP_PKEY_SLH_DSA_SHA2_256F: - case EVP_PKEY_SLH_DSA_SHA2_256S: - case EVP_PKEY_SLH_DSA_SHAKE_128F: - case EVP_PKEY_SLH_DSA_SHAKE_128S: - case EVP_PKEY_SLH_DSA_SHAKE_192F: - case EVP_PKEY_SLH_DSA_SHAKE_192S: - case EVP_PKEY_SLH_DSA_SHAKE_256F: - case EVP_PKEY_SLH_DSA_SHAKE_256S: + if (IsPqcSignatureKeyId(id)) return true; #endif - return true; - default: - return false; - } +#ifndef OPENSSL_IS_BORINGSSL + if (id == EVP_PKEY_ED25519 || id == EVP_PKEY_ED448) return true; +#endif + return false; } } // namespace diff --git a/src/crypto/crypto_util.cc b/src/crypto/crypto_util.cc index 53d6142917dc58..b9d037fb72352b 100644 --- a/src/crypto/crypto_util.cc +++ b/src/crypto/crypto_util.cc @@ -139,7 +139,7 @@ void InitCryptoOnce() { OPENSSL_init_ssl(0, settings); -#if OPENSSL_WITH_PQC +#if OPENSSL_WITH_OPENSSL_PQC // Configure all loaded providers to prefer seed-only format for ML-KEM and // ML-DSA private keys in PKCS#8 export, falling back to priv-only when a // seed is not available. The provider encoder reads these parameters at diff --git a/test/fixtures/keys/Makefile b/test/fixtures/keys/Makefile index def378b70fef92..c1e2fde9c3874b 100644 --- a/test/fixtures/keys/Makefile +++ b/test/fixtures/keys/Makefile @@ -102,6 +102,8 @@ all: \ ml_dsa_44_private.pem \ ml_dsa_44_private_seed_only.pem \ ml_dsa_44_private_priv_only.pem \ + ml_dsa_44_private_encrypted.pem \ + ml_dsa_44_private_encrypted.der \ ml_dsa_44_public.pem \ ml_dsa_65_private.pem \ ml_dsa_65_private_seed_only.pem \ @@ -124,6 +126,8 @@ all: \ ml_kem_768_private.pem \ ml_kem_768_private_seed_only.pem \ ml_kem_768_private_priv_only.pem \ + ml_kem_768_private_encrypted.pem \ + ml_kem_768_private_encrypted.der \ ml_kem_768_public.pem \ ml_kem_1024_private.pem \ ml_kem_1024_private_seed_only.pem \ @@ -1028,6 +1032,12 @@ ml_dsa_44_private_priv_only.pem: ml_dsa_44_private.pem ml_dsa_44_public.pem: ml_dsa_44_private.pem openssl pkey -in ml_dsa_44_private.pem -pubout -out ml_dsa_44_public.pem +ml_dsa_44_private_encrypted.pem: ml_dsa_44_private_seed_only.pem + openssl pkcs8 -topk8 -v2 aes-256-cbc -provparam ml-dsa.output_formats=seed-only -in ml_dsa_44_private_seed_only.pem -passout 'pass:password' -out ml_dsa_44_private_encrypted.pem + +ml_dsa_44_private_encrypted.der: ml_dsa_44_private_seed_only.pem + openssl pkcs8 -topk8 -v2 aes-256-cbc -provparam ml-dsa.output_formats=seed-only -in ml_dsa_44_private_seed_only.pem -passout 'pass:password' -outform DER -out ml_dsa_44_private_encrypted.der + ml_dsa_65_private.pem: openssl genpkey -algorithm ml-dsa-65 -out ml_dsa_65_private.pem @@ -1076,6 +1086,12 @@ ml_kem_768_private_priv_only.pem: ml_kem_768_private.pem ml_kem_768_public.pem: ml_kem_768_private.pem openssl pkey -in ml_kem_768_private.pem -pubout -out ml_kem_768_public.pem +ml_kem_768_private_encrypted.pem: ml_kem_768_private_seed_only.pem + openssl pkcs8 -topk8 -v2 aes-256-cbc -provparam ml-kem.output_formats=seed-only -in ml_kem_768_private_seed_only.pem -passout 'pass:password' -out ml_kem_768_private_encrypted.pem + +ml_kem_768_private_encrypted.der: ml_kem_768_private_seed_only.pem + openssl pkcs8 -topk8 -v2 aes-256-cbc -provparam ml-kem.output_formats=seed-only -in ml_kem_768_private_seed_only.pem -passout 'pass:password' -outform DER -out ml_kem_768_private_encrypted.der + ml_kem_1024_private.pem: openssl genpkey -algorithm ml-kem-1024 -out ml_kem_1024_private.pem diff --git a/test/fixtures/keys/ml_dsa_44_private_encrypted.der b/test/fixtures/keys/ml_dsa_44_private_encrypted.der new file mode 100644 index 0000000000000000000000000000000000000000..2ae136bc7961e5fbcd3be7c19b4a3394a6ffdf25 GIT binary patch literal 166 zcmXqLTx<}}#;Mij(e|B}k(JjV$iNW6AOlb39Ol4+a)M61>&*ISfpVxQO&6=-`Eprm`SRBGuE%`QezIP0J z1M|8SyCc%b8*tA~?e3`bs$G$oE()}%ymS>mM Kp6{Ay^&0?pj6U@M literal 0 HcmV?d00001 diff --git a/test/fixtures/keys/ml_dsa_44_private_encrypted.pem b/test/fixtures/keys/ml_dsa_44_private_encrypted.pem new file mode 100644 index 00000000000000..e127aa0085bc5f --- /dev/null +++ b/test/fixtures/keys/ml_dsa_44_private_encrypted.pem @@ -0,0 +1,6 @@ +-----BEGIN ENCRYPTED PRIVATE KEY----- +MIGjMF8GCSqGSIb3DQEFDTBSMDEGCSqGSIb3DQEFDDAkBBD1YJCeuwCAuw/ktX9I +K9g9AgIIADAMBggqhkiG9w0CCQUAMB0GCWCGSAFlAwQBKgQQ7kmeI0FzRNLI2m54 +BMASEgRAWBi1BRsuBBVt2kWVTbz8tQa8K3lV+nNE+iRGlMaOhnF5o5Kx4mQnzE1q +ppIFNbWPGGr+xKHTU6fNfNnMecVXKA== +-----END ENCRYPTED PRIVATE KEY----- diff --git a/test/fixtures/keys/ml_kem_768_private_encrypted.der b/test/fixtures/keys/ml_kem_768_private_encrypted.der new file mode 100644 index 0000000000000000000000000000000000000000..4f9097751c2249b118f919cb244ddecbae399726 GIT binary patch literal 198 zcmXqLJZuop#;Mij(e|B}k(JjV$iNW6Bl!re{s>;}1+s91I3L zY#b0hOq{F?2C{6N32h#Xsmv^lS}Xz=8qR66`4mV{dIBhwrvSFNgJ zn!e7*@X8F1H8*~R9Bhi{&(l?$(YO58E0y_f+XW@JE?#VV_u#IU<=d-|JlMv~kz%9r tl$FE(#unzIw->stUevvD$CfwTYxMpc`KDZV^ReOqo0h2yGvl&<004`KP}Kkc literal 0 HcmV?d00001 diff --git a/test/fixtures/keys/ml_kem_768_private_encrypted.pem b/test/fixtures/keys/ml_kem_768_private_encrypted.pem new file mode 100644 index 00000000000000..0e3d54e75a3259 --- /dev/null +++ b/test/fixtures/keys/ml_kem_768_private_encrypted.pem @@ -0,0 +1,7 @@ +-----BEGIN ENCRYPTED PRIVATE KEY----- +MIHDMF8GCSqGSIb3DQEFDTBSMDEGCSqGSIb3DQEFDDAkBBBSwnAxR1nLC5FZtJyu +lumDAgIIADAMBggqhkiG9w0CCQUAMB0GCWCGSAFlAwQBKgQQyBgMhkKPAMK6jaIc +YxhYcgRg3P97VHfT14YDN024txZznhhzC0mWGNpP6f1EV/mP/YttQp2JTXMKID4V +um3QuQes5my0oOIuiRl3gYIz/BDjKkqLagYBQmUcUUlURgaYJ67Yk3BZg6ULjXmq +EdLYqK5D +-----END ENCRYPTED PRIVATE KEY----- diff --git a/test/fixtures/webcrypto/supports-modern-algorithms.mjs b/test/fixtures/webcrypto/supports-modern-algorithms.mjs index 956a94b191d266..2d370b8e21d3d5 100644 --- a/test/fixtures/webcrypto/supports-modern-algorithms.mjs +++ b/test/fixtures/webcrypto/supports-modern-algorithms.mjs @@ -2,13 +2,13 @@ import * as crypto from 'node:crypto' import { hasOpenSSL } from '../../common/crypto.js' -const pqc = hasOpenSSL(3, 5); +const boringSSL = process.features.openssl_is_boringssl; +const pqc = hasOpenSSL(3, 5) || boringSSL; const argon2 = hasOpenSSL(3, 2); const shake128 = crypto.getHashes().includes('shake128'); const shake256 = crypto.getHashes().includes('shake256'); const ocb = hasOpenSSL(3); const kmac = hasOpenSSL(3); -const boringSSL = process.features.openssl_is_boringssl; const { subtle } = globalThis.crypto; const X25519 = await subtle.generateKey('X25519', false, ['deriveBits', 'deriveKey']); @@ -74,7 +74,7 @@ export const vectors = { [pqc, 'ML-DSA-44'], [pqc, 'ML-DSA-65'], [pqc, 'ML-DSA-87'], - [pqc, 'ML-KEM-512'], + [pqc && !boringSSL, 'ML-KEM-512'], [pqc, 'ML-KEM-768'], [pqc, 'ML-KEM-1024'], [true, 'ChaCha20-Poly1305'], @@ -95,7 +95,7 @@ export const vectors = { [pqc, 'ML-DSA-44'], [pqc, 'ML-DSA-65'], [pqc, 'ML-DSA-87'], - [pqc, 'ML-KEM-512'], + [pqc && !boringSSL, 'ML-KEM-512'], [pqc, 'ML-KEM-768'], [pqc, 'ML-KEM-1024'], [true, 'ChaCha20-Poly1305'], @@ -116,7 +116,7 @@ export const vectors = { [pqc, 'ML-DSA-44'], [pqc, 'ML-DSA-65'], [pqc, 'ML-DSA-87'], - [pqc, 'ML-KEM-512'], + [pqc && !boringSSL, 'ML-KEM-512'], [pqc, 'ML-KEM-768'], [pqc, 'ML-KEM-1024'], [true, 'ChaCha20-Poly1305'], @@ -140,7 +140,7 @@ export const vectors = { [pqc, 'ML-DSA-44'], [pqc, 'ML-DSA-65'], [pqc, 'ML-DSA-87'], - [pqc, 'ML-KEM-512'], + [pqc && !boringSSL, 'ML-KEM-512'], [pqc, 'ML-KEM-768'], [pqc, 'ML-KEM-1024'], [false, 'AES-CTR'], @@ -199,37 +199,39 @@ export const vectors = { [false, 'AES-OCB'], ], 'encapsulateBits': [ - [pqc, 'ML-KEM-512'], + [pqc && !boringSSL, 'ML-KEM-512'], [pqc, 'ML-KEM-768'], [pqc, 'ML-KEM-1024'], ], 'encapsulateKey': [ - [pqc, 'ML-KEM-512', 'AES-KW'], - [pqc, 'ML-KEM-512', 'AES-GCM'], - [pqc, 'ML-KEM-512', 'AES-CTR'], - [pqc, 'ML-KEM-512', 'AES-CBC'], - [pqc, 'ML-KEM-512', 'ChaCha20-Poly1305'], - [pqc, 'ML-KEM-512', 'HKDF'], - [pqc, 'ML-KEM-512', 'PBKDF2'], - [pqc, 'ML-KEM-512', { name: 'HMAC', hash: 'SHA-256' }], - [pqc, 'ML-KEM-512', { name: 'HMAC', hash: 'SHA-256', length: 256 }], - [false, 'ML-KEM-512', { name: 'HMAC', hash: 'SHA-256', length: 128 }], + [pqc && !boringSSL, 'ML-KEM-512', 'AES-KW'], + [pqc, 'ML-KEM-768', 'AES-KW'], + [pqc, 'ML-KEM-768', 'AES-GCM'], + [pqc, 'ML-KEM-768', 'AES-CTR'], + [pqc, 'ML-KEM-768', 'AES-CBC'], + [pqc, 'ML-KEM-768', 'ChaCha20-Poly1305'], + [pqc, 'ML-KEM-768', 'HKDF'], + [pqc, 'ML-KEM-768', 'PBKDF2'], + [pqc, 'ML-KEM-768', { name: 'HMAC', hash: 'SHA-256' }], + [pqc, 'ML-KEM-768', { name: 'HMAC', hash: 'SHA-256', length: 256 }], + [false, 'ML-KEM-768', { name: 'HMAC', hash: 'SHA-256', length: 128 }], ], 'decapsulateBits': [ - [pqc, 'ML-KEM-512'], + [pqc && !boringSSL, 'ML-KEM-512'], [pqc, 'ML-KEM-768'], [pqc, 'ML-KEM-1024'], ], 'decapsulateKey': [ - [pqc, 'ML-KEM-512', 'AES-KW'], - [pqc, 'ML-KEM-512', 'AES-GCM'], - [pqc, 'ML-KEM-512', 'AES-CTR'], - [pqc, 'ML-KEM-512', 'AES-CBC'], - [pqc, 'ML-KEM-512', 'ChaCha20-Poly1305'], - [pqc, 'ML-KEM-512', 'HKDF'], - [pqc, 'ML-KEM-512', 'PBKDF2'], - [pqc, 'ML-KEM-512', { name: 'HMAC', hash: 'SHA-256' }], - [pqc, 'ML-KEM-512', { name: 'HMAC', hash: 'SHA-256', length: 256 }], - [false, 'ML-KEM-512', { name: 'HMAC', hash: 'SHA-256', length: 128 }], + [pqc && !boringSSL, 'ML-KEM-512', 'AES-KW'], + [pqc, 'ML-KEM-768', 'AES-KW'], + [pqc, 'ML-KEM-768', 'AES-GCM'], + [pqc, 'ML-KEM-768', 'AES-CTR'], + [pqc, 'ML-KEM-768', 'AES-CBC'], + [pqc, 'ML-KEM-768', 'ChaCha20-Poly1305'], + [pqc, 'ML-KEM-768', 'HKDF'], + [pqc, 'ML-KEM-768', 'PBKDF2'], + [pqc, 'ML-KEM-768', { name: 'HMAC', hash: 'SHA-256' }], + [pqc, 'ML-KEM-768', { name: 'HMAC', hash: 'SHA-256', length: 256 }], + [false, 'ML-KEM-768', { name: 'HMAC', hash: 'SHA-256', length: 128 }], ], }; diff --git a/test/parallel/test-crypto-encap-decap.js b/test/parallel/test-crypto-encap-decap.js index 38e24a7341713a..f2259194a9e15d 100644 --- a/test/parallel/test-crypto-encap-decap.js +++ b/test/parallel/test-crypto-encap-decap.js @@ -9,7 +9,9 @@ const fixtures = require('../common/fixtures'); const { hasOpenSSL } = require('../common/crypto'); const { promisify } = require('util'); -if (!hasOpenSSL(3)) { +const isBoringSSL = process.features.openssl_is_boringssl; + +if (!hasOpenSSL(3) && !isBoringSSL) { assert.throws(() => crypto.encapsulate(), { code: 'ERR_CRYPTO_KEM_NOT_SUPPORTED' }); return; } @@ -79,25 +81,25 @@ const keys = { raw: true, }, 'ml-kem-512': { - supported: hasOpenSSL(3, 5), + supported: hasOpenSSL(3, 5), // BoringSSL does not support ML-KEM-512 publicKey: fixtures.readKey('ml_kem_512_public.pem', 'ascii'), - privateKey: fixtures.readKey('ml_kem_512_private.pem', 'ascii'), + privateKey: fixtures.readKey('ml_kem_512_private_seed_only.pem', 'ascii'), sharedSecretLength: 32, ciphertextLength: 768, raw: true, }, 'ml-kem-768': { - supported: hasOpenSSL(3, 5), + supported: hasOpenSSL(3, 5) || isBoringSSL, publicKey: fixtures.readKey('ml_kem_768_public.pem', 'ascii'), - privateKey: fixtures.readKey('ml_kem_768_private.pem', 'ascii'), + privateKey: fixtures.readKey('ml_kem_768_private_seed_only.pem', 'ascii'), sharedSecretLength: 32, ciphertextLength: 1088, raw: true, }, 'ml-kem-1024': { - supported: hasOpenSSL(3, 5), + supported: hasOpenSSL(3, 5) || isBoringSSL, publicKey: fixtures.readKey('ml_kem_1024_public.pem', 'ascii'), - privateKey: fixtures.readKey('ml_kem_1024_private.pem', 'ascii'), + privateKey: fixtures.readKey('ml_kem_1024_private_seed_only.pem', 'ascii'), sharedSecretLength: 32, ciphertextLength: 1568, raw: true, @@ -109,7 +111,7 @@ for (const [name, { }] of Object.entries(keys)) { if (!supported) { assert.throws(() => crypto.encapsulate(publicKey), - { code: /ERR_OSSL_EVP_DECODE_ERROR|ERR_CRYPTO_OPERATION_FAILED/ }); + { code: /ERR_OSSL_EVP_DECODE_ERROR|ERR_OSSL_EVP_UNSUPPORTED_ALGORITHM|ERR_CRYPTO_OPERATION_FAILED/ }); continue; } @@ -211,7 +213,7 @@ for (const [name, { } else if (name.startsWith('p-')) { wrongPrivateKey = name === 'p-256' ? keys['p-384'].privateKey : keys['p-256'].privateKey; } else if (name.startsWith('ml-')) { - wrongPrivateKey = name === 'ml-kem-512' ? keys['ml-kem-768'].privateKey : keys['ml-kem-512'].privateKey; + wrongPrivateKey = name === 'ml-kem-768' ? keys['ml-kem-1024'].privateKey : keys['ml-kem-768'].privateKey; } else { wrongPrivateKey = keys.x25519.privateKey; } diff --git a/test/parallel/test-crypto-key-objects-raw.js b/test/parallel/test-crypto-key-objects-raw.js index 583cd4a1712a83..024d5f6f199ffc 100644 --- a/test/parallel/test-crypto-key-objects-raw.js +++ b/test/parallel/test-crypto-key-objects-raw.js @@ -76,7 +76,7 @@ const { hasOpenSSL } = require('../common/crypto'); common.printSkipMessage('Skipping unsupported ed448/x448 test cases'); } - if (hasOpenSSL(3, 5)) { + if (hasOpenSSL(3, 5) || process.features.openssl_is_boringssl) { rawPublicKeys.push( ['ml-dsa-44', 'ml_dsa_44_public.pem'], ['ml-kem-768', 'ml_kem_768_public.pem'], @@ -170,15 +170,22 @@ if (hasOpenSSL(3, 5)) { // PQC import throws when PQC is not supported if (!hasOpenSSL(3, 5)) { - for (const asymmetricKeyType of [ - 'ml-dsa-44', 'ml-dsa-65', 'ml-dsa-87', - 'ml-kem-512', 'ml-kem-768', 'ml-kem-1024', - 'slh-dsa-sha2-128f', 'slh-dsa-shake-128f', - ]) { + const unsupported = process.features.openssl_is_boringssl ? + // BoringSSL supports ML-DSA and ML-KEM-{768,1024}, but not ML-KEM-512 or SLH-DSA. + ['ml-kem-512', 'slh-dsa-sha2-128f', 'slh-dsa-shake-128f'] : + [ + 'ml-dsa-44', 'ml-dsa-65', 'ml-dsa-87', + 'ml-kem-512', 'ml-kem-768', 'ml-kem-1024', + 'slh-dsa-sha2-128f', 'slh-dsa-shake-128f', + ]; + for (const asymmetricKeyType of unsupported) { for (const format of ['raw-public', 'raw-private', 'raw-seed']) { assert.throws(() => crypto.createPublicKey({ key: Buffer.alloc(32), format, asymmetricKeyType, - }), { code: 'ERR_INVALID_ARG_VALUE' }); + }), { + code: 'ERR_INVALID_ARG_VALUE', + message: /Invalid asymmetricKeyType|Unsupported key type/ + }); } } } @@ -224,27 +231,27 @@ if (!hasOpenSSL(3, 5)) { }), { code: 'ERR_INVALID_ARG_VALUE' }); } -// ML-KEM: -768 and -512 public keys cannot be imported as the other type -if (hasOpenSSL(3, 5)) { - const mlKem512Pub = crypto.createPublicKey( - fixtures.readKey('ml_kem_512_public.pem', 'ascii')); +// ML-KEM: public keys of different type cannot be imported as the other type +if (hasOpenSSL(3, 5) || process.features.openssl_is_boringssl) { const mlKem768Pub = crypto.createPublicKey( fixtures.readKey('ml_kem_768_public.pem', 'ascii')); + const mlKem1024Pub = crypto.createPublicKey( + fixtures.readKey('ml_kem_1024_public.pem', 'ascii')); - const mlKem512RawPub = mlKem512Pub.export({ format: 'raw-public' }); const mlKem768RawPub = mlKem768Pub.export({ format: 'raw-public' }); + const mlKem1024RawPub = mlKem1024Pub.export({ format: 'raw-public' }); assert.throws(() => crypto.createPublicKey({ - key: mlKem512RawPub, format: 'raw-public', asymmetricKeyType: 'ml-kem-768', + key: mlKem768RawPub, format: 'raw-public', asymmetricKeyType: 'ml-kem-1024', }), { code: 'ERR_INVALID_ARG_VALUE' }); assert.throws(() => crypto.createPublicKey({ - key: mlKem768RawPub, format: 'raw-public', asymmetricKeyType: 'ml-kem-512', + key: mlKem1024RawPub, format: 'raw-public', asymmetricKeyType: 'ml-kem-768', }), { code: 'ERR_INVALID_ARG_VALUE' }); } // ML-DSA: -44 and -65 public keys cannot be imported as the other type -if (hasOpenSSL(3, 5)) { +if (hasOpenSSL(3, 5) || process.features.openssl_is_boringssl) { const mlDsa44Pub = crypto.createPublicKey( fixtures.readKey('ml_dsa_44_public.pem', 'ascii')); const mlDsa65Pub = crypto.createPublicKey( @@ -357,10 +364,10 @@ if (hasOpenSSL(3, 5)) { } // raw-private cannot be used for ml-kem and ml-dsa -if (hasOpenSSL(3, 5)) { - for (const type of ['ml-kem-512', 'ml-dsa-44']) { +if (hasOpenSSL(3, 5) || process.features.openssl_is_boringssl) { + for (const type of ['ml-kem-768', 'ml-dsa-44']) { const priv = crypto.createPrivateKey( - fixtures.readKey(`${type.replaceAll('-', '_')}_private.pem`, 'ascii')); + fixtures.readKey(`${type.replaceAll('-', '_')}_private_seed_only.pem`, 'ascii')); assert.throws(() => priv.export({ format: 'raw-private' }), { code: 'ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS' }); assert.throws(() => crypto.createPrivateKey({ @@ -465,9 +472,9 @@ if (hasOpenSSL(3, 5)) { { code: 'ERR_INVALID_ARG_VALUE' }); // PQC raw-seed -> createPublicKey - if (hasOpenSSL(3, 5)) { + if (hasOpenSSL(3, 5) || process.features.openssl_is_boringssl) { const mlDsaPriv = crypto.createPrivateKey( - fixtures.readKey('ml_dsa_44_private.pem', 'ascii')); + fixtures.readKey('ml_dsa_44_private_seed_only.pem', 'ascii')); const mlDsaPub = crypto.createPublicKey( fixtures.readKey('ml_dsa_44_public.pem', 'ascii')); const mlDsaRawSeed = mlDsaPriv.export({ format: 'raw-seed' }); diff --git a/test/parallel/test-crypto-key-objects-to-crypto-key.js b/test/parallel/test-crypto-key-objects-to-crypto-key.js index e3bea9948708dd..5c3148647324b0 100644 --- a/test/parallel/test-crypto-key-objects-to-crypto-key.js +++ b/test/parallel/test-crypto-key-objects-to-crypto-key.js @@ -195,7 +195,7 @@ function assertCryptoKey(cryptoKey, keyObject, algorithm, extractable, usages) { } } -if (hasOpenSSL(3, 5)) { +if (hasOpenSSL(3, 5) || process.features.openssl_is_boringssl) { for (const name of ['ML-DSA-44', 'ML-DSA-65', 'ML-DSA-87']) { const { publicKey, privateKey } = generateKeyPairSync(name.toLowerCase()); assert.throws(() => { diff --git a/test/parallel/test-crypto-keygen-raw.js b/test/parallel/test-crypto-keygen-raw.js index 5b7abe3f72d9dd..e55c3f10eed8e3 100644 --- a/test/parallel/test-crypto-keygen-raw.js +++ b/test/parallel/test-crypto-keygen-raw.js @@ -205,7 +205,7 @@ if (!process.features.openssl_is_boringssl) { } // PQC key types -if (hasOpenSSL(3, 5)) { +if (hasOpenSSL(3, 5) || process.features.openssl_is_boringssl) { // Test raw encoding for ML-DSA key types (raw-public + raw-seed only). { for (const type of ['ml-dsa-44', 'ml-dsa-65', 'ml-dsa-87']) { @@ -232,6 +232,10 @@ if (hasOpenSSL(3, 5)) { // Test raw encoding for ML-KEM key types (raw-public + raw-seed only). { for (const type of ['ml-kem-512', 'ml-kem-768', 'ml-kem-1024']) { + if (process.features.openssl_is_boringssl && type === 'ml-kem-512') { + common.printSkipMessage(`Skipping unsupported ${type} test case`); + continue; + } const { publicKey, privateKey } = generateKeyPairSync(type, { publicKeyEncoding: { format: 'raw-public' }, privateKeyEncoding: { format: 'raw-seed' }, @@ -246,7 +250,7 @@ if (hasOpenSSL(3, 5)) { // Test error: raw-private with ML-KEM (not supported). { - assert.throws(() => generateKeyPairSync('ml-kem-512', { + assert.throws(() => generateKeyPairSync('ml-kem-768', { publicKeyEncoding: { format: 'raw-public' }, privateKeyEncoding: { format: 'raw-private' }, }), { code: 'ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS' }); @@ -255,6 +259,10 @@ if (hasOpenSSL(3, 5)) { // Test raw encoding for SLH-DSA key types. { for (const type of ['slh-dsa-sha2-128f', 'slh-dsa-shake-128f']) { + if (process.features.openssl_is_boringssl) { + common.printSkipMessage(`Skipping unsupported ${type} test case`); + continue; + } const { publicKey, privateKey } = generateKeyPairSync(type, { publicKeyEncoding: { format: 'raw-public' }, privateKeyEncoding: { format: 'raw-private' }, @@ -266,11 +274,13 @@ if (hasOpenSSL(3, 5)) { } // Test error: raw-seed with SLH-DSA (not supported). - { + if (!process.features.openssl_is_boringssl) { assert.throws(() => generateKeyPairSync('slh-dsa-sha2-128f', { publicKeyEncoding: { format: 'raw-public' }, privateKeyEncoding: { format: 'raw-seed' }, }), { code: 'ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS' }); + } else { + common.printSkipMessage('Skipping unsupported slh-dsa test case'); } // Test async generateKeyPair with raw encoding for PQC types. diff --git a/test/parallel/test-crypto-pqc-encrypted-pkcs8.js b/test/parallel/test-crypto-pqc-encrypted-pkcs8.js new file mode 100644 index 00000000000000..b4a1b586d21d10 --- /dev/null +++ b/test/parallel/test-crypto-pqc-encrypted-pkcs8.js @@ -0,0 +1,134 @@ +'use strict'; + +const common = require('../common'); +if (!common.hasCrypto) + common.skip('missing crypto'); + +const { hasOpenSSL } = require('../common/crypto'); + +if (!hasOpenSSL(3, 5) && !process.features.openssl_is_boringssl) + common.skip('requires OpenSSL >= 3.5 or BoringSSL'); + +const assert = require('assert'); +const { + createPrivateKey, + generateKeyPairSync, + getCiphers, +} = require('crypto'); + +const algorithms = new Set([ + 'ml-dsa-44', 'ml-dsa-65', 'ml-dsa-87', + 'ml-kem-512', 'ml-kem-768', 'ml-kem-1024', +]); +// BoringSSL does not support ML-KEM-512. +if (process.features.openssl_is_boringssl) { + algorithms.delete('ml-kem-512'); +} + +// Exercise each CBC cipher that PBES2 may use. This covers multiple +// EVP_CIPHER_key_length values (16 / 24 / 32) and, for variable-key +// ciphers like RC2, the optional PBKDF2 keyLength INTEGER branch in +// the EncryptedPrivateKeyInfo parser. +const availableCiphers = new Set(getCiphers()); +const ciphers = [ + 'aes-128-cbc', 'aes-192-cbc', 'aes-256-cbc', + 'des-ede3-cbc', 'rc2-cbc', +].filter((c) => availableCiphers.has(c)); + +const passphrase = 'top secret'; +const wrongPassphraseError = + /bad decrypt|DECRYPTION_FAILED|BAD_DECRYPT|bad password|DECODE[ _]ERROR/i; +// A wrong passphrase usually fails during cipher finalization, but CBC output +// can have valid padding by chance. OpenSSL then parses the bad plaintext as +// PKCS#8 and may report ASN.1 or decoder errors from the same failed import. +function assertWrongPassphrase(fn) { + assert.throws(fn, (err) => wrongPassphraseError.test(err.message) || + err.code?.startsWith('ERR_OSSL_ASN1_') || + err.code === 'ERR_OSSL_UNSUPPORTED'); +} + +for (const asymmetricKeyType of algorithms) { + const { privateKey } = generateKeyPairSync(asymmetricKeyType); + assert.strictEqual(privateKey.asymmetricKeyType, asymmetricKeyType); + + const plainDer = privateKey.export({ type: 'pkcs8', format: 'der' }); + + for (const cipher of ciphers) { + for (const format of ['pem', 'der']) { + const encrypted = privateKey.export({ + type: 'pkcs8', + format, + cipher, + passphrase, + }); + + const imported = createPrivateKey({ + key: encrypted, + format, + type: 'pkcs8', + passphrase, + }); + assert.strictEqual(imported.type, 'private'); + assert.strictEqual(imported.asymmetricKeyType, asymmetricKeyType); + assert.deepStrictEqual( + imported.export({ type: 'pkcs8', format: 'der' }), + plainDer, + ); + + assertWrongPassphrase(() => createPrivateKey({ + key: encrypted, + format, + type: 'pkcs8', + passphrase: 'wrong', + })); + } + } +} + +// Cross-implementation compatibility: load encrypted PKCS#8 fixtures that +// were generated by OpenSSL's `openssl pkcs8` from the seed-only PQC +// PrivateKeyInfo fixtures. The inner seed-only form is portable across +// OpenSSL (>=3.5) and BoringSSL, and the matching JWK fixture provides the +// canonical key material used to derive the expected PKCS#8 bytes. +const fixtures = require('../common/fixtures'); +const fixtureCases = [ + { alg: 'ml-dsa-44', jwkFile: 'ml-dsa-44.json', + encBase: 'ml_dsa_44_private_encrypted' }, + { alg: 'ml-kem-768', jwkFile: 'ml-kem-768.json', + encBase: 'ml_kem_768_private_encrypted' }, +]; + +for (const { alg, jwkFile, encBase } of fixtureCases) { + const jwkKey = createPrivateKey({ + key: JSON.parse(fixtures.readKey(jwkFile, 'utf8')), + format: 'jwk', + }); + assert.strictEqual(jwkKey.asymmetricKeyType, alg); + const expectedDer = jwkKey.export({ type: 'pkcs8', format: 'der' }); + + for (const format of ['pem', 'der']) { + const encryptedFixture = fixtures.readKey( + `${encBase}.${format}`, + format === 'pem' ? 'utf8' : null, + ); + + const imported = createPrivateKey({ + key: encryptedFixture, + format, + type: 'pkcs8', + passphrase: 'password', + }); + assert.strictEqual(imported.asymmetricKeyType, alg); + assert.deepStrictEqual( + imported.export({ type: 'pkcs8', format: 'der' }), + expectedDer, + ); + + assertWrongPassphrase(() => createPrivateKey({ + key: encryptedFixture, + format, + type: 'pkcs8', + passphrase: 'wrong', + })); + } +} diff --git a/test/parallel/test-crypto-pqc-key-objects-ml-dsa.js b/test/parallel/test-crypto-pqc-key-objects-ml-dsa.js index f18c555d4653d4..f2a19799c51541 100644 --- a/test/parallel/test-crypto-pqc-key-objects-ml-dsa.js +++ b/test/parallel/test-crypto-pqc-key-objects-ml-dsa.js @@ -4,10 +4,6 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); -if (process.features.openssl_is_boringssl) { - common.skip('Skipping unsupported ML-DSA key tests'); -} - const { hasOpenSSL } = require('../common/crypto'); const assert = require('assert'); @@ -104,7 +100,7 @@ for (const [asymmetricKeyType, pubLen] of [ } } - if (!hasOpenSSL(3, 5)) { + if (!hasOpenSSL(3, 5) && !process.features.openssl_is_boringssl) { assert.throws(() => createPublicKey(keys.public), { code: hasOpenSSL(3) ? 'ERR_OSSL_EVP_DECODE_ERROR' : 'ERR_OSSL_EVP_UNSUPPORTED_ALGORITHM', }); @@ -119,11 +115,15 @@ for (const [asymmetricKeyType, pubLen] of [ assertPublicKey(publicKey); { - for (const [pem, hasSeed] of [ - [keys.private, true], - [keys.private_seed_only, true], - [keys.private_priv_only, false], + for (const [pem, hasSeed, seedOnly] of [ + [keys.private, true, false], + [keys.private_seed_only, true, true], + [keys.private_priv_only, false, false], ]) { + if (process.features.openssl_is_boringssl && !seedOnly) { + common.printSkipMessage('Skipping unsupported private key format test'); + continue; + } const pubFromPriv = createPublicKey(pem); assertPublicKey(pubFromPriv); assertPrivateKey(createPrivateKey(pem), hasSeed); diff --git a/test/parallel/test-crypto-pqc-key-objects-ml-kem.js b/test/parallel/test-crypto-pqc-key-objects-ml-kem.js index 19ed840544320d..81353b5115dd36 100644 --- a/test/parallel/test-crypto-pqc-key-objects-ml-kem.js +++ b/test/parallel/test-crypto-pqc-key-objects-ml-kem.js @@ -4,10 +4,6 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); -if (process.features.openssl_is_boringssl) { - common.skip('Skipping unsupported ML-KEM key tests'); -} - const { hasOpenSSL } = require('../common/crypto'); const assert = require('assert'); @@ -104,7 +100,7 @@ for (const [asymmetricKeyType, pubLen] of [ } } - if (!hasOpenSSL(3, 5)) { + if (!hasOpenSSL(3, 5) && !process.features.openssl_is_boringssl) { assert.throws(() => createPublicKey(keys.public), { code: hasOpenSSL(3) ? 'ERR_OSSL_EVP_DECODE_ERROR' : 'ERR_OSSL_EVP_UNSUPPORTED_ALGORITHM', }); @@ -114,16 +110,28 @@ for (const [asymmetricKeyType, pubLen] of [ code: hasOpenSSL(3) ? 'ERR_OSSL_UNSUPPORTED' : 'ERR_OSSL_EVP_UNSUPPORTED_ALGORITHM', }); } + } else if (process.features.openssl_is_boringssl && asymmetricKeyType === 'ml-kem-512') { + // BoringSSL does not support ML-KEM-512. + assert.throws(() => createPublicKey(keys.public), + { code: 'ERR_OSSL_EVP_UNSUPPORTED_ALGORITHM' }); + for (const pem of [keys.private, keys.private_seed_only, keys.private_priv_only]) { + assert.throws(() => createPrivateKey(pem), + { code: 'ERR_OSSL_EVP_UNSUPPORTED_ALGORITHM' }); + } } else { const publicKey = createPublicKey(keys.public); assertPublicKey(publicKey); { - for (const [pem, hasSeed] of [ - [keys.private, true], - [keys.private_seed_only, true], - [keys.private_priv_only, false], - ]) { + const entries = process.features.openssl_is_boringssl ? + // BoringSSL only supports the seed-only PKCS#8 private key encoding. + [[keys.private_seed_only, true]] : + [ + [keys.private, true], + [keys.private_seed_only, true], + [keys.private_priv_only, false], + ]; + for (const [pem, hasSeed] of entries) { const pubFromPriv = createPublicKey(pem); assertPublicKey(pubFromPriv); assertPrivateKey(createPrivateKey(pem), hasSeed); diff --git a/test/parallel/test-crypto-pqc-keygen-ml-dsa.js b/test/parallel/test-crypto-pqc-keygen-ml-dsa.js index abad2c15cf01d1..e6534c988c4e2b 100644 --- a/test/parallel/test-crypto-pqc-keygen-ml-dsa.js +++ b/test/parallel/test-crypto-pqc-keygen-ml-dsa.js @@ -11,7 +11,7 @@ const { generateKeyPair, } = require('crypto'); -if (!hasOpenSSL(3, 5)) { +if (!hasOpenSSL(3, 5) && !process.features.openssl_is_boringssl) { for (const asymmetricKeyType of ['ml-dsa-44', 'ml-dsa-65', 'ml-dsa-87']) { assert.throws(() => generateKeyPair(asymmetricKeyType, common.mustNotCall()), { code: 'ERR_INVALID_ARG_VALUE', diff --git a/test/parallel/test-crypto-pqc-keygen-ml-kem.js b/test/parallel/test-crypto-pqc-keygen-ml-kem.js index ea3ac9f4dde137..620f65c3a8d156 100644 --- a/test/parallel/test-crypto-pqc-keygen-ml-kem.js +++ b/test/parallel/test-crypto-pqc-keygen-ml-kem.js @@ -11,7 +11,12 @@ const { generateKeyPair, } = require('crypto'); -if (!hasOpenSSL(3, 5)) { +const algorithms = process.features.openssl_is_boringssl ? + // BoringSSL does not support ML-KEM-512. + ['ml-kem-768', 'ml-kem-1024'] : + ['ml-kem-512', 'ml-kem-768', 'ml-kem-1024']; + +if (!hasOpenSSL(3, 5) && !process.features.openssl_is_boringssl) { for (const asymmetricKeyType of ['ml-kem-512', 'ml-kem-768', 'ml-kem-1024']) { assert.throws(() => generateKeyPair(asymmetricKeyType, common.mustNotCall()), { code: 'ERR_INVALID_ARG_VALUE', @@ -19,8 +24,7 @@ if (!hasOpenSSL(3, 5)) { }); } } else { - for (const asymmetricKeyType of ['ml-kem-512', 'ml-kem-768', 'ml-kem-1024']) { - + for (const asymmetricKeyType of algorithms) { function assertJwk(jwk) { assert.strictEqual(jwk.kty, 'AKP'); assert.strictEqual(jwk.alg, asymmetricKeyType.toUpperCase()); @@ -67,3 +71,10 @@ if (!hasOpenSSL(3, 5)) { } } } + +if (process.features.openssl_is_boringssl) { + assert.throws(() => generateKeyPair('ml-kem-512', common.mustNotCall()), { + code: 'ERR_INVALID_ARG_VALUE', + message: /The argument 'type' must be a supported key type/ + }); +} diff --git a/test/parallel/test-crypto-pqc-sign-verify-ml-dsa.js b/test/parallel/test-crypto-pqc-sign-verify-ml-dsa.js index 57d6692ca79b55..535e6a33d5ccb0 100644 --- a/test/parallel/test-crypto-pqc-sign-verify-ml-dsa.js +++ b/test/parallel/test-crypto-pqc-sign-verify-ml-dsa.js @@ -6,8 +6,8 @@ if (!common.hasCrypto) const { hasOpenSSL } = require('../common/crypto'); -if (!hasOpenSSL(3, 5)) - common.skip('requires OpenSSL >= 3.5'); +if (!hasOpenSSL(3, 5) && !process.features.openssl_is_boringssl) + common.skip('requires OpenSSL >= 3.5 or BoringSSL'); const assert = require('assert'); const { @@ -34,7 +34,15 @@ for (const [asymmetricKeyType, sigLen] of [ private_priv_only: fixtures.readKey(getKeyFileName(asymmetricKeyType, 'private_priv_only'), 'ascii'), }; - for (const privateKey of [keys.private, keys.private_seed_only, keys.private_priv_only]) { + for (const [privateKey, seedOnly] of [ + [keys.private, false], + [keys.private_seed_only, true], + [keys.private_priv_only, false], + ]) { + if (process.features.openssl_is_boringssl && !seedOnly) { + common.printSkipMessage('Skipping unsupported private key format test'); + continue; + } for (const data of [randomBytes(0), randomBytes(1), randomBytes(32), randomBytes(128), randomBytes(1024)]) { // sync { @@ -44,10 +52,12 @@ for (const [asymmetricKeyType, sigLen] of [ assert.strictEqual(verify(undefined, data, keys.public, Buffer.alloc(sigLen)), false); assert.strictEqual(verify(undefined, data, keys.public, signature), true); assert.strictEqual(verify(undefined, data, privateKey, signature), true); - assert.throws(() => sign('sha256', data, privateKey), { code: 'ERR_OSSL_INVALID_DIGEST' }); + const code = process.features.openssl_is_boringssl ? + 'ERR_OSSL_EVP_COMMAND_NOT_SUPPORTED' : 'ERR_OSSL_INVALID_DIGEST'; + assert.throws(() => sign('sha256', data, privateKey), { code }); assert.throws( () => verify('sha256', data, keys.public, Buffer.alloc(sigLen)), - { code: 'ERR_OSSL_INVALID_DIGEST' }); + { code }); } // async @@ -62,8 +72,9 @@ for (const [asymmetricKeyType, sigLen] of [ })); })); - sign('sha256', data, privateKey, common.expectsError(/invalid digest/)); - verify('sha256', data, keys.public, Buffer.alloc(sigLen), common.expectsError(/invalid digest/)); + const message = process.features.openssl_is_boringssl ? /COMMAND_NOT_SUPPORTED/ : /invalid digest/; + sign('sha256', data, privateKey, common.expectsError(message)); + verify('sha256', data, keys.public, Buffer.alloc(sigLen), common.expectsError(message)); } } } diff --git a/test/parallel/test-webcrypto-deduplicate-usages.js b/test/parallel/test-webcrypto-deduplicate-usages.js index e9ce750a9487f1..70b35f6cfa3849 100644 --- a/test/parallel/test-webcrypto-deduplicate-usages.js +++ b/test/parallel/test-webcrypto-deduplicate-usages.js @@ -107,7 +107,7 @@ function assertSameSet(actual, expected, msg) { privateExpected: ['deriveKey', 'deriveBits'] }, ]; - if (hasOpenSSL(3, 5)) { + if (hasOpenSSL(3, 5) || process.features.openssl_is_boringssl) { asymmetric.push({ algorithm: { name: 'ML-DSA-65' }, usages: ['verify', 'sign', 'verify', 'sign'], @@ -122,7 +122,7 @@ function assertSameSet(actual, expected, msg) { privateExpected: ['decapsulateKey', 'decapsulateBits'], }); } else { - common.printSkipMessage('ML-DSA and ML-KEM require OpenSSL >= 3.5'); + common.printSkipMessage('ML-DSA and ML-KEM require OpenSSL >= 3.5 or BoringSSL'); } for (const { algorithm, usages, publicExpected, privateExpected } of asymmetric) { @@ -289,7 +289,7 @@ function assertSameSet(actual, expected, msg) { assert.deepStrictEqual(imported.usages, ['sign']); })()); - if (hasOpenSSL(3, 5)) { + if (hasOpenSSL(3, 5) || process.features.openssl_is_boringssl) { // ML-DSA JWK roundtrip. tests.push((async () => { const { privateKey } = await subtle.generateKey( @@ -315,7 +315,7 @@ function assertSameSet(actual, expected, msg) { ['decapsulateKey', 'decapsulateBits']); })()); } else { - common.printSkipMessage('ML-DSA and ML-KEM require OpenSSL >= 3.5'); + common.printSkipMessage('ML-DSA and ML-KEM require OpenSSL >= 3.5 or BoringSSL'); } // Spki import of RSA public key. @@ -491,7 +491,7 @@ function assertSameSet(actual, expected, msg) { privateExpected: ['deriveKey', 'deriveBits'] }, ]; - if (hasOpenSSL(3, 5)) { + if (hasOpenSSL(3, 5) || process.features.openssl_is_boringssl) { jwkPairVectors.push({ algorithm: { name: 'ML-DSA-65' }, usages: ['verify', 'sign', 'verify', 'sign'], @@ -506,7 +506,7 @@ function assertSameSet(actual, expected, msg) { privateExpected: ['decapsulateKey', 'decapsulateBits'], }); } else { - common.printSkipMessage('ML-DSA and ML-KEM require OpenSSL >= 3.5'); + common.printSkipMessage('ML-DSA and ML-KEM require OpenSSL >= 3.5 or BoringSSL'); } for (const { algorithm, usages, publicExpected, privateExpected } of jwkPairVectors) { diff --git a/test/parallel/test-webcrypto-encap-decap-ml-kem.js b/test/parallel/test-webcrypto-encap-decap-ml-kem.js index 450ba2cefb0a4f..958a4d240db148 100644 --- a/test/parallel/test-webcrypto-encap-decap-ml-kem.js +++ b/test/parallel/test-webcrypto-encap-decap-ml-kem.js @@ -7,8 +7,8 @@ if (!common.hasCrypto) const { hasOpenSSL } = require('../common/crypto'); -if (!hasOpenSSL(3, 5)) - common.skip('requires OpenSSL >= 3.5'); +if (!hasOpenSSL(3, 5) && !process.features.openssl_is_boringssl) + common.skip('requires OpenSSL >= 3.5 or BoringSSL'); const assert = require('assert'); const crypto = require('crypto'); @@ -253,12 +253,16 @@ async function testDecapsulateBits({ name, publicKeyPem, privateKeyPem, results (async function() { const variations = []; - vectors.forEach((vector) => { + for (const vector of vectors) { + if (process.features.openssl_is_boringssl && vector.name === 'ML-KEM-512') { + common.printSkipMessage(`Skipping unsupported ${vector.name} test`); + continue; + } variations.push(testEncapsulateKey(vector)); variations.push(testEncapsulateBits(vector)); variations.push(testDecapsulateKey(vector)); variations.push(testDecapsulateBits(vector)); - }); + } await Promise.all(variations); })().then(common.mustCall()); diff --git a/test/parallel/test-webcrypto-export-import-ml-dsa.js b/test/parallel/test-webcrypto-export-import-ml-dsa.js index 63766a7b377c77..20d46870e430f1 100644 --- a/test/parallel/test-webcrypto-export-import-ml-dsa.js +++ b/test/parallel/test-webcrypto-export-import-ml-dsa.js @@ -7,8 +7,8 @@ if (!common.hasCrypto) const { hasOpenSSL } = require('../common/crypto'); -if (!hasOpenSSL(3, 5)) - common.skip('requires OpenSSL >= 3.5'); +if (!hasOpenSSL(3, 5) && !process.features.openssl_is_boringssl) + common.skip('requires OpenSSL >= 3.5 or BoringSSL'); const assert = require('assert'); const { subtle } = globalThis.crypto; @@ -96,12 +96,23 @@ async function testImportSpki({ name, publicUsages }, extractable) { } async function testImportPkcs8({ name, privateUsages }, extractable) { - const key = await subtle.importKey( - 'pkcs8', - keyData[name].pkcs8, - { name }, - extractable, - privateUsages); + let key; + try { + key = await subtle.importKey( + 'pkcs8', + keyData[name].pkcs8, + { name }, + extractable, + privateUsages); + } catch (err) { + if (process.features.openssl_is_boringssl) { + assert.strictEqual(err.name, 'DataError'); + assert.strictEqual(err.cause.code, 'ERR_OSSL_EVP_PRIVATE_KEY_WAS_NOT_SEED'); + common.printSkipMessage('Skipping unsupported private key format test'); + return; + } + throw err; + } assert.strictEqual(key.type, 'private'); assert.strictEqual(key.extractable, extractable); assert.deepStrictEqual(key.usages, privateUsages); @@ -480,14 +491,18 @@ async function testImportRawSeed({ name, privateUsages }, extractable) { }); })().then(common.mustCall()); -(async function() { - for (const { name, privateUsages } of testVectors) { - const pem = fixtures.readKey(getKeyFileName(name.toLowerCase(), 'private_priv_only'), 'ascii'); - const keyObject = createPrivateKey(pem); - const key = keyObject.toCryptoKey({ name }, true, privateUsages); - await assert.rejects(subtle.exportKey('pkcs8', key), (err) => { - assert.strictEqual(err.name, 'OperationError'); - return true; - }); - } -})().then(common.mustCall()); +if (!process.features.openssl_is_boringssl) { + (async function() { + for (const { name, privateUsages } of testVectors) { + const pem = fixtures.readKey(getKeyFileName(name.toLowerCase(), 'private_priv_only'), 'ascii'); + const keyObject = createPrivateKey(pem); + const key = keyObject.toCryptoKey({ name }, true, privateUsages); + await assert.rejects(subtle.exportKey('pkcs8', key), (err) => { + assert.strictEqual(err.name, 'OperationError'); + return true; + }); + } + })().then(common.mustCall()); +} else { + common.printSkipMessage('Skipping unsupported private key format test'); +} diff --git a/test/parallel/test-webcrypto-export-import-ml-kem.js b/test/parallel/test-webcrypto-export-import-ml-kem.js index 332d88d93f69d1..a3b1b3fe773090 100644 --- a/test/parallel/test-webcrypto-export-import-ml-kem.js +++ b/test/parallel/test-webcrypto-export-import-ml-kem.js @@ -7,8 +7,8 @@ if (!common.hasCrypto) const { hasOpenSSL } = require('../common/crypto'); -if (!hasOpenSSL(3, 5)) - common.skip('requires OpenSSL >= 3.5'); +if (!hasOpenSSL(3, 5) && !process.features.openssl_is_boringssl) + common.skip('requires OpenSSL >= 3.5 or BoringSSL'); const assert = require('assert'); const { subtle } = globalThis.crypto; @@ -96,12 +96,26 @@ async function testImportSpki({ name, publicUsages }, extractable) { } async function testImportPkcs8({ name, privateUsages }, extractable) { - const key = await subtle.importKey( - 'pkcs8', - keyData[name].pkcs8, - { name }, - extractable, - privateUsages); + let key; + try { + key = await subtle.importKey( + 'pkcs8', + keyData[name].pkcs8, + { name }, + extractable, + privateUsages); + } catch (err) { + if (process.features.openssl_is_boringssl) { + assert.strictEqual(err.name, 'DataError'); + // It should really only be ERR_OSSL_EVP_PRIVATE_KEY_WAS_NOT_SEED + // but BoringSSL is inconsistent between handling ML-KEM and ML-DSA + // Fixed in https://github.com/google/boringssl/commit/94c4c7f9e0eeeff72ea1ac6abf1aed5bd2a82c0c + assert.match(err.cause.code, /ERR_OSSL_EVP_UNSUPPORTED_ALGORITHM|ERR_OSSL_EVP_PRIVATE_KEY_WAS_NOT_SEED/); + common.printSkipMessage('Skipping unsupported private key format test'); + return; + } + throw err; + } assert.strictEqual(key.type, 'private'); assert.strictEqual(key.extractable, extractable); assert.deepStrictEqual(key.usages, privateUsages); @@ -239,7 +253,7 @@ async function testImportRawPublic({ name, publicUsages }, extractable) { subtle.importKey( 'raw-public', pub, - { name: name === 'ML-KEM-512' ? 'ML-KEM-768' : 'ML-KEM-512' }, + { name: name === 'ML-KEM-768' ? 'ML-KEM-1024' : 'ML-KEM-768' }, extractable, publicUsages), { message: 'Invalid keyData' }); } @@ -415,7 +429,7 @@ async function testImportJwk({ name, publicUsages, privateUsages }, extractable) privateUsages), // Invalid for a public key { message: /Unsupported key usage/ }); - for (const alg of [undefined, name === 'ML-KEM-512' ? 'ML-KEM-1024' : 'ML-KEM-512']) { + for (const alg of [undefined, name === 'ML-KEM-768' ? 'ML-KEM-1024' : 'ML-KEM-768']) { await assert.rejects( subtle.importKey( 'jwk', @@ -457,6 +471,10 @@ async function testImportJwk({ name, publicUsages, privateUsages }, extractable) (async function() { const tests = []; for (const vector of testVectors) { + if (process.features.openssl_is_boringssl && vector.name === 'ML-KEM-512') { + common.printSkipMessage('Skipping unsupported ML-KEM-512 test'); + continue; + } for (const extractable of [true, false]) { tests.push(testImportSpki(vector, extractable)); tests.push(testImportPkcs8(vector, extractable)); @@ -472,26 +490,14 @@ async function testImportJwk({ name, publicUsages, privateUsages }, extractable) })().then(common.mustCall()); (async function() { - const alg = 'ML-KEM-512'; + const alg = 'ML-KEM-768'; const pub = Buffer.from(keyData[alg].jwk.pub, 'base64url'); await assert.rejects(subtle.importKey('raw', pub, alg, false, []), { name: 'NotSupportedError', - message: 'Unable to import ML-KEM-512 using raw format', + message: 'Unable to import ML-KEM-768 using raw format', }); })().then(common.mustCall()); -(async function() { - for (const { name, privateUsages } of testVectors) { - const pem = fixtures.readKey(getKeyFileName(name.toLowerCase(), 'private_priv_only'), 'ascii'); - const keyObject = createPrivateKey(pem); - const key = keyObject.toCryptoKey({ name }, true, privateUsages); - await assert.rejects(subtle.exportKey('pkcs8', key), (err) => { - assert.strictEqual(err.name, 'OperationError'); - return true; - }); - } -})().then(common.mustCall()); - // Regression test: JWK `key_ops` validation must recognize ML-KEM operations // (encapsulateKey, encapsulateBits, decapsulateKey, decapsulateBits) so that // duplicate entries are rejected @@ -504,3 +510,19 @@ async function testImportJwk({ name, publicUsages, privateUsages }, extractable) { name: 'DataError', message: /Duplicate key operation/ }); } })().then(common.mustCall()); + +if (!process.features.openssl_is_boringssl) { + (async function() { + for (const { name, privateUsages } of testVectors) { + const pem = fixtures.readKey(getKeyFileName(name.toLowerCase(), 'private_priv_only'), 'ascii'); + const keyObject = createPrivateKey(pem); + const key = keyObject.toCryptoKey({ name }, true, privateUsages); + await assert.rejects(subtle.exportKey('pkcs8', key), (err) => { + assert.strictEqual(err.name, 'OperationError'); + return true; + }); + } + })().then(common.mustCall()); +} else { + common.printSkipMessage('Skipping unsupported private key format test'); +} diff --git a/test/parallel/test-webcrypto-keygen.js b/test/parallel/test-webcrypto-keygen.js index 323bb638c57d86..d73ffd21e563a5 100644 --- a/test/parallel/test-webcrypto-keygen.js +++ b/test/parallel/test-webcrypto-keygen.js @@ -196,7 +196,7 @@ if (hasOpenSSL(3)) { } } -if (hasOpenSSL(3, 5)) { +if (hasOpenSSL(3, 5) || process.features.openssl_is_boringssl) { for (const name of ['ML-DSA-44', 'ML-DSA-65', 'ML-DSA-87']) { vectors[name] = { result: 'CryptoKeyPair', @@ -765,7 +765,7 @@ assert.throws(() => new CryptoKey(), { code: 'ERR_ILLEGAL_CONSTRUCTOR' }); } // Test ML-DSA Key Generation -if (hasOpenSSL(3, 5)) { +if (hasOpenSSL(3, 5) || process.features.openssl_is_boringssl) { async function test( name, privateUsages, @@ -808,7 +808,7 @@ if (hasOpenSSL(3, 5)) { } // Test ML-KEM Key Generation -if (hasOpenSSL(3, 5)) { +if (hasOpenSSL(3, 5) || process.features.openssl_is_boringssl) { async function test( name, privateUsages, @@ -843,7 +843,13 @@ if (hasOpenSSL(3, 5)) { assert.strictEqual(publicKey.usages, publicKey.usages); } - const kTests = ['ML-KEM-512', 'ML-KEM-768', 'ML-KEM-1024']; + const kTests = ['ML-KEM-768', 'ML-KEM-1024']; + + if (!process.features.openssl_is_boringssl) { + kTests.unshift('ML-KEM-512'); + } else { + common.printSkipMessage('Skipping unsupported ML-KEM-512 test'); + } const tests = kTests.map((name) => test(name, ['decapsulateKey', 'decapsulateBits'], diff --git a/test/parallel/test-webcrypto-promise-prototype-pollution.mjs b/test/parallel/test-webcrypto-promise-prototype-pollution.mjs index b4fbedba5e3242..d479abe3dcc989 100644 --- a/test/parallel/test-webcrypto-promise-prototype-pollution.mjs +++ b/test/parallel/test-webcrypto-promise-prototype-pollution.mjs @@ -76,7 +76,7 @@ const { privateKey } = await subtle.generateKey( await subtle.getPublicKey(privateKey, ['verify']); -if (hasOpenSSL(3, 5)) { +if (hasOpenSSL(3, 5) || process.features.openssl_is_boringssl) { const kemPair = await subtle.generateKey( { name: 'ML-KEM-768' }, false, ['encapsulateKey', 'encapsulateBits', 'decapsulateKey', 'decapsulateBits']); diff --git a/test/parallel/test-webcrypto-sign-verify-ml-dsa.js b/test/parallel/test-webcrypto-sign-verify-ml-dsa.js index 1ed74c2508f438..b11e65ade79185 100644 --- a/test/parallel/test-webcrypto-sign-verify-ml-dsa.js +++ b/test/parallel/test-webcrypto-sign-verify-ml-dsa.js @@ -7,8 +7,8 @@ if (!common.hasCrypto) const { hasOpenSSL } = require('../common/crypto'); -if (!hasOpenSSL(3, 5)) - common.skip('requires OpenSSL >= 3.5'); +if (!hasOpenSSL(3, 5) && !process.features.openssl_is_boringssl) + common.skip('requires OpenSSL >= 3.5 or BoringSSL'); const assert = require('assert'); const crypto = require('crypto'); diff --git a/test/parallel/test-webcrypto-sign-verify.js b/test/parallel/test-webcrypto-sign-verify.js index 26e66d9aa0fa8b..0a6f5cffe7b934 100644 --- a/test/parallel/test-webcrypto-sign-verify.js +++ b/test/parallel/test-webcrypto-sign-verify.js @@ -173,7 +173,7 @@ if (!process.features.openssl_is_boringssl) { } // Test Sign/Verify ML-DSA -if (hasOpenSSL(3, 5)) { +if (hasOpenSSL(3, 5) || process.features.openssl_is_boringssl) { async function test(name, data) { const ec = new TextEncoder(); const { publicKey, privateKey } = await subtle.generateKey({ diff --git a/test/parallel/test-webcrypto-wrap-unwrap.js b/test/parallel/test-webcrypto-wrap-unwrap.js index a8450df571b47e..49f63e215fadfc 100644 --- a/test/parallel/test-webcrypto-wrap-unwrap.js +++ b/test/parallel/test-webcrypto-wrap-unwrap.js @@ -200,7 +200,7 @@ async function generateKeysToWrap() { }, ]; - if (hasOpenSSL(3, 5)) { + if (hasOpenSSL(3, 5) || process.features.openssl_is_boringssl) { for (const name of ['ML-DSA-44', 'ML-DSA-65', 'ML-DSA-87']) { parameters.push({ algorithm: { name }, diff --git a/test/wpt/status/WebCryptoAPI.cjs b/test/wpt/status/WebCryptoAPI.cjs index 316652d0730626..4b01978511548f 100644 --- a/test/wpt/status/WebCryptoAPI.cjs +++ b/test/wpt/status/WebCryptoAPI.cjs @@ -45,7 +45,7 @@ if (!hasOpenSSL(3, 2)) { 'import_export/Argon2_importKey.tentative.https.any.js'); } -if (!hasOpenSSL(3, 5)) { +if (!hasOpenSSL(3, 5) && !process.features.openssl_is_boringssl) { skip( 'encap_decap/encap_decap_bits.tentative.https.any.js', 'encap_decap/encap_decap_keys.tentative.https.any.js', @@ -77,6 +77,13 @@ if (process.features.openssl_is_boringssl) { 'import_export/okp_importKey_X448.tentative.https.any.js', 'sign_verify/eddsa_curve448.tentative.https.any.js'); + skipSubtests( + ['encap_decap/encap_decap_bits.tentative.https.any.js', /ml-kem-512/i], + ['encap_decap/encap_decap_keys.tentative.https.any.js', /ml-kem-512/i], + ['generateKey/failures_ML-KEM.tentative.https.any.js', /ml-kem-512/i], + ['generateKey/successes_ML-KEM.tentative.https.any.js', /ml-kem-512/i], + ['import_export/ML-KEM_importKey.tentative.https.any.js', /ml-kem-512/i], + ['supports-modern.tentative.https.any.js', /ml-kem-512/i]); } function assertNoOverlap(fileSkips, subtestSkips) {