node_quic_session-inl.h

#ifndef SRC_QUIC_NODE_QUIC_SESSION_INL_H_
#define SRC_QUIC_NODE_QUIC_SESSION_INL_H_

#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#include "debug_utils-inl.h"
#include "node_crypto.h"
#include "crypto/crypto_common.h"
#include "node_quic_crypto.h"
#include "node_quic_session.h"
#include "node_quic_socket-inl.h"
#include "node_quic_stream-inl.h"

#include <openssl/ssl.h>
#include <memory>
#include <string>

namespace node {

namespace quic {

void QuicSessionConfig::GenerateStatelessResetToken(
    QuicSession* session,
    const QuicCID& cid) {
  transport_params.stateless_reset_token_present = 1;
  StatelessResetToken token(
    transport_params.stateless_reset_token,
    session->socket()->session_reset_secret(),
    cid);
  Debug(session, "Generated stateless reset token %s for CID %s", token, cid);
}

void QuicSessionConfig::GeneratePreferredAddressToken(
    ConnectionIDStrategy connection_id_strategy,
    QuicSession* session,
    QuicCID* pscid) {
  connection_id_strategy(session, pscid->cid(), kScidLen);
  transport_params.preferred_address.cid = **pscid;

  StatelessResetToken(
    transport_params.preferred_address.stateless_reset_token,
    session->socket()->session_reset_secret(),
    *pscid);
}

void QuicSessionConfig::set_original_connection_id(
    const QuicCID& ocid,
    const QuicCID& scid) {
  if (ocid) {
    transport_params.original_dcid = *ocid;
    transport_params.retry_scid = *scid;
    transport_params.retry_scid_present = 1;
  } else {
    transport_params.original_dcid = *scid;
  }
}

void QuicSessionConfig::set_qlog(const ngtcp2_qlog_settings& qlog_) {
  qlog = qlog_;
}

QuicCryptoContext::QuicCryptoContext(
    QuicSession* session,
    BaseObjectPtr<crypto::SecureContext> secure_context,
    ngtcp2_crypto_side side,
    uint32_t options) :
    session_(session),
    secure_context_(secure_context),
    side_(side),
    options_(options) {
  ssl_.reset(SSL_new(secure_context_->ctx_.get()));
  CHECK(ssl_);
}

void QuicCryptoContext::Initialize() {
  InitializeTLS(session(), ssl_);
}

// Cancels and frees any remaining outbound handshake data
// at each crypto level.
uint64_t QuicCryptoContext::Cancel() {
  uint64_t len = handshake_[0].Cancel();
  len += handshake_[1].Cancel();
  len += handshake_[2].Cancel();
  return len;
}

v8::MaybeLocal<v8::Value> QuicCryptoContext::ocsp_response() const {
  Environment* env = session()->env();
  return crypto::GetSSLOCSPResponse(
      env,
      ssl_.get(),
      v8::Undefined(env->isolate()));
}

ngtcp2_crypto_level QuicCryptoContext::read_crypto_level() const {
  return from_ossl_level(SSL_quic_read_level(ssl_.get()));
}

ngtcp2_crypto_level QuicCryptoContext::write_crypto_level() const {
  return from_ossl_level(SSL_quic_write_level(ssl_.get()));
}

// TLS Keylogging is enabled per-QuicSession by attaching an handler to the
// "keylog" event. Each keylog line is emitted to JavaScript where it can
// be routed to whatever destination makes sense. Typically, this will be
// to a keylog file that can be consumed by tools like Wireshark to intercept
// and decrypt QUIC network traffic.
void QuicCryptoContext::Keylog(const char* line) {
  if (UNLIKELY(session_->state_->keylog_enabled))
    session_->listener()->OnKeylog(line, strlen(line));
}

// Following a pause in the handshake for OCSP or client hello, we kickstart
// the handshake again here by triggering ngtcp2 to serialize data.
void QuicCryptoContext::ResumeHandshake() {
  // We haven't received any actual new handshake data but calling
  // this will trigger the handshake to continue.
  Receive(read_crypto_level(), 0, nullptr, 0);
  session_->SendPendingData();
}

// For 0RTT, this sets the TLS session data from the given buffer.
bool QuicCryptoContext::set_session(crypto::SSLSessionPointer session) {
  if (side_ == NGTCP2_CRYPTO_SIDE_CLIENT && session != nullptr) {
    set_early_data(
        SSL_SESSION_get_max_early_data(session.get()) == 0xffffffffUL);
  }
  return crypto::SetTLSSession(ssl_, std::move(session));
}

v8::MaybeLocal<v8::Array> QuicCryptoContext::hello_ciphers() const {
  return crypto::GetClientHelloCiphers(session()->env(), ssl_);
}

v8::MaybeLocal<v8::Value> QuicCryptoContext::cipher_name() const {
  return crypto::GetCipherName(session()->env(), ssl_);
}

v8::MaybeLocal<v8::Value> QuicCryptoContext::cipher_version() const {
  return crypto::GetCipherVersion(session()->env(), ssl_);
}

const char* QuicCryptoContext::servername() const {
  return crypto::GetServerName(ssl_.get());
}

const char* QuicCryptoContext::hello_alpn() const {
  return crypto::GetClientHelloALPN(ssl_);
}

const char* QuicCryptoContext::hello_servername() const {
  return crypto::GetClientHelloServerName(ssl_);
}

v8::MaybeLocal<v8::Object> QuicCryptoContext::ephemeral_key() const {
  return crypto::GetEphemeralKey(session()->env(), ssl_);
}

v8::MaybeLocal<v8::Value> QuicCryptoContext::peer_cert(bool abbreviated) const {
  return crypto::GetPeerCert(
      session()->env(),
      ssl_,
      abbreviated,
      session()->is_server());
}

v8::MaybeLocal<v8::Value> QuicCryptoContext::cert() const {
  return crypto::GetCert(session()->env(), ssl_);
}

std::string QuicCryptoContext::selected_alpn() const {
  const unsigned char* alpn_buf = nullptr;
  unsigned int alpnlen;
  SSL_get0_alpn_selected(ssl_.get(), &alpn_buf, &alpnlen);
  return alpnlen ?
      std::string(reinterpret_cast<const char*>(alpn_buf), alpnlen) :
      std::string();
}

bool QuicCryptoContext::early_data() const {
  return
      (is_early_data() &&
       SSL_get_early_data_status(ssl_.get()) == SSL_EARLY_DATA_ACCEPTED) ||
      SSL_get_max_early_data(ssl_.get()) == 0xffffffffUL;
}

void QuicCryptoContext::set_tls_alert(int err) {
  Debug(session(), "TLS Alert [%d]: %s", err, SSL_alert_type_string_long(err));
  session_->set_last_error(QuicError(QUIC_ERROR_CRYPTO, err));
}

QuicApplication::QuicApplication(QuicSession* session) : session_(session) {}

void QuicApplication::set_stream_fin(int64_t stream_id) {
  BaseObjectPtr<QuicStream> stream = session()->FindStream(stream_id);
  CHECK(stream);
  stream->set_fin_sent();
}

std::unique_ptr<QuicPacket> QuicApplication::CreateStreamDataPacket() {
  return QuicPacket::Create(
      "stream data",
      session()->max_packet_length());
}

Environment* QuicApplication::env() const {
  return session()->env();
}

// Extends the stream-level flow control by the given number of bytes.
void QuicSession::ExtendStreamOffset(int64_t stream_id, size_t amount) {
  Debug(this, "Extending max stream %" PRId64 " offset by %" PRId64 " bytes",
        stream_id, amount);
  ngtcp2_conn_extend_max_stream_offset(
      connection(),
      stream_id,
      amount);
}

// Extends the connection-level flow control for the entire session by
// the given number of bytes.
void QuicSession::ExtendOffset(size_t amount) {
  Debug(this, "Extending session offset by %" PRId64 " bytes", amount);
  ngtcp2_conn_extend_max_offset(connection(), amount);
}

// Copies the local transport params into the given struct for serialization.
void QuicSession::GetLocalTransportParams(ngtcp2_transport_params* params) {
  CHECK(!is_destroyed());
  ngtcp2_conn_get_local_transport_params(connection(), params);
}

// Gets the QUIC version negotiated for this QuicSession
uint32_t QuicSession::negotiated_version() const {
  CHECK(!is_destroyed());
  return ngtcp2_conn_get_negotiated_version(connection());
}

bool QuicSession::is_handshake_completed() const {
  DCHECK(!is_destroyed());
  return ngtcp2_conn_get_handshake_completed(connection());
}

void QuicSession::ShutdownStream(int64_t stream_id, uint64_t code) {
  if (is_in_closing_period() ||
      is_in_draining_period() ||
      is_silent_closing()) {
    return;  // Nothing to do because we can't send any frames.
  }
  SendSessionScope send_scope(this);
  ngtcp2_conn_shutdown_stream(connection(), stream_id, 0);
}

// When a QuicSession hits the idle timeout, it is to be silently and
// immediately closed without attempting to send any additional data to
// the peer. All existing streams are abandoned and closed.
void QuicSession::OnIdleTimeout() {
  if (!is_destroyed()) {
    if (state_->idle_timeout == 1) {
      Debug(this, "Idle timeout");
      Close(QuicSessionListener::SESSION_CLOSE_FLAG_SILENT);
      return;
    }
    state_->idle_timeout = 1;
    UpdateClosingTimer();
  }
}

QuicCID QuicSession::dcid() const {
  return QuicCID(ngtcp2_conn_get_dcid(connection()));
}

void QuicSession::CheckAllocatedSize(size_t previous_size) const {
  CHECK_GE(current_ngtcp2_memory_, previous_size);
}

void QuicSession::IncreaseAllocatedSize(size_t size) {
  current_ngtcp2_memory_ += size;
}

void QuicSession::DecreaseAllocatedSize(size_t size) {
  current_ngtcp2_memory_ -= size;
}

uint64_t QuicSession::max_data_left() const {
  return ngtcp2_conn_get_max_data_left(connection());
}

uint64_t QuicSession::max_local_streams_uni() const {
  return ngtcp2_conn_get_max_local_streams_uni(connection());
}

void QuicSession::set_last_error(QuicError error) {
  last_error_ = error;
}

void QuicSession::set_last_error(int32_t family, uint64_t code) {
  set_last_error({ family, code });
}

void QuicSession::set_last_error(int32_t family, int code) {
  set_last_error({ family, code });
}

bool QuicSession::is_in_closing_period() const {
  return ngtcp2_conn_is_in_closing_period(connection());
}

bool QuicSession::is_in_draining_period() const {
  return ngtcp2_conn_is_in_draining_period(connection());
}

bool QuicSession::HasStream(int64_t id) const {
  return streams_.find(id) != std::end(streams_);
}

bool QuicSession::allow_early_data() const {
  // TODO(@jasnell): For now, we always allow early data.
  // Later there will be reasons we do not want to allow
  // it, such as lack of available system resources.
  return true;
}

void QuicSession::SetSessionTicketAppData(
    const SessionTicketAppData& app_data) {
  application_->SetSessionTicketAppData(app_data);
}

SessionTicketAppData::Status QuicSession::GetSessionTicketAppData(
    const SessionTicketAppData& app_data,
    SessionTicketAppData::Flag flag) {
  return application_->GetSessionTicketAppData(app_data, flag);
}

bool QuicSession::is_server() const {
  return crypto_context_->side() == NGTCP2_CRYPTO_SIDE_SERVER;
}

void QuicSession::StartGracefulClose() {
  set_graceful_closing();
  RecordTimestamp(&QuicSessionStats::closing_at);
}

// The connection ID Strategy is a function that generates
// connection ID values. By default these are generated randomly.
void QuicSession::set_connection_id_strategy(ConnectionIDStrategy strategy) {
  CHECK_NOT_NULL(strategy);
  connection_id_strategy_ = strategy;
}

bool QuicSession::is_unable_to_send_packets() {
  return NgCallbackScope::InNgCallbackScope(this) ||
      is_destroyed() ||
      is_in_draining_period() ||
      (is_server() && is_in_closing_period()) ||
      socket() == nullptr;
}

void QuicSession::set_preferred_address_strategy(
    PreferredAddressStrategy strategy) {
  preferred_address_strategy_ = strategy;
}

QuicSocket* QuicSession::socket() const {
  return socket_.get();
}

// Indicates that the stream is blocked from transmitting any
// data. The specific handling of this is application specific.
// By default, we keep track of statistics but leave it up to
// the application to perform specific handling.
void QuicSession::StreamDataBlocked(int64_t stream_id) {
  IncrementStat(&QuicSessionStats::block_count);
  listener_->OnStreamBlocked(stream_id);
}

// When a server advertises a preferred address in its initial
// transport parameters, ngtcp2 on the client side will trigger
// the OnSelectPreferredAdddress callback which will call this.
// The paddr argument contains the advertised preferred address.
// If the new address is going to be used, it needs to be copied
// over to dest, otherwise dest is left alone. There are two
// possible strategies that we currently support via user
// configuration: use the preferred address or ignore it.
void QuicSession::SelectPreferredAddress(
    const PreferredAddress& preferred_address) {
  CHECK(!is_server());
  preferred_address_strategy_(this, preferred_address);
}

// This variant of SendPacket is used by QuicApplication
// instances to transmit a packet and update the network
// path used at the same time.
bool QuicSession::SendPacket(
  std::unique_ptr<QuicPacket> packet,
  const ngtcp2_path_storage& path) {
  UpdateEndpoint(path.path);
  return SendPacket(std::move(packet));
}

// Set the transport parameters received from the remote peer
void QuicSession::set_remote_transport_params() {
  DCHECK(!is_destroyed());
  ngtcp2_conn_get_remote_transport_params(connection(), &transport_params_);
  set_transport_params_set();
}

// Submits information headers only if the selected application
// supports headers.
bool QuicSession::SubmitInformation(
    int64_t stream_id,
    v8::Local<v8::Array> headers) {
  return application_->SubmitInformation(stream_id, headers);
}

// Submits initial headers only if the selected application
// supports headers. For http3, for instance, this is the
// method used to submit both request and response headers.
bool QuicSession::SubmitHeaders(
    int64_t stream_id,
    v8::Local<v8::Array> headers,
    uint32_t flags) {
  return application_->SubmitHeaders(stream_id, headers, flags);
}

// Submits trailing headers only if the selected application
// supports headers.
bool QuicSession::SubmitTrailers(
    int64_t stream_id,
    v8::Local<v8::Array> headers) {
  return application_->SubmitTrailers(stream_id, headers);
}

// Submits a new push stream
BaseObjectPtr<QuicStream> QuicSession::SubmitPush(
    int64_t stream_id,
    v8::Local<v8::Array> headers) {
  return application_->SubmitPush(stream_id, headers);
}

}  // namespace quic
}  // namespace node

#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#endif  // SRC_QUIC_NODE_QUIC_SESSION_INL_H_