'use strict';

const {

ArrayFrom,

ArrayIsArray,

MathMin,

Number,

ObjectAssign,

ObjectDefineProperty,

ObjectEntries,

ObjectHasOwn,

Promise,

Proxy,

ReflectApply,

ReflectGet,

ReflectGetPrototypeOf,

ReflectSet,

SafeMap,

SafeSet,

Symbol,

SymbolAsyncDispose,

SymbolDispose,

Uint32Array,

Uint8Array,

} = primordials;

const {

assignFunctionName,

assertCrypto,

customInspectSymbol: kInspect,

kEmptyObject,

promisify,

deprecate,

deprecateProperty,

} = require('internal/util');

assertCrypto();

const assert = require('assert');

const EventEmitter = require('events');

const { addAbortListener } = require('internal/events/abort_listener');

const fs = require('fs');

const http = require('http');

const { readUInt16BE, readUInt32BE } = require('internal/buffer');

const { URL, getURLOrigin } = require('internal/url');

const net = require('net');

const { Duplex } = require('stream');

const tls = require('tls');

const { setImmediate, setTimeout, clearTimeout } = require('timers');

const {

Server: HttpServer,

httpServerPreClose,

setupConnectionsTracking,

storeHTTPOptions,

} = require('_http_server');

const JSStreamSocket = require('internal/js_stream_socket');

const {

defaultTriggerAsyncIdScope,

symbols: {

async_id_symbol,

owner_symbol,

},

} = require('internal/async_hooks');

const { AsyncResource } = require('async_hooks');

const {

AbortError,

aggregateTwoErrors,

codes: {

ERR_HTTP2_ALTSVC_INVALID_ORIGIN,

ERR_HTTP2_ALTSVC_LENGTH,

ERR_HTTP2_GOAWAY_SESSION,

ERR_HTTP2_HEADERS_AFTER_RESPOND,

ERR_HTTP2_HEADERS_SENT,

ERR_HTTP2_INVALID_INFO_STATUS,

ERR_HTTP2_INVALID_ORIGIN,

ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH,

ERR_HTTP2_INVALID_SESSION,

ERR_HTTP2_INVALID_SETTING_VALUE,

ERR_HTTP2_INVALID_STREAM,

ERR_HTTP2_MAX_PENDING_SETTINGS_ACK,

ERR_HTTP2_NESTED_PUSH,

ERR_HTTP2_NO_MEM,

ERR_HTTP2_NO_SOCKET_MANIPULATION,

ERR_HTTP2_ORIGIN_LENGTH,

ERR_HTTP2_OUT_OF_STREAMS,

ERR_HTTP2_PAYLOAD_FORBIDDEN,

ERR_HTTP2_PING_CANCEL,

ERR_HTTP2_PING_LENGTH,

ERR_HTTP2_PUSH_DISABLED,

ERR_HTTP2_SEND_FILE,

ERR_HTTP2_SEND_FILE_NOSEEK,

ERR_HTTP2_SESSION_ERROR,

ERR_HTTP2_SETTINGS_CANCEL,

ERR_HTTP2_SOCKET_BOUND,

ERR_HTTP2_SOCKET_UNBOUND,

ERR_HTTP2_STATUS_101,

ERR_HTTP2_STATUS_INVALID,

ERR_HTTP2_STREAM_ABORTED,

ERR_HTTP2_STREAM_CANCEL,

ERR_HTTP2_STREAM_ERROR,

ERR_HTTP2_STREAM_SELF_DEPENDENCY,

ERR_HTTP2_TOO_MANY_CUSTOM_SETTINGS,

ERR_HTTP2_TRAILERS_ALREADY_SENT,

ERR_HTTP2_TRAILERS_NOT_READY,

ERR_HTTP2_UNSUPPORTED_PROTOCOL,

ERR_INVALID_ARG_TYPE,

ERR_INVALID_ARG_VALUE,

ERR_INVALID_CHAR,

ERR_OUT_OF_RANGE,

ERR_SOCKET_CLOSED,

},

hideStackFrames,

} = require('internal/errors');

const {

isUint32,

validateAbortSignal,

validateBoolean,

validateBuffer,

validateFunction,

validateInt32,

validateInteger,

validateNumber,

validateString,

validateUint32,

} = require('internal/validators');

const fsPromisesInternal = require('internal/fs/promises');

const { utcDate } = require('internal/http');

const {

Http2ServerRequest,

Http2ServerResponse,

onServerStream,

} = require('internal/http2/compat');

const {

assertIsObject,

assertIsArray,

assertValidPseudoHeader,

assertValidPseudoHeaderResponse,

assertValidPseudoHeaderTrailer,

assertWithinRange,

buildNgHeaderString,

getAuthority,

getDefaultSettings,

getSessionState,

getSettings,

getStreamState,

isPayloadMeaningless,

kAuthority,

kSensitiveHeaders,

kStrictSingleValueFields,

kSocket,

kRequest,

kProtocol,

kProxySocket,

MAX_ADDITIONAL_SETTINGS,

NghttpError,

prepareRequestHeadersArray,

prepareRequestHeadersObject,

remoteCustomSettingsToBuffer,

sessionName,

toHeaderObject,

updateOptionsBuffer,

updateSettingsBuffer,

} = require('internal/http2/util');

const {

writeGeneric,

writevGeneric,

onStreamRead,

kAfterAsyncWrite,

kMaybeDestroy,

kUpdateTimer,

kHandle,

kSession,

kBoundSession,

setStreamTimeout,

} = require('internal/stream_base_commons');

const { kTimeout } = require('internal/timers');

const { isArrayBufferView } = require('internal/util/types');

const { format } = require('internal/util/inspect');

const { FileHandle } = internalBinding('fs');

const binding = internalBinding('http2');

const {

ShutdownWrap,

kReadBytesOrError,

streamBaseState,

} = internalBinding('stream_wrap');

const { UV_EOF } = internalBinding('uv');

const { StreamPipe } = internalBinding('stream_pipe');

const { _connectionListener: httpConnectionListener } = http;

const dc = require('diagnostics_channel');

const onClientStreamCreatedChannel = dc.channel('http2.client.stream.created');

const onClientStreamStartChannel = dc.channel('http2.client.stream.start');

const onClientStreamErrorChannel = dc.channel('http2.client.stream.error');

const onClientStreamBodyChunkSentChannel = dc.channel('http2.client.stream.bodyChunkSent');

const onClientStreamBodySentChannel = dc.channel('http2.client.stream.bodySent');

const onClientStreamFinishChannel = dc.channel('http2.client.stream.finish');

const onClientStreamCloseChannel = dc.channel('http2.client.stream.close');

const onServerStreamCreatedChannel = dc.channel('http2.server.stream.created');

const onServerStreamStartChannel = dc.channel('http2.server.stream.start');

const onServerStreamErrorChannel = dc.channel('http2.server.stream.error');

const onServerStreamFinishChannel = dc.channel('http2.server.stream.finish');

const onServerStreamCloseChannel = dc.channel('http2.server.stream.close');

let debug = require('internal/util/debuglog').debuglog('http2', (fn) => {

debug = fn;

});

const debugEnabled = debug.enabled;

function debugStream(id, sessionType, message, ...args) {

if (!debugEnabled) {

return;

}

debug('Http2Stream %s [Http2Session %s]: ' + message,

id, sessionName(sessionType), ...args);

}

function debugStreamObj(stream, message, ...args) {

const session = stream[kSession];

const type = session ? session[kType] : undefined;

debugStream(stream[kID], type, message, ...args);

}

function debugSession(sessionType, message, ...args) {

debug('Http2Session %s: ' + message, sessionName(sessionType),

...args);

}

function debugSessionObj(session, message, ...args) {

debugSession(session[kType], message, ...args);

}

const kMaxFrameSize = (2 ** 24) - 1;

const kMaxInt = (2 ** 32) - 1;

const kMaxInitialWindowSize = (2 ** 31) - 1; // HTTP/2 spec maximum

const kMaxStreams = (2 ** 32) - 1;

const kMaxALTSVC = (2 ** 14) - 2;

// eslint-disable-next-line no-control-regex

const kQuotedString = /^[\x09\x20-\x5b\x5d-\x7e\x80-\xff]*$/;

const { constants, nameForErrorCode } = binding;

const NETServer = net.Server;

const TLSServer = tls.Server;

const kAlpnProtocol = Symbol('alpnProtocol');

const kEncrypted = Symbol('encrypted');

const kID = Symbol('id');

const kInit = Symbol('init');

const kInfoHeaders = Symbol('sent-info-headers');

const kLocalSettings = Symbol('local-settings');

const kNativeFields = Symbol('kNativeFields');

const kOptions = Symbol('options');

const kOwner = owner_symbol;

const kOrigin = Symbol('origin');

const kPendingRequestCalls = Symbol('kPendingRequestCalls');

const kProceed = Symbol('proceed');

const kRemoteSettings = Symbol('remote-settings');

const kRequestAsyncResource = Symbol('requestAsyncResource');

const kSentHeaders = Symbol('sent-headers');

const kRawHeaders = Symbol('raw-headers');

const kSentTrailers = Symbol('sent-trailers');

const kFilePipeFinalCb = Symbol('kFilePipeFinalCb');

const kFilePipeReachedEOF = Symbol('kFilePipeReachedEOF');

const kServer = Symbol('server');

const kState = Symbol('state');

const kType = Symbol('type');

const kWriteGeneric = Symbol('write-generic');

const kSessions = Symbol('sessions');

const {

kBitfield,

kSessionPriorityListenerCount,

kSessionFrameErrorListenerCount,

kSessionMaxInvalidFrames,

kSessionMaxRejectedStreams,

kSessionUint8FieldCount,

kSessionHasRemoteSettingsListeners,

kSessionRemoteSettingsIsUpToDate,

kSessionHasPingListeners,

kSessionHasAltsvcListeners,

} = binding;

const {

NGHTTP2_CANCEL,

NGHTTP2_REFUSED_STREAM,

NGHTTP2_DEFAULT_WEIGHT,

NGHTTP2_FLAG_END_STREAM,

NGHTTP2_HCAT_PUSH_RESPONSE,

NGHTTP2_HCAT_RESPONSE,

NGHTTP2_INTERNAL_ERROR,

NGHTTP2_NO_ERROR,

NGHTTP2_SESSION_CLIENT,

NGHTTP2_SESSION_SERVER,

NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE,

NGHTTP2_ERR_INVALID_ARGUMENT,

NGHTTP2_ERR_STREAM_CLOSED,

NGHTTP2_ERR_NOMEM,

HTTP2_HEADER_AUTHORITY,

HTTP2_HEADER_DATE,

HTTP2_HEADER_METHOD,

HTTP2_HEADER_PATH,

HTTP2_HEADER_SCHEME,

HTTP2_HEADER_STATUS,

HTTP2_HEADER_CONTENT_LENGTH,

NGHTTP2_SETTINGS_HEADER_TABLE_SIZE,

NGHTTP2_SETTINGS_ENABLE_PUSH,

NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS,

NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE,

NGHTTP2_SETTINGS_MAX_FRAME_SIZE,

NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE,

NGHTTP2_SETTINGS_ENABLE_CONNECT_PROTOCOL,

HTTP2_METHOD_GET,

HTTP2_METHOD_HEAD,

HTTP_STATUS_CONTINUE,

HTTP_STATUS_RESET_CONTENT,

HTTP_STATUS_OK,

HTTP_STATUS_NO_CONTENT,

HTTP_STATUS_NOT_MODIFIED,

HTTP_STATUS_SWITCHING_PROTOCOLS,

HTTP_STATUS_MISDIRECTED_REQUEST,

STREAM_OPTION_EMPTY_PAYLOAD,

STREAM_OPTION_GET_TRAILERS,

} = constants;

const STREAM_FLAGS_PENDING = 0x0;

const STREAM_FLAGS_READY = 0x1;

const STREAM_FLAGS_CLOSED = 0x2;

const STREAM_FLAGS_HEADERS_SENT = 0x4;

const STREAM_FLAGS_HEAD_REQUEST = 0x8;

const STREAM_FLAGS_ABORTED = 0x10;

const STREAM_FLAGS_HAS_TRAILERS = 0x20;

const SESSION_FLAGS_PENDING = 0x0;

const SESSION_FLAGS_READY = 0x1;

const SESSION_FLAGS_CLOSED = 0x2;

const SESSION_FLAGS_DESTROYED = 0x4;

// Top level to avoid creating a closure

function emit(self, ...args) {

ReflectApply(self.emit, self, args);

}

// Called when a new block of headers has been received for a given

// stream. The stream may or may not be new. If the stream is new,

// create the associated Http2Stream instance and emit the 'stream'

// event. If the stream is not new, emit the 'headers' event to pass

// the block of headers on.

function onSessionHeaders(handle, id, cat, flags, headers, sensitiveHeaders) {

const session = this[kOwner];

if (session.destroyed)

return;

const type = session[kType];

session[kUpdateTimer]();

debugStream(id, type, 'headers received');

const streams = session[kState].streams;

const endOfStream = !!(flags & NGHTTP2_FLAG_END_STREAM);

let stream = streams.get(id);

// Convert the array of header name value pairs into an object

const obj = toHeaderObject(headers, sensitiveHeaders);

if (stream === undefined) {

if (session.closed) {

// We are not accepting any new streams at this point. This callback

// should not be invoked at this point in time, but just in case it is,

// refuse the stream using an RST_STREAM and destroy the handle.

handle.rstStream(NGHTTP2_REFUSED_STREAM);

handle.destroy();

return;

}

// session[kType] can be only one of two possible values

if (type === NGHTTP2_SESSION_SERVER) {

// eslint-disable-next-line no-use-before-define

stream = new ServerHttp2Stream(session, handle, id, {}, obj);

if (onServerStreamCreatedChannel.hasSubscribers) {

onServerStreamCreatedChannel.publish({

stream,

headers: obj,

});

}

if (onServerStreamStartChannel.hasSubscribers) {

onServerStreamStartChannel.publish({

stream,

headers: obj,

});

}

if (endOfStream) {

stream.push(null);

}

if (obj[HTTP2_HEADER_METHOD] === HTTP2_METHOD_HEAD) {

// For head requests, there must not be a body...

// end the writable side immediately.

stream.end();

stream[kState].flags |= STREAM_FLAGS_HEAD_REQUEST;

}

} else {

// eslint-disable-next-line no-use-before-define

stream = new ClientHttp2Stream(session, handle, id, {});

if (onClientStreamCreatedChannel.hasSubscribers) {

onClientStreamCreatedChannel.publish({

stream,

headers: obj,

});

}

if (onClientStreamStartChannel.hasSubscribers) {

onClientStreamStartChannel.publish({

stream,

headers: obj,

});

}

if (endOfStream) {

stream.push(null);

}

stream.end();

}

if (endOfStream)

stream[kState].endAfterHeaders = true;

process.nextTick(emit, session, 'stream', stream, obj, flags, headers);

} else {

let event;

const status = obj[HTTP2_HEADER_STATUS];

if (cat === NGHTTP2_HCAT_RESPONSE) {

if (!endOfStream &&

status !== undefined &&

status >= 100 &&

status < 200) {

event = 'headers';

} else {

event = 'response';

}

} else if (cat === NGHTTP2_HCAT_PUSH_RESPONSE) {

event = 'push';

} else if (status !== undefined && status >= 200) {

event = 'response';

} else {

event = endOfStream ? 'trailers' : 'headers';

}

const session = stream.session;

if (status === HTTP_STATUS_MISDIRECTED_REQUEST) {

const originSet = session[kState].originSet = initOriginSet(session);

originSet.delete(stream[kOrigin]);

}

debugStream(id, type, "emitting stream '%s' event", event);

const reqAsync = stream[kRequestAsyncResource];

// Mirrors HTTP/1's `if (!req.emit('response', res)) res._dump();`:

// drain the readable when the response has no listener.

const dispatch = () => {

const hadListeners = stream.emit(event, obj, flags, headers);

if (event === 'response' && !hadListeners)

autoDrainReadable.call(stream);

};

if (reqAsync)

reqAsync.runInAsyncScope(process.nextTick, null, dispatch);

else

process.nextTick(dispatch);

if ((event === 'response' ||

event === 'push') &&

onClientStreamFinishChannel.hasSubscribers) {

onClientStreamFinishChannel.publish({

stream,

headers: obj,

flags: flags,

});

}

}

if (endOfStream) {

stream.push(null);

}

}

function tryClose(fd) {

// Try to close the file descriptor. If closing fails, assert because

// an error really should not happen at this point.

fs.close(fd, assert.ifError);

}

// Called when the Http2Stream has finished sending data and is ready for

// trailers to be sent. This will only be called if the { hasOptions: true }

// option is set.

function onStreamTrailers() {

const stream = this[kOwner];

stream[kState].trailersReady = true;

if (stream.destroyed || stream.closed)

return;

if (!stream.emit('wantTrailers')) {

// There are no listeners, send empty trailing HEADERS frame and close.

stream.sendTrailers({});

}

}

// Submit an RST-STREAM frame to be sent to the remote peer.

// This will cause the Http2Stream to be closed.

function submitRstStream(code) {

if (this[kHandle] !== undefined) {

this[kHandle].rstStream(code);

}

}

// Keep track of the number/presence of JS event listeners. Knowing that there

// are no listeners allows the C++ code to skip calling into JS for an event.

function sessionListenerAdded(name) {

switch (name) {

case 'ping':

this[kNativeFields][kBitfield] |= 1 << kSessionHasPingListeners;

break;

case 'altsvc':

this[kNativeFields][kBitfield] |= 1 << kSessionHasAltsvcListeners;

break;

case 'remoteSettings':

this[kNativeFields][kBitfield] |= 1 << kSessionHasRemoteSettingsListeners;

break;

case 'priority':

this[kNativeFields][kSessionPriorityListenerCount]++;

break;

case 'frameError':

this[kNativeFields][kSessionFrameErrorListenerCount]++;

break;

}

}

function sessionListenerRemoved(name) {

switch (name) {

case 'ping':

if (this.listenerCount(name) > 0) return;

this[kNativeFields][kBitfield] &= ~(1 << kSessionHasPingListeners);

break;

case 'altsvc':

if (this.listenerCount(name) > 0) return;

this[kNativeFields][kBitfield] &= ~(1 << kSessionHasAltsvcListeners);

break;

case 'remoteSettings':

if (this.listenerCount(name) > 0) return;

this[kNativeFields][kBitfield] &=

~(1 << kSessionHasRemoteSettingsListeners);

break;

case 'priority':

this[kNativeFields][kSessionPriorityListenerCount]--;

break;

case 'frameError':

this[kNativeFields][kSessionFrameErrorListenerCount]--;

break;

}

}

// Also keep track of listeners for the Http2Stream instances, as some events

// are emitted on those objects.

function streamListenerAdded(name) {

const session = this[kSession];

if (!session) return;

switch (name) {

case 'priority':

session[kNativeFields][kSessionPriorityListenerCount]++;

break;

case 'frameError':

session[kNativeFields][kSessionFrameErrorListenerCount]++;

break;

}

}

function streamListenerRemoved(name) {

const session = this[kSession];

if (!session) return;

switch (name) {

case 'priority':

session[kNativeFields][kSessionPriorityListenerCount]--;

break;

case 'frameError':

session[kNativeFields][kSessionFrameErrorListenerCount]--;

break;

}

}

function onPing(payload) {

const session = this[kOwner];

if (session.destroyed)

return;

session[kUpdateTimer]();

debugSessionObj(session, 'new ping received');

session.emit('ping', payload);

}

// Fired by C++ when nghttp2's on_stream_close fires. `peerReset` is

// true when the peer sent a RST_STREAM frame - peer RST_STREAM(NO_ERROR)

// is otherwise indistinguishable from a clean END_STREAM exchange at

// this layer.

//

// 'error' fires iff the reset was peer-initiated AND either:

// * peer didn't END_STREAM (the consumer will never see 'end'), or

// * peer signalled a non-clean code while writes were still in flight.

// Clean code = NO_ERROR or CANCEL.

//

// Natural close defers destroy until 'end' and 'finish' - nghttp2 can

// fire on_stream_close ahead of our last frame leaving the socket.

function onStreamClose(code, peerReset) {

const stream = this[kOwner];

if (!stream || stream.destroyed)

return false;

debugStreamObj(

stream, 'closed code=%d peerReset=%s closed=%s',

code, peerReset, stream.closed,

);

// stream.closed is set by closeStream; true here means we initiated.

const locallyInitiated = stream.closed;

if (!locallyInitiated)

closeStream(stream, code, kNoRstStream);

stream[kState].fd = -1;

if (locallyInitiated) {

stream.destroy();

return true;

}

const peerReadableEnded = stream._readableState.ended;

const cleanCode = code === NGHTTP2_NO_ERROR || code === NGHTTP2_CANCEL;

if (!peerReadableEnded) {

stream.destroy(cleanCode ?

new ERR_HTTP2_STREAM_ABORTED() :

new ERR_HTTP2_STREAM_ERROR(nameForErrorCode[code] || code));

return true;

}

// Peer END_STREAMed - reads will complete. Only the writable half can

// still be in flight at the protocol layer.

if (peerReset) {

if (!cleanCode && !stream._writableState.finished) {

stream.destroy(

new ERR_HTTP2_STREAM_ERROR(nameForErrorCode[code] || code));

} else {

stream.destroy();

}

return true;

}

// Natural close: wait for 'end' and 'finish'. autoDestroy is disabled

// on Http2Stream, so an errored writable won't fire 'finish' and an

// errored readable won't fire 'end' - and on a Duplex a writable

// error propagates to readable.errored, blocking 'end' too. Treat

// either side's errored state as settled.

const readDone = () => stream._readableState.endEmitted ||

!!stream._readableState.errored;

const writeDone = () => stream._writableState.finished ||

!!stream._writableState.errored;

if (readDone() && writeDone()) {

stream.destroy();

return true;

}

const maybeDestroy = () => {

if (!stream.destroyed && readDone() && writeDone())

stream.destroy();

};

stream.once('end', maybeDestroy);

stream.once('finish', maybeDestroy);

stream.once('error', maybeDestroy);

if (stream[kSession][kType] === NGHTTP2_SESSION_SERVER &&

!stream[kState].didRead &&

stream.readableFlowing === null) {

// On the server, if you don't try to read the request body

// at all before the stream closes, we dump it, like HTTP/1.

stream.resume();

} else {

stream.read(0);

}

return true;

}

// Called when the remote peer settings have been updated.

// Resets the cached settings.

function onSettings() {

const session = this[kOwner];

if (session.destroyed)

return;

session[kUpdateTimer]();

debugSessionObj(session, 'new settings received');

session[kRemoteSettings] = undefined;

session.emit('remoteSettings', session.remoteSettings);

}

// If the stream exists, an attempt will be made to emit an event

// on the stream object itself. Otherwise, forward it on to the

// session (which may, in turn, forward it on to the server)

function onPriority(id, parent, weight, exclusive) {

const session = this[kOwner];

if (session.destroyed)

return;

debugStream(id, session[kType],

'priority [parent: %d, weight: %d, exclusive: %s]',

parent, weight, exclusive);

const emitter = session[kState].streams.get(id) || session;

if (!emitter.destroyed) {

emitter[kUpdateTimer]();

emitter.emit('priority', id, parent, weight, exclusive);

}

}

// Called by the native layer when an error has occurred sending a

// frame. This should be exceedingly rare.

function onFrameError(id, type, code) {

const session = this[kOwner];

if (session.destroyed)

return;

debugSessionObj(session, 'error sending frame type %d on stream %d, code: %d',

type, id, code);

const stream = session[kState].streams.get(id);

const emitter = stream || session;

emitter[kUpdateTimer]();

emitter.emit('frameError', type, code, id);

// When a frameError happens is not uncommon that a pending GOAWAY

// package from nghttp2 is on flight with a correct error code.

// We schedule it using setImmediate to give some time for that

// package to arrive.

setImmediate(() => {

stream?.close(code);

session.close();

});

}

function onAltSvc(stream, origin, alt) {

const session = this[kOwner];

if (session.destroyed)

return;

debugSessionObj(session, 'altsvc received: stream: %d, origin: %s, alt: %s',

stream, origin, alt);

session[kUpdateTimer]();

session.emit('altsvc', alt, origin, stream);

}

function initOriginSet(session) {

let originSet = session[kState].originSet;

if (originSet === undefined) {

const socket = session[kSocket];

session[kState].originSet = originSet = new SafeSet();

let hostName = socket.servername;

if (hostName === null || hostName === false) {

if (socket.remoteFamily === 'IPv6') {

hostName = `[${socket.remoteAddress}]`;

} else {

hostName = socket.remoteAddress;

}

}

let originString = `https://${hostName}`;

if (socket.remotePort != null)

originString += `:${socket.remotePort}`;

// We have to ensure that it is a properly serialized

// ASCII origin string. The socket.servername might not

// be properly ASCII encoded.

originSet.add(getURLOrigin(originString));

}

return originSet;

}

function onOrigin(origins) {

const session = this[kOwner];

if (session.destroyed)

return;

debugSessionObj(session, 'origin received: %j', origins);

session[kUpdateTimer]();

if (!session.encrypted || session.destroyed)

return undefined;

const originSet = initOriginSet(session);

for (let n = 0; n < origins.length; n++)

originSet.add(origins[n]);

session.emit('origin', origins);

}

// Receiving a GOAWAY frame from the connected peer is a signal that no

// new streams should be created. If the code === NGHTTP2_NO_ERROR, we

// are going to send our close, but allow existing frames to close

// normally. If code !== NGHTTP2_NO_ERROR, we are going to send our own

// close using the same code then destroy the session with an error.

// The goaway event will be emitted on next tick.

function onGoawayData(code, lastStreamID, buf) {

const session = this[kOwner];

if (session.destroyed)

return;

debugSessionObj(session, 'goaway %d received [last stream id: %d]',

code, lastStreamID);

const state = session[kState];

state.goawayCode = code;

state.goawayLastStreamID = lastStreamID;

session.emit('goaway', code, lastStreamID, buf);

if (code === NGHTTP2_NO_ERROR) {

// If this is a no error goaway, begin shutting down.

// No new streams permitted, but existing streams may

// close naturally on their own.

session.close();

} else {

// However, if the code is not NGHTTP_NO_ERROR, destroy the

// session immediately. We destroy with an error but send a

// goaway using NGHTTP2_NO_ERROR because there was no error

// condition on this side of the session that caused the

// shutdown.

session.destroy(new ERR_HTTP2_SESSION_ERROR(code), NGHTTP2_NO_ERROR);

}

}

// TODO(aduh95): remove this in future semver-major

const deprecateWeight = deprecateProperty('weight',

'Priority signaling has been deprecated as of RFC 9113.',

'DEP0194');

// When a ClientHttp2Session is first created, the socket may not yet be

// connected. If request() is called during this time, the actual request

// will be deferred until the socket is ready to go.

function requestOnConnect(headersList, options) {

const session = this[kSession];

// At this point, the stream should have already been destroyed during

// the session.destroy() method. Do nothing else.

if (session === undefined || session.destroyed)

return;

// If the session was closed while waiting for the connect, destroy

// the stream and do not continue with the request.

if (session.closed) {

const err = new ERR_HTTP2_GOAWAY_SESSION();

this.destroy(err);

return;

}

debugSessionObj(session, 'connected, initializing request');

let streamOptions = 0;

if (options.endStream)

streamOptions |= STREAM_OPTION_EMPTY_PAYLOAD;

if (options.waitForTrailers)

streamOptions |= STREAM_OPTION_GET_TRAILERS;

deprecateWeight(options);

// `ret` will be either the reserved stream ID (if positive)

// or an error code (if negative)

const ret = session[kHandle].request(headersList,

streamOptions,

options.parent | 0,

NGHTTP2_DEFAULT_WEIGHT,

!!options.exclusive);

// In an error condition, one of three possible response codes will be

// possible:

// * NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE - Maximum stream ID is reached, this

// is fatal for the session

// * NGHTTP2_ERR_INVALID_ARGUMENT - Stream was made dependent on itself, this

// impacts on this stream.

// For the first two, emit the error on the session,

// For the third, emit the error on the stream, it will bubble up to the

// session if not handled.

if (typeof ret === 'number') {

let err;

switch (ret) {

case NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE:

err = new ERR_HTTP2_OUT_OF_STREAMS();

this.destroy(err);

break;

case NGHTTP2_ERR_INVALID_ARGUMENT:

err = new ERR_HTTP2_STREAM_SELF_DEPENDENCY();

this.destroy(err);

break;

default:

session.destroy(new NghttpError(ret));

}

return;

}

this[kInit](ret.id(), ret);

if (onClientStreamStartChannel.hasSubscribers) {

onClientStreamStartChannel.publish({

stream: this,

headers: this.sentHeaders,

});

}

}

function requestOnError(error) {

this.destroy(error);

}

// Validates that priority options are correct, specifically:

// 1. options.weight must be a number

// 2. options.parent must be a positive number

// 3. options.exclusive must be a boolean

// 4. if specified, options.silent must be a boolean

//

// Also sets the default priority options if they are not set.

const setAndValidatePriorityOptions = hideStackFrames((options) => {

deprecateWeight(options);

if (options.parent === undefined) {

options.parent = 0;

} else {

validateNumber.withoutStackTrace(options.parent, 'options.parent', 0);

}

if (options.exclusive === undefined) {

options.exclusive = false;

} else {

validateBoolean.withoutStackTrace(options.exclusive, 'options.exclusive');

}

if (options.silent === undefined) {

options.silent = false;

} else {

validateBoolean.withoutStackTrace(options.silent, 'options.silent');

}

});

// When an error occurs internally at the binding level, immediately

// destroy the session.

function onSessionInternalError(integerCode, customErrorCode) {

if (this[kOwner] !== undefined)

this[kOwner].destroy(new NghttpError(integerCode, customErrorCode));

}

function settingsCallback(cb, ack, duration) {

this[kState].pendingAck--;

this[kLocalSettings] = undefined;

if (ack) {

debugSessionObj(this, 'settings received');

const settings = this.localSettings;

if (typeof cb === 'function')

cb(null, settings, duration);

this.emit('localSettings', settings);

} else {

debugSessionObj(this, 'settings canceled');

if (typeof cb === 'function')

cb(new ERR_HTTP2_SETTINGS_CANCEL());

}

}

// Submits a SETTINGS frame to be sent to the remote peer.

function submitSettings(settings, callback) {

if (this.destroyed)

return;

debugSessionObj(this, 'submitting settings');

this[kUpdateTimer]();

updateSettingsBuffer(settings);

if (!this[kHandle].settings(settingsCallback.bind(this, callback))) {

this.destroy(new ERR_HTTP2_MAX_PENDING_SETTINGS_ACK());

}

}

// Submit a GOAWAY frame to be sent to the remote peer.

// If the lastStreamID is set to <= 0, then the lastProcStreamID will

// be used. The opaqueData must either be a typed array or undefined

// (which will be checked elsewhere).

function submitGoaway(code, lastStreamID, opaqueData) {

if (this.destroyed)

return;

debugSessionObj(this, 'submitting goaway');

this[kUpdateTimer]();

this[kHandle].goaway(code, lastStreamID, opaqueData);

}

const proxySocketHandler = {

get(session, prop) {

switch (prop) {

case 'setTimeout':

case 'ref':

case 'unref':

return session[prop].bind(session);

case 'destroy':

case 'emit':

case 'end':

case 'pause':

case 'read':

case 'resume':

case 'write':

case 'setEncoding':

case 'setKeepAlive':

case 'setNoDelay':

throw new ERR_HTTP2_NO_SOCKET_MANIPULATION();

default: {

const socket = session[kSocket];

if (socket === undefined)

throw new ERR_HTTP2_SOCKET_UNBOUND();

const value = socket[prop];

return typeof value === 'function' ?

value.bind(socket) :

value;