chromium/net/third_party/quiche/src/quiche/quic/core/quic_crypto_client_handshaker.cc

// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "quiche/quic/core/quic_crypto_client_handshaker.h"

#include <memory>
#include <string>
#include <utility>

#include "absl/strings/str_cat.h"
#include "quiche/quic/core/crypto/crypto_protocol.h"
#include "quiche/quic/core/crypto/crypto_utils.h"
#include "quiche/quic/core/quic_session.h"
#include "quiche/quic/core/quic_types.h"
#include "quiche/quic/platform/api/quic_client_stats.h"
#include "quiche/quic/platform/api/quic_flags.h"
#include "quiche/quic/platform/api/quic_logging.h"
#include "quiche/common/platform/api/quiche_logging.h"

namespace quic {

QuicCryptoClientHandshaker::ProofVerifierCallbackImpl::
    ProofVerifierCallbackImpl(QuicCryptoClientHandshaker* parent)
    : … { … }

QuicCryptoClientHandshaker::ProofVerifierCallbackImpl::
    ~ProofVerifierCallbackImpl() { … }

void QuicCryptoClientHandshaker::ProofVerifierCallbackImpl::Run(
    bool ok, const std::string& error_details,
    std::unique_ptr<ProofVerifyDetails>* details) { … }

void QuicCryptoClientHandshaker::ProofVerifierCallbackImpl::Cancel() { … }

QuicCryptoClientHandshaker::QuicCryptoClientHandshaker(
    const QuicServerId& server_id, QuicCryptoClientStream* stream,
    QuicSession* session, std::unique_ptr<ProofVerifyContext> verify_context,
    QuicCryptoClientConfig* crypto_config,
    QuicCryptoClientStream::ProofHandler* proof_handler)
    : … { … }

QuicCryptoClientHandshaker::~QuicCryptoClientHandshaker() { … }

void QuicCryptoClientHandshaker::OnHandshakeMessage(
    const CryptoHandshakeMessage& message) { … }

bool QuicCryptoClientHandshaker::CryptoConnect() { … }

int QuicCryptoClientHandshaker::num_sent_client_hellos() const { … }

bool QuicCryptoClientHandshaker::ResumptionAttempted() const { … }

bool QuicCryptoClientHandshaker::IsResumption() const { … }

bool QuicCryptoClientHandshaker::EarlyDataAccepted() const { … }

ssl_early_data_reason_t QuicCryptoClientHandshaker::EarlyDataReason() const { … }

bool QuicCryptoClientHandshaker::ReceivedInchoateReject() const { … }

int QuicCryptoClientHandshaker::num_scup_messages_received() const { … }

std::string QuicCryptoClientHandshaker::chlo_hash() const { … }

bool QuicCryptoClientHandshaker::encryption_established() const { … }

bool QuicCryptoClientHandshaker::IsCryptoFrameExpectedForEncryptionLevel(
    EncryptionLevel /*level*/) const { … }

EncryptionLevel
QuicCryptoClientHandshaker::GetEncryptionLevelToSendCryptoDataOfSpace(
    PacketNumberSpace space) const { … }

bool QuicCryptoClientHandshaker::one_rtt_keys_available() const { … }

const QuicCryptoNegotiatedParameters&
QuicCryptoClientHandshaker::crypto_negotiated_params() const { … }

CryptoMessageParser* QuicCryptoClientHandshaker::crypto_message_parser() { … }

HandshakeState QuicCryptoClientHandshaker::GetHandshakeState() const { … }

void QuicCryptoClientHandshaker::OnHandshakeDoneReceived() { … }

void QuicCryptoClientHandshaker::OnNewTokenReceived(
    absl::string_view /*token*/) { … }

size_t QuicCryptoClientHandshaker::BufferSizeLimitForLevel(
    EncryptionLevel level) const { … }

std::unique_ptr<QuicDecrypter>
QuicCryptoClientHandshaker::AdvanceKeysAndCreateCurrentOneRttDecrypter() { … }

std::unique_ptr<QuicEncrypter>
QuicCryptoClientHandshaker::CreateCurrentOneRttEncrypter() { … }

void QuicCryptoClientHandshaker::OnConnectionClosed(
    QuicErrorCode /*error*/, ConnectionCloseSource /*source*/) { … }

void QuicCryptoClientHandshaker::HandleServerConfigUpdateMessage(
    const CryptoHandshakeMessage& server_config_update) { … }

void QuicCryptoClientHandshaker::DoHandshakeLoop(
    const CryptoHandshakeMessage* in) { … }

void QuicCryptoClientHandshaker::DoInitialize(
    QuicCryptoClientConfig::CachedState* cached) { … }

void QuicCryptoClientHandshaker::DoSendCHLO(
    QuicCryptoClientConfig::CachedState* cached) { … }

void QuicCryptoClientHandshaker::DoReceiveREJ(
    const CryptoHandshakeMessage* in,
    QuicCryptoClientConfig::CachedState* cached) { … }

QuicAsyncStatus QuicCryptoClientHandshaker::DoVerifyProof(
    QuicCryptoClientConfig::CachedState* cached) { … }

void QuicCryptoClientHandshaker::DoVerifyProofComplete(
    QuicCryptoClientConfig::CachedState* cached) { … }

void QuicCryptoClientHandshaker::DoReceiveSHLO(
    const CryptoHandshakeMessage* in,
    QuicCryptoClientConfig::CachedState* cached) { … }

void QuicCryptoClientHandshaker::DoInitializeServerConfigUpdate(
    QuicCryptoClientConfig::CachedState* cached) { … }

void QuicCryptoClientHandshaker::SetCachedProofValid(
    QuicCryptoClientConfig::CachedState* cached) { … }

}  // namespace quic