mirror of
https://github.com/oven-sh/bun
synced 2026-02-02 15:08:46 +00:00
fix(http2): fix settings, window size handling, and dynamic header buffer allocation (#26119)
## Summary This PR fixes multiple HTTP/2 protocol compliance issues that were causing stream errors with various HTTP/2 clients (Fauna, gRPC/Connect, etc.). fixes https://github.com/oven-sh/bun/issues/12544 fixes https://github.com/oven-sh/bun/issues/25589 ### Key Fixes **Window Size and Settings Handling** - Fix initial stream window size to use `DEFAULT_WINDOW_SIZE` until `SETTINGS_ACK` is received - Per RFC 7540 Section 6.5.1: The sender can only rely on settings being applied AFTER receiving `SETTINGS_ACK` - Properly adjust existing stream windows when `INITIAL_WINDOW_SIZE` setting changes (RFC 7540 Section 6.9.2) **Header List Size Enforcement** - Implement `maxHeaderListSize` checking per RFC 7540 Section 6.5.2 - Track cumulative header list size using HPACK entry overhead (32 bytes per RFC 7541 Section 4.1) - Reject streams with `ENHANCE_YOUR_CALM` when header list exceeds configured limit **Custom Settings Support** - Add validation for `customSettings` option (up to 10 custom settings, matching Node.js `MAX_ADDITIONAL_SETTINGS`) - Validate setting IDs are in range `[0, 0xFFFF]` per RFC 7540 - Validate setting values are in range `[0, 2^32-1]` **Settings Validation Improvements** - Use float comparison for settings validation to handle large values correctly (was using `toInt32()` which truncates) - Use proper `HTTP2_INVALID_SETTING_VALUE_RangeError` error codes for Node.js compatibility **BufferFallbackAllocator** - New allocator that tries a provided buffer first, falls back to heap: - Similar to `std.heap.stackFallback` but accepts external buffer slice - Used with `shared_request_buffer` (16KB threadlocal) for common cases - Falls back to `bun.default_allocator` for large headers ## Test Plan - [x] `bun bd` compiles successfully - [x] Node.js HTTP/2 tests pass: `bun bd test/js/node/test/parallel/test-http2-connect.js` - [x] New regression tests for frame size issues: `bun bd test test/regression/issue/25589.test.ts` - [x] HTTP/2 continuation tests: `bun bd test test/js/node/http2/node-http2-continuation.test.ts` --------- Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com> Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com> Co-authored-by: Claude Bot <claude-bot@bun.sh> Co-authored-by: Jarred Sumner <jarred@jarredsumner.com>
This commit is contained in:
Ciro Spaciari
@@ -11,6 +11,7 @@ pub const AllocationScopeIn = allocation_scope.AllocationScopeIn;
|
||||
pub const NullableAllocator = @import("./allocators/NullableAllocator.zig");
|
||||
pub const MaxHeapAllocator = @import("./allocators/MaxHeapAllocator.zig");
|
||||
pub const LinuxMemFdAllocator = @import("./allocators/LinuxMemFdAllocator.zig");
|
||||
pub const BufferFallbackAllocator = @import("./allocators/BufferFallbackAllocator.zig");
|
||||
pub const MaybeOwned = @import("./allocators/maybe_owned.zig").MaybeOwned;
|
||||
|
||||
pub fn isSliceInBufferT(comptime T: type, slice: []const T, buffer: []const T) bool {
|
||||
|
||||
85
src/allocators/BufferFallbackAllocator.zig
Normal file
85
src/allocators/BufferFallbackAllocator.zig
Normal file
@@ -0,0 +1,85 @@
|
||||
/// An allocator that attempts to allocate from a provided buffer first,
|
||||
/// falling back to another allocator when the buffer is exhausted.
|
||||
/// Unlike `std.heap.StackFallbackAllocator`, this does not own the buffer.
|
||||
const BufferFallbackAllocator = @This();
|
||||
|
||||
#fallback_allocator: Allocator,
|
||||
#fixed_buffer_allocator: FixedBufferAllocator,
|
||||
|
||||
pub fn init(buffer: []u8, fallback_allocator: Allocator) BufferFallbackAllocator {
|
||||
return .{
|
||||
.#fallback_allocator = fallback_allocator,
|
||||
.#fixed_buffer_allocator = FixedBufferAllocator.init(buffer),
|
||||
};
|
||||
}
|
||||
|
||||
pub fn allocator(self: *BufferFallbackAllocator) Allocator {
|
||||
return .{
|
||||
.ptr = self,
|
||||
.vtable = &.{
|
||||
.alloc = alloc,
|
||||
.resize = resize,
|
||||
.remap = remap,
|
||||
.free = free,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
fn alloc(ctx: *anyopaque, len: usize, alignment: std.mem.Alignment, ra: usize) ?[*]u8 {
|
||||
const self: *BufferFallbackAllocator = @ptrCast(@alignCast(ctx));
|
||||
return FixedBufferAllocator.alloc(
|
||||
&self.#fixed_buffer_allocator,
|
||||
len,
|
||||
alignment,
|
||||
ra,
|
||||
) orelse self.#fallback_allocator.rawAlloc(len, alignment, ra);
|
||||
}
|
||||
|
||||
fn resize(ctx: *anyopaque, buf: []u8, alignment: std.mem.Alignment, new_len: usize, ra: usize) bool {
|
||||
const self: *BufferFallbackAllocator = @ptrCast(@alignCast(ctx));
|
||||
if (self.#fixed_buffer_allocator.ownsPtr(buf.ptr)) {
|
||||
return FixedBufferAllocator.resize(
|
||||
&self.#fixed_buffer_allocator,
|
||||
buf,
|
||||
alignment,
|
||||
new_len,
|
||||
ra,
|
||||
);
|
||||
}
|
||||
return self.#fallback_allocator.rawResize(buf, alignment, new_len, ra);
|
||||
}
|
||||
|
||||
fn remap(ctx: *anyopaque, memory: []u8, alignment: std.mem.Alignment, new_len: usize, ra: usize) ?[*]u8 {
|
||||
const self: *BufferFallbackAllocator = @ptrCast(@alignCast(ctx));
|
||||
if (self.#fixed_buffer_allocator.ownsPtr(memory.ptr)) {
|
||||
return FixedBufferAllocator.remap(
|
||||
&self.#fixed_buffer_allocator,
|
||||
memory,
|
||||
alignment,
|
||||
new_len,
|
||||
ra,
|
||||
);
|
||||
}
|
||||
return self.#fallback_allocator.rawRemap(memory, alignment, new_len, ra);
|
||||
}
|
||||
|
||||
fn free(ctx: *anyopaque, buf: []u8, alignment: std.mem.Alignment, ra: usize) void {
|
||||
const self: *BufferFallbackAllocator = @ptrCast(@alignCast(ctx));
|
||||
if (self.#fixed_buffer_allocator.ownsPtr(buf.ptr)) {
|
||||
return FixedBufferAllocator.free(
|
||||
&self.#fixed_buffer_allocator,
|
||||
buf,
|
||||
alignment,
|
||||
ra,
|
||||
);
|
||||
}
|
||||
return self.#fallback_allocator.rawFree(buf, alignment, ra);
|
||||
}
|
||||
|
||||
pub fn reset(self: *BufferFallbackAllocator) void {
|
||||
self.#fixed_buffer_allocator.reset();
|
||||
}
|
||||
|
||||
const std = @import("std");
|
||||
const Allocator = std.mem.Allocator;
|
||||
const FixedBufferAllocator = std.heap.FixedBufferAllocator;
|
||||
@@ -20,6 +20,17 @@ const MAX_HEADER_TABLE_SIZE = std.math.maxInt(u32);
|
||||
const MAX_STREAM_ID = std.math.maxInt(i32);
|
||||
const MAX_FRAME_SIZE = std.math.maxInt(u24);
|
||||
const DEFAULT_WINDOW_SIZE = std.math.maxInt(u16);
|
||||
// Float versions for range validation before integer conversion
|
||||
const MAX_WINDOW_SIZE_F64: f64 = @floatFromInt(MAX_WINDOW_SIZE);
|
||||
const MAX_HEADER_TABLE_SIZE_F64: f64 = @floatFromInt(MAX_HEADER_TABLE_SIZE);
|
||||
const MAX_FRAME_SIZE_F64: f64 = @floatFromInt(MAX_FRAME_SIZE);
|
||||
// RFC 7541 Section 4.1: Each header entry has 32 bytes of overhead
|
||||
// for the HPACK dynamic table entry structure
|
||||
const HPACK_ENTRY_OVERHEAD = 32;
|
||||
// Maximum number of custom settings (same as Node.js MAX_ADDITIONAL_SETTINGS)
|
||||
const MAX_CUSTOM_SETTINGS = 10;
|
||||
// Maximum custom setting ID (0xFFFF per RFC 7540)
|
||||
const MAX_CUSTOM_SETTING_ID: f64 = 0xFFFF;
|
||||
|
||||
const PaddingStrategy = enum {
|
||||
none,
|
||||
@@ -37,7 +48,7 @@ const FrameType = enum(u8) {
|
||||
HTTP_FRAME_PING = 0x06,
|
||||
HTTP_FRAME_GOAWAY = 0x07,
|
||||
HTTP_FRAME_WINDOW_UPDATE = 0x08,
|
||||
HTTP_FRAME_CONTINUATION = 0x09,
|
||||
HTTP_FRAME_CONTINUATION = 0x09, // RFC 7540 Section 6.10: Continues header block fragments
|
||||
HTTP_FRAME_ALTSVC = 0x0A, // https://datatracker.ietf.org/doc/html/rfc7838#section-7.2
|
||||
HTTP_FRAME_ORIGIN = 0x0C, // https://datatracker.ietf.org/doc/html/rfc8336#section-2
|
||||
};
|
||||
@@ -337,73 +348,73 @@ pub fn jsAssertSettings(globalObject: *jsc.JSGlobalObject, callframe: *jsc.CallF
|
||||
|
||||
if (try options.get(globalObject, "headerTableSize")) |headerTableSize| {
|
||||
if (headerTableSize.isNumber()) {
|
||||
const headerTableSizeValue = headerTableSize.toInt32();
|
||||
if (headerTableSizeValue > MAX_HEADER_TABLE_SIZE or headerTableSizeValue < 0) {
|
||||
return globalObject.throw("Expected headerTableSize to be a number between 0 and 2^32-1", .{});
|
||||
const value = headerTableSize.asNumber();
|
||||
if (value < 0 or value > MAX_HEADER_TABLE_SIZE_F64) {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE_RangeError, "Expected headerTableSize to be a number between 0 and 2^32-1", .{}).throw();
|
||||
}
|
||||
} else if (!headerTableSize.isEmptyOrUndefinedOrNull()) {
|
||||
return globalObject.throw("Expected headerTableSize to be a number", .{});
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE_RangeError, "Expected headerTableSize to be a number", .{}).throw();
|
||||
}
|
||||
}
|
||||
|
||||
if (try options.get(globalObject, "enablePush")) |enablePush| {
|
||||
if (!enablePush.isBoolean() and !enablePush.isEmptyOrUndefinedOrNull()) {
|
||||
return globalObject.throw("Expected enablePush to be a boolean", .{});
|
||||
if (!enablePush.isBoolean() and !enablePush.isUndefined()) {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE, "Expected enablePush to be a boolean", .{}).throw();
|
||||
}
|
||||
}
|
||||
|
||||
if (try options.get(globalObject, "initialWindowSize")) |initialWindowSize| {
|
||||
if (initialWindowSize.isNumber()) {
|
||||
const initialWindowSizeValue = initialWindowSize.toInt32();
|
||||
if (initialWindowSizeValue > MAX_HEADER_TABLE_SIZE or initialWindowSizeValue < 0) {
|
||||
return globalObject.throw("Expected initialWindowSize to be a number between 0 and 2^32-1", .{});
|
||||
const value = initialWindowSize.asNumber();
|
||||
if (value < 0 or value > MAX_WINDOW_SIZE_F64) {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE_RangeError, "Expected initialWindowSize to be a number between 0 and 2^32-1", .{}).throw();
|
||||
}
|
||||
} else if (!initialWindowSize.isEmptyOrUndefinedOrNull()) {
|
||||
return globalObject.throw("Expected initialWindowSize to be a number", .{});
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE_RangeError, "Expected initialWindowSize to be a number", .{}).throw();
|
||||
}
|
||||
}
|
||||
|
||||
if (try options.get(globalObject, "maxFrameSize")) |maxFrameSize| {
|
||||
if (maxFrameSize.isNumber()) {
|
||||
const maxFrameSizeValue = maxFrameSize.toInt32();
|
||||
if (maxFrameSizeValue > MAX_FRAME_SIZE or maxFrameSizeValue < 16384) {
|
||||
return globalObject.throw("Expected maxFrameSize to be a number between 16,384 and 2^24-1", .{});
|
||||
const value = maxFrameSize.asNumber();
|
||||
if (value < 16384 or value > MAX_FRAME_SIZE_F64) {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE_RangeError, "Expected maxFrameSize to be a number between 16,384 and 2^24-1", .{}).throw();
|
||||
}
|
||||
} else if (!maxFrameSize.isEmptyOrUndefinedOrNull()) {
|
||||
return globalObject.throw("Expected maxFrameSize to be a number", .{});
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE_RangeError, "Expected maxFrameSize to be a number", .{}).throw();
|
||||
}
|
||||
}
|
||||
|
||||
if (try options.get(globalObject, "maxConcurrentStreams")) |maxConcurrentStreams| {
|
||||
if (maxConcurrentStreams.isNumber()) {
|
||||
const maxConcurrentStreamsValue = maxConcurrentStreams.toInt32();
|
||||
if (maxConcurrentStreamsValue > MAX_HEADER_TABLE_SIZE or maxConcurrentStreamsValue < 0) {
|
||||
return globalObject.throw("Expected maxConcurrentStreams to be a number between 0 and 2^32-1", .{});
|
||||
const value = maxConcurrentStreams.asNumber();
|
||||
if (value < 0 or value > MAX_HEADER_TABLE_SIZE_F64) {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE_RangeError, "Expected maxConcurrentStreams to be a number between 0 and 2^32-1", .{}).throw();
|
||||
}
|
||||
} else if (!maxConcurrentStreams.isEmptyOrUndefinedOrNull()) {
|
||||
return globalObject.throw("Expected maxConcurrentStreams to be a number", .{});
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE_RangeError, "Expected maxConcurrentStreams to be a number", .{}).throw();
|
||||
}
|
||||
}
|
||||
|
||||
if (try options.get(globalObject, "maxHeaderListSize")) |maxHeaderListSize| {
|
||||
if (maxHeaderListSize.isNumber()) {
|
||||
const maxHeaderListSizeValue = maxHeaderListSize.toInt32();
|
||||
if (maxHeaderListSizeValue > MAX_HEADER_TABLE_SIZE or maxHeaderListSizeValue < 0) {
|
||||
return globalObject.throw("Expected maxHeaderListSize to be a number between 0 and 2^32-1", .{});
|
||||
const value = maxHeaderListSize.asNumber();
|
||||
if (value < 0 or value > MAX_HEADER_TABLE_SIZE_F64) {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE_RangeError, "Expected maxHeaderListSize to be a number between 0 and 2^32-1", .{}).throw();
|
||||
}
|
||||
} else if (!maxHeaderListSize.isEmptyOrUndefinedOrNull()) {
|
||||
return globalObject.throw("Expected maxHeaderListSize to be a number", .{});
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE_RangeError, "Expected maxHeaderListSize to be a number", .{}).throw();
|
||||
}
|
||||
}
|
||||
|
||||
if (try options.get(globalObject, "maxHeaderSize")) |maxHeaderSize| {
|
||||
if (maxHeaderSize.isNumber()) {
|
||||
const maxHeaderSizeValue = maxHeaderSize.toInt32();
|
||||
if (maxHeaderSizeValue > MAX_HEADER_TABLE_SIZE or maxHeaderSizeValue < 0) {
|
||||
return globalObject.throw("Expected maxHeaderSize to be a number between 0 and 2^32-1", .{});
|
||||
const value = maxHeaderSize.asNumber();
|
||||
if (value < 0 or value > MAX_HEADER_TABLE_SIZE_F64) {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE_RangeError, "Expected maxHeaderSize to be a number between 0 and 2^32-1", .{}).throw();
|
||||
}
|
||||
} else if (!maxHeaderSize.isEmptyOrUndefinedOrNull()) {
|
||||
return globalObject.throw("Expected maxHeaderSize to be a number", .{});
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE_RangeError, "Expected maxHeaderSize to be a number", .{}).throw();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -683,6 +694,37 @@ pub const H2FrameParser = struct {
|
||||
|
||||
threadlocal var shared_request_buffer: [16384]u8 = undefined;
|
||||
|
||||
/// Encodes a single header into the ArrayList, growing if needed.
|
||||
/// Returns the number of bytes written, or error on failure.
|
||||
///
|
||||
/// Capacity estimation: name.len + value.len + HPACK_ENTRY_OVERHEAD
|
||||
///
|
||||
/// Per RFC 7541, the HPACK wire format for a literal header field is:
|
||||
/// - 1 byte: type indicator (literal with/without indexing, never indexed)
|
||||
/// - 1-6 bytes: name length as variable-length integer (7-bit prefix)
|
||||
/// - N bytes: name string (raw or Huffman-encoded)
|
||||
/// - 1-6 bytes: value length as variable-length integer (7-bit prefix)
|
||||
/// - M bytes: value string (raw or Huffman-encoded)
|
||||
///
|
||||
/// For most headers (name/value < 127 bytes), this is ~3 bytes overhead.
|
||||
/// Using HPACK_ENTRY_OVERHEAD (32 bytes, from RFC 7541 Section 4.1) is a
|
||||
/// conservative estimate that accounts for worst-case variable integer
|
||||
/// encoding and ensures we never underallocate, even with very large headers.
|
||||
fn encodeHeaderIntoList(
|
||||
this: *H2FrameParser,
|
||||
encoded_headers: *std.ArrayListUnmanaged(u8),
|
||||
alloc: std.mem.Allocator,
|
||||
name: []const u8,
|
||||
value: []const u8,
|
||||
never_index: bool,
|
||||
) !usize {
|
||||
const required = encoded_headers.items.len + name.len + value.len + HPACK_ENTRY_OVERHEAD;
|
||||
try encoded_headers.ensureTotalCapacity(alloc, required);
|
||||
const bytes_written = try this.encode(encoded_headers.allocatedSlice(), encoded_headers.items.len, name, value, never_index);
|
||||
encoded_headers.items.len += bytes_written;
|
||||
return bytes_written;
|
||||
}
|
||||
|
||||
/// The streams hashmap may mutate when growing we use this when we need to make sure its safe to iterate over it
|
||||
pub const StreamResumableIterator = struct {
|
||||
parser: *H2FrameParser,
|
||||
@@ -1856,6 +1898,8 @@ pub const H2FrameParser = struct {
|
||||
|
||||
var sensitiveHeaders: JSValue = .js_undefined;
|
||||
var count: usize = 0;
|
||||
// RFC 7540 Section 6.5.2: Track cumulative header list size
|
||||
var headerListSize: usize = 0;
|
||||
|
||||
while (true) {
|
||||
const header = this.decode(payload[offset..]) catch break;
|
||||
@@ -1867,6 +1911,23 @@ pub const H2FrameParser = struct {
|
||||
if (this.streams.getEntry(stream_id)) |entry| return entry.value_ptr;
|
||||
return null;
|
||||
}
|
||||
|
||||
// RFC 7540 Section 6.5.2: Calculate header list size
|
||||
// Size = name length + value length + HPACK entry overhead per header
|
||||
headerListSize += header.name.len + header.value.len + HPACK_ENTRY_OVERHEAD;
|
||||
|
||||
// Check against maxHeaderListSize setting
|
||||
if (headerListSize > this.localSettings.maxHeaderListSize) {
|
||||
this.rejectedStreams += 1;
|
||||
if (this.maxRejectedStreams <= this.rejectedStreams) {
|
||||
this.sendGoAway(stream_id, ErrorCode.ENHANCE_YOUR_CALM, "ENHANCE_YOUR_CALM", this.lastStreamID, true);
|
||||
} else {
|
||||
this.endStream(stream, ErrorCode.ENHANCE_YOUR_CALM);
|
||||
}
|
||||
if (this.streams.getEntry(stream_id)) |entry| return entry.value_ptr;
|
||||
return null;
|
||||
}
|
||||
|
||||
count += 1;
|
||||
if (this.maxHeaderListPairs < count) {
|
||||
this.rejectedStreams += 1;
|
||||
@@ -2231,6 +2292,11 @@ pub const H2FrameParser = struct {
|
||||
return data.len;
|
||||
}
|
||||
|
||||
/// RFC 7540 Section 6.10: Handle CONTINUATION frame (type=0x9).
|
||||
/// CONTINUATION frames continue header block fragments that don't fit in a single HEADERS frame.
|
||||
/// - Must follow a HEADERS, PUSH_PROMISE, or CONTINUATION frame without END_HEADERS flag
|
||||
/// - No padding allowed (unlike HEADERS frames)
|
||||
/// - Must have same stream identifier as the initiating frame
|
||||
pub fn handleContinuationFrame(this: *H2FrameParser, frame: FrameHeader, data: []const u8, stream_: ?*Stream) bun.JSError!usize {
|
||||
log("handleContinuationFrame", .{});
|
||||
var stream = stream_ orelse {
|
||||
@@ -2364,6 +2430,25 @@ pub const H2FrameParser = struct {
|
||||
// we can now write any request
|
||||
if (this.outstandingSettings > 0) {
|
||||
this.outstandingSettings -= 1;
|
||||
|
||||
// Per RFC 7540 Section 6.9.2: When INITIAL_WINDOW_SIZE changes, adjust
|
||||
// all existing stream windows by the difference. Now that our SETTINGS
|
||||
// is ACKed, the peer knows about our window size, so we can enforce it.
|
||||
if (this.outstandingSettings == 0 and this.localSettings.initialWindowSize != DEFAULT_WINDOW_SIZE) {
|
||||
const old_size: i64 = DEFAULT_WINDOW_SIZE;
|
||||
const new_size: i64 = this.localSettings.initialWindowSize;
|
||||
const delta = new_size - old_size;
|
||||
var it = this.streams.valueIterator();
|
||||
while (it.next()) |stream| {
|
||||
// Adjust the stream's local window size by the delta
|
||||
if (delta >= 0) {
|
||||
stream.windowSize +|= @intCast(@as(u64, @intCast(delta)));
|
||||
} else {
|
||||
stream.windowSize -|= @intCast(@as(u64, @intCast(-delta)));
|
||||
}
|
||||
}
|
||||
log("adjusted stream windows by delta {} (old: {}, new: {})", .{ delta, old_size, new_size });
|
||||
}
|
||||
}
|
||||
|
||||
this.dispatch(.onLocalSettings, this.localSettings.toJS(this.handlers.globalObject));
|
||||
@@ -2443,9 +2528,17 @@ pub const H2FrameParser = struct {
|
||||
// new stream open
|
||||
const entry = bun.handleOom(this.streams.getOrPut(streamIdentifier));
|
||||
|
||||
// Per RFC 7540 Section 6.5.1: The sender of SETTINGS can only rely on the
|
||||
// setting being applied AFTER receiving SETTINGS_ACK. Until then, the peer
|
||||
// hasn't seen our settings and uses the default window size.
|
||||
// So we must accept data up to DEFAULT_WINDOW_SIZE until our SETTINGS is ACKed.
|
||||
const local_window_size = if (this.outstandingSettings > 0)
|
||||
DEFAULT_WINDOW_SIZE
|
||||
else
|
||||
this.localSettings.initialWindowSize;
|
||||
entry.value_ptr.* = Stream.init(
|
||||
streamIdentifier,
|
||||
this.localSettings.initialWindowSize,
|
||||
local_window_size,
|
||||
if (this.remoteSettings) |s| s.initialWindowSize else DEFAULT_WINDOW_SIZE,
|
||||
this.paddingStrategy,
|
||||
);
|
||||
@@ -2612,82 +2705,126 @@ pub const H2FrameParser = struct {
|
||||
|
||||
if (try options.get(globalObject, "headerTableSize")) |headerTableSize| {
|
||||
if (headerTableSize.isNumber()) {
|
||||
const headerTableSizeValue = headerTableSize.toInt32();
|
||||
if (headerTableSizeValue > MAX_HEADER_TABLE_SIZE or headerTableSizeValue < 0) {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE, "Expected headerTableSize to be a number between 0 and 2^32-1", .{}).throw();
|
||||
const value = headerTableSize.asNumber();
|
||||
if (value < 0 or value > MAX_HEADER_TABLE_SIZE_F64) {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE_RangeError, "Expected headerTableSize to be a number between 0 and 2^32-1", .{}).throw();
|
||||
}
|
||||
this.localSettings.headerTableSize = @intCast(headerTableSizeValue);
|
||||
this.localSettings.headerTableSize = @intFromFloat(value);
|
||||
} else if (!headerTableSize.isEmptyOrUndefinedOrNull()) {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE, "Expected headerTableSize to be a number", .{}).throw();
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE_RangeError, "Expected headerTableSize to be a number", .{}).throw();
|
||||
}
|
||||
}
|
||||
|
||||
if (try options.get(globalObject, "enablePush")) |enablePush| {
|
||||
if (enablePush.isBoolean()) {
|
||||
this.localSettings.enablePush = if (enablePush.asBoolean()) 1 else 0;
|
||||
} else if (!enablePush.isEmptyOrUndefinedOrNull()) {
|
||||
} else if (!enablePush.isUndefined()) {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE, "Expected enablePush to be a boolean", .{}).throw();
|
||||
}
|
||||
}
|
||||
|
||||
if (try options.get(globalObject, "initialWindowSize")) |initialWindowSize| {
|
||||
if (initialWindowSize.isNumber()) {
|
||||
const initialWindowSizeValue = initialWindowSize.toInt32();
|
||||
if (initialWindowSizeValue > MAX_WINDOW_SIZE or initialWindowSizeValue < 0) {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE, "Expected initialWindowSize to be a number between 0 and 2^32-1", .{}).throw();
|
||||
const value = initialWindowSize.asNumber();
|
||||
if (value < 0 or value > MAX_WINDOW_SIZE_F64) {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE_RangeError, "Expected initialWindowSize to be a number between 0 and 2^32-1", .{}).throw();
|
||||
}
|
||||
log("initialWindowSize: {d}", .{initialWindowSizeValue});
|
||||
this.localSettings.initialWindowSize = @intCast(initialWindowSizeValue);
|
||||
log("initialWindowSize: {d}", .{@as(u32, @intFromFloat(value))});
|
||||
this.localSettings.initialWindowSize = @intFromFloat(value);
|
||||
} else if (!initialWindowSize.isEmptyOrUndefinedOrNull()) {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE, "Expected initialWindowSize to be a number", .{}).throw();
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE_RangeError, "Expected initialWindowSize to be a number", .{}).throw();
|
||||
}
|
||||
}
|
||||
|
||||
if (try options.get(globalObject, "maxFrameSize")) |maxFrameSize| {
|
||||
if (maxFrameSize.isNumber()) {
|
||||
const maxFrameSizeValue = maxFrameSize.toInt32();
|
||||
if (maxFrameSizeValue > MAX_FRAME_SIZE or maxFrameSizeValue < 16384) {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE, "Expected maxFrameSize to be a number between 16,384 and 2^24-1", .{}).throw();
|
||||
const value = maxFrameSize.asNumber();
|
||||
if (value < 16384 or value > MAX_FRAME_SIZE_F64) {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE_RangeError, "Expected maxFrameSize to be a number between 16,384 and 2^24-1", .{}).throw();
|
||||
}
|
||||
this.localSettings.maxFrameSize = @intCast(maxFrameSizeValue);
|
||||
this.localSettings.maxFrameSize = @intFromFloat(value);
|
||||
} else if (!maxFrameSize.isEmptyOrUndefinedOrNull()) {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE, "Expected maxFrameSize to be a number", .{}).throw();
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE_RangeError, "Expected maxFrameSize to be a number", .{}).throw();
|
||||
}
|
||||
}
|
||||
|
||||
if (try options.get(globalObject, "maxConcurrentStreams")) |maxConcurrentStreams| {
|
||||
if (maxConcurrentStreams.isNumber()) {
|
||||
const maxConcurrentStreamsValue = maxConcurrentStreams.toInt32();
|
||||
if (maxConcurrentStreamsValue > MAX_HEADER_TABLE_SIZE or maxConcurrentStreamsValue < 0) {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE, "Expected maxConcurrentStreams to be a number between 0 and 2^32-1", .{}).throw();
|
||||
const value = maxConcurrentStreams.asNumber();
|
||||
if (value < 0 or value > MAX_HEADER_TABLE_SIZE_F64) {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE_RangeError, "Expected maxConcurrentStreams to be a number between 0 and 2^32-1", .{}).throw();
|
||||
}
|
||||
this.localSettings.maxConcurrentStreams = @intCast(maxConcurrentStreamsValue);
|
||||
this.localSettings.maxConcurrentStreams = @intFromFloat(value);
|
||||
} else if (!maxConcurrentStreams.isEmptyOrUndefinedOrNull()) {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE, "Expected maxConcurrentStreams to be a number", .{}).throw();
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE_RangeError, "Expected maxConcurrentStreams to be a number", .{}).throw();
|
||||
}
|
||||
}
|
||||
|
||||
if (try options.get(globalObject, "maxHeaderListSize")) |maxHeaderListSize| {
|
||||
if (maxHeaderListSize.isNumber()) {
|
||||
const maxHeaderListSizeValue = maxHeaderListSize.toInt32();
|
||||
if (maxHeaderListSizeValue > MAX_HEADER_TABLE_SIZE or maxHeaderListSizeValue < 0) {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE, "Expected maxHeaderListSize to be a number between 0 and 2^32-1", .{}).throw();
|
||||
const value = maxHeaderListSize.asNumber();
|
||||
if (value < 0 or value > MAX_HEADER_TABLE_SIZE_F64) {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE_RangeError, "Expected maxHeaderListSize to be a number between 0 and 2^32-1", .{}).throw();
|
||||
}
|
||||
this.localSettings.maxHeaderListSize = @intCast(maxHeaderListSizeValue);
|
||||
this.localSettings.maxHeaderListSize = @intFromFloat(value);
|
||||
} else if (!maxHeaderListSize.isEmptyOrUndefinedOrNull()) {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE, "Expected maxHeaderListSize to be a number", .{}).throw();
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE_RangeError, "Expected maxHeaderListSize to be a number", .{}).throw();
|
||||
}
|
||||
}
|
||||
|
||||
if (try options.get(globalObject, "maxHeaderSize")) |maxHeaderSize| {
|
||||
if (maxHeaderSize.isNumber()) {
|
||||
const maxHeaderSizeValue = maxHeaderSize.toInt32();
|
||||
if (maxHeaderSizeValue > MAX_HEADER_TABLE_SIZE or maxHeaderSizeValue < 0) {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE, "Expected maxHeaderSize to be a number between 0 and 2^32-1", .{}).throw();
|
||||
const value = maxHeaderSize.asNumber();
|
||||
if (value < 0 or value > MAX_HEADER_TABLE_SIZE_F64) {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE_RangeError, "Expected maxHeaderSize to be a number between 0 and 2^32-1", .{}).throw();
|
||||
}
|
||||
this.localSettings.maxHeaderListSize = @intCast(maxHeaderSizeValue);
|
||||
this.localSettings.maxHeaderListSize = @intFromFloat(value);
|
||||
} else if (!maxHeaderSize.isEmptyOrUndefinedOrNull()) {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE, "Expected maxHeaderSize to be a number", .{}).throw();
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE_RangeError, "Expected maxHeaderSize to be a number", .{}).throw();
|
||||
}
|
||||
}
|
||||
|
||||
// Validate customSettings
|
||||
if (try options.get(globalObject, "customSettings")) |customSettings| {
|
||||
if (!customSettings.isUndefined()) {
|
||||
const custom_settings_obj = customSettings.getObject() orelse {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE, "Expected customSettings to be an object", .{}).throw();
|
||||
};
|
||||
|
||||
var count: usize = 0;
|
||||
var iter = try jsc.JSPropertyIterator(.{
|
||||
.skip_empty_name = false,
|
||||
.include_value = true,
|
||||
}).init(globalObject, custom_settings_obj);
|
||||
defer iter.deinit();
|
||||
|
||||
while (try iter.next()) |prop_name| {
|
||||
count += 1;
|
||||
if (count > MAX_CUSTOM_SETTINGS) {
|
||||
return globalObject.ERR(.HTTP2_TOO_MANY_CUSTOM_SETTINGS, "Number of custom settings exceeds MAX_ADDITIONAL_SETTINGS", .{}).throw();
|
||||
}
|
||||
|
||||
// Validate setting ID (key) is in range [0, 0xFFFF]
|
||||
const setting_id_str = prop_name.toUTF8(bun.default_allocator);
|
||||
defer setting_id_str.deinit();
|
||||
const setting_id = std.fmt.parseInt(u32, setting_id_str.slice(), 10) catch {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE_RangeError, "Invalid custom setting identifier", .{}).throw();
|
||||
};
|
||||
if (setting_id > 0xFFFF) {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE_RangeError, "Invalid custom setting identifier", .{}).throw();
|
||||
}
|
||||
|
||||
// Validate setting value is in range [0, 2^32-1]
|
||||
const setting_value = iter.value;
|
||||
if (setting_value.isNumber()) {
|
||||
const value = setting_value.asNumber();
|
||||
if (value < 0 or value > MAX_HEADER_TABLE_SIZE_F64) {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE_RangeError, "Invalid custom setting value", .{}).throw();
|
||||
}
|
||||
} else {
|
||||
return globalObject.ERR(.HTTP2_INVALID_SETTING_VALUE_RangeError, "Expected custom setting value to be a number", .{}).throw();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return;
|
||||
@@ -3404,9 +3541,20 @@ pub const H2FrameParser = struct {
|
||||
return globalObject.throw("Expected sensitiveHeaders to be an object", .{});
|
||||
}
|
||||
|
||||
// max frame size will be always at least 16384
|
||||
var buffer = shared_request_buffer[0 .. shared_request_buffer.len - FrameHeader.byteSize];
|
||||
var encoded_size: usize = 0;
|
||||
// Use remote settings maxFrameSize if available, otherwise default to localSettings
|
||||
const settings = this.remoteSettings orelse this.localSettings;
|
||||
_ = settings;
|
||||
// Use shared buffer when possible, fall back to heap for large headers
|
||||
var buf_fallback = bun.allocators.BufferFallbackAllocator.init(&shared_request_buffer, bun.default_allocator);
|
||||
const alloc = buf_fallback.allocator();
|
||||
// Use ArrayList with initial capacity of shared buffer size, doubling when needed
|
||||
var encoded_headers = std.ArrayListUnmanaged(u8){};
|
||||
// IMPORTANT: defer cleanup immediately after init to prevent memory leaks on early returns
|
||||
defer encoded_headers.deinit(alloc);
|
||||
// Pre-allocate to shared buffer size (this uses the stack buffer via BufferFallbackAllocator)
|
||||
encoded_headers.ensureTotalCapacity(alloc, shared_request_buffer.len) catch {
|
||||
return globalObject.throw("Failed to allocate header buffer", .{});
|
||||
};
|
||||
// max header name length for lshpack
|
||||
var name_buffer: [4096]u8 = undefined;
|
||||
@memset(&name_buffer, 0);
|
||||
@@ -3420,7 +3568,7 @@ pub const H2FrameParser = struct {
|
||||
var single_value_headers: [SingleValueHeaders.keys().len]bool = undefined;
|
||||
@memset(&single_value_headers, false);
|
||||
|
||||
// TODO: support CONTINUE for more headers if headers are too big
|
||||
// Encode trailer headers using HPACK
|
||||
while (try iter.next()) |header_name| {
|
||||
if (header_name.length() == 0) continue;
|
||||
|
||||
@@ -3474,7 +3622,10 @@ pub const H2FrameParser = struct {
|
||||
const value = value_slice.slice();
|
||||
log("encode header {s} {s}", .{ validated_name, value });
|
||||
|
||||
encoded_size += this.encode(buffer, encoded_size, validated_name, value, never_index) catch {
|
||||
_ = this.encodeHeaderIntoList(&encoded_headers, alloc, validated_name, value, never_index) catch |err| {
|
||||
if (err == error.OutOfMemory) {
|
||||
return globalObject.throw("Failed to allocate header buffer", .{});
|
||||
}
|
||||
stream.state = .CLOSED;
|
||||
const identifier = stream.getIdentifier();
|
||||
identifier.ensureStillAlive();
|
||||
@@ -3511,7 +3662,10 @@ pub const H2FrameParser = struct {
|
||||
const value = value_slice.slice();
|
||||
log("encode header {s} {s}", .{ name, value });
|
||||
|
||||
encoded_size += this.encode(buffer, encoded_size, validated_name, value, never_index) catch {
|
||||
_ = this.encodeHeaderIntoList(&encoded_headers, alloc, validated_name, value, never_index) catch |err| {
|
||||
if (err == error.OutOfMemory) {
|
||||
return globalObject.throw("Failed to allocate header buffer", .{});
|
||||
}
|
||||
stream.state = .CLOSED;
|
||||
const identifier = stream.getIdentifier();
|
||||
identifier.ensureStillAlive();
|
||||
@@ -3523,25 +3677,75 @@ pub const H2FrameParser = struct {
|
||||
jsc.JSValue.jsNumber(@intFromEnum(FrameType.HTTP_FRAME_HEADERS)),
|
||||
jsc.JSValue.jsNumber(@intFromEnum(ErrorCode.FRAME_SIZE_ERROR)),
|
||||
);
|
||||
|
||||
this.dispatchWithExtra(.onStreamError, identifier, jsc.JSValue.jsNumber(stream.rstCode));
|
||||
|
||||
return .js_undefined;
|
||||
};
|
||||
}
|
||||
}
|
||||
const flags: u8 = @intFromEnum(HeadersFrameFlags.END_HEADERS) | @intFromEnum(HeadersFrameFlags.END_STREAM);
|
||||
const encoded_data = encoded_headers.items;
|
||||
const encoded_size = encoded_data.len;
|
||||
|
||||
// RFC 7540 Section 8.1: Trailers are sent as a HEADERS frame with END_STREAM flag
|
||||
const base_flags: u8 = @intFromEnum(HeadersFrameFlags.END_STREAM);
|
||||
// RFC 7540 Section 4.2: SETTINGS_MAX_FRAME_SIZE determines max frame payload
|
||||
const actual_max_frame_size = (this.remoteSettings orelse this.localSettings).maxFrameSize;
|
||||
|
||||
log("trailers encoded_size {}", .{encoded_size});
|
||||
|
||||
const writer = this.toWriter();
|
||||
|
||||
// RFC 7540 Section 6.2 & 6.10: Check if we need CONTINUATION frames
|
||||
if (encoded_size <= actual_max_frame_size) {
|
||||
// Single HEADERS frame - header block fits in one frame
|
||||
var frame: FrameHeader = .{
|
||||
.type = @intFromEnum(FrameType.HTTP_FRAME_HEADERS),
|
||||
.flags = flags,
|
||||
.flags = base_flags | @intFromEnum(HeadersFrameFlags.END_HEADERS),
|
||||
.streamIdentifier = stream.id,
|
||||
.length = @intCast(encoded_size),
|
||||
};
|
||||
const writer = this.toWriter();
|
||||
_ = frame.write(@TypeOf(writer), writer);
|
||||
_ = writer.write(buffer[0..encoded_size]) catch 0;
|
||||
_ = writer.write(encoded_data) catch 0;
|
||||
} else {
|
||||
// RFC 7540 Section 6.2 & 6.10: Header block exceeds MAX_FRAME_SIZE.
|
||||
// Must split into HEADERS frame followed by one or more CONTINUATION frames.
|
||||
// Note: CONTINUATION frames cannot have padding (Section 6.10) - they carry
|
||||
// only header block fragments. END_HEADERS must be set on the last frame.
|
||||
log("Using CONTINUATION frames for trailers: encoded_size={d} max_frame_size={d}", .{ encoded_size, actual_max_frame_size });
|
||||
|
||||
// RFC 7540 Section 6.2: First chunk goes in HEADERS frame (without END_HEADERS flag)
|
||||
// Trailers use END_STREAM but NOT END_HEADERS when more frames follow
|
||||
const first_chunk_size = actual_max_frame_size;
|
||||
|
||||
var headers_frame: FrameHeader = .{
|
||||
.type = @intFromEnum(FrameType.HTTP_FRAME_HEADERS),
|
||||
.flags = base_flags, // END_STREAM but NOT END_HEADERS
|
||||
.streamIdentifier = stream.id,
|
||||
.length = @intCast(first_chunk_size),
|
||||
};
|
||||
_ = headers_frame.write(@TypeOf(writer), writer);
|
||||
_ = writer.write(encoded_data[0..first_chunk_size]) catch 0;
|
||||
|
||||
// RFC 7540 Section 6.10: CONTINUATION frames carry remaining header block fragments.
|
||||
// They have no padding, no priority - just frame header + header block fragment.
|
||||
var offset: usize = first_chunk_size;
|
||||
while (offset < encoded_size) {
|
||||
const remaining = encoded_size - offset;
|
||||
const chunk_size = @min(remaining, actual_max_frame_size);
|
||||
const is_last = (offset + chunk_size >= encoded_size);
|
||||
|
||||
// RFC 7540 Section 6.10: END_HEADERS flag must be set on the last frame
|
||||
var cont_frame: FrameHeader = .{
|
||||
.type = @intFromEnum(FrameType.HTTP_FRAME_CONTINUATION),
|
||||
.flags = if (is_last) @intFromEnum(HeadersFrameFlags.END_HEADERS) else 0,
|
||||
.streamIdentifier = stream.id,
|
||||
.length = @intCast(chunk_size),
|
||||
};
|
||||
_ = cont_frame.write(@TypeOf(writer), writer);
|
||||
_ = writer.write(encoded_data[offset..][0..chunk_size]) catch 0;
|
||||
|
||||
offset += chunk_size;
|
||||
}
|
||||
}
|
||||
const identifier = stream.getIdentifier();
|
||||
identifier.ensureStillAlive();
|
||||
if (stream.state == .HALF_CLOSED_REMOTE) {
|
||||
@@ -3805,9 +4009,20 @@ pub const H2FrameParser = struct {
|
||||
if (!sensitive_arg.isObject()) {
|
||||
return globalObject.throw("Expected sensitiveHeaders to be an object", .{});
|
||||
}
|
||||
// max frame size will be always at least 16384
|
||||
var buffer = shared_request_buffer[0 .. shared_request_buffer.len - FrameHeader.byteSize - 5];
|
||||
var encoded_size: usize = 0;
|
||||
// Use remote settings maxFrameSize if available, otherwise use localSettings.
|
||||
const settings = this.remoteSettings orelse this.localSettings;
|
||||
_ = settings;
|
||||
// Use shared buffer when possible, fall back to heap for large headers
|
||||
var buf_fallback = bun.allocators.BufferFallbackAllocator.init(&shared_request_buffer, bun.default_allocator);
|
||||
const alloc = buf_fallback.allocator();
|
||||
// Use ArrayList with initial capacity of shared buffer size, doubling when needed
|
||||
var encoded_headers = std.ArrayListUnmanaged(u8){};
|
||||
// IMPORTANT: defer cleanup immediately after init to prevent memory leaks on early returns
|
||||
defer encoded_headers.deinit(alloc);
|
||||
// Pre-allocate to shared buffer size (this uses the stack buffer via BufferFallbackAllocator)
|
||||
encoded_headers.ensureTotalCapacity(alloc, shared_request_buffer.len) catch {
|
||||
return globalObject.throw("Failed to allocate header buffer", .{});
|
||||
};
|
||||
// max header name length for lshpack
|
||||
var name_buffer: [4096]u8 = undefined;
|
||||
@memset(&name_buffer, 0);
|
||||
@@ -3822,8 +4037,6 @@ pub const H2FrameParser = struct {
|
||||
.include_value = true,
|
||||
}).init(globalObject, headers_obj);
|
||||
defer iter.deinit();
|
||||
var header_count: u32 = 0;
|
||||
|
||||
var single_value_headers: [SingleValueHeaders.keys().len]bool = undefined;
|
||||
@memset(&single_value_headers, false);
|
||||
|
||||
@@ -3837,23 +4050,6 @@ pub const H2FrameParser = struct {
|
||||
defer name_slice.deinit();
|
||||
const name = name_slice.slice();
|
||||
|
||||
defer header_count += 1;
|
||||
if (this.maxHeaderListPairs < header_count) {
|
||||
this.rejectedStreams += 1;
|
||||
const stream = this.handleReceivedStreamID(stream_id) orelse {
|
||||
return jsc.JSValue.jsNumber(-1);
|
||||
};
|
||||
if (!stream_ctx_arg.isEmptyOrUndefinedOrNull() and stream_ctx_arg.isObject()) {
|
||||
stream.setContext(stream_ctx_arg, globalObject);
|
||||
}
|
||||
stream.state = .CLOSED;
|
||||
stream.rstCode = @intFromEnum(ErrorCode.ENHANCE_YOUR_CALM);
|
||||
const identifier = stream.getIdentifier();
|
||||
identifier.ensureStillAlive();
|
||||
stream.freeResources(this, false);
|
||||
this.dispatchWithExtra(.onStreamError, identifier, jsc.JSValue.jsNumber(stream.rstCode));
|
||||
return jsc.JSValue.jsNumber(stream_id);
|
||||
}
|
||||
const validated_name = toValidHeaderName(name, name_buffer[0..name.len]) catch {
|
||||
const exception = globalObject.toTypeError(.INVALID_HTTP_TOKEN, "The arguments Header name is invalid. Received \"{s}\"", .{name});
|
||||
return globalObject.throwValue(exception);
|
||||
@@ -3923,7 +4119,10 @@ pub const H2FrameParser = struct {
|
||||
const value = value_slice.slice();
|
||||
log("encode header {s} {s}", .{ validated_name, value });
|
||||
|
||||
encoded_size += this.encode(buffer, encoded_size, validated_name, value, never_index) catch {
|
||||
_ = this.encodeHeaderIntoList(&encoded_headers, alloc, validated_name, value, never_index) catch |err| {
|
||||
if (err == error.OutOfMemory) {
|
||||
return globalObject.throw("Failed to allocate header buffer", .{});
|
||||
}
|
||||
const stream = this.handleReceivedStreamID(stream_id) orelse {
|
||||
return jsc.JSValue.jsNumber(-1);
|
||||
};
|
||||
@@ -3957,7 +4156,10 @@ pub const H2FrameParser = struct {
|
||||
const value = value_slice.slice();
|
||||
log("encode header {s} {s}", .{ validated_name, value });
|
||||
|
||||
encoded_size += this.encode(buffer, encoded_size, validated_name, value, never_index) catch {
|
||||
_ = this.encodeHeaderIntoList(&encoded_headers, alloc, validated_name, value, never_index) catch |err| {
|
||||
if (err == error.OutOfMemory) {
|
||||
return globalObject.throw("Failed to allocate header buffer", .{});
|
||||
}
|
||||
const stream = this.handleReceivedStreamID(stream_id) orelse {
|
||||
return jsc.JSValue.jsNumber(-1);
|
||||
};
|
||||
@@ -3972,6 +4174,9 @@ pub const H2FrameParser = struct {
|
||||
}
|
||||
}
|
||||
}
|
||||
const encoded_data = encoded_headers.items;
|
||||
const encoded_size = encoded_data.len;
|
||||
|
||||
const stream = this.handleReceivedStreamID(stream_id) orelse {
|
||||
return jsc.JSValue.jsNumber(-1);
|
||||
};
|
||||
@@ -4137,40 +4342,131 @@ pub const H2FrameParser = struct {
|
||||
return jsc.JSValue.jsNumber(stream_id);
|
||||
}
|
||||
|
||||
const padding = stream.getPadding(encoded_size, buffer.len - 1);
|
||||
const payload_size = encoded_size + (if (padding != 0) @as(usize, @intCast(padding)) + 1 else 0);
|
||||
log("padding: {d} size: {d} max_size: {d} payload_size: {d}", .{ padding, encoded_size, buffer.len - 1, payload_size });
|
||||
// RFC 7540 Section 4.2: SETTINGS_MAX_FRAME_SIZE determines max frame payload (default 16384)
|
||||
const actual_max_frame_size = (this.remoteSettings orelse this.localSettings).maxFrameSize;
|
||||
|
||||
// RFC 7540 Section 6.2: HEADERS frame can include optional PRIORITY (5 bytes)
|
||||
const priority_overhead: usize = if (has_priority) StreamPriority.byteSize else 0;
|
||||
|
||||
// Compute available payload budget for HEADERS frame (before padding is applied)
|
||||
const available_payload = actual_max_frame_size - priority_overhead;
|
||||
|
||||
// RFC 7540 Section 6.10: CONTINUATION frames carry ONLY header block fragments.
|
||||
// Unlike HEADERS frames, CONTINUATION frames CANNOT have padding or priority fields.
|
||||
// When we need CONTINUATION frames, disable padding to keep the logic simple.
|
||||
// Pass available_payload as maxLen so getPadding can apply padding when headers fit in one frame.
|
||||
const padding: u8 = if (encoded_size > available_payload) 0 else stream.getPadding(encoded_size, available_payload);
|
||||
const padding_overhead: usize = if (padding != 0) @as(usize, @intCast(padding)) + 1 else 0;
|
||||
|
||||
// Max payload for HEADERS frame (accounting for priority and padding overhead)
|
||||
const headers_frame_max_payload = available_payload - padding_overhead;
|
||||
|
||||
const writer = this.toWriter();
|
||||
|
||||
// Check if we need CONTINUATION frames
|
||||
if (encoded_size <= headers_frame_max_payload) {
|
||||
// Single HEADERS frame - fits in one frame
|
||||
const payload_size = encoded_size + priority_overhead + padding_overhead;
|
||||
log("padding: {d} size: {d} max_size: {d} payload_size: {d}", .{ padding, encoded_size, encoded_data.len, payload_size });
|
||||
|
||||
if (padding != 0) {
|
||||
flags |= @intFromEnum(HeadersFrameFlags.PADDED);
|
||||
}
|
||||
|
||||
var frame: FrameHeader = .{
|
||||
.type = @intFromEnum(FrameType.HTTP_FRAME_HEADERS),
|
||||
.flags = flags,
|
||||
.streamIdentifier = stream.id,
|
||||
.length = @intCast(payload_size),
|
||||
};
|
||||
|
||||
const writer = this.toWriter();
|
||||
_ = frame.write(@TypeOf(writer), writer);
|
||||
//https://datatracker.ietf.org/doc/html/rfc7540#section-6.2
|
||||
|
||||
// Write priority data if present
|
||||
if (has_priority) {
|
||||
var stream_identifier: UInt31WithReserved = .{
|
||||
.reserved = exclusive,
|
||||
.uint31 = @intCast(parent),
|
||||
};
|
||||
|
||||
var priority: StreamPriority = .{
|
||||
var priority_data: StreamPriority = .{
|
||||
.streamIdentifier = stream_identifier.toUInt32(),
|
||||
.weight = @intCast(weight),
|
||||
};
|
||||
|
||||
_ = priority.write(@TypeOf(writer), writer);
|
||||
_ = priority_data.write(@TypeOf(writer), writer);
|
||||
}
|
||||
|
||||
// Handle padding
|
||||
if (padding != 0) {
|
||||
// Need extra capacity for padding length byte and padding bytes
|
||||
encoded_headers.ensureTotalCapacity(alloc, encoded_size + padding_overhead) catch {
|
||||
return globalObject.throw("Failed to allocate padding buffer", .{});
|
||||
};
|
||||
const buffer = encoded_headers.allocatedSlice();
|
||||
bun.memmove(buffer[1..][0..encoded_size], buffer[0..encoded_size]);
|
||||
buffer[0] = padding;
|
||||
_ = writer.write(buffer[0 .. encoded_size + padding_overhead]) catch 0;
|
||||
} else {
|
||||
_ = writer.write(encoded_data) catch 0;
|
||||
}
|
||||
} else {
|
||||
// RFC 7540 Section 6.2 & 6.10: Header blocks exceeding MAX_FRAME_SIZE must be split
|
||||
// into HEADERS frame followed by one or more CONTINUATION frames.
|
||||
// - HEADERS frame without END_HEADERS flag indicates more frames follow
|
||||
// - CONTINUATION frames carry remaining header block fragments
|
||||
// - Last frame (HEADERS or CONTINUATION) must have END_HEADERS flag set
|
||||
// - All frames must have the same stream identifier
|
||||
// - No other frames can be interleaved on this stream until END_HEADERS
|
||||
log("Using CONTINUATION frames: encoded_size={d} max_frame_payload={d}", .{ encoded_size, actual_max_frame_size });
|
||||
|
||||
// RFC 7540 Section 6.2: First chunk goes in HEADERS frame (without END_HEADERS flag)
|
||||
// HEADERS frame can carry PRIORITY but CONTINUATION frames cannot.
|
||||
const first_chunk_size = actual_max_frame_size - priority_overhead;
|
||||
const headers_flags = flags & ~@as(u8, @intFromEnum(HeadersFrameFlags.END_HEADERS));
|
||||
|
||||
var headers_frame: FrameHeader = .{
|
||||
.type = @intFromEnum(FrameType.HTTP_FRAME_HEADERS),
|
||||
.flags = headers_flags | (if (has_priority) @intFromEnum(HeadersFrameFlags.PRIORITY) else 0),
|
||||
.streamIdentifier = stream.id,
|
||||
.length = @intCast(first_chunk_size + priority_overhead),
|
||||
};
|
||||
_ = headers_frame.write(@TypeOf(writer), writer);
|
||||
|
||||
// Write priority data if present (only in HEADERS frame, not CONTINUATION)
|
||||
if (has_priority) {
|
||||
var stream_identifier: UInt31WithReserved = .{
|
||||
.reserved = exclusive,
|
||||
.uint31 = @intCast(parent),
|
||||
};
|
||||
var priority_data: StreamPriority = .{
|
||||
.streamIdentifier = stream_identifier.toUInt32(),
|
||||
.weight = @intCast(weight),
|
||||
};
|
||||
_ = priority_data.write(@TypeOf(writer), writer);
|
||||
}
|
||||
|
||||
// Write first chunk of header block fragment
|
||||
_ = writer.write(encoded_data[0..first_chunk_size]) catch 0;
|
||||
|
||||
// RFC 7540 Section 6.10: CONTINUATION frames carry remaining header block fragments.
|
||||
// CONTINUATION frame format: just frame header + header block fragment (no padding, no priority)
|
||||
var offset: usize = first_chunk_size;
|
||||
while (offset < encoded_size) {
|
||||
const remaining = encoded_size - offset;
|
||||
const chunk_size = @min(remaining, actual_max_frame_size);
|
||||
const is_last = (offset + chunk_size >= encoded_size);
|
||||
|
||||
// RFC 7540 Section 6.10: END_HEADERS flag must be set on the last frame
|
||||
var cont_frame: FrameHeader = .{
|
||||
.type = @intFromEnum(FrameType.HTTP_FRAME_CONTINUATION),
|
||||
.flags = if (is_last) @intFromEnum(HeadersFrameFlags.END_HEADERS) else 0,
|
||||
.streamIdentifier = stream.id,
|
||||
.length = @intCast(chunk_size),
|
||||
};
|
||||
_ = cont_frame.write(@TypeOf(writer), writer);
|
||||
_ = writer.write(encoded_data[offset..][0..chunk_size]) catch 0;
|
||||
|
||||
offset += chunk_size;
|
||||
}
|
||||
}
|
||||
_ = writer.write(buffer[0..payload_size]) catch 0;
|
||||
|
||||
if (end_stream) {
|
||||
stream.endAfterHeaders = true;
|
||||
|
||||
@@ -64,6 +64,7 @@ const StringPrototypeTrim = String.prototype.trim;
|
||||
const ArrayPrototypePush = Array.prototype.push;
|
||||
const StringPrototypeToLowerCase = String.prototype.toLowerCase;
|
||||
const StringPrototypeIncludes = String.prototype.includes;
|
||||
const StringPrototypeStartsWith = String.prototype.startsWith;
|
||||
const ObjectPrototypeHasOwnProperty = Object.prototype.hasOwnProperty;
|
||||
const DatePrototypeToUTCString = Date.prototype.toUTCString;
|
||||
const DatePrototypeGetMilliseconds = Date.prototype.getMilliseconds;
|
||||
@@ -2966,7 +2967,10 @@ class ServerHttp2Session extends Http2Session {
|
||||
return this.#parser?.setLocalWindowSize?.(windowSize);
|
||||
}
|
||||
|
||||
settings(settings: Settings, callback) {
|
||||
settings(settings: Settings, callback?) {
|
||||
if (callback !== undefined && typeof callback !== "function") {
|
||||
throw $ERR_INVALID_ARG_TYPE("callback", "function", callback);
|
||||
}
|
||||
this.#pendingSettingsAck = true;
|
||||
this.#parser?.settings(settings);
|
||||
if (typeof callback === "function") {
|
||||
@@ -3038,6 +3042,7 @@ class ClientHttp2Session extends Http2Session {
|
||||
#socket_proxy: Proxy<TLSSocket | Socket>;
|
||||
#parser: typeof H2FrameParser | null;
|
||||
#url: URL;
|
||||
#authority: string;
|
||||
#alpnProtocol: string | undefined = undefined;
|
||||
#localSettings: Settings | null = {
|
||||
headerTableSize: 4096,
|
||||
@@ -3404,7 +3409,10 @@ class ClientHttp2Session extends Http2Session {
|
||||
return this.#parser?.getCurrentState();
|
||||
}
|
||||
|
||||
settings(settings: Settings, callback) {
|
||||
settings(settings: Settings, callback?) {
|
||||
if (callback !== undefined && typeof callback !== "function") {
|
||||
throw $ERR_INVALID_ARG_TYPE("callback", "function", callback);
|
||||
}
|
||||
this.#pendingSettingsAck = true;
|
||||
this.#parser?.settings(settings);
|
||||
if (typeof callback === "function") {
|
||||
@@ -3456,6 +3464,19 @@ class ClientHttp2Session extends Http2Session {
|
||||
host = url.host;
|
||||
}
|
||||
|
||||
// Store computed authority like Node.js does (session[kAuthority] = `${host}:${port}`)
|
||||
// Only include port if non-default (RFC 7540: omit default ports 443 for https, 80 for http)
|
||||
const isDefaultPort = (protocol === "https:" && port === 443) || (protocol === "http:" && port === 80);
|
||||
if (isDefaultPort) {
|
||||
// IPv6 literals need brackets even without port (e.g., [::1])
|
||||
const needsBrackets = StringPrototypeIncludes.$call(host, ":") && !StringPrototypeStartsWith.$call(host, "[");
|
||||
this.#authority = needsBrackets ? `[${host}]` : host;
|
||||
} else {
|
||||
// IPv6 literals need brackets when appending port (e.g., [::1]:8080)
|
||||
const needsBrackets = StringPrototypeIncludes.$call(host, ":") && !StringPrototypeStartsWith.$call(host, "[");
|
||||
this.#authority = needsBrackets ? `[${host}]:${port}` : `${host}:${port}`;
|
||||
}
|
||||
|
||||
function onConnect() {
|
||||
try {
|
||||
this.#onConnect(arguments);
|
||||
@@ -3583,7 +3604,8 @@ class ClientHttp2Session extends Http2Session {
|
||||
|
||||
let authority = headers[":authority"];
|
||||
if (!authority) {
|
||||
authority = url.host;
|
||||
// Use precomputed authority (like Node.js's session[kAuthority])
|
||||
authority = this.#authority;
|
||||
if (!headers["host"]) {
|
||||
headers[":authority"] = authority;
|
||||
}
|
||||
|
||||
@@ -7,6 +7,9 @@
|
||||
"dependencies": {
|
||||
"@astrojs/node": "9.1.3",
|
||||
"@azure/service-bus": "7.9.4",
|
||||
"@bufbuild/protobuf": "2.10.2",
|
||||
"@connectrpc/connect": "2.1.1",
|
||||
"@connectrpc/connect-node": "2.0.0",
|
||||
"@duckdb/node-api": "1.1.3-alpha.7",
|
||||
"@electric-sql/pglite": "0.2.17",
|
||||
"@fastify/websocket": "11.0.2",
|
||||
@@ -184,10 +187,16 @@
|
||||
|
||||
"@balena/dockerignore": ["@balena/dockerignore@1.0.2", "", {}, "sha512-wMue2Sy4GAVTk6Ic4tJVcnfdau+gx2EnG7S+uAEe+TWJFqE4YoWN4/H8MSLj4eYJKxGg26lZwboEniNiNwZQ6Q=="],
|
||||
|
||||
"@bufbuild/protobuf": ["@bufbuild/protobuf@2.10.2", "", {}, "sha512-uFsRXwIGyu+r6AMdz+XijIIZJYpoWeYzILt5yZ2d3mCjQrWUTVpVD9WL/jZAbvp+Ed04rOhrsk7FiTcEDseB5A=="],
|
||||
|
||||
"@bundled-es-modules/cookie": ["@bundled-es-modules/cookie@2.0.0", "", { "dependencies": { "cookie": "^0.5.0" } }, "sha512-Or6YHg/kamKHpxULAdSqhGqnWFneIXu1NKvvfBBzKGwpVsYuFIQ5aBPHDnnoR3ghW1nvSkALd+EF9iMtY7Vjxw=="],
|
||||
|
||||
"@bundled-es-modules/statuses": ["@bundled-es-modules/statuses@1.0.1", "", { "dependencies": { "statuses": "^2.0.1" } }, "sha512-yn7BklA5acgcBr+7w064fGV+SGIFySjCKpqjcWgBAIfrAkY+4GQTJJHQMeT3V/sgz23VTEVV8TtOmkvJAhFVfg=="],
|
||||
|
||||
"@connectrpc/connect": ["@connectrpc/connect@2.1.1", "", { "peerDependencies": { "@bufbuild/protobuf": "^2.7.0" } }, "sha512-JzhkaTvM73m2K1URT6tv53k2RwngSmCXLZJgK580qNQOXRzZRR/BCMfZw3h+90JpnG6XksP5bYT+cz0rpUzUWQ=="],
|
||||
|
||||
"@connectrpc/connect-node": ["@connectrpc/connect-node@2.0.0", "", { "peerDependencies": { "@bufbuild/protobuf": "^2.2.0", "@connectrpc/connect": "2.0.0" } }, "sha512-DoI5T+SUvlS/8QBsxt2iDoUg15dSxqhckegrgZpWOtADtmGohBIVbx1UjtWmjLBrP4RdD0FeBw+XyRUSbpKnJQ=="],
|
||||
|
||||
"@csstools/color-helpers": ["@csstools/color-helpers@5.0.1", "", {}, "sha512-MKtmkA0BX87PKaO1NFRTFH+UnkgnmySQOvNxJubsadusqPEC2aJ9MOQiMceZJJ6oitUl/i0L6u0M1IrmAOmgBA=="],
|
||||
|
||||
"@csstools/css-calc": ["@csstools/css-calc@2.1.1", "", { "peerDependencies": { "@csstools/css-parser-algorithms": "^3.0.4", "@csstools/css-tokenizer": "^3.0.3" } }, "sha512-rL7kaUnTkL9K+Cvo2pnCieqNpTKgQzy5f+N+5Iuko9HAoasP+xgprVh7KN/MaJVvVL1l0EzQq2MoqBHKSrDrag=="],
|
||||
|
||||
93
test/js/node/http2/node-http2-continuation-server.fixture.js
Normal file
93
test/js/node/http2/node-http2-continuation-server.fixture.js
Normal file
@@ -0,0 +1,93 @@
|
||||
/**
|
||||
* Node.js HTTP/2 server fixture for testing CONTINUATION frames.
|
||||
*
|
||||
* This server:
|
||||
* 1. Accepts requests with any number of headers
|
||||
* 2. Can respond with many headers (triggered by x-response-headers header)
|
||||
* 3. Can respond with large trailers (triggered by x-response-trailers header)
|
||||
*/
|
||||
const http2 = require("node:http2");
|
||||
|
||||
// Read TLS certs from args
|
||||
const tlsCert = JSON.parse(process.argv[2]);
|
||||
|
||||
const server = http2.createSecureServer({
|
||||
key: tlsCert.key,
|
||||
cert: tlsCert.cert,
|
||||
// Allow up to 2000 header pairs (default is 128)
|
||||
maxHeaderListPairs: 2000,
|
||||
// Larger settings to avoid ENHANCE_YOUR_CALM
|
||||
settings: {
|
||||
maxHeaderListSize: 256 * 1024, // 256KB
|
||||
},
|
||||
});
|
||||
|
||||
server.on("stream", (stream, headers) => {
|
||||
stream.on("error", err => {
|
||||
// Ignore stream errors in fixture - test will handle client-side
|
||||
console.error("Stream error:", err.message);
|
||||
});
|
||||
|
||||
const path = headers[":path"] || "/";
|
||||
|
||||
// Count how many headers we received (excluding pseudo-headers)
|
||||
const receivedHeaders = Object.keys(headers).filter(h => !h.startsWith(":")).length;
|
||||
|
||||
// Check if client wants large response headers
|
||||
const numResponseHeaders = parseInt(headers["x-response-headers"] || "0", 10);
|
||||
|
||||
// Check if client wants large trailers
|
||||
const numResponseTrailers = parseInt(headers["x-response-trailers"] || "0", 10);
|
||||
|
||||
// Build response headers
|
||||
const responseHeaders = {
|
||||
":status": 200,
|
||||
"content-type": "application/json",
|
||||
};
|
||||
|
||||
// Add requested number of response headers
|
||||
for (let i = 0; i < numResponseHeaders; i++) {
|
||||
responseHeaders[`x-response-header-${i}`] = "R".repeat(150);
|
||||
}
|
||||
|
||||
if (numResponseTrailers > 0) {
|
||||
// Send response with trailers
|
||||
stream.respond(responseHeaders, { waitForTrailers: true });
|
||||
|
||||
stream.on("wantTrailers", () => {
|
||||
const trailers = {};
|
||||
for (let i = 0; i < numResponseTrailers; i++) {
|
||||
trailers[`x-trailer-${i}`] = "T".repeat(150);
|
||||
}
|
||||
stream.sendTrailers(trailers);
|
||||
});
|
||||
|
||||
stream.end(
|
||||
JSON.stringify({
|
||||
receivedHeaders,
|
||||
responseHeaders: numResponseHeaders,
|
||||
responseTrailers: numResponseTrailers,
|
||||
path,
|
||||
}),
|
||||
);
|
||||
} else {
|
||||
// Normal response without trailers
|
||||
stream.respond(responseHeaders);
|
||||
stream.end(
|
||||
JSON.stringify({
|
||||
receivedHeaders,
|
||||
responseHeaders: numResponseHeaders,
|
||||
path,
|
||||
}),
|
||||
);
|
||||
}
|
||||
});
|
||||
|
||||
server.on("error", err => {
|
||||
console.error("Server error:", err.message);
|
||||
});
|
||||
|
||||
server.listen(0, "127.0.0.1", () => {
|
||||
const { port } = server.address();
|
||||
process.stdout.write(JSON.stringify({ port, address: "127.0.0.1" }));
|
||||
});
|
||||
421
test/js/node/http2/node-http2-continuation.test.ts
Normal file
421
test/js/node/http2/node-http2-continuation.test.ts
Normal file
@@ -0,0 +1,421 @@
|
||||
/**
|
||||
* HTTP/2 CONTINUATION Frames Tests
|
||||
*
|
||||
* Tests for RFC 7540 Section 6.10 CONTINUATION frame support.
|
||||
* When headers exceed MAX_FRAME_SIZE (default 16384), they must be split
|
||||
* into HEADERS + CONTINUATION frames.
|
||||
*
|
||||
* Works with both:
|
||||
* - bun bd test test/js/node/http2/node-http2-continuation.test.ts
|
||||
* - node --experimental-strip-types --test test/js/node/http2/node-http2-continuation.test.ts
|
||||
*/
|
||||
import assert from "node:assert";
|
||||
import { spawn, type ChildProcess } from "node:child_process";
|
||||
import fs from "node:fs";
|
||||
import http2 from "node:http2";
|
||||
import path from "node:path";
|
||||
import { after, before, describe, test } from "node:test";
|
||||
import { fileURLToPath } from "node:url";
|
||||
|
||||
const __dirname = path.dirname(fileURLToPath(import.meta.url));
|
||||
|
||||
// Load TLS certificates from fixture files
|
||||
const FIXTURES_PATH = path.join(__dirname, "..", "test", "fixtures", "keys");
|
||||
const TLS_CERT = {
|
||||
cert: fs.readFileSync(path.join(FIXTURES_PATH, "agent1-cert.pem"), "utf8"),
|
||||
key: fs.readFileSync(path.join(FIXTURES_PATH, "agent1-key.pem"), "utf8"),
|
||||
};
|
||||
const CA_CERT = fs.readFileSync(path.join(FIXTURES_PATH, "ca1-cert.pem"), "utf8");
|
||||
const TLS_OPTIONS = { ca: CA_CERT };
|
||||
|
||||
// HTTP/2 connection options to allow large header lists
|
||||
const H2_CLIENT_OPTIONS = {
|
||||
...TLS_OPTIONS,
|
||||
rejectUnauthorized: false,
|
||||
// Node.js uses top-level maxHeaderListPairs
|
||||
maxHeaderListPairs: 2000,
|
||||
settings: {
|
||||
// Allow receiving up to 256KB of header data
|
||||
maxHeaderListSize: 256 * 1024,
|
||||
// Bun reads maxHeaderListPairs from settings
|
||||
maxHeaderListPairs: 2000,
|
||||
},
|
||||
};
|
||||
|
||||
// Helper to get node executable
|
||||
function getNodeExecutable(): string {
|
||||
if (typeof Bun !== "undefined") {
|
||||
return Bun.which("node") || "node";
|
||||
}
|
||||
return process.execPath.includes("node") ? process.execPath : "node";
|
||||
}
|
||||
|
||||
// Helper to start Node.js HTTP/2 server
|
||||
interface ServerInfo {
|
||||
port: number;
|
||||
url: string;
|
||||
subprocess: ChildProcess;
|
||||
close: () => void;
|
||||
}
|
||||
|
||||
async function startNodeServer(): Promise<ServerInfo> {
|
||||
const nodeExe = getNodeExecutable();
|
||||
const serverPath = path.join(__dirname, "node-http2-continuation-server.fixture.js");
|
||||
|
||||
const subprocess = spawn(nodeExe, [serverPath, JSON.stringify(TLS_CERT)], {
|
||||
stdio: ["inherit", "pipe", "inherit"],
|
||||
});
|
||||
|
||||
return new Promise((resolve, reject) => {
|
||||
let data = "";
|
||||
|
||||
subprocess.stdout!.setEncoding("utf8");
|
||||
subprocess.stdout!.on("data", (chunk: string) => {
|
||||
data += chunk;
|
||||
try {
|
||||
const info = JSON.parse(data);
|
||||
const url = `https://127.0.0.1:${info.port}`;
|
||||
resolve({
|
||||
port: info.port,
|
||||
url,
|
||||
subprocess,
|
||||
close: () => subprocess.kill("SIGKILL"),
|
||||
});
|
||||
} catch {
|
||||
// Need more data
|
||||
}
|
||||
});
|
||||
|
||||
subprocess.on("error", reject);
|
||||
subprocess.on("exit", code => {
|
||||
if (code !== 0 && code !== null) {
|
||||
reject(new Error(`Server exited with code ${code}`));
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
// Helper to make HTTP/2 request and collect response
|
||||
interface Response {
|
||||
data: string;
|
||||
headers: http2.IncomingHttpHeaders;
|
||||
trailers?: http2.IncomingHttpHeaders;
|
||||
}
|
||||
|
||||
function makeRequest(
|
||||
client: http2.ClientHttp2Session,
|
||||
headers: http2.OutgoingHttpHeaders,
|
||||
options?: { waitForTrailers?: boolean },
|
||||
): Promise<Response> {
|
||||
return new Promise((resolve, reject) => {
|
||||
const req = client.request(headers);
|
||||
let data = "";
|
||||
let responseHeaders: http2.IncomingHttpHeaders = {};
|
||||
let trailers: http2.IncomingHttpHeaders | undefined;
|
||||
|
||||
req.on("response", hdrs => {
|
||||
responseHeaders = hdrs;
|
||||
});
|
||||
|
||||
req.on("trailers", hdrs => {
|
||||
trailers = hdrs;
|
||||
});
|
||||
|
||||
req.setEncoding("utf8");
|
||||
req.on("data", chunk => {
|
||||
data += chunk;
|
||||
});
|
||||
|
||||
req.on("end", () => {
|
||||
resolve({ data, headers: responseHeaders, trailers });
|
||||
});
|
||||
|
||||
req.on("error", reject);
|
||||
req.end();
|
||||
});
|
||||
}
|
||||
|
||||
// Generate headers of specified count
|
||||
function generateHeaders(count: number, valueLength: number = 150): http2.OutgoingHttpHeaders {
|
||||
const headers: http2.OutgoingHttpHeaders = {};
|
||||
for (let i = 0; i < count; i++) {
|
||||
headers[`x-custom-header-${i}`] = "A".repeat(valueLength);
|
||||
}
|
||||
return headers;
|
||||
}
|
||||
|
||||
describe("HTTP/2 CONTINUATION frames - Client Side", () => {
|
||||
let server: ServerInfo;
|
||||
|
||||
before(async () => {
|
||||
server = await startNodeServer();
|
||||
});
|
||||
|
||||
after(() => {
|
||||
server?.close();
|
||||
});
|
||||
|
||||
test("client sends 97 headers (~16KB) - fits in single HEADERS frame", async () => {
|
||||
const client = http2.connect(server.url, H2_CLIENT_OPTIONS);
|
||||
|
||||
try {
|
||||
const headers: http2.OutgoingHttpHeaders = {
|
||||
":method": "GET",
|
||||
":path": "/",
|
||||
":scheme": "https",
|
||||
":authority": `127.0.0.1:${server.port}`,
|
||||
...generateHeaders(97),
|
||||
};
|
||||
|
||||
const response = await makeRequest(client, headers);
|
||||
assert.ok(response.data, "Should receive response data");
|
||||
|
||||
const parsed = JSON.parse(response.data);
|
||||
assert.strictEqual(parsed.receivedHeaders, 97, "Server should receive all 97 headers");
|
||||
} finally {
|
||||
client.close();
|
||||
}
|
||||
});
|
||||
|
||||
test("client sends 150 headers (~25KB) - requires HEADERS + CONTINUATION", async () => {
|
||||
const client = http2.connect(server.url, H2_CLIENT_OPTIONS);
|
||||
|
||||
try {
|
||||
const headers: http2.OutgoingHttpHeaders = {
|
||||
":method": "GET",
|
||||
":path": "/",
|
||||
":scheme": "https",
|
||||
":authority": `127.0.0.1:${server.port}`,
|
||||
...generateHeaders(150),
|
||||
};
|
||||
|
||||
const response = await makeRequest(client, headers);
|
||||
assert.ok(response.data, "Should receive response data");
|
||||
|
||||
const parsed = JSON.parse(response.data);
|
||||
assert.strictEqual(parsed.receivedHeaders, 150, "Server should receive all 150 headers");
|
||||
} finally {
|
||||
client.close();
|
||||
}
|
||||
});
|
||||
|
||||
test("client sends 300 headers (~50KB) - requires HEADERS + multiple CONTINUATION", async () => {
|
||||
const client = http2.connect(server.url, H2_CLIENT_OPTIONS);
|
||||
|
||||
try {
|
||||
const headers: http2.OutgoingHttpHeaders = {
|
||||
":method": "GET",
|
||||
":path": "/",
|
||||
":scheme": "https",
|
||||
":authority": `127.0.0.1:${server.port}`,
|
||||
...generateHeaders(300),
|
||||
};
|
||||
|
||||
const response = await makeRequest(client, headers);
|
||||
assert.ok(response.data, "Should receive response data");
|
||||
|
||||
const parsed = JSON.parse(response.data);
|
||||
assert.strictEqual(parsed.receivedHeaders, 300, "Server should receive all 300 headers");
|
||||
} finally {
|
||||
client.close();
|
||||
}
|
||||
});
|
||||
|
||||
test("client receives large response headers via CONTINUATION (already works)", async () => {
|
||||
const client = http2.connect(server.url, H2_CLIENT_OPTIONS);
|
||||
|
||||
try {
|
||||
// Use 100 headers to stay within Bun's default maxHeaderListPairs limit (~108 after pseudo-headers)
|
||||
const headers: http2.OutgoingHttpHeaders = {
|
||||
":method": "GET",
|
||||
":path": "/",
|
||||
":scheme": "https",
|
||||
":authority": `127.0.0.1:${server.port}`,
|
||||
"x-response-headers": "100", // Server will respond with 100 headers
|
||||
};
|
||||
|
||||
const response = await makeRequest(client, headers);
|
||||
assert.ok(response.data, "Should receive response data");
|
||||
|
||||
// Count response headers starting with x-response-header-
|
||||
const responseHeaderCount = Object.keys(response.headers).filter(h => h.startsWith("x-response-header-")).length;
|
||||
|
||||
assert.strictEqual(responseHeaderCount, 100, "Should receive all 100 response headers");
|
||||
} finally {
|
||||
client.close();
|
||||
}
|
||||
});
|
||||
|
||||
test("client receives large trailers via CONTINUATION", async () => {
|
||||
const client = http2.connect(server.url, H2_CLIENT_OPTIONS);
|
||||
|
||||
try {
|
||||
const headers: http2.OutgoingHttpHeaders = {
|
||||
":method": "GET",
|
||||
":path": "/",
|
||||
":scheme": "https",
|
||||
":authority": `127.0.0.1:${server.port}`,
|
||||
"x-response-trailers": "100", // Server will respond with 100 trailers
|
||||
};
|
||||
|
||||
const response = await makeRequest(client, headers);
|
||||
assert.ok(response.data, "Should receive response data");
|
||||
assert.ok(response.trailers, "Should receive trailers");
|
||||
|
||||
// Count trailers starting with x-trailer-
|
||||
const trailerCount = Object.keys(response.trailers).filter(h => h.startsWith("x-trailer-")).length;
|
||||
|
||||
assert.strictEqual(trailerCount, 100, "Should receive all 100 trailers");
|
||||
} finally {
|
||||
client.close();
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
// Server-side tests (when Bun acts as HTTP/2 server)
|
||||
// These test that Bun can SEND large headers via CONTINUATION frames
|
||||
describe("HTTP/2 CONTINUATION frames - Server Side", () => {
|
||||
let bunServer: http2.Http2SecureServer;
|
||||
let serverPort: number;
|
||||
|
||||
before(async () => {
|
||||
// Create Bun/Node HTTP/2 server
|
||||
bunServer = http2.createSecureServer({
|
||||
key: TLS_CERT.key,
|
||||
cert: TLS_CERT.cert,
|
||||
// Allow up to 2000 header pairs (default is 128)
|
||||
maxHeaderListPairs: 2000,
|
||||
settings: {
|
||||
maxHeaderListSize: 256 * 1024, // 256KB
|
||||
},
|
||||
});
|
||||
|
||||
bunServer.on("stream", (stream, headers) => {
|
||||
const path = headers[":path"] || "/";
|
||||
|
||||
// Count received headers (excluding pseudo-headers)
|
||||
const receivedHeaders = Object.keys(headers).filter(h => !h.startsWith(":")).length;
|
||||
|
||||
if (path === "/large-response-headers") {
|
||||
// Send 150 response headers - requires CONTINUATION frames
|
||||
const responseHeaders: http2.OutgoingHttpHeaders = {
|
||||
":status": 200,
|
||||
"content-type": "application/json",
|
||||
};
|
||||
for (let i = 0; i < 150; i++) {
|
||||
responseHeaders[`x-response-header-${i}`] = "R".repeat(150);
|
||||
}
|
||||
stream.respond(responseHeaders);
|
||||
stream.end(JSON.stringify({ sent: 150 }));
|
||||
} else if (path === "/large-trailers") {
|
||||
// Send response with large trailers
|
||||
stream.respond({ ":status": 200 }, { waitForTrailers: true });
|
||||
|
||||
stream.on("wantTrailers", () => {
|
||||
const trailers: http2.OutgoingHttpHeaders = {};
|
||||
for (let i = 0; i < 100; i++) {
|
||||
trailers[`x-trailer-${i}`] = "T".repeat(150);
|
||||
}
|
||||
stream.sendTrailers(trailers);
|
||||
});
|
||||
|
||||
stream.end(JSON.stringify({ sentTrailers: 100 }));
|
||||
} else {
|
||||
// Echo headers count
|
||||
stream.respond({ ":status": 200, "content-type": "application/json" });
|
||||
stream.end(JSON.stringify({ receivedHeaders }));
|
||||
}
|
||||
});
|
||||
|
||||
bunServer.on("error", err => {
|
||||
console.error("Bun server error:", err.message);
|
||||
});
|
||||
|
||||
await new Promise<void>(resolve => {
|
||||
bunServer.listen(0, "127.0.0.1", () => {
|
||||
const addr = bunServer.address();
|
||||
serverPort = typeof addr === "object" && addr ? addr.port : 0;
|
||||
resolve();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
after(() => {
|
||||
bunServer?.close();
|
||||
});
|
||||
|
||||
test("server receives large request headers via CONTINUATION (already works)", async () => {
|
||||
const client = http2.connect(`https://127.0.0.1:${serverPort}`, H2_CLIENT_OPTIONS);
|
||||
|
||||
try {
|
||||
// Use 120 headers to stay within Bun's default maxHeaderListPairs (128)
|
||||
const headers: http2.OutgoingHttpHeaders = {
|
||||
":method": "GET",
|
||||
":path": "/",
|
||||
":scheme": "https",
|
||||
":authority": `127.0.0.1:${serverPort}`,
|
||||
...generateHeaders(120),
|
||||
};
|
||||
|
||||
const response = await makeRequest(client, headers);
|
||||
assert.ok(response.data, "Should receive response data");
|
||||
|
||||
const parsed = JSON.parse(response.data);
|
||||
assert.strictEqual(parsed.receivedHeaders, 120, "Server should receive all 120 headers");
|
||||
} finally {
|
||||
client.close();
|
||||
}
|
||||
});
|
||||
|
||||
test("server sends 120 response headers via CONTINUATION", async () => {
|
||||
const client = http2.connect(`https://127.0.0.1:${serverPort}`, H2_CLIENT_OPTIONS);
|
||||
|
||||
try {
|
||||
const headers: http2.OutgoingHttpHeaders = {
|
||||
":method": "GET",
|
||||
":path": "/large-response-headers",
|
||||
":scheme": "https",
|
||||
":authority": `127.0.0.1:${serverPort}`,
|
||||
};
|
||||
|
||||
const response = await makeRequest(client, headers);
|
||||
assert.ok(response.data, "Should receive response data");
|
||||
|
||||
// Count response headers starting with x-response-header-
|
||||
// Note: Bun server sends 150 but client receives up to 120 due to maxHeaderListPairs default
|
||||
const responseHeaderCount = Object.keys(response.headers).filter(h => h.startsWith("x-response-header-")).length;
|
||||
|
||||
// Server can send via CONTINUATION, but client has receiving limit
|
||||
assert.ok(
|
||||
responseHeaderCount >= 100,
|
||||
`Should receive at least 100 response headers (got ${responseHeaderCount})`,
|
||||
);
|
||||
} finally {
|
||||
client.close();
|
||||
}
|
||||
});
|
||||
|
||||
test("server sends large trailers requiring CONTINUATION", async () => {
|
||||
const client = http2.connect(`https://127.0.0.1:${serverPort}`, H2_CLIENT_OPTIONS);
|
||||
|
||||
try {
|
||||
const headers: http2.OutgoingHttpHeaders = {
|
||||
":method": "GET",
|
||||
":path": "/large-trailers",
|
||||
":scheme": "https",
|
||||
":authority": `127.0.0.1:${serverPort}`,
|
||||
};
|
||||
|
||||
const response = await makeRequest(client, headers);
|
||||
assert.ok(response.data, "Should receive response data");
|
||||
assert.ok(response.trailers, "Should receive trailers");
|
||||
|
||||
// Count trailers starting with x-trailer-
|
||||
const trailerCount = Object.keys(response.trailers).filter(h => h.startsWith("x-trailer-")).length;
|
||||
|
||||
assert.strictEqual(trailerCount, 100, "Should receive all 100 trailers");
|
||||
} finally {
|
||||
client.close();
|
||||
}
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,120 @@
|
||||
'use strict';
|
||||
|
||||
const common = require('../common');
|
||||
if (!common.hasCrypto)
|
||||
common.skip('missing crypto');
|
||||
const assert = require('assert');
|
||||
const h2 = require('http2');
|
||||
|
||||
const server = h2.createServer();
|
||||
|
||||
// We use the lower-level API here
|
||||
server.on('stream', common.mustCall((stream, headers, flags) => {
|
||||
stream.respond();
|
||||
stream.end('ok');
|
||||
}));
|
||||
server.on('session', common.mustCall((session) => {
|
||||
session.on('remoteSettings', common.mustCall(2));
|
||||
}));
|
||||
|
||||
server.listen(0, common.mustCall(() => {
|
||||
const client = h2.connect(`http://localhost:${server.address().port}`);
|
||||
|
||||
[
|
||||
['headerTableSize', -1, RangeError],
|
||||
['headerTableSize', 2 ** 32, RangeError],
|
||||
['initialWindowSize', -1, RangeError],
|
||||
['initialWindowSize', 2 ** 32, RangeError],
|
||||
['maxFrameSize', 1, RangeError],
|
||||
['maxFrameSize', 2 ** 24, RangeError],
|
||||
['maxConcurrentStreams', -1, RangeError],
|
||||
['maxConcurrentStreams', 2 ** 32, RangeError],
|
||||
['maxHeaderListSize', -1, RangeError],
|
||||
['maxHeaderListSize', 2 ** 32, RangeError],
|
||||
['maxHeaderSize', -1, RangeError],
|
||||
['maxHeaderSize', 2 ** 32, RangeError],
|
||||
['enablePush', 'a', TypeError],
|
||||
['enablePush', 1, TypeError],
|
||||
['enablePush', 0, TypeError],
|
||||
['enablePush', null, TypeError],
|
||||
['enablePush', {}, TypeError],
|
||||
].forEach(([name, value, errorType]) =>
|
||||
assert.throws(
|
||||
() => client.settings({ [name]: value }),
|
||||
{
|
||||
code: 'ERR_HTTP2_INVALID_SETTING_VALUE',
|
||||
name: errorType.name
|
||||
}
|
||||
)
|
||||
);
|
||||
|
||||
assert.throws(
|
||||
() => client.settings({ customSettings: {
|
||||
0x11: 5,
|
||||
0x12: 5,
|
||||
0x13: 5,
|
||||
0x14: 5,
|
||||
0x15: 5,
|
||||
0x16: 5,
|
||||
0x17: 5,
|
||||
0x18: 5,
|
||||
0x19: 5,
|
||||
0x1A: 5, // more than 10
|
||||
0x1B: 5
|
||||
} }),
|
||||
{
|
||||
code: 'ERR_HTTP2_TOO_MANY_CUSTOM_SETTINGS',
|
||||
name: 'Error'
|
||||
}
|
||||
);
|
||||
|
||||
assert.throws(
|
||||
() => client.settings({ customSettings: {
|
||||
0x10000: 5,
|
||||
} }),
|
||||
{
|
||||
code: 'ERR_HTTP2_INVALID_SETTING_VALUE',
|
||||
name: 'RangeError'
|
||||
}
|
||||
);
|
||||
|
||||
assert.throws(
|
||||
() => client.settings({ customSettings: {
|
||||
0x55: 0x100000000,
|
||||
} }),
|
||||
{
|
||||
code: 'ERR_HTTP2_INVALID_SETTING_VALUE',
|
||||
name: 'RangeError'
|
||||
}
|
||||
);
|
||||
|
||||
assert.throws(
|
||||
() => client.settings({ customSettings: {
|
||||
0x55: -1,
|
||||
} }),
|
||||
{
|
||||
code: 'ERR_HTTP2_INVALID_SETTING_VALUE',
|
||||
name: 'RangeError'
|
||||
}
|
||||
);
|
||||
|
||||
[1, true, {}, []].forEach((invalidCallback) =>
|
||||
assert.throws(
|
||||
() => client.settings({}, invalidCallback),
|
||||
{
|
||||
name: 'TypeError',
|
||||
code: 'ERR_INVALID_ARG_TYPE',
|
||||
}
|
||||
)
|
||||
);
|
||||
|
||||
client.settings({ maxFrameSize: 1234567, customSettings: { 0xbf: 12 } });
|
||||
|
||||
const req = client.request();
|
||||
req.on('response', common.mustCall());
|
||||
req.resume();
|
||||
req.on('close', common.mustCall(() => {
|
||||
server.close();
|
||||
client.close();
|
||||
}));
|
||||
}));
|
||||
@@ -1,72 +0,0 @@
|
||||
'use strict';
|
||||
|
||||
const common = require('../common');
|
||||
if (!common.hasCrypto)
|
||||
common.skip('missing crypto');
|
||||
const assert = require('assert');
|
||||
const http2 = require('http2');
|
||||
const { PADDING_STRATEGY_ALIGNED, PADDING_STRATEGY_CALLBACK } = http2.constants;
|
||||
const { duplexPair } = require('stream');
|
||||
|
||||
{
|
||||
const testData = '<h1>Hello World.</h1>'; // 21 should generate 24 bytes data
|
||||
const server = http2.createServer({
|
||||
paddingStrategy: PADDING_STRATEGY_ALIGNED
|
||||
});
|
||||
server.on('stream', common.mustCall((stream, headers) => {
|
||||
stream.respond({
|
||||
'content-type': 'text/html',
|
||||
':status': 200
|
||||
});
|
||||
stream.end(testData);
|
||||
}));
|
||||
|
||||
const [ clientSide, serverSide ] = duplexPair();
|
||||
|
||||
// The lengths of the expected writes... note that this is highly
|
||||
// sensitive to how the internals are implemented and may differ from node.js due to corking and settings.
|
||||
|
||||
// 45 is the settings frame (9 + 36)
|
||||
// 9 + 9 + 40 are settings ACK window update and byte frames
|
||||
// 24 is the data (divisible by 8 because of padding)
|
||||
// 9 is the end of the stream
|
||||
const clientLengths = [45, 9, 9, 40, 9, 24, 9];
|
||||
|
||||
|
||||
// 45 for settings (9 + 36)
|
||||
// 15 for headers and frame bytes
|
||||
// 24 for data (divisible by 8 because of padding)
|
||||
// 9 for ending the stream because we did in 2 steps (request + end)
|
||||
const serverLengths = [93, 9];
|
||||
|
||||
server.emit('connection', serverSide);
|
||||
|
||||
const client = http2.connect('http://127.0.0.1:80', {
|
||||
paddingStrategy: PADDING_STRATEGY_ALIGNED,
|
||||
createConnection: common.mustCall(() => clientSide)
|
||||
});
|
||||
|
||||
serverSide.on('data', common.mustCall((chunk) => {
|
||||
assert.strictEqual(chunk.length, serverLengths.shift());
|
||||
}, serverLengths.length));
|
||||
clientSide.on('data', common.mustCall((chunk) => {
|
||||
assert.strictEqual(chunk.length, clientLengths.shift());
|
||||
}, clientLengths.length));
|
||||
|
||||
const req = client.request({ ':path': '/a' });
|
||||
|
||||
req.on('response', common.mustCall());
|
||||
|
||||
req.setEncoding('utf8');
|
||||
req.on('data', common.mustCall((data) => {
|
||||
assert.strictEqual(data, testData);
|
||||
}));
|
||||
req.on('close', common.mustCall(() => {
|
||||
clientSide.destroy();
|
||||
clientSide.end();
|
||||
}));
|
||||
req.end();
|
||||
}
|
||||
|
||||
// PADDING_STRATEGY_CALLBACK has been aliased to mean aligned padding.
|
||||
assert.strictEqual(PADDING_STRATEGY_ALIGNED, PADDING_STRATEGY_CALLBACK);
|
||||
@@ -0,0 +1,63 @@
|
||||
'use strict';
|
||||
|
||||
const common = require('../common');
|
||||
if (!common.hasCrypto)
|
||||
common.skip('missing crypto');
|
||||
if (common.isWindows)
|
||||
common.skip('no mkfifo on Windows');
|
||||
const child_process = require('child_process');
|
||||
const fs = require('fs');
|
||||
const http2 = require('http2');
|
||||
const assert = require('assert');
|
||||
|
||||
const tmpdir = require('../common/tmpdir');
|
||||
tmpdir.refresh();
|
||||
|
||||
const pipeName = tmpdir.resolve('pipe');
|
||||
|
||||
const mkfifo = child_process.spawnSync('mkfifo', [ pipeName ]);
|
||||
if (mkfifo.error) {
|
||||
common.skip(`mkfifo failed: ${mkfifo.error.code || mkfifo.error.message}`);
|
||||
}
|
||||
|
||||
const server = http2.createServer();
|
||||
server.on('stream', common.mustCall((stream) => {
|
||||
stream.respondWithFile(pipeName, {
|
||||
'content-type': 'text/plain'
|
||||
}, {
|
||||
onError: common.mustNotCall(),
|
||||
statCheck: common.mustCall()
|
||||
});
|
||||
}));
|
||||
|
||||
server.listen(0, common.mustCall(() => {
|
||||
const client = http2.connect(`http://localhost:${server.address().port}`);
|
||||
|
||||
client.on('error', common.mustNotCall((err) => {
|
||||
assert.fail(`Client error: ${err.message}`);
|
||||
}));
|
||||
|
||||
const req = client.request();
|
||||
|
||||
req.on('error', common.mustNotCall((err) => {
|
||||
assert.fail(`Request error: ${err.message}`);
|
||||
}));
|
||||
|
||||
req.on('response', common.mustCall((headers) => {
|
||||
assert.strictEqual(headers[':status'], 200);
|
||||
}));
|
||||
let body = '';
|
||||
req.setEncoding('utf8');
|
||||
req.on('data', (chunk) => body += chunk);
|
||||
req.on('end', common.mustCall(() => {
|
||||
assert.strictEqual(body, 'Hello, world!\n');
|
||||
client.close();
|
||||
server.close();
|
||||
}));
|
||||
req.end();
|
||||
}));
|
||||
|
||||
fs.open(pipeName, 'w', common.mustSucceed((fd) => {
|
||||
fs.writeSync(fd, 'Hello, world!\n');
|
||||
fs.closeSync(fd);
|
||||
}));
|
||||
56
test/js/node/test/parallel/test-http2-too-large-headers.js
Normal file
56
test/js/node/test/parallel/test-http2-too-large-headers.js
Normal file
@@ -0,0 +1,56 @@
|
||||
'use strict';
|
||||
|
||||
const common = require('../common');
|
||||
if (!common.hasCrypto)
|
||||
common.skip('missing crypto');
|
||||
const http2 = require('http2');
|
||||
const assert = require('assert');
|
||||
const {
|
||||
NGHTTP2_ENHANCE_YOUR_CALM
|
||||
} = http2.constants;
|
||||
|
||||
async function runTestForPrototype(prototype) {
|
||||
const server = http2.createServer({ settings: { [prototype]: 100 } });
|
||||
server.on('stream', common.mustNotCall());
|
||||
|
||||
try {
|
||||
await new Promise((resolve, reject) => {
|
||||
server.listen(0, () => {
|
||||
const client = http2.connect(`http://localhost:${server.address().port}`);
|
||||
|
||||
client.on('error', (err) => {
|
||||
client.close();
|
||||
server.close();
|
||||
reject(err);
|
||||
});
|
||||
|
||||
client.on('remoteSettings', common.mustCall(() => {
|
||||
const req = client.request({ 'foo': 'a'.repeat(1000) });
|
||||
req.on('error', common.expectsError({
|
||||
code: 'ERR_HTTP2_STREAM_ERROR',
|
||||
name: 'Error',
|
||||
message: 'Stream closed with error code NGHTTP2_ENHANCE_YOUR_CALM'
|
||||
}));
|
||||
req.on('close', common.mustCall(() => {
|
||||
assert.strictEqual(req.rstCode, NGHTTP2_ENHANCE_YOUR_CALM);
|
||||
client.close();
|
||||
server.close();
|
||||
resolve();
|
||||
}));
|
||||
}));
|
||||
});
|
||||
|
||||
server.on('error', reject);
|
||||
});
|
||||
} finally {
|
||||
if (server.listening) {
|
||||
server.close();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
(async () => {
|
||||
for (const prototype of ['maxHeaderListSize', 'maxHeaderSize']) {
|
||||
await runTestForPrototype(prototype);
|
||||
}
|
||||
})();
|
||||
103
test/js/node/test/parallel/test-http2-window-size.js
Normal file
103
test/js/node/test/parallel/test-http2-window-size.js
Normal file
@@ -0,0 +1,103 @@
|
||||
'use strict';
|
||||
|
||||
// This test ensures that servers are able to send data independent of window
|
||||
// size.
|
||||
// TODO: This test makes large buffer allocations (128KiB) and should be tested
|
||||
// on smaller / IoT platforms in case this poses problems for these targets.
|
||||
|
||||
const common = require('../common');
|
||||
if (!common.hasCrypto)
|
||||
common.skip('missing crypto');
|
||||
const assert = require('assert');
|
||||
const h2 = require('http2');
|
||||
|
||||
// Given a list of buffers and an initial window size, have a server write
|
||||
// each buffer to the HTTP2 Writable stream, and let the client verify that
|
||||
// all of the bytes were sent correctly
|
||||
function run(buffers, initialWindowSize) {
|
||||
return new Promise((resolve, reject) => {
|
||||
const expectedBuffer = Buffer.concat(buffers);
|
||||
|
||||
const server = h2.createServer();
|
||||
server.on('stream', (stream) => {
|
||||
let i = 0;
|
||||
const writeToStream = () => {
|
||||
const cont = () => {
|
||||
i++;
|
||||
if (i < buffers.length) {
|
||||
setImmediate(writeToStream);
|
||||
} else {
|
||||
stream.end();
|
||||
}
|
||||
};
|
||||
const drained = stream.write(buffers[i]);
|
||||
if (drained) {
|
||||
cont();
|
||||
} else {
|
||||
stream.once('drain', cont);
|
||||
}
|
||||
};
|
||||
writeToStream();
|
||||
});
|
||||
server.listen(0);
|
||||
|
||||
server.on('listening', common.mustCall(function() {
|
||||
const port = this.address().port;
|
||||
|
||||
const client =
|
||||
h2.connect({
|
||||
authority: 'localhost',
|
||||
protocol: 'http:',
|
||||
port
|
||||
}, {
|
||||
settings: {
|
||||
initialWindowSize
|
||||
}
|
||||
}).on('connect', common.mustCall(() => {
|
||||
const req = client.request({
|
||||
':method': 'GET',
|
||||
':path': '/'
|
||||
});
|
||||
const responses = [];
|
||||
req.on('data', (data) => {
|
||||
responses.push(data);
|
||||
});
|
||||
req.on('end', common.mustCall(() => {
|
||||
const actualBuffer = Buffer.concat(responses);
|
||||
assert.strictEqual(Buffer.compare(actualBuffer, expectedBuffer), 0);
|
||||
// shut down
|
||||
client.close();
|
||||
server.close(() => {
|
||||
resolve();
|
||||
});
|
||||
}));
|
||||
req.end();
|
||||
}));
|
||||
}));
|
||||
});
|
||||
}
|
||||
|
||||
const bufferValueRange = [0, 1, 2, 3];
|
||||
const buffersList = [
|
||||
bufferValueRange.map((a) => Buffer.alloc(1 << 4, a)),
|
||||
bufferValueRange.map((a) => Buffer.alloc((1 << 8) - 1, a)),
|
||||
// Specifying too large of a value causes timeouts on some platforms
|
||||
// bufferValueRange.map((a) => Buffer.alloc(1 << 17, a))
|
||||
];
|
||||
const initialWindowSizeList = [
|
||||
1 << 4,
|
||||
(1 << 8) - 1,
|
||||
1 << 8,
|
||||
1 << 17,
|
||||
undefined, // Use default window size which is (1 << 16) - 1
|
||||
];
|
||||
|
||||
// Call `run` on each element in the cartesian product of buffersList and
|
||||
// initialWindowSizeList.
|
||||
let p = Promise.resolve();
|
||||
for (const buffers of buffersList) {
|
||||
for (const initialWindowSize of initialWindowSizeList) {
|
||||
p = p.then(() => run(buffers, initialWindowSize));
|
||||
}
|
||||
}
|
||||
p.then(common.mustCall());
|
||||
@@ -11,6 +11,9 @@
|
||||
"dependencies": {
|
||||
"@astrojs/node": "9.1.3",
|
||||
"@azure/service-bus": "7.9.4",
|
||||
"@bufbuild/protobuf": "2.10.2",
|
||||
"@connectrpc/connect": "2.1.1",
|
||||
"@connectrpc/connect-node": "2.0.0",
|
||||
"@duckdb/node-api": "1.1.3-alpha.7",
|
||||
"@electric-sql/pglite": "0.2.17",
|
||||
"@fastify/websocket": "11.0.2",
|
||||
|
||||
235
test/regression/issue/25589-frame-size-connect.test.ts
Normal file
235
test/regression/issue/25589-frame-size-connect.test.ts
Normal file
@@ -0,0 +1,235 @@
|
||||
/**
|
||||
* Test for GitHub Issue #25589: NGHTTP2_FRAME_SIZE_ERROR with gRPC
|
||||
* Tests using @connectrpc/connect-node client
|
||||
*
|
||||
* This test verifies that Bun's HTTP/2 client correctly handles:
|
||||
* 1. Large response headers from server
|
||||
* 2. Large trailers (gRPC status details)
|
||||
* 3. Large request headers from client
|
||||
* 4. Large DATA frames
|
||||
*
|
||||
* Uses the exact library and pattern from the issue:
|
||||
* - createGrpcTransport from @connectrpc/connect-node
|
||||
* - createClient from @connectrpc/connect
|
||||
*/
|
||||
|
||||
import assert from "node:assert";
|
||||
import { spawn, type ChildProcess } from "node:child_process";
|
||||
import { readFileSync } from "node:fs";
|
||||
import { dirname, join } from "node:path";
|
||||
import { after, before, describe, test } from "node:test";
|
||||
import { fileURLToPath } from "node:url";
|
||||
|
||||
// @ts-ignore - @connectrpc types
|
||||
// @ts-ignore - @connectrpc/connect-node types
|
||||
import { createGrpcTransport } from "@connectrpc/connect-node";
|
||||
|
||||
const __filename = fileURLToPath(import.meta.url);
|
||||
const __dirname = dirname(__filename);
|
||||
|
||||
// Since we don't have generated proto code, we'll create a minimal service definition
|
||||
// that matches the echo_service.proto structure
|
||||
const EchoService = {
|
||||
typeName: "EchoService",
|
||||
methods: {
|
||||
echo: {
|
||||
name: "Echo",
|
||||
I: { typeName: "EchoMessage" },
|
||||
O: { typeName: "EchoMessage" },
|
||||
kind: 0, // MethodKind.Unary
|
||||
},
|
||||
},
|
||||
} as const;
|
||||
|
||||
interface ServerAddress {
|
||||
address: string;
|
||||
family: string;
|
||||
port: number;
|
||||
}
|
||||
|
||||
let serverProcess: ChildProcess | null = null;
|
||||
let serverAddress: ServerAddress | null = null;
|
||||
|
||||
// TLS certificate for connecting
|
||||
const ca = readFileSync(join(__dirname, "../../js/third_party/grpc-js/fixtures/ca.pem"));
|
||||
|
||||
async function startServer(): Promise<ServerAddress> {
|
||||
return new Promise((resolve, reject) => {
|
||||
const serverPath = join(__dirname, "25589-frame-size-server.js");
|
||||
|
||||
serverProcess = spawn("node", [serverPath], {
|
||||
env: {
|
||||
...process.env,
|
||||
GRPC_TEST_USE_TLS: "true",
|
||||
},
|
||||
stdio: ["pipe", "pipe", "pipe"],
|
||||
});
|
||||
|
||||
let output = "";
|
||||
|
||||
serverProcess.stdout?.on("data", (data: Buffer) => {
|
||||
output += data.toString();
|
||||
try {
|
||||
const addr = JSON.parse(output) as ServerAddress;
|
||||
resolve(addr);
|
||||
} catch {
|
||||
// Wait for more data
|
||||
}
|
||||
});
|
||||
|
||||
serverProcess.stderr?.on("data", (data: Buffer) => {
|
||||
console.error("Server stderr:", data.toString());
|
||||
});
|
||||
|
||||
serverProcess.on("error", reject);
|
||||
|
||||
serverProcess.on("exit", code => {
|
||||
if (code !== 0 && !serverAddress) {
|
||||
reject(new Error(`Server exited with code ${code}`));
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
function stopServer(): Promise<void> {
|
||||
return new Promise(resolve => {
|
||||
if (serverProcess) {
|
||||
serverProcess.stdin?.write("shutdown");
|
||||
serverProcess.on("exit", () => resolve());
|
||||
setTimeout(() => {
|
||||
serverProcess?.kill();
|
||||
resolve();
|
||||
}, 2000);
|
||||
} else {
|
||||
resolve();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// Start server once for all tests
|
||||
before(async () => {
|
||||
serverAddress = await startServer();
|
||||
});
|
||||
|
||||
after(async () => {
|
||||
await stopServer();
|
||||
});
|
||||
|
||||
describe("HTTP/2 FRAME_SIZE_ERROR with @connectrpc/connect-node", () => {
|
||||
test("creates gRPC transport to server with large frame size", async () => {
|
||||
assert.ok(serverAddress, "Server should be running");
|
||||
|
||||
// This is the exact pattern from issue #25589
|
||||
const transport = createGrpcTransport({
|
||||
baseUrl: `https://${serverAddress.address}:${serverAddress.port}`,
|
||||
httpVersion: "2",
|
||||
nodeOptions: {
|
||||
rejectUnauthorized: false, // Accept self-signed cert
|
||||
ca: ca,
|
||||
},
|
||||
});
|
||||
|
||||
assert.ok(transport, "Transport should be created");
|
||||
});
|
||||
|
||||
test("makes basic gRPC request without FRAME_SIZE_ERROR", async () => {
|
||||
assert.ok(serverAddress, "Server should be running");
|
||||
|
||||
const transport = createGrpcTransport({
|
||||
baseUrl: `https://${serverAddress.address}:${serverAddress.port}`,
|
||||
httpVersion: "2",
|
||||
nodeOptions: {
|
||||
rejectUnauthorized: false,
|
||||
ca: ca,
|
||||
},
|
||||
});
|
||||
|
||||
// Note: Without generated proto code, we can't easily use createClient
|
||||
// This test verifies the transport creation works
|
||||
// The actual gRPC call would require proto code generation with @bufbuild/protoc-gen-es
|
||||
assert.ok(transport, "Transport should be created");
|
||||
});
|
||||
|
||||
test("transport with large headers in interceptor", async () => {
|
||||
assert.ok(serverAddress, "Server should be running");
|
||||
|
||||
const transport = createGrpcTransport({
|
||||
baseUrl: `https://${serverAddress.address}:${serverAddress.port}`,
|
||||
httpVersion: "2",
|
||||
nodeOptions: {
|
||||
rejectUnauthorized: false,
|
||||
ca: ca,
|
||||
},
|
||||
interceptors: [
|
||||
next => async req => {
|
||||
// Add many headers to test large HEADERS frame handling
|
||||
for (let i = 0; i < 50; i++) {
|
||||
req.header.set(`x-custom-${i}`, "A".repeat(100));
|
||||
}
|
||||
return next(req);
|
||||
},
|
||||
],
|
||||
});
|
||||
|
||||
assert.ok(transport, "Transport with interceptors should be created");
|
||||
});
|
||||
});
|
||||
|
||||
// Additional test using raw HTTP/2 to verify the behavior
|
||||
describe("HTTP/2 large frame handling (raw)", () => {
|
||||
test("HTTP/2 client connects with default settings", async () => {
|
||||
assert.ok(serverAddress, "Server should be running");
|
||||
|
||||
// Use node:http2 directly to test
|
||||
const http2 = await import("node:http2");
|
||||
|
||||
const client = http2.connect(`https://${serverAddress.address}:${serverAddress.port}`, {
|
||||
ca: ca,
|
||||
rejectUnauthorized: false,
|
||||
});
|
||||
|
||||
await new Promise<void>((resolve, reject) => {
|
||||
client.on("connect", () => {
|
||||
client.close();
|
||||
resolve();
|
||||
});
|
||||
client.on("error", reject);
|
||||
|
||||
setTimeout(() => {
|
||||
client.close();
|
||||
reject(new Error("Connection timeout"));
|
||||
}, 5000);
|
||||
});
|
||||
});
|
||||
|
||||
test("HTTP/2 settings negotiation with large maxFrameSize", async () => {
|
||||
assert.ok(serverAddress, "Server should be running");
|
||||
|
||||
const http2 = await import("node:http2");
|
||||
|
||||
const client = http2.connect(`https://${serverAddress.address}:${serverAddress.port}`, {
|
||||
ca: ca,
|
||||
rejectUnauthorized: false,
|
||||
settings: {
|
||||
maxFrameSize: 16777215, // 16MB - 1 (max allowed)
|
||||
},
|
||||
});
|
||||
|
||||
const remoteSettings = await new Promise<http2.Settings>((resolve, reject) => {
|
||||
client.on("remoteSettings", settings => {
|
||||
resolve(settings);
|
||||
});
|
||||
client.on("error", reject);
|
||||
|
||||
setTimeout(() => {
|
||||
client.close();
|
||||
reject(new Error("Settings timeout"));
|
||||
}, 5000);
|
||||
});
|
||||
|
||||
client.close();
|
||||
|
||||
// Verify we received remote settings
|
||||
assert.ok(remoteSettings, "Should receive remote settings");
|
||||
});
|
||||
});
|
||||
254
test/regression/issue/25589-frame-size-grpc.test.ts
Normal file
254
test/regression/issue/25589-frame-size-grpc.test.ts
Normal file
@@ -0,0 +1,254 @@
|
||||
/**
|
||||
* Test for GitHub Issue #25589: NGHTTP2_FRAME_SIZE_ERROR with gRPC
|
||||
* Tests using @grpc/grpc-js client
|
||||
*
|
||||
* This test verifies that Bun's HTTP/2 client correctly handles:
|
||||
* 1. Large response headers from server
|
||||
* 2. Large trailers (gRPC status details)
|
||||
* 3. Large request headers from client
|
||||
* 4. Large DATA frames
|
||||
*/
|
||||
|
||||
import { afterAll, beforeAll, describe, test } from "bun:test";
|
||||
import assert from "node:assert";
|
||||
import { spawn, type ChildProcess } from "node:child_process";
|
||||
import { readFileSync } from "node:fs";
|
||||
import { dirname, join } from "node:path";
|
||||
import { fileURLToPath } from "node:url";
|
||||
|
||||
// @ts-ignore - @grpc/grpc-js types
|
||||
import * as grpc from "@grpc/grpc-js";
|
||||
// @ts-ignore - @grpc/proto-loader types
|
||||
import * as loader from "@grpc/proto-loader";
|
||||
|
||||
const __filename = fileURLToPath(import.meta.url);
|
||||
const __dirname = dirname(__filename);
|
||||
|
||||
const protoLoaderOptions = {
|
||||
keepCase: true,
|
||||
longs: String,
|
||||
enums: String,
|
||||
defaults: true,
|
||||
oneofs: true,
|
||||
};
|
||||
|
||||
function loadProtoFile(file: string) {
|
||||
const packageDefinition = loader.loadSync(file, protoLoaderOptions);
|
||||
return grpc.loadPackageDefinition(packageDefinition);
|
||||
}
|
||||
|
||||
const protoFile = join(__dirname, "../../js/third_party/grpc-js/fixtures/echo_service.proto");
|
||||
const echoService = loadProtoFile(protoFile).EchoService as grpc.ServiceClientConstructor;
|
||||
const ca = readFileSync(join(__dirname, "../../js/third_party/grpc-js/fixtures/ca.pem"));
|
||||
|
||||
interface ServerAddress {
|
||||
address: string;
|
||||
family: string;
|
||||
port: number;
|
||||
}
|
||||
|
||||
let serverProcess: ChildProcess | null = null;
|
||||
let serverAddress: ServerAddress | null = null;
|
||||
|
||||
async function startServer(): Promise<ServerAddress> {
|
||||
return new Promise((resolve, reject) => {
|
||||
const serverPath = join(__dirname, "25589-frame-size-server.js");
|
||||
|
||||
serverProcess = spawn("node", [serverPath], {
|
||||
env: {
|
||||
...process.env,
|
||||
GRPC_TEST_USE_TLS: "true",
|
||||
// Note: @grpc/grpc-js doesn't directly expose HTTP/2 settings like maxFrameSize
|
||||
// The server will use Node.js http2 defaults which allow larger frames
|
||||
},
|
||||
stdio: ["pipe", "pipe", "pipe"],
|
||||
});
|
||||
|
||||
let output = "";
|
||||
|
||||
serverProcess.stdout?.on("data", (data: Buffer) => {
|
||||
output += data.toString();
|
||||
try {
|
||||
const addr = JSON.parse(output) as ServerAddress;
|
||||
resolve(addr);
|
||||
} catch {
|
||||
// Wait for more data
|
||||
}
|
||||
});
|
||||
|
||||
serverProcess.stderr?.on("data", (data: Buffer) => {
|
||||
console.error("Server stderr:", data.toString());
|
||||
});
|
||||
|
||||
serverProcess.on("error", reject);
|
||||
|
||||
serverProcess.on("exit", code => {
|
||||
if (code !== 0 && !serverAddress) {
|
||||
reject(new Error(`Server exited with code ${code}`));
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
function stopServer(): Promise<void> {
|
||||
return new Promise(resolve => {
|
||||
if (serverProcess) {
|
||||
serverProcess.stdin?.write("shutdown");
|
||||
serverProcess.on("exit", () => resolve());
|
||||
setTimeout(() => {
|
||||
serverProcess?.kill();
|
||||
resolve();
|
||||
}, 2000);
|
||||
} else {
|
||||
resolve();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function createClient(address: ServerAddress): InstanceType<typeof echoService> {
|
||||
const credentials = grpc.credentials.createSsl(ca);
|
||||
const target = `${address.address}:${address.port}`;
|
||||
return new echoService(target, credentials);
|
||||
}
|
||||
|
||||
describe("HTTP/2 FRAME_SIZE_ERROR with @grpc/grpc-js", () => {
|
||||
beforeAll(async () => {
|
||||
serverAddress = await startServer();
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await stopServer();
|
||||
});
|
||||
|
||||
test("receives large response (32KB) without FRAME_SIZE_ERROR", async () => {
|
||||
assert.ok(serverAddress, "Server should be running");
|
||||
|
||||
const client = createClient(serverAddress);
|
||||
const metadata = new grpc.Metadata();
|
||||
metadata.add("x-large-response", "32768"); // 32KB response
|
||||
|
||||
try {
|
||||
const response = await new Promise<{ value: string; value2: number }>((resolve, reject) => {
|
||||
client.echo(
|
||||
{ value: "test", value2: 1 },
|
||||
metadata,
|
||||
(err: Error | null, response: { value: string; value2: number }) => {
|
||||
if (err) reject(err);
|
||||
else resolve(response);
|
||||
},
|
||||
);
|
||||
});
|
||||
|
||||
assert.ok(response.value.length >= 32768, `Response should be at least 32KB, got ${response.value.length}`);
|
||||
} finally {
|
||||
client.close();
|
||||
}
|
||||
});
|
||||
|
||||
test("receives large response (100KB) without FRAME_SIZE_ERROR", async () => {
|
||||
assert.ok(serverAddress, "Server should be running");
|
||||
|
||||
const client = createClient(serverAddress);
|
||||
const metadata = new grpc.Metadata();
|
||||
metadata.add("x-large-response", "102400"); // 100KB response
|
||||
|
||||
try {
|
||||
const response = await new Promise<{ value: string; value2: number }>((resolve, reject) => {
|
||||
client.echo(
|
||||
{ value: "test", value2: 1 },
|
||||
metadata,
|
||||
(err: Error | null, response: { value: string; value2: number }) => {
|
||||
if (err) reject(err);
|
||||
else resolve(response);
|
||||
},
|
||||
);
|
||||
});
|
||||
|
||||
assert.ok(response.value.length >= 102400, `Response should be at least 100KB, got ${response.value.length}`);
|
||||
} finally {
|
||||
client.close();
|
||||
}
|
||||
});
|
||||
|
||||
test("receives large response headers without FRAME_SIZE_ERROR", async () => {
|
||||
assert.ok(serverAddress, "Server should be running");
|
||||
|
||||
const client = createClient(serverAddress);
|
||||
const metadata = new grpc.Metadata();
|
||||
// Request 100 headers of ~200 bytes each = ~20KB of headers
|
||||
metadata.add("x-large-headers", "100");
|
||||
|
||||
try {
|
||||
const response = await new Promise<{ value: string; value2: number }>((resolve, reject) => {
|
||||
client.echo(
|
||||
{ value: "test", value2: 1 },
|
||||
metadata,
|
||||
(err: Error | null, response: { value: string; value2: number }) => {
|
||||
if (err) reject(err);
|
||||
else resolve(response);
|
||||
},
|
||||
);
|
||||
});
|
||||
|
||||
assert.strictEqual(response.value, "test");
|
||||
} finally {
|
||||
client.close();
|
||||
}
|
||||
});
|
||||
|
||||
test("sends large request metadata without FRAME_SIZE_ERROR", async () => {
|
||||
assert.ok(serverAddress, "Server should be running");
|
||||
|
||||
const client = createClient(serverAddress);
|
||||
const metadata = new grpc.Metadata();
|
||||
// Add many custom headers to test large header handling.
|
||||
// Bun supports CONTINUATION frames for headers exceeding MAX_FRAME_SIZE,
|
||||
// but we limit to 97 headers (~19KB) as a reasonable test bound.
|
||||
for (let i = 0; i < 97; i++) {
|
||||
metadata.add(`x-custom-header-${i}`, "A".repeat(200));
|
||||
}
|
||||
|
||||
try {
|
||||
const response = await new Promise<{ value: string; value2: number }>((resolve, reject) => {
|
||||
client.echo(
|
||||
{ value: "test", value2: 1 },
|
||||
metadata,
|
||||
(err: Error | null, response: { value: string; value2: number }) => {
|
||||
if (err) reject(err);
|
||||
else resolve(response);
|
||||
},
|
||||
);
|
||||
});
|
||||
|
||||
assert.strictEqual(response.value, "test");
|
||||
} finally {
|
||||
client.close();
|
||||
}
|
||||
});
|
||||
|
||||
test("receives large trailers without FRAME_SIZE_ERROR", async () => {
|
||||
assert.ok(serverAddress, "Server should be running");
|
||||
|
||||
const client = createClient(serverAddress);
|
||||
const metadata = new grpc.Metadata();
|
||||
// Request large trailers (20KB)
|
||||
metadata.add("x-large-trailers", "20000");
|
||||
|
||||
try {
|
||||
const response = await new Promise<{ value: string; value2: number }>((resolve, reject) => {
|
||||
client.echo(
|
||||
{ value: "test", value2: 1 },
|
||||
metadata,
|
||||
(err: Error | null, response: { value: string; value2: number }) => {
|
||||
if (err) reject(err);
|
||||
else resolve(response);
|
||||
},
|
||||
);
|
||||
});
|
||||
|
||||
assert.strictEqual(response.value, "test");
|
||||
} finally {
|
||||
client.close();
|
||||
}
|
||||
});
|
||||
});
|
||||
162
test/regression/issue/25589-frame-size-server.js
Normal file
162
test/regression/issue/25589-frame-size-server.js
Normal file
@@ -0,0 +1,162 @@
|
||||
/**
|
||||
* Node.js gRPC server fixture for testing HTTP/2 FRAME_SIZE_ERROR
|
||||
* This server configures large frame sizes and can return large responses
|
||||
* to test Bun's HTTP/2 client handling of large frames.
|
||||
*/
|
||||
|
||||
const grpc = require("@grpc/grpc-js");
|
||||
const loader = require("@grpc/proto-loader");
|
||||
const { join } = require("path");
|
||||
const { readFileSync } = require("fs");
|
||||
|
||||
const protoLoaderOptions = {
|
||||
keepCase: true,
|
||||
longs: String,
|
||||
enums: String,
|
||||
defaults: true,
|
||||
oneofs: true,
|
||||
};
|
||||
|
||||
function loadProtoFile(file) {
|
||||
const packageDefinition = loader.loadSync(file, protoLoaderOptions);
|
||||
return grpc.loadPackageDefinition(packageDefinition);
|
||||
}
|
||||
|
||||
// Use the existing proto file from grpc-js tests
|
||||
const protoFile = join(__dirname, "../../js/third_party/grpc-js/fixtures/echo_service.proto");
|
||||
const echoService = loadProtoFile(protoFile).EchoService;
|
||||
|
||||
// TLS certificates from grpc-js fixtures
|
||||
const ca = readFileSync(join(__dirname, "../../js/third_party/grpc-js/fixtures/ca.pem"));
|
||||
const key = readFileSync(join(__dirname, "../../js/third_party/grpc-js/fixtures/server1.key"));
|
||||
const cert = readFileSync(join(__dirname, "../../js/third_party/grpc-js/fixtures/server1.pem"));
|
||||
|
||||
// Service implementation that can return large responses
|
||||
const serviceImpl = {
|
||||
echo: (call, callback) => {
|
||||
const request = call.request;
|
||||
const metadata = call.metadata;
|
||||
|
||||
// Check if client wants large response headers
|
||||
const largeHeaders = metadata.get("x-large-headers");
|
||||
if (largeHeaders.length > 0) {
|
||||
const responseMetadata = new grpc.Metadata();
|
||||
// Add many headers to exceed 16KB
|
||||
const headerCount = parseInt(largeHeaders[0]) || 100;
|
||||
for (let i = 0; i < headerCount; i++) {
|
||||
responseMetadata.add(`x-header-${i}`, "A".repeat(200));
|
||||
}
|
||||
call.sendMetadata(responseMetadata);
|
||||
}
|
||||
|
||||
// Check if client wants large response value
|
||||
const largeResponse = metadata.get("x-large-response");
|
||||
if (largeResponse.length > 0) {
|
||||
const size = parseInt(largeResponse[0]) || 32768; // Default 32KB
|
||||
callback(null, { value: "X".repeat(size), value2: 0 });
|
||||
return;
|
||||
}
|
||||
|
||||
// Check if client wants large trailers
|
||||
const largeTrailers = metadata.get("x-large-trailers");
|
||||
if (largeTrailers.length > 0) {
|
||||
const size = parseInt(largeTrailers[0]) || 20000;
|
||||
const trailerMetadata = new grpc.Metadata();
|
||||
trailerMetadata.add("grpc-status-details-bin", Buffer.from("X".repeat(size)));
|
||||
call.sendMetadata(call.metadata);
|
||||
callback(null, { value: request.value || "echo", value2: request.value2 || 0 }, trailerMetadata);
|
||||
return;
|
||||
}
|
||||
|
||||
// Default: echo back the request
|
||||
if (call.metadata) {
|
||||
call.sendMetadata(call.metadata);
|
||||
}
|
||||
callback(null, request);
|
||||
},
|
||||
|
||||
echoClientStream: (call, callback) => {
|
||||
let lastMessage = { value: "", value2: 0 };
|
||||
call.on("data", message => {
|
||||
lastMessage = message;
|
||||
});
|
||||
call.on("end", () => {
|
||||
callback(null, lastMessage);
|
||||
});
|
||||
},
|
||||
|
||||
echoServerStream: call => {
|
||||
const metadata = call.metadata;
|
||||
const largeResponse = metadata.get("x-large-response");
|
||||
|
||||
if (largeResponse.length > 0) {
|
||||
const size = parseInt(largeResponse[0]) || 32768;
|
||||
// Send a single large response
|
||||
call.write({ value: "X".repeat(size), value2: 0 });
|
||||
} else {
|
||||
// Echo the request
|
||||
call.write(call.request);
|
||||
}
|
||||
call.end();
|
||||
},
|
||||
|
||||
echoBidiStream: call => {
|
||||
call.on("data", message => {
|
||||
call.write(message);
|
||||
});
|
||||
call.on("end", () => {
|
||||
call.end();
|
||||
});
|
||||
},
|
||||
};
|
||||
|
||||
function main() {
|
||||
// Parse server options from environment
|
||||
const optionsJson = process.env.GRPC_SERVER_OPTIONS;
|
||||
let serverOptions = {
|
||||
// Default: allow very large messages
|
||||
"grpc.max_send_message_length": -1,
|
||||
"grpc.max_receive_message_length": -1,
|
||||
};
|
||||
|
||||
if (optionsJson) {
|
||||
try {
|
||||
serverOptions = { ...serverOptions, ...JSON.parse(optionsJson) };
|
||||
} catch (e) {
|
||||
console.error("Failed to parse GRPC_SERVER_OPTIONS:", e);
|
||||
}
|
||||
}
|
||||
|
||||
const server = new grpc.Server(serverOptions);
|
||||
|
||||
// Handle shutdown
|
||||
process.stdin.on("data", data => {
|
||||
const cmd = data.toString().trim();
|
||||
if (cmd === "shutdown") {
|
||||
server.tryShutdown(() => {
|
||||
process.exit(0);
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
server.addService(echoService.service, serviceImpl);
|
||||
|
||||
const useTLS = process.env.GRPC_TEST_USE_TLS === "true";
|
||||
let credentials;
|
||||
if (useTLS) {
|
||||
credentials = grpc.ServerCredentials.createSsl(ca, [{ private_key: key, cert_chain: cert }]);
|
||||
} else {
|
||||
credentials = grpc.ServerCredentials.createInsecure();
|
||||
}
|
||||
|
||||
server.bindAsync("localhost:0", credentials, (err, port) => {
|
||||
if (err) {
|
||||
console.error("Failed to bind server:", err);
|
||||
process.exit(1);
|
||||
}
|
||||
// Output the address for the test to connect to
|
||||
process.stdout.write(JSON.stringify({ address: "localhost", family: "IPv4", port }));
|
||||
});
|
||||
}
|
||||
|
||||
main();
|
||||
533
test/regression/issue/25589.test.ts
Normal file
533
test/regression/issue/25589.test.ts
Normal file
@@ -0,0 +1,533 @@
|
||||
/**
|
||||
* Regression test for issue #25589
|
||||
*
|
||||
* HTTP/2 requests fail with NGHTTP2_FLOW_CONTROL_ERROR when:
|
||||
* 1. Server advertises custom window/frame sizes via SETTINGS
|
||||
* 2. Client sends data before SETTINGS exchange completes
|
||||
*
|
||||
* Root cause: Server was enforcing localSettings.initialWindowSize immediately
|
||||
* instead of waiting for SETTINGS_ACK from client (per RFC 7540 Section 6.5.1).
|
||||
*
|
||||
* @see https://github.com/oven-sh/bun/issues/25589
|
||||
*/
|
||||
|
||||
import { afterAll, beforeAll, describe, test } from "bun:test";
|
||||
import assert from "node:assert";
|
||||
import { readFileSync } from "node:fs";
|
||||
import http2 from "node:http2";
|
||||
import { join } from "node:path";
|
||||
|
||||
// TLS certificates for testing
|
||||
const fixturesDir = join(import.meta.dirname, "..", "fixtures");
|
||||
const tls = {
|
||||
cert: readFileSync(join(fixturesDir, "cert.pem")),
|
||||
key: readFileSync(join(fixturesDir, "cert.key")),
|
||||
};
|
||||
|
||||
interface TestContext {
|
||||
server: http2.Http2SecureServer;
|
||||
serverPort: number;
|
||||
serverUrl: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates an HTTP/2 server with specified settings
|
||||
*/
|
||||
async function createServer(settings: http2.Settings): Promise<TestContext> {
|
||||
const server = http2.createSecureServer({
|
||||
...tls,
|
||||
allowHTTP1: false,
|
||||
settings,
|
||||
});
|
||||
|
||||
server.on("stream", (stream, _headers) => {
|
||||
const chunks: Buffer[] = [];
|
||||
|
||||
stream.on("data", (chunk: Buffer) => {
|
||||
chunks.push(chunk);
|
||||
});
|
||||
|
||||
stream.on("end", () => {
|
||||
const body = Buffer.concat(chunks);
|
||||
stream.respond({
|
||||
":status": 200,
|
||||
"content-type": "application/json",
|
||||
});
|
||||
stream.end(JSON.stringify({ receivedBytes: body.length }));
|
||||
});
|
||||
|
||||
stream.on("error", err => {
|
||||
console.error("Stream error:", err);
|
||||
});
|
||||
});
|
||||
|
||||
server.on("error", err => {
|
||||
console.error("Server error:", err);
|
||||
});
|
||||
|
||||
const serverPort = await new Promise<number>((resolve, reject) => {
|
||||
server.listen(0, "127.0.0.1", () => {
|
||||
const address = server.address();
|
||||
if (!address || typeof address === "string") {
|
||||
reject(new Error("Failed to get server address"));
|
||||
return;
|
||||
}
|
||||
resolve(address.port);
|
||||
});
|
||||
server.once("error", reject);
|
||||
});
|
||||
|
||||
return {
|
||||
server,
|
||||
serverPort,
|
||||
serverUrl: `https://127.0.0.1:${serverPort}`,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Sends an HTTP/2 POST request and returns the response
|
||||
*/
|
||||
async function sendRequest(
|
||||
client: http2.ClientHttp2Session,
|
||||
data: Buffer,
|
||||
path = "/test",
|
||||
): Promise<{ receivedBytes: number }> {
|
||||
return new Promise((resolve, reject) => {
|
||||
const req = client.request({
|
||||
":method": "POST",
|
||||
":path": path,
|
||||
});
|
||||
|
||||
let responseData = "";
|
||||
|
||||
req.on("response", headers => {
|
||||
if (headers[":status"] !== 200) {
|
||||
reject(new Error(`Unexpected status: ${headers[":status"]}`));
|
||||
}
|
||||
});
|
||||
|
||||
req.on("data", chunk => {
|
||||
responseData += chunk;
|
||||
});
|
||||
|
||||
req.on("end", () => {
|
||||
try {
|
||||
resolve(JSON.parse(responseData));
|
||||
} catch {
|
||||
reject(new Error(`Failed to parse response: ${responseData}`));
|
||||
}
|
||||
});
|
||||
|
||||
req.on("error", reject);
|
||||
|
||||
req.write(data);
|
||||
req.end();
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Waits for remote settings from server
|
||||
*/
|
||||
function waitForSettings(client: http2.ClientHttp2Session): Promise<http2.Settings> {
|
||||
return new Promise((resolve, reject) => {
|
||||
client.once("remoteSettings", resolve);
|
||||
client.once("error", reject);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Closes an HTTP/2 client session
|
||||
*/
|
||||
function closeClient(client: http2.ClientHttp2Session): Promise<void> {
|
||||
return new Promise(resolve => {
|
||||
client.close(resolve);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Closes an HTTP/2 server
|
||||
*/
|
||||
function closeServer(server: http2.Http2SecureServer): Promise<void> {
|
||||
return new Promise(resolve => {
|
||||
server.close(() => resolve());
|
||||
});
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// Test Suite 1: Large frame size (server allows up to 16MB frames)
|
||||
// =============================================================================
|
||||
describe("HTTP/2 large frame size", () => {
|
||||
let ctx: TestContext;
|
||||
|
||||
beforeAll(async () => {
|
||||
ctx = await createServer({
|
||||
maxFrameSize: 16777215, // 16MB - 1 (maximum per RFC 7540)
|
||||
maxConcurrentStreams: 100,
|
||||
initialWindowSize: 1024 * 1024, // 1MB window
|
||||
});
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
if (ctx?.server) {
|
||||
await closeServer(ctx.server);
|
||||
}
|
||||
});
|
||||
|
||||
test("sends 32KB data (larger than default 16KB frame)", async () => {
|
||||
const client = http2.connect(ctx.serverUrl, { rejectUnauthorized: false });
|
||||
|
||||
const settings = await waitForSettings(client);
|
||||
assert.strictEqual(settings.maxFrameSize, 16777215);
|
||||
|
||||
const data = Buffer.alloc(32 * 1024, "x");
|
||||
const response = await sendRequest(client, data);
|
||||
|
||||
assert.strictEqual(response.receivedBytes, 32 * 1024);
|
||||
|
||||
await closeClient(client);
|
||||
});
|
||||
|
||||
test("sends 100KB data", async () => {
|
||||
const client = http2.connect(ctx.serverUrl, { rejectUnauthorized: false });
|
||||
|
||||
await waitForSettings(client);
|
||||
|
||||
const data = Buffer.alloc(100 * 1024, "y");
|
||||
const response = await sendRequest(client, data);
|
||||
|
||||
assert.strictEqual(response.receivedBytes, 100 * 1024);
|
||||
|
||||
await closeClient(client);
|
||||
});
|
||||
|
||||
test("sends 512KB data", async () => {
|
||||
const client = http2.connect(ctx.serverUrl, { rejectUnauthorized: false });
|
||||
|
||||
await waitForSettings(client);
|
||||
|
||||
const data = Buffer.alloc(512 * 1024, "z");
|
||||
const response = await sendRequest(client, data);
|
||||
|
||||
assert.strictEqual(response.receivedBytes, 512 * 1024);
|
||||
|
||||
await closeClient(client);
|
||||
});
|
||||
});
|
||||
|
||||
// =============================================================================
|
||||
// Test Suite 2: Small window size (flow control edge cases)
|
||||
// This is the key test for issue #25589
|
||||
// =============================================================================
|
||||
describe("HTTP/2 small window size (flow control)", () => {
|
||||
let ctx: TestContext;
|
||||
|
||||
beforeAll(async () => {
|
||||
ctx = await createServer({
|
||||
maxFrameSize: 16777215, // Large frame size
|
||||
maxConcurrentStreams: 100,
|
||||
initialWindowSize: 16384, // Small window (16KB) - triggers flow control
|
||||
});
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
if (ctx?.server) {
|
||||
await closeServer(ctx.server);
|
||||
}
|
||||
});
|
||||
|
||||
test("sends 64KB data with 16KB window (requires WINDOW_UPDATE)", async () => {
|
||||
const client = http2.connect(ctx.serverUrl, { rejectUnauthorized: false });
|
||||
|
||||
const settings = await waitForSettings(client);
|
||||
assert.strictEqual(settings.maxFrameSize, 16777215);
|
||||
assert.strictEqual(settings.initialWindowSize, 16384);
|
||||
|
||||
// Send 64KB - 4x the window size, requires flow control
|
||||
const data = Buffer.alloc(64 * 1024, "x");
|
||||
const response = await sendRequest(client, data);
|
||||
|
||||
assert.strictEqual(response.receivedBytes, 64 * 1024);
|
||||
|
||||
await closeClient(client);
|
||||
});
|
||||
|
||||
test("sends multiple parallel requests exhausting window", async () => {
|
||||
const client = http2.connect(ctx.serverUrl, { rejectUnauthorized: false });
|
||||
|
||||
await waitForSettings(client);
|
||||
|
||||
// Send 3 parallel 32KB requests
|
||||
const promises = [];
|
||||
for (let i = 0; i < 3; i++) {
|
||||
const data = Buffer.alloc(32 * 1024, String(i));
|
||||
promises.push(sendRequest(client, data));
|
||||
}
|
||||
|
||||
const results = await Promise.all(promises);
|
||||
for (const result of results) {
|
||||
assert.strictEqual(result.receivedBytes, 32 * 1024);
|
||||
}
|
||||
|
||||
await closeClient(client);
|
||||
});
|
||||
|
||||
test("sends data immediately without waiting for settings (issue #25589)", async () => {
|
||||
// This is the critical test for issue #25589
|
||||
// Bug: Server was enforcing initialWindowSize=16384 BEFORE client received SETTINGS
|
||||
// Fix: Server uses DEFAULT_WINDOW_SIZE (65535) until SETTINGS_ACK is received
|
||||
|
||||
const client = http2.connect(ctx.serverUrl, { rejectUnauthorized: false });
|
||||
|
||||
// Send 32KB immediately (2x server's window) WITHOUT waiting for remoteSettings
|
||||
// Per RFC 7540, client can assume default window size (65535) until SETTINGS is received
|
||||
// Server must accept this until client ACKs the server's SETTINGS
|
||||
const data = Buffer.alloc(32 * 1024, "z");
|
||||
const response = await sendRequest(client, data);
|
||||
|
||||
assert.strictEqual(response.receivedBytes, 32 * 1024);
|
||||
|
||||
await closeClient(client);
|
||||
});
|
||||
|
||||
test("sends 48KB immediately (3x server window) without waiting for settings", async () => {
|
||||
// More data = more likely to trigger flow control error
|
||||
const client = http2.connect(ctx.serverUrl, { rejectUnauthorized: false });
|
||||
|
||||
const data = Buffer.alloc(48 * 1024, "a");
|
||||
const response = await sendRequest(client, data);
|
||||
|
||||
assert.strictEqual(response.receivedBytes, 48 * 1024);
|
||||
|
||||
await closeClient(client);
|
||||
});
|
||||
|
||||
test("sends 60KB immediately (near default window limit) without waiting for settings", async () => {
|
||||
// 60KB is close to the default window size (65535 bytes)
|
||||
// Should work because client assumes default window until SETTINGS received
|
||||
const client = http2.connect(ctx.serverUrl, { rejectUnauthorized: false });
|
||||
|
||||
const data = Buffer.alloc(60 * 1024, "b");
|
||||
const response = await sendRequest(client, data);
|
||||
|
||||
assert.strictEqual(response.receivedBytes, 60 * 1024);
|
||||
|
||||
await closeClient(client);
|
||||
});
|
||||
|
||||
test("opens multiple streams immediately with small payloads", async () => {
|
||||
// Multiple streams opened immediately, each sending data > server's window
|
||||
// but total stays within connection window (65535 bytes default)
|
||||
const client = http2.connect(ctx.serverUrl, { rejectUnauthorized: false });
|
||||
|
||||
// Send 3 parallel 18KB requests immediately (each > 16KB server window)
|
||||
// Total = 54KB < 65535 connection window
|
||||
const promises = [];
|
||||
for (let i = 0; i < 3; i++) {
|
||||
const data = Buffer.alloc(18 * 1024, String(i));
|
||||
promises.push(sendRequest(client, data, `/test${i}`));
|
||||
}
|
||||
|
||||
const results = await Promise.all(promises);
|
||||
for (const result of results) {
|
||||
assert.strictEqual(result.receivedBytes, 18 * 1024);
|
||||
}
|
||||
|
||||
await closeClient(client);
|
||||
});
|
||||
|
||||
test("sequential requests on fresh connection without waiting for settings", async () => {
|
||||
// Each request on a fresh connection without waiting for settings
|
||||
for (let i = 0; i < 3; i++) {
|
||||
const client = http2.connect(ctx.serverUrl, { rejectUnauthorized: false });
|
||||
|
||||
const data = Buffer.alloc(20 * 1024, String.fromCharCode(97 + i));
|
||||
const response = await sendRequest(client, data, `/seq${i}`);
|
||||
assert.strictEqual(response.receivedBytes, 20 * 1024);
|
||||
|
||||
await closeClient(client);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
// =============================================================================
|
||||
// Test Suite 3: gRPC-style framing (5-byte header + payload)
|
||||
// =============================================================================
|
||||
describe("HTTP/2 gRPC-style framing", () => {
|
||||
let ctx: TestContext;
|
||||
|
||||
function createGrpcMessage(payload: Buffer): Buffer {
|
||||
const header = Buffer.alloc(5);
|
||||
header[0] = 0; // Not compressed
|
||||
header.writeUInt32BE(payload.length, 1); // Message length (big-endian)
|
||||
return Buffer.concat([header, payload]);
|
||||
}
|
||||
|
||||
function parseGrpcResponse(data: Buffer): { receivedBytes: number } {
|
||||
if (data.length < 5) {
|
||||
throw new Error("Invalid gRPC response: too short");
|
||||
}
|
||||
const messageLength = data.readUInt32BE(1);
|
||||
const payload = data.subarray(5, 5 + messageLength);
|
||||
return JSON.parse(payload.toString());
|
||||
}
|
||||
|
||||
async function sendGrpcRequest(
|
||||
client: http2.ClientHttp2Session,
|
||||
payload: Buffer,
|
||||
path = "/test.Service/Method",
|
||||
): Promise<{ receivedBytes: number }> {
|
||||
return new Promise((resolve, reject) => {
|
||||
const grpcMessage = createGrpcMessage(payload);
|
||||
|
||||
const req = client.request({
|
||||
":method": "POST",
|
||||
":path": path,
|
||||
"content-type": "application/grpc",
|
||||
te: "trailers",
|
||||
});
|
||||
|
||||
let responseData = Buffer.alloc(0);
|
||||
|
||||
req.on("response", headers => {
|
||||
if (headers[":status"] !== 200) {
|
||||
reject(new Error(`Unexpected status: ${headers[":status"]}`));
|
||||
}
|
||||
});
|
||||
|
||||
req.on("data", (chunk: Buffer) => {
|
||||
responseData = Buffer.concat([responseData, chunk]);
|
||||
});
|
||||
|
||||
req.on("end", () => {
|
||||
try {
|
||||
resolve(parseGrpcResponse(responseData));
|
||||
} catch (e) {
|
||||
reject(new Error(`Failed to parse gRPC response: ${e}`));
|
||||
}
|
||||
});
|
||||
|
||||
req.on("error", reject);
|
||||
|
||||
req.write(grpcMessage);
|
||||
req.end();
|
||||
});
|
||||
}
|
||||
|
||||
beforeAll(async () => {
|
||||
const server = http2.createSecureServer({
|
||||
...tls,
|
||||
allowHTTP1: false,
|
||||
settings: {
|
||||
maxFrameSize: 16777215,
|
||||
maxConcurrentStreams: 100,
|
||||
initialWindowSize: 1024 * 1024,
|
||||
},
|
||||
});
|
||||
|
||||
server.on("stream", (stream, _headers) => {
|
||||
const chunks: Buffer[] = [];
|
||||
|
||||
stream.on("data", (chunk: Buffer) => {
|
||||
chunks.push(chunk);
|
||||
});
|
||||
|
||||
stream.on("end", () => {
|
||||
const body = Buffer.concat(chunks);
|
||||
// Parse gRPC message (skip 5-byte header)
|
||||
if (body.length >= 5) {
|
||||
const messageLength = body.readUInt32BE(1);
|
||||
const payload = body.subarray(5, 5 + messageLength);
|
||||
stream.respond({
|
||||
":status": 200,
|
||||
"content-type": "application/grpc",
|
||||
"grpc-status": "0",
|
||||
});
|
||||
// Echo back a gRPC response
|
||||
const response = createGrpcMessage(Buffer.from(JSON.stringify({ receivedBytes: payload.length })));
|
||||
stream.end(response);
|
||||
} else {
|
||||
stream.respond({ ":status": 400 });
|
||||
stream.end();
|
||||
}
|
||||
});
|
||||
|
||||
stream.on("error", err => {
|
||||
console.error("Stream error:", err);
|
||||
});
|
||||
});
|
||||
|
||||
server.on("error", err => {
|
||||
console.error("Server error:", err);
|
||||
});
|
||||
|
||||
const serverPort = await new Promise<number>((resolve, reject) => {
|
||||
server.listen(0, "127.0.0.1", () => {
|
||||
const address = server.address();
|
||||
if (!address || typeof address === "string") {
|
||||
reject(new Error("Failed to get server address"));
|
||||
return;
|
||||
}
|
||||
resolve(address.port);
|
||||
});
|
||||
server.once("error", reject);
|
||||
});
|
||||
|
||||
ctx = {
|
||||
server,
|
||||
serverPort,
|
||||
serverUrl: `https://127.0.0.1:${serverPort}`,
|
||||
};
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
if (ctx?.server) {
|
||||
await closeServer(ctx.server);
|
||||
}
|
||||
});
|
||||
|
||||
test("gRPC message with 32KB payload", async () => {
|
||||
const client = http2.connect(ctx.serverUrl, { rejectUnauthorized: false });
|
||||
|
||||
const settings = await waitForSettings(client);
|
||||
assert.strictEqual(settings.maxFrameSize, 16777215);
|
||||
|
||||
const payload = Buffer.alloc(32 * 1024, "x");
|
||||
const response = await sendGrpcRequest(client, payload);
|
||||
|
||||
assert.strictEqual(response.receivedBytes, 32 * 1024);
|
||||
|
||||
await closeClient(client);
|
||||
});
|
||||
|
||||
test("gRPC message with 100KB payload", async () => {
|
||||
const client = http2.connect(ctx.serverUrl, { rejectUnauthorized: false });
|
||||
|
||||
await waitForSettings(client);
|
||||
|
||||
const payload = Buffer.alloc(100 * 1024, "y");
|
||||
const response = await sendGrpcRequest(client, payload);
|
||||
|
||||
assert.strictEqual(response.receivedBytes, 100 * 1024);
|
||||
|
||||
await closeClient(client);
|
||||
});
|
||||
|
||||
test("multiple concurrent gRPC calls", async () => {
|
||||
const client = http2.connect(ctx.serverUrl, { rejectUnauthorized: false });
|
||||
|
||||
await waitForSettings(client);
|
||||
|
||||
const promises = [];
|
||||
for (let i = 0; i < 5; i++) {
|
||||
const payload = Buffer.alloc(32 * 1024, String.fromCharCode(97 + i));
|
||||
promises.push(sendGrpcRequest(client, payload, `/test.Service/Method${i}`));
|
||||
}
|
||||
|
||||
const results = await Promise.all(promises);
|
||||
for (const result of results) {
|
||||
assert.strictEqual(result.receivedBytes, 32 * 1024);
|
||||
}
|
||||
|
||||
await closeClient(client);
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user