#if HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC

#include "session.h"

#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 "logstream.h"

#include "packet.h"

#include "preferredaddress.h"

#include "sessionticket.h"

#include "streams.h"

#include "tlscontext.h"

#include "transportparams.h"

namespace node {

using v8::Array;

using v8::ArrayBuffer;

using v8::ArrayBufferView;

using v8::BigInt;

using v8::Boolean;

using v8::FunctionCallbackInfo;

using v8::FunctionTemplate;

using v8::HandleScope;

using v8::Integer;

using v8::Just;

using v8::Local;

using v8::Maybe;

using v8::Nothing;

using v8::Object;

using v8::PropertyAttribute;

using v8::String;

using v8::Uint32;

using v8::Undefined;

using v8::Value;

namespace quic {

#define SESSION_STATE(V) \

/* Set if the JavaScript wrapper has a path-validation event listener */ \

V(PATH_VALIDATION, path_validation, uint8_t) \

/* Set if the JavaScript wrapper has a version-negotiation event listener */ \

V(VERSION_NEGOTIATION, version_negotiation, uint8_t) \

/* Set if the JavaScript wrapper has a datagram event listener */ \

V(DATAGRAM, datagram, uint8_t) \

/* Set if the JavaScript wrapper has a session-ticket event listener */ \

V(SESSION_TICKET, session_ticket, uint8_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(DESTROYED, destroyed, 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) \

/* A Session is wrapped if it has been passed out to JS */ \

V(WRAPPED, wrapped, uint8_t) \

V(LAST_DATAGRAM_ID, last_datagram_id, uint64_t)

#define SESSION_STATS(V) \

V(CREATED_AT, created_at) \

V(CLOSING_AT, closing_at) \

V(DESTROYED_AT, destroyed_at) \

V(HANDSHAKE_COMPLETED_AT, handshake_completed_at) \

V(HANDSHAKE_CONFIRMED_AT, handshake_confirmed_at) \

V(GRACEFUL_CLOSING_AT, graceful_closing_at) \

V(BYTES_RECEIVED, bytes_received) \

V(BYTES_SENT, bytes_sent) \

V(BIDI_IN_STREAM_COUNT, bidi_in_stream_count) \

V(BIDI_OUT_STREAM_COUNT, bidi_out_stream_count) \

V(UNI_IN_STREAM_COUNT, uni_in_stream_count) \

V(UNI_OUT_STREAM_COUNT, uni_out_stream_count) \

V(LOSS_RETRANSMIT_COUNT, loss_retransmit_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(DATAGRAMS_RECEIVED, datagrams_received) \

V(DATAGRAMS_SENT, datagrams_sent) \

V(DATAGRAMS_ACKNOWLEDGED, datagrams_acknowledged) \

V(DATAGRAMS_LOST, datagrams_lost)

#define SESSION_JS_METHODS(V) \

V(DoDestroy, destroy, false) \

V(GetRemoteAddress, getRemoteAddress, true) \

V(GetCertificate, getCertificate, true) \

V(GetEphemeralKeyInfo, getEphemeralKey, true) \

V(GetPeerCertificate, getPeerCertificate, true) \

V(GracefulClose, gracefulClose, false) \

V(SilentClose, silentClose, false) \

V(UpdateKey, updateKey, false) \

V(DoOpenStream, openStream, false) \

V(DoSendDatagram, sendDatagram, false)

struct Session::State {

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

SESSION_STATE(V)

#undef V

};

STAT_STRUCT(Session, SESSION)

struct Session::MaybeCloseConnectionScope final {

Session* session;

bool silent = false;

MaybeCloseConnectionScope(Session* session_, bool silent_)

}

DISALLOW_COPY_AND_MOVE(MaybeCloseConnectionScope)

~MaybeCloseConnectionScope() {

// We only want to trigger the sending the connection close if ...

// a) Silent is not explicitly true at this scope.

// b) We're not within the scope of an ngtcp2 callback, and

// c) We are not already in a closing or draining period.

if (--session->connection_close_depth_ == 0 && !silent &&

session->can_send_packets()) {

session->SendConnectionClose();

}

}

};

Session::SendPendingDataScope::SendPendingDataScope(Session* session)

: session(session) {

Debug(session, "Entering send pending data scope");

session->send_scope_depth_++;

}

Session::SendPendingDataScope::SendPendingDataScope(

const BaseObjectPtr<Session>& session)

: SendPendingDataScope(session.get()) {}

Session::SendPendingDataScope::~SendPendingDataScope() {

if (--session->send_scope_depth_ == 0 && session->can_send_packets()) {

session->application().SendPendingData();

}

}

namespace {

inline std::string to_string(ngtcp2_encryption_level level) {

}

void on_qlog_write(void* user_data,

}

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

}

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

bool SetOption(Environment* env,

}

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

bool SetOption(Environment* env,

}

template <typename Opt, Session::Application_Options Opt::*member>

bool SetOption(Environment* env,

}

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

bool SetOption(Environment* env,

}

} // namespace

Session::Config::Config(Side side,

const Endpoint& endpoint,

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();

// We currently do not support Path MTU Discovery. Once we do, unset this.

settings.no_pmtud = 1;

settings.tokenlen = 0;

settings.token = nullptr;

if (options.qlog) {

settings.qlog_write = on_qlog_write;

}

if (endpoint.env()->enabled_debug_list()->enabled(

DebugCategory::NGTCP2_DEBUG)) {

settings.log_printf = ngtcp2_debug_log;

}

// We pull parts of the settings for the session from the endpoint options.

auto& config = endpoint.options();

settings.no_tx_udp_payload_size_shaping = config.no_udp_payload_size_shaping;

settings.handshake_timeout = config.handshake_timeout;

settings.max_stream_window = config.max_stream_window;

settings.max_window = config.max_window;

settings.cc_algo = config.cc_algorithm;

settings.max_tx_udp_payload_size = config.max_payload_size;

if (config.unacknowledged_packet_threshold > 0) {

settings.ack_thresh = config.unacknowledged_packet_threshold;

}

}

Session::Config::Config(const Endpoint& endpoint,

const Options& options,

const SocketAddress& local_address,

const SocketAddress& remote_address,

const CID& ocid)

: Config(Side::CLIENT,

endpoint,

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("{");

auto sidestr = ([&] {

switch (side) {

case Side::CLIENT:

return "client";

case Side::SERVER:

return "server";

}

return "<unknown>";

})();

res += prefix + "side: " + std::string(sidestr);

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(application_options) || !SET(qlog)) {

return Nothing<Options>();

}

#undef SET

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

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

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("application_options", application_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);

auto policy = ([&] {

switch (preferred_address_strategy) {

case PreferredAddress::Policy::USE_PREFERRED:

return "use";

case PreferredAddress::Policy::IGNORE_PREFERRED:

return "ignore";

}

return "<unknown>";

})();

res += prefix + "preferred address policy: " + std::string(policy);

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

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

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

res += prefix + "qlog: " + (qlog ? std::string("yes") : std::string("no"));

res += indent.Close();

return res;

}

bool Session::HasInstance(Environment* env, Local<Value> value) {

return GetConstructorTemplate(env)->HasInstance(value);

}

BaseObjectPtr<Session> Session::Create(

}

Session::Session(Endpoint* endpoint,

}

Session::~Session() {

Debug(this, "Session destroyed.");

if (conn_closebuf_) {

conn_closebuf_->Done(0);

}

if (qlog_stream_) {

Debug(this, "Closing the qlog stream for this session");

env()->SetImmediate(

[ptr = std::move(qlog_stream_)](Environment*) { ptr->End(); });

}

if (keylog_stream_) {

Debug(this, "Closing the keylog stream for this session");

env()->SetImmediate(

[ptr = std::move(keylog_stream_)](Environment*) { ptr->End(); });

}

DCHECK(streams_.empty());

}

size_t Session::max_packet_size() const {

return ngtcp2_conn_get_max_tx_udp_payload_size(*this);

}

Session::operator ngtcp2_conn*() const {

return connection_.get();

}

uint32_t Session::version() const {

return config_.version;

}

Endpoint& Session::endpoint() const {

return *endpoint_;

}

TLSSession& Session::tls_session() {

return *tls_session_;

}

Session::Application& Session::application() {

return *application_;

}

const SocketAddress& Session::remote_address() const {

return remote_address_;

}

const SocketAddress& Session::local_address() const {

return local_address_;

}

bool Session::is_closing() const {

return state_->closing;

}

bool Session::is_graceful_closing() const {

return state_->graceful_close;

}

bool Session::is_silent_closing() const {

return state_->silent_close;

}

bool Session::is_destroyed() const {

return state_->destroyed;

}

bool Session::is_server() const {

return config_.side == Side::SERVER;

}

std::string Session::diagnostic_name() const {

}

const Session::Config& Session::config() const {

return config_;

}

const Session::Options& Session::options() const {

return config_.options;

}

void Session::HandleQlog(uint32_t flags, const void* data, size_t len) {

}

TransportParams Session::GetLocalTransportParams() const {

DCHECK(!is_destroyed());

return TransportParams(ngtcp2_conn_get_local_transport_params(*this));

}

TransportParams Session::GetRemoteTransportParams() const {

DCHECK(!is_destroyed());

return TransportParams(ngtcp2_conn_get_remote_transport_params(*this));

}

void Session::SetLastError(QuicError&& error) {

Debug(this, "Setting last error to %s", error);

last_error_ = std::move(error);

}

void Session::Close(Session::CloseMethod method) {

}

void Session::Destroy() {

}

bool Session::Receive(Store&& store,

}

void Session::Send(Packet* packet) {

}

void Session::Send(Packet* packet, const PathStorage& path) {

UpdatePath(path);

Send(packet);

}

void Session::UpdatePacketTxTime() {

ngtcp2_conn_update_pkt_tx_time(*this, uv_hrtime());

}

uint64_t Session::SendDatagram(Store&& data) {

}

void Session::UpdatePath(const PathStorage& storage) {