#if HAVE_OPENSSL && HAVE_QUIC

#include "guard.h"

#ifndef OPENSSL_NO_QUIC

#include <aliased_struct-inl.h>

#include <async_wrap-inl.h>

#include <crypto/crypto_util.h>

#include <debug_utils-inl.h>

#include <env-inl.h>

#include <memory_tracker-inl.h>

#include <ngtcp2/ngtcp2.h>

#include <node_bob-inl.h>

#include <node_errors.h>

#include <node_http_common-inl.h>

#include <node_sockaddr-inl.h>

#include <req_wrap-inl.h>

#include <timer_wrap-inl.h>

#include <util-inl.h>

#include <uv.h>

#include <v8.h>

#include "application.h"

#include "bindingdata.h"

#include "cid.h"

#include "data.h"

#include "defs.h"

#include "endpoint.h"

#include "http3.h"

#include "ncrypto.h"

#include "packet.h"

#include "preferredaddress.h"

#include "session.h"

#include "session_manager.h"

#include "sessionticket.h"

#include "streams.h"

#include "tlscontext.h"

#include "transportparams.h"

namespace node {

using v8::Array;

using v8::ArrayBufferView;

using v8::BigInt;

using v8::Boolean;

using v8::Function;

using v8::FunctionCallbackInfo;

using v8::Global;

using v8::HandleScope;

using v8::Int32;

using v8::Integer;

using v8::Just;

using v8::Local;

using v8::LocalVector;

using v8::Maybe;

using v8::MaybeLocal;

using v8::Nothing;

using v8::Number;

using v8::Object;

using v8::ObjectTemplate;

using v8::String;

using v8::Uint32;

using v8::Undefined;

using v8::Value;

namespace quic {

// Listener flags are packed into a single uint32_t bitfield to reduce

// the size of the shared state buffer. Each bit indicates whether a

// corresponding JS callback is registered.

enum class SessionListenerFlags : uint32_t {

PATH_VALIDATION = 1 << 0,

DATAGRAM = 1 << 1,

DATAGRAM_STATUS = 1 << 2,

SESSION_TICKET = 1 << 3,

NEW_TOKEN = 1 << 4,

ORIGIN = 1 << 5,

APPLICATION = 1 << 6

};

inline SessionListenerFlags operator|(SessionListenerFlags a,

SessionListenerFlags b) {

return static_cast<SessionListenerFlags>(static_cast<uint32_t>(a) |

static_cast<uint32_t>(b));

}

inline SessionListenerFlags operator&(SessionListenerFlags a,

SessionListenerFlags b) {

return static_cast<SessionListenerFlags>(static_cast<uint32_t>(a) &

static_cast<uint32_t>(b));

}

inline SessionListenerFlags operator&(uint32_t a, SessionListenerFlags b) {

return static_cast<SessionListenerFlags>(a & static_cast<uint32_t>(b));

}

inline bool operator!(SessionListenerFlags a) {

return static_cast<uint32_t>(a) == 0;

}

inline bool HasListenerFlag(uint32_t flags, SessionListenerFlags flag) {

return !!(flags & flag);

}

// Compute the maximum datagram payload that fits within the peer's

// max_datagram_frame_size transport parameter. The DATAGRAM frame has

// overhead of 1 byte (frame type) + variable-length integer encoding

// of the payload length. This mirrors the check in ngtcp2's

// ngtcp2_pkt_datagram_framelen (1 + varint_len(payload) + payload).

uint64_t MaxDatagramPayload(uint64_t max_frame_size) {

// A DATAGRAM frame needs at least 1 (type) + 1 (varint) + 0 (data).

if (max_frame_size < 2) return 0;

// QUIC variable-length integer encoding sizes (RFC 9000 Section 16).

auto varint_len = [](uint64_t n) -> uint64_t {

if (n < 64) return 1;

if (n < 16384) return 2;

if (n < 1073741824) return 4;

return 8;

};

// Start with the optimistic payload assuming minimum varint (1 byte).

uint64_t payload = max_frame_size - 2;

// If the payload requires a larger varint, the overhead increases.

// Recompute with the actual varint length of the candidate payload.

uint64_t overhead = 1 + varint_len(payload);

if (overhead + payload > max_frame_size) {

payload = max_frame_size - 1 - varint_len(max_frame_size - 3);

}

return payload;

}

#define SESSION_STATE(V) \

V(LISTENER_FLAGS, listener_flags, uint32_t) \

V(CLOSING, closing, uint8_t) \

V(GRACEFUL_CLOSE, graceful_close, uint8_t) \

V(SILENT_CLOSE, silent_close, uint8_t) \

V(STATELESS_RESET, stateless_reset, uint8_t) \

V(HANDSHAKE_COMPLETED, handshake_completed, uint8_t) \

V(HANDSHAKE_CONFIRMED, handshake_confirmed, uint8_t) \

V(STREAM_OPEN_ALLOWED, stream_open_allowed, uint8_t) \

V(PRIORITY_SUPPORTED, priority_supported, uint8_t) \

V(HEADERS_SUPPORTED, headers_supported, uint8_t) \

V(WRAPPED, wrapped, uint8_t) \

V(APPLICATION_TYPE, application_type, uint8_t) \

V(NO_ERROR_CODE, no_error_code, error_code) \

V(INTERNAL_ERROR_CODE, internal_error_code, error_code) \

V(MAX_DATAGRAM_SIZE, max_datagram_size, uint16_t) \

V(LAST_DATAGRAM_ID, last_datagram_id, datagram_id) \

V(MAX_PENDING_DATAGRAMS, max_pending_datagrams, uint16_t)

#define SESSION_STATS(V) \

V(CREATED_AT, created_at) \

V(DESTROYED_AT, destroyed_at) \

V(CLOSING_AT, closing_at) \

V(HANDSHAKE_COMPLETED_AT, handshake_completed_at) \

V(HANDSHAKE_CONFIRMED_AT, handshake_confirmed_at) \

V(BYTES_RECEIVED, bytes_received) \

V(BIDI_IN_STREAM_COUNT, bidi_in_stream_count) \

V(BIDI_OUT_STREAM_COUNT, bidi_out_stream_count) \

V(UNI_IN_STREAM_COUNT, uni_in_stream_count) \

V(UNI_OUT_STREAM_COUNT, uni_out_stream_count) \

V(MAX_BYTES_IN_FLIGHT, max_bytes_in_flight) \

V(BYTES_IN_FLIGHT, bytes_in_flight) \

V(BLOCK_COUNT, block_count) \

V(CWND, cwnd) \

V(LATEST_RTT, latest_rtt) \

V(MIN_RTT, min_rtt) \

V(RTTVAR, rttvar) \

V(SMOOTHED_RTT, smoothed_rtt) \

V(SSTHRESH, ssthresh) \

V(PKT_SENT, pkt_sent) \

V(BYTES_SENT, bytes_sent) \

V(PKT_RECV, pkt_recv) \

V(BYTES_RECV, bytes_recv) \

V(PKT_LOST, pkt_lost) \

V(BYTES_LOST, bytes_lost) \

V(PING_RECV, ping_recv) \

V(PKT_DISCARDED, pkt_discarded) \

V(DATAGRAMS_RECEIVED, datagrams_received) \

V(DATAGRAMS_SENT, datagrams_sent) \

V(DATAGRAMS_ACKNOWLEDGED, datagrams_acknowledged) \

V(DATAGRAMS_LOST, datagrams_lost) \

V(STREAMS_IDLE_TIMED_OUT, streams_idle_timed_out)

#define NO_SIDE_EFFECT true

#define SIDE_EFFECT false

#define SESSION_JS_METHODS(V) \

V(Destroy, destroy, SIDE_EFFECT) \

V(GetRemoteAddress, getRemoteAddress, NO_SIDE_EFFECT) \

V(GetLocalAddress, getLocalAddress, NO_SIDE_EFFECT) \

V(GetCertificate, getCertificate, NO_SIDE_EFFECT) \

V(GetEphemeralKeyInfo, getEphemeralKey, NO_SIDE_EFFECT) \

V(GetPeerCertificate, getPeerCertificate, NO_SIDE_EFFECT) \

V(GracefulClose, gracefulClose, SIDE_EFFECT) \

V(SilentClose, silentClose, SIDE_EFFECT) \

V(UpdateKey, updateKey, SIDE_EFFECT) \

V(OpenStream, openStream, SIDE_EFFECT) \

V(SendDatagram, sendDatagram, SIDE_EFFECT) \

V(LocalTransportParams, localTransportParams, NO_SIDE_EFFECT) \

V(RemoteTransportParams, remoteTransportParams, NO_SIDE_EFFECT) \

V(ApplicationOptions, applicationOptions, NO_SIDE_EFFECT)

struct Session::State final {

#define V(_, name, type) type name;

SESSION_STATE(V)

#undef V

};

STAT_STRUCT(Session, SESSION)

using SessionStateArena = AliasedStructArena<Session::State>;

using SessionStatsArena = AliasedStructArena<Session::Stats>;

// Session uses arena-allocated stats, not AliasedStruct, so override the

// STAT_* macros to use impl_->stats() instead of stats_.Data().

#undef STAT_INCREMENT

#undef STAT_INCREMENT_N

#undef STAT_RECORD_TIMESTAMP

#undef STAT_SET

#undef STAT_GET

#define STAT_INCREMENT(Type, name) \

IncrementStat<Type, &Type::name>(impl_->stats());

#define STAT_INCREMENT_N(Type, name, amt) \

IncrementStat<Type, &Type::name>(impl_->stats(), amt);

#define STAT_RECORD_TIMESTAMP(Type, name) \

RecordTimestampStat<Type, &Type::name>(impl_->stats());

#define STAT_SET(Type, name, val) \

SetStat<Type, &Type::name>(impl_->stats(), val)

#define STAT_GET(Type, name) GetStat<Type, &Type::name>(impl_->stats())

namespace {

SessionStateArena& GetSessionStateArena(BindingData& binding) {

if (!binding.session_state_arena_) {

auto* arena = new SessionStateArena();

binding.session_state_arena_ = BindingData::ArenaPtr(

arena, +[](void* p) { delete static_cast<SessionStateArena*>(p); });

}

return *static_cast<SessionStateArena*>(binding.session_state_arena_.get());

}

SessionStatsArena& GetSessionStatsArena(BindingData& binding) {

if (!binding.session_stats_arena_) {

auto* arena = new SessionStatsArena();

binding.session_stats_arena_ = BindingData::ArenaPtr(

arena, +[](void* p) { delete static_cast<SessionStatsArena*>(p); });

}

return *static_cast<SessionStatsArena*>(binding.session_stats_arena_.get());

}

} // namespace

// ============================================================================

class Http3Application;

namespace {

constexpr std::string to_string(PreferredAddress::Policy policy) {

switch (policy) {

case PreferredAddress::Policy::USE_PREFERRED:

return "use";

case PreferredAddress::Policy::IGNORE_PREFERRED:

return "ignore";

}

return "<unknown>";

}

constexpr std::string to_string(Side side) {

switch (side) {

case Side::CLIENT:

return "client";

case Side::SERVER:

return "server";

}

return "<unknown>";

}

constexpr std::string to_string(ngtcp2_encryption_level level) {

switch (level) {

case NGTCP2_ENCRYPTION_LEVEL_1RTT:

return "1rtt";

case NGTCP2_ENCRYPTION_LEVEL_0RTT:

return "0rtt";

case NGTCP2_ENCRYPTION_LEVEL_HANDSHAKE:

return "handshake";

case NGTCP2_ENCRYPTION_LEVEL_INITIAL:

return "initial";

}

return "<unknown>";

}

constexpr std::string to_string(ngtcp2_cc_algo cc_algorithm) {

#define V(name, label) \

case NGTCP2_CC_ALGO_##name: \

return #label;

switch (cc_algorithm) { /* NOLINT(whitespace/newline) */

CC_ALGOS(V)

}

return "<unknown>";

#undef V

}

Maybe<ngtcp2_cc_algo> getAlgoFromString(Environment* env, Local<String> input) {

auto& state = BindingData::Get(env);

#define V(name, str) \

if (input->StringEquals(state.str##_string())) { \

return Just(NGTCP2_CC_ALGO_##name); \

}

CC_ALGOS(V)

#undef V

return Nothing<ngtcp2_cc_algo>();

}

// Qlog is a JSON-based logging format that is being standardized for low-level

// debug logging of QUIC connections and dataflows. The qlog output is generated

// optionally by ngtcp2 for us. The on_qlog_write callback is registered with

// ngtcp2 to emit the qlog information. Every Session will have it's own qlog

// stream.

void on_qlog_write(void* user_data,

uint32_t flags,

const void* data,

size_t len) {

static_cast<Session*>(user_data)->EmitQlog(

flags, std::string_view(static_cast<const char*>(data), len));

}

// Forwards detailed(verbose) debugging information from ngtcp2. Enabled using

// the NODE_DEBUG_NATIVE=NGTCP2 category.

void ngtcp2_debug_log(void* user_data, const char* fmt, ...) {

va_list ap;

va_start(ap, fmt);

std::string format(fmt, strlen(fmt) + 1);

format[strlen(fmt)] = '\n';

// Debug() does not work with the va_list here. So we use vfprintf

// directly instead. Ngtcp2DebugLog is only enabled when the debug

// category is enabled. The thread ID prefix helps distinguish output

// from concurrent sessions across worker threads.

fprintf(stderr, "ngtcp2 ");

vfprintf(stderr, format.c_str(), ap);

va_end(ap);

}

template <typename Opt, PreferredAddress::Policy Opt::*member>

bool SetOption(Environment* env,

Opt* options,

const Local<Object>& object,

const Local<String>& name) {

Local<Value> value;

PreferredAddress::Policy policy = PreferredAddress::Policy::USE_PREFERRED;

if (!object->Get(env->context(), name).ToLocal(&value) ||

!PreferredAddress::tryGetPolicy(env, value).To(&policy)) {

return false;

}

options->*member = policy;

return true;

}

template <typename Opt, TLSContext::Options Opt::*member>

bool SetOption(Environment* env,

Opt* options,

const Local<Object>& object,

const Local<String>& name) {

Local<Value> value;

TLSContext::Options opts;

if (!object->Get(env->context(), name).ToLocal(&value) ||

!TLSContext::Options::From(env, value).To(&opts)) {

return false;

}

options->*member = opts;

return true;

}

template <typename Opt, TransportParams::Options Opt::*member>

bool SetOption(Environment* env,

Opt* options,

const Local<Object>& object,

const Local<String>& name) {

Local<Value> value;

TransportParams::Options opts;

if (!object->Get(env->context(), name).ToLocal(&value) ||

!TransportParams::Options::From(env, value).To(&opts)) {

return false;

}

options->*member = opts;

return true;

}

template <typename Opt, ngtcp2_cc_algo Opt::*member>

bool SetOption(Environment* env,

Opt* options,

const Local<Object>& object,

const Local<String>& name) {

Local<Value> value;

if (!object->Get(env->context(), name).ToLocal(&value)) return false;

if (!value->IsUndefined()) {

ngtcp2_cc_algo algo;

if (value->IsString()) {

if (!getAlgoFromString(env, value.As<String>()).To(&algo)) {

THROW_ERR_INVALID_ARG_VALUE(env, "The cc_algorithm option is invalid");

return false;

}

} else {

if (!value->IsInt32()) {

THROW_ERR_INVALID_ARG_VALUE(

env, "The cc_algorithm option must be a string or an integer");

return false;

}

Local<Int32> num;

if (!value->ToInt32(env->context()).ToLocal(&num)) {

THROW_ERR_INVALID_ARG_VALUE(env, "The cc_algorithm option is invalid");

return false;

}

switch (num->Value()) {

#define V(name, _) \

case NGTCP2_CC_ALGO_##name: \

break;

CC_ALGOS(V)

#undef V

default:

THROW_ERR_INVALID_ARG_VALUE(env,

"The cc_algorithm option is invalid");

return false;

}

algo = FromV8Value<ngtcp2_cc_algo>(num);

}

options->*member = algo;

}

return true;

}

template <typename Opt, uint8_t Opt::*member>

bool SetOption(Environment* env,

Opt* options,

const Local<Object>& object,

const Local<String>& name) {

Local<Value> value;

if (!object->Get(env->context(), name).ToLocal(&value)) return false;

if (!value->IsUndefined()) {

if (!value->IsUint32()) {

Utf8Value nameStr(env->isolate(), name);

THROW_ERR_INVALID_ARG_VALUE(

env, "The %s option must be an uint8", *nameStr);

return false;

}

uint32_t val = value.As<Uint32>()->Value();

if (val > 255) {

Utf8Value nameStr(env->isolate(), name);

THROW_ERR_INVALID_ARG_VALUE(

env, "The %s option must be <= 255", *nameStr);

return false;

}

options->*member = static_cast<uint8_t>(val);

}

return true;

}

} // namespace

// ============================================================================

Session::Config::Config(Environment* env,

Side side,

const Options& options,

uint32_t version,

const SocketAddress& local_address,

const SocketAddress& remote_address,

const CID& dcid,

const CID& scid,

const CID& ocid)

: side(side),

options(options),

version(version),

local_address(local_address),

remote_address(remote_address),

dcid(dcid),

scid(scid),

ocid(ocid) {

ngtcp2_settings_default(&settings);

settings.initial_ts = uv_hrtime();

// Advertise all versions ngtcp2 supports for compatible version

// negotiation (RFC 9368). The preferred list orders the newest

// version first so that negotiation upgrades when possible. The

// initial packet version (options.version) defaults to V1 for

// maximum compatibility with peers that don't support version

// negotiation.

static const uint32_t kSupportedVersions[] = {NGTCP2_PROTO_VER_V2,

NGTCP2_PROTO_VER_V1};

settings.preferred_versions = kSupportedVersions;

settings.preferred_versionslen = std::size(kSupportedVersions);

settings.available_versions = kSupportedVersions;

settings.available_versionslen = std::size(kSupportedVersions);

// TODO(@jasnell): Path MTU Discovery is disabled because libuv does not

// currently expose the IP_DONTFRAG / IP_MTU_DISCOVER socket options

// needed for PMTUD probes to work correctly. Revisit when libuv adds

// support or if we bypass libuv for the UDP socket options.

settings.no_pmtud = 1;

// Per the ngtcp2 documentation, when no_tx_udp_payload_size_shaping is set

// to a non-zero value, it tells ngtcp2 not to limit the UDP payload size to

// NGTCP2_MAX_UDP_PAYLOAD_SIZE` and will instead "use the minimum size among

// the given buffer size, :member:`max_tx_udp_payload_size`, and the

// received max_udp_payload_size QUIC transport parameter." For now, this

// works for us, especially since we do not implement Path MTU discovery.

settings.no_tx_udp_payload_size_shaping = 1;

settings.max_tx_udp_payload_size = options.max_payload_size;

settings.tokenlen = 0;

settings.token = nullptr;

if (options.qlog) {

settings.qlog_write = on_qlog_write;

}

if (env->enabled_debug_list()->enabled(DebugCategory::NGTCP2)) {

settings.log_printf = ngtcp2_debug_log;

}

// The handshake_timeout option is in milliseconds; ngtcp2 expects

// nanoseconds (ngtcp2_duration). UINT64_MAX means no timeout.

settings.handshake_timeout =

options.handshake_timeout == UINT64_MAX

? UINT64_MAX

: options.handshake_timeout * NGTCP2_MILLISECONDS;

// The initial_rtt option is in milliseconds; ngtcp2 expects nanoseconds.

// A value of 0 leaves the ngtcp2 default (333ms) unchanged.

if (options.initial_rtt > 0)

settings.initial_rtt = options.initial_rtt * NGTCP2_MILLISECONDS;

settings.max_stream_window = options.max_stream_window;

settings.max_window = options.max_window;

settings.ack_thresh = options.unacknowledged_packet_threshold;

settings.cc_algo = options.cc_algorithm;

if (side == Side::CLIENT && options.token.has_value()) {

ngtcp2_vec vec = options.token.value();

set_token(vec.base, vec.len, NGTCP2_TOKEN_TYPE_NEW_TOKEN);

}

}

Session::Config::Config(Environment* env,

const Options& options,

const SocketAddress& local_address,

const SocketAddress& remote_address,

const CID& ocid)

: Config(env,

Side::CLIENT,

options,

options.version,

local_address,

remote_address,

CID::Factory::random().Generate(NGTCP2_MIN_INITIAL_DCIDLEN),

options.cid_factory->Generate(),

ocid) {}

void Session::Config::MemoryInfo(MemoryTracker* tracker) const {

tracker->TrackField("options", options);

tracker->TrackField("local_address", local_address);

tracker->TrackField("remote_address", remote_address);

tracker->TrackField("dcid", dcid);

tracker->TrackField("scid", scid);

tracker->TrackField("ocid", ocid);

tracker->TrackField("retry_scid", retry_scid);

}

void Session::Config::set_token(const uint8_t* token,

size_t len,

ngtcp2_token_type type) {

settings.token = token;

settings.tokenlen = len;

settings.token_type = type;

}

void Session::Config::set_token(const RetryToken& token) {

ngtcp2_vec vec = token;

set_token(vec.base, vec.len, NGTCP2_TOKEN_TYPE_RETRY);

}

void Session::Config::set_token(const RegularToken& token) {

ngtcp2_vec vec = token;

set_token(vec.base, vec.len, NGTCP2_TOKEN_TYPE_NEW_TOKEN);

}

std::string Session::Config::ToString() const {

DebugIndentScope indent;

auto prefix = indent.Prefix();

std::string res("{");

res += prefix + "side: " + to_string(side);

res += prefix + "options: " + options.ToString();

res += prefix + "version: " + std::to_string(version);

res += prefix + "local address: " + local_address.ToString();

res += prefix + "remote address: " + remote_address.ToString();

res += prefix + "dcid: " + dcid.ToString();

res += prefix + "scid: " + scid.ToString();

res += prefix + "ocid: " + ocid.ToString();

res += prefix + "retry scid: " + retry_scid.ToString();

res += prefix + "preferred address cid: " + preferred_address_cid.ToString();

res += indent.Close();

return res;

}

// ============================================================================

Maybe<Session::Options> Session::Options::From(Environment* env,

Local<Value> value) {

if (value.IsEmpty() || !value->IsObject()) {

THROW_ERR_INVALID_ARG_TYPE(env, "options must be an object");

return Nothing<Options>();

}

auto& state = BindingData::Get(env);

auto params = value.As<Object>();

Options options;

#define SET(name) \

SetOption<Session::Options, &Session::Options::name>( \

env, &options, params, state.name##_string())

if (!SET(version) || !SET(min_version) || !SET(preferred_address_strategy) ||

!SET(transport_params) || !SET(tls_options) || !SET(qlog) ||

!SET(handshake_timeout) || !SET(initial_rtt) ||

!SET(keep_alive_timeout) || !SET(max_stream_window) || !SET(max_window) ||

!SET(max_payload_size) || !SET(unacknowledged_packet_threshold) ||

!SET(cc_algorithm) || !SET(draining_period_multiplier) ||

!SET(max_datagram_send_attempts) || !SET(stream_idle_timeout)) {

return Nothing<Options>();

}

#undef SET

// RFC 9000 Section 10.2 requires the draining period to be at least 3x PTO.

static const uint8_t kMinDrainingPeriodMultiplier = 3;

options.draining_period_multiplier = std::max(

options.draining_period_multiplier, kMinDrainingPeriodMultiplier);

// At least 1 send attempt is required.

options.max_datagram_send_attempts =

std::max(options.max_datagram_send_attempts, static_cast<uint8_t>(1));

// Parse the datagram drop policy from a string option.

{

Local<Value> policy_val;

if (params->Get(env->context(), state.datagram_drop_policy_string())

.ToLocal(&policy_val) &&

!policy_val->IsUndefined()) {

Utf8Value policy_str(env->isolate(), policy_val);

if (strcmp(*policy_str, "drop-newest") == 0) {

options.datagram_drop_policy = DatagramDropPolicy::DROP_NEWEST;

}

// Default is DROP_OLDEST, no need to check for "drop-oldest".

}

}

// Parse the application-specific options (HTTP/3 qpack settings, etc.).

// These are used if the negotiated ALPN selects Http3ApplicationImpl.

{

Local<Value> app_val;

if (params->Get(env->context(), state.application_string())

.ToLocal(&app_val) &&

!app_val->IsUndefined()) {

if (!Application_Options::From(env, app_val)

.To(&options.application_options)) {

return Nothing<Options>();

}

}

}

// Parse the SNI map from the tls options.

{

Local<Value> tls_val;

if (params->Get(env->context(), state.tls_options_string())

.ToLocal(&tls_val) &&

tls_val->IsObject()) {

Local<Value> sni_val;

if (tls_val.As<Object>()

->Get(env->context(), state.sni_string())

.ToLocal(&sni_val) &&

sni_val->IsObject()) {

auto sni_obj = sni_val.As<Object>();

Local<Array> hostnames;

if (sni_obj->GetOwnPropertyNames(env->context()).ToLocal(&hostnames)) {

for (uint32_t i = 0; i < hostnames->Length(); i++) {

Local<Value> key;

Local<Value> entry_val;

if (!hostnames->Get(env->context(), i).ToLocal(&key) ||

!key->IsString() ||

!sni_obj->Get(env->context(), key).ToLocal(&entry_val)) {

continue;

}

Utf8Value hostname(env->isolate(), key);

auto entry_options = TLSContext::Options::From(env, entry_val);

if (entry_options.IsNothing()) {

return Nothing<Options>();

}

options.sni[std::string(*hostname, hostname.length())] =

entry_options.FromJust();

}

}

}

}

}

// TODO(@jasnell): Later we will also support setting the CID::Factory.

// For now, we're just using the default random factory.

// Parse the optional NEW_TOKEN for address validation on reconnection.

Local<Value> token_val;

if (params->Get(env->context(), state.token_string()).ToLocal(&token_val) &&

token_val->IsArrayBufferView()) {

Store token_store;

if (Store::From(token_val.As<ArrayBufferView>()).To(&token_store)) {

options.token = std::move(token_store);

}

}

return Just<Options>(options);

}

void Session::Options::MemoryInfo(MemoryTracker* tracker) const {

tracker->TrackField("transport_params", transport_params);

tracker->TrackField("crypto_options", tls_options);

tracker->TrackField("cid_factory_ref", cid_factory_ref);

}

std::string Session::Options::ToString() const {

DebugIndentScope indent;

auto prefix = indent.Prefix();

std::string res("{");

res += prefix + "version: " + std::to_string(version);

res += prefix + "min version: " + std::to_string(min_version);

res += prefix +

"preferred address policy: " + to_string(preferred_address_strategy);

res += prefix + "transport params: " + transport_params.ToString();

res += prefix + "crypto options: " + tls_options.ToString();

if (qlog) {

res += prefix + "qlog: yes";

}

if (handshake_timeout == UINT64_MAX) {

res += prefix + "handshake timeout: <none>";

} else {

res += prefix + "handshake timeout: " + std::to_string(handshake_timeout) +

" nanoseconds";

}

if (initial_rtt > 0) {

res += prefix + "initial rtt: " + std::to_string(initial_rtt) +

" milliseconds";

} else {

res += prefix + "initial rtt: <default>";

}

res += prefix + "max stream window: " + std::to_string(max_stream_window);

res += prefix + "max window: " + std::to_string(max_window);

res += prefix + "max payload size: " + std::to_string(max_payload_size);

if (unacknowledged_packet_threshold != 0) {

res += prefix + "unacknowledged packet threshold: " +

std::to_string(unacknowledged_packet_threshold);

} else {

res += prefix + "unacknowledged packet threshold: <default>";

}

res += prefix + "cc algorithm: " + to_string(cc_algorithm);

res += indent.Close();

return res;

}

// ============================================================================

// ngtcp2 static callback functions

// Utility used only within Session::Impl to reduce boilerplate

// Resolves the Session* from ngtcp2 callback arguments. The

// NgTcp2CallbackScope is NOT created here — it is placed at the

// ngtcp2 entry points (Receive, OnTimeout) so that the deferred

// destroy only fires after all callbacks for that call have completed.

#define NGTCP2_CALLBACK_SCOPE(name) \

auto name = Impl::From(conn, user_data); \

if (name == nullptr) return NGTCP2_ERR_CALLBACK_FAILURE;

// Session::Impl maintains most of the internal state of an active Session.

struct Session::Impl final : public MemoryRetainer {

Session* session_;

ArenaSlotBase stats_slot_;

ArenaSlotBase state_slot_;

BaseObjectWeakPtr<Endpoint> endpoint_;

Config config_;

SocketAddress local_address_;

SocketAddress remote_address_;

std::unique_ptr<Application> application_;

StreamsMap streams_;

TimerWrapHandle timer_;

size_t send_scope_depth_ = 0;

QuicError last_error_;

// Datagrams queued for sending. Serialized into packets by

// SendPendingData alongside stream data.

std::deque<Session::PendingDatagram> pending_datagrams_;

PendingStream::PendingStreamQueue pending_bidi_stream_queue_;

PendingStream::PendingStreamQueue pending_uni_stream_queue_;

// Session ticket app data parsed before ALPN negotiation.

// Validated and applied in SetApplication() after ALPN selects

// the application type.

std::optional<PendingTicketAppData> pending_ticket_data_;

// When true, the handshake is deferred until the first stream or

// datagram is sent. This is set for client sessions with a session

// ticket, enabling 0-RTT: the first send triggers the handshake

// and the stream/datagram data is included in the 0-RTT flight.

bool handshake_deferred_ = false;

Stats* stats() { return static_cast<Stats*>(stats_slot_.ptr); }

const Stats* stats() const {

return static_cast<const Stats*>(stats_slot_.ptr);

}

State* state() { return static_cast<State*>(state_slot_.ptr); }

const State* state() const {

return static_cast<const State*>(state_slot_.ptr);

}

Impl(Session* session, Endpoint* endpoint, const Config& config)

: session_(session),

endpoint_(endpoint),

config_(config),

local_address_(config.local_address),

remote_address_(config.remote_address),

timer_(session_->env(), [this] { session_->OnTimeout(); }) {

auto& binding = BindingData::Get(env());

stats_slot_ = GetSessionStatsArena(binding).Allocate(env()->isolate());

state_slot_ = GetSessionStateArena(binding).Allocate(env()->isolate());

timer_.Unref();

}

DISALLOW_COPY_AND_MOVE(Impl)

inline bool is_closing() const { return state()->closing; }

~Impl() {

// Ensure that Close() was called before dropping

DCHECK(is_closing());

DCHECK(endpoint_);

// Removing the session from the endpoint may cause the endpoint to be

// destroyed if it is waiting on the last session to be destroyed. Let's

// grab a reference just to be safe for the rest of the function.

BaseObjectPtr<Endpoint> endpoint = endpoint_;

endpoint_.reset();

MaybeStackBuffer<ngtcp2_cid, 10> cids(

ngtcp2_conn_get_scid(*session_, nullptr));

ngtcp2_conn_get_scid(*session_, cids.out());

MaybeStackBuffer<ngtcp2_cid_token2, 10> tokens(

ngtcp2_conn_get_active_dcid2(*session_, nullptr));

ngtcp2_conn_get_active_dcid2(*session_, tokens.out());

endpoint->DisassociateCID(config_.dcid);

endpoint->DisassociateCID(config_.preferred_address_cid);

for (size_t n = 0; n < cids.length(); n++) {

endpoint->DisassociateCID(CID(cids[n]));

}

for (size_t n = 0; n < tokens.length(); n++) {

if (tokens[n].token_present) {

endpoint->DisassociateStatelessResetToken(

StatelessResetToken(&tokens[n].token));

}

}

endpoint->RemoveSession(config_.scid, remote_address_);

auto& binding = BindingData::Get(env());

if (stats_slot_) GetSessionStatsArena(binding).ReleaseSlot(stats_slot_);

if (state_slot_) GetSessionStateArena(binding).ReleaseSlot(state_slot_);

}

void MemoryInfo(MemoryTracker* tracker) const override {

tracker->TrackField("config", config_);

tracker->TrackField("endpoint", endpoint_);

tracker->TrackField("streams", streams_);

tracker->TrackField("local_address", local_address_);

tracker->TrackField("remote_address", remote_address_);

tracker->TrackField("application", application_);

tracker->TrackField("timer", timer_);

}

SET_SELF_SIZE(Impl)

SET_MEMORY_INFO_NAME(Session::Impl)

Environment* env() const { return session_->env(); }

// Gets the Session pointer from the user_data void pointer

// provided by ngtcp2.

static Session* From(ngtcp2_conn* conn, void* user_data) {

if (user_data == nullptr) [[unlikely]] {

return nullptr;

}

auto session = static_cast<Session*>(user_data);

if (session->is_destroyed()) [[unlikely]] {

return nullptr;

}

return session;

}

// JavaScript APIs

// TODO(@jasnell): Fast API alternatives for each of these

// Parse optional close error code options: { code, type, reason }

// Returns true on success (including when no options were provided).

// Returns false on validation error (exception thrown).

// Sets *did_set to true if an error code was actually applied.

static bool MaybeSetCloseError(const FunctionCallbackInfo<Value>& args,

int options_index,

Session* session,

bool* did_set = nullptr) {

if (did_set) *did_set = false;

auto env = Environment::GetCurrent(args);

if (args.Length() <= options_index || args[options_index]->IsUndefined()) {

return true;

}

if (!args[options_index]->IsObject()) {

THROW_ERR_INVALID_ARG_TYPE(env, "options must be an object");

return false;

}

auto options = args[options_index].As<Object>();

auto& state = BindingData::Get(env);

auto context = env->context();

// code: bigint (optional)

Local<Value> code_val;

if (!options->Get(context, state.code_string()).ToLocal(&code_val)) {

return false;

}

if (code_val->IsUndefined()) return true;

uint64_t code;

if (code_val->IsBigInt()) {

bool lossless;

code = code_val.As<BigInt>()->Uint64Value(&lossless);

if (!lossless) {

THROW_ERR_INVALID_ARG_VALUE(env, "options.code is too large");

return false;

}

} else if (code_val->IsNumber()) {

code = static_cast<uint64_t>(code_val.As<Number>()->Value());

} else {

THROW_ERR_INVALID_ARG_TYPE(env,

"options.code must be a bigint or number");

return false;

}

// type: string (optional, default 'transport')

Local<Value> type_val;

if (!options->Get(context, state.type_string()).ToLocal(&type_val)) {

return false;

}

bool is_application = false;

if (!type_val->IsUndefined()) {

if (type_val->StrictEquals(state.application_string())) {

is_application = true;

} else if (!type_val->StrictEquals(state.transport_string())) {

THROW_ERR_INVALID_ARG_VALUE(

env, "options.type must be 'transport' or 'application'");

return false;

}

}

// reason: string (optional)

std::string reason;

Local<Value> reason_val;

if (!options->Get(context, state.reason_string()).ToLocal(&reason_val)) {

return false;

}

if (!reason_val->IsUndefined()) {

Utf8Value reason_str(env->isolate(), reason_val);

reason = std::string(*reason_str, reason_str.length());

}

if (is_application) {

session->SetLastError(QuicError::ForApplication(code, std::move(reason)));

} else {

session->SetLastError(QuicError::ForTransport(code, std::move(reason)));

}

if (did_set) *did_set = true;

return true;

}

JS_METHOD(Destroy) {

auto env = Environment::GetCurrent(args);

Session* session;

ASSIGN_OR_RETURN_UNWRAP(&session, args.This());

if (session->is_destroyed()) {

// At this layer, Destroy should only be called once. At the

// JavaScript layer calling destroy() multiple times should be

// an idempotent operation. Be sure to check for that there

// as we strictly enforce it here.

return THROW_ERR_INVALID_STATE(env, "Session is destroyed");

}

// args[0] is the optional close error options object.

bool has_close_options = false;

if (!MaybeSetCloseError(args, 0, session, &has_close_options)) return;

// If an error code was provided by the caller, send CONNECTION_CLOSE

// with that code before destroying. SendConnectionClose writes the

// packet and hands it to the endpoint — it doesn't wait for ack.

if (has_close_options) {

session->SendConnectionClose();

}