quic_crypto_client_stream.cc | Explore in Territory

// 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_stream.h"

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

#include "quiche/quic/core/crypto/crypto_protocol.h"
#include "quiche/quic/core/crypto/crypto_utils.h"
#include "quiche/quic/core/crypto/null_encrypter.h"
#include "quiche/quic/core/crypto/quic_crypto_client_config.h"
#include "quiche/quic/core/quic_crypto_client_handshaker.h"
#include "quiche/quic/core/quic_packets.h"
#include "quiche/quic/core/quic_session.h"
#include "quiche/quic/core/quic_utils.h"
#include "quiche/quic/core/tls_client_handshaker.h"
#include "quiche/quic/platform/api/quic_flags.h"
#include "quiche/quic/platform/api/quic_logging.h"

namespace quic {

const int QuicCryptoClientStream::kMaxClientHellos;

QuicCryptoClientStreamBase::QuicCryptoClientStreamBase(QuicSession* session)
    : … { … }

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

QuicCryptoClientStream::~QuicCryptoClientStream() { … }

bool QuicCryptoClientStream::CryptoConnect() { … }

int QuicCryptoClientStream::num_sent_client_hellos() const { … }

bool QuicCryptoClientStream::ResumptionAttempted() const { … }

bool QuicCryptoClientStream::IsResumption() const { … }

bool QuicCryptoClientStream::EarlyDataAccepted() const { … }

ssl_early_data_reason_t QuicCryptoClientStream::EarlyDataReason() const { … }

bool QuicCryptoClientStream::ReceivedInchoateReject() const { … }

int QuicCryptoClientStream::num_scup_messages_received() const { … }

bool QuicCryptoClientStream::encryption_established() const { … }

bool QuicCryptoClientStream::one_rtt_keys_available() const { … }

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

CryptoMessageParser* QuicCryptoClientStream::crypto_message_parser() { … }

HandshakeState QuicCryptoClientStream::GetHandshakeState() const { … }

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

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

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

bool QuicCryptoClientStream::ExportKeyingMaterial(absl::string_view label,
                                                  absl::string_view context,
                                                  size_t result_len,
                                                  std::string* result) { … }

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

void QuicCryptoClientStream::OnOneRttPacketAcknowledged() { … }

void QuicCryptoClientStream::OnHandshakePacketSent() { … }

void QuicCryptoClientStream::OnConnectionClosed(
    const QuicConnectionCloseFrame& frame, ConnectionCloseSource source) { … }

void QuicCryptoClientStream::OnHandshakeDoneReceived() { … }

void QuicCryptoClientStream::OnNewTokenReceived(absl::string_view token) { … }

void QuicCryptoClientStream::SetServerApplicationStateForResumption(
    std::unique_ptr<ApplicationState> application_state) { … }

SSL* QuicCryptoClientStream::GetSsl() const { … }

bool QuicCryptoClientStream::IsCryptoFrameExpectedForEncryptionLevel(
    EncryptionLevel level) const { … }

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

}  // namespace quic
chromium/net/third_party/quiche/src/quiche/quic/core/quic_crypto_client_stream.cc
