quic_connection.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_connection.h"

#include <string.h>
#include <sys/types.h>

#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <iterator>
#include <limits>
#include <memory>
#include <optional>
#include <ostream>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>

#include "absl/strings/escaping.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/str_format.h"
#include "absl/strings/string_view.h"
#include "quiche/quic/core/congestion_control/rtt_stats.h"
#include "quiche/quic/core/congestion_control/send_algorithm_interface.h"
#include "quiche/quic/core/crypto/crypto_protocol.h"
#include "quiche/quic/core/crypto/crypto_utils.h"
#include "quiche/quic/core/crypto/quic_decrypter.h"
#include "quiche/quic/core/crypto/quic_encrypter.h"
#include "quiche/quic/core/quic_bandwidth.h"
#include "quiche/quic/core/quic_config.h"
#include "quiche/quic/core/quic_connection_id.h"
#include "quiche/quic/core/quic_constants.h"
#include "quiche/quic/core/quic_error_codes.h"
#include "quiche/quic/core/quic_packet_creator.h"
#include "quiche/quic/core/quic_packet_writer.h"
#include "quiche/quic/core/quic_packets.h"
#include "quiche/quic/core/quic_path_validator.h"
#include "quiche/quic/core/quic_time.h"
#include "quiche/quic/core/quic_types.h"
#include "quiche/quic/core/quic_utils.h"
#include "quiche/quic/platform/api/quic_bug_tracker.h"
#include "quiche/quic/platform/api/quic_client_stats.h"
#include "quiche/quic/platform/api/quic_exported_stats.h"
#include "quiche/quic/platform/api/quic_flag_utils.h"
#include "quiche/quic/platform/api/quic_flags.h"
#include "quiche/quic/platform/api/quic_logging.h"
#include "quiche/quic/platform/api/quic_socket_address.h"
#include "quiche/common/platform/api/quiche_flag_utils.h"
#include "quiche/common/platform/api/quiche_testvalue.h"
#include "quiche/common/quiche_text_utils.h"

namespace quic {

class QuicDecrypter;
class QuicEncrypter;

namespace {

// Maximum number of consecutive sent nonretransmittable packets.
const QuicPacketCount kMaxConsecutiveNonRetransmittablePackets = …;

// The minimum release time into future in ms.
const int kMinReleaseTimeIntoFutureMs = …;

// The maximum number of recorded client addresses.
const size_t kMaxReceivedClientAddressSize = …;

// An arbitrary limit on the number of PTOs before giving up on ECN, if no ECN-
// marked packet is acked. Avoids abandoning ECN because of one burst loss,
// but doesn't allow multiple RTTs of user delay in the hope of using ECN.
const uint8_t kEcnPtoLimit = …;

// When the clearer goes out of scope, the coalesced packet gets cleared.
class ScopedCoalescedPacketClearer { … };

// Whether this incoming packet is allowed to replace our connection ID.
bool PacketCanReplaceServerConnectionId(const QuicPacketHeader& header,
                                        Perspective perspective) { … }

// Due to a lost Initial packet, a Handshake packet might use a new connection
// ID we haven't seen before. We shouldn't update the connection ID based on
// this, but should buffer the packet in case it works out.
bool NewServerConnectionIdMightBeValid(const QuicPacketHeader& header,
                                       Perspective perspective,
                                       bool connection_id_already_replaced) { … }

CongestionControlType GetDefaultCongestionControlType() { … }

bool ContainsNonProbingFrame(const SerializedPacket& packet) { … }

}  // namespace

#define ENDPOINT …

QuicConnection::QuicConnection(
    QuicConnectionId server_connection_id,
    QuicSocketAddress initial_self_address,
    QuicSocketAddress initial_peer_address,
    QuicConnectionHelperInterface* helper, QuicAlarmFactory* alarm_factory,
    QuicPacketWriter* writer, bool owns_writer, Perspective perspective,
    const ParsedQuicVersionVector& supported_versions,
    ConnectionIdGeneratorInterface& generator)
    : … { … }

void QuicConnection::InstallInitialCrypters(QuicConnectionId connection_id) { … }

QuicConnection::~QuicConnection() { … }

void QuicConnection::ClearQueuedPackets() { … }

bool QuicConnection::ValidateConfigConnectionIds(const QuicConfig& config) { … }

void QuicConnection::SetFromConfig(const QuicConfig& config) { … }

void QuicConnection::AddDispatcherSentPackets(
    absl::Span<const DispatcherSentPacket> dispatcher_sent_packets) { … }

bool QuicConnection::MaybeTestLiveness() { … }

void QuicConnection::ApplyConnectionOptions(
    const QuicTagVector& connection_options) { … }

void QuicConnection::OnSendConnectionState(
    const CachedNetworkParameters& cached_network_params) { … }

void QuicConnection::OnReceiveConnectionState(
    const CachedNetworkParameters& cached_network_params) { … }

void QuicConnection::ResumeConnectionState(
    const CachedNetworkParameters& cached_network_params,
    bool max_bandwidth_resumption) { … }

void QuicConnection::SetMaxPacingRate(QuicBandwidth max_pacing_rate) { … }

void QuicConnection::AdjustNetworkParameters(
    const SendAlgorithmInterface::NetworkParams& params) { … }

void QuicConnection::SetLossDetectionTuner(
    std::unique_ptr<LossDetectionTunerInterface> tuner) { … }

void QuicConnection::OnConfigNegotiated() { … }

QuicBandwidth QuicConnection::MaxPacingRate() const { … }

bool QuicConnection::SelectMutualVersion(
    const ParsedQuicVersionVector& available_versions) { … }

void QuicConnection::OnError(QuicFramer* framer) { … }

void QuicConnection::OnPacket() { … }

bool QuicConnection::OnProtocolVersionMismatch(
    ParsedQuicVersion received_version) { … }

// Handles version negotiation for client connection.
void QuicConnection::OnVersionNegotiationPacket(
    const QuicVersionNegotiationPacket& packet) { … }

// Handles retry for client connection.
void QuicConnection::OnRetryPacket(QuicConnectionId original_connection_id,
                                   QuicConnectionId new_connection_id,
                                   absl::string_view retry_token,
                                   absl::string_view retry_integrity_tag,
                                   absl::string_view retry_without_tag) { … }

void QuicConnection::SetOriginalDestinationConnectionId(
    const QuicConnectionId& original_destination_connection_id) { … }

QuicConnectionId QuicConnection::GetOriginalDestinationConnectionId() const { … }

void QuicConnection::RetireOriginalDestinationConnectionId() { … }

void QuicConnection::OnDiscardZeroRttDecryptionKeysAlarm() { … }

bool QuicConnection::ValidateServerConnectionId(
    const QuicPacketHeader& header) const { … }

bool QuicConnection::OnUnauthenticatedPublicHeader(
    const QuicPacketHeader& header) { … }

bool QuicConnection::OnUnauthenticatedHeader(const QuicPacketHeader& header) { … }

void QuicConnection::OnSuccessfulVersionNegotiation() { … }

void QuicConnection::OnSuccessfulMigration(bool is_port_change) { … }

void QuicConnection::OnTransportParametersSent(
    const TransportParameters& transport_parameters) const { … }

void QuicConnection::OnTransportParametersReceived(
    const TransportParameters& transport_parameters) const { … }

void QuicConnection::OnTransportParametersResumed(
    const TransportParameters& transport_parameters) const { … }

void QuicConnection::OnEncryptedClientHelloSent(
    absl::string_view client_hello) const { … }

void QuicConnection::OnEncryptedClientHelloReceived(
    absl::string_view client_hello) const { … }

bool QuicConnection::HasPendingAcks() const { … }

void QuicConnection::OnUserAgentIdKnown(const std::string& /*user_agent_id*/) { … }

void QuicConnection::OnDecryptedPacket(size_t /*length*/,
                                       EncryptionLevel level) { … }

QuicSocketAddress QuicConnection::GetEffectivePeerAddressFromCurrentPacket()
    const { … }

bool QuicConnection::OnPacketHeader(const QuicPacketHeader& header) { … }

bool QuicConnection::OnStreamFrame(const QuicStreamFrame& frame) { … }

bool QuicConnection::OnCryptoFrame(const QuicCryptoFrame& frame) { … }

bool QuicConnection::OnAckFrameStart(QuicPacketNumber largest_acked,
                                     QuicTime::Delta ack_delay_time) { … }

bool QuicConnection::OnAckRange(QuicPacketNumber start, QuicPacketNumber end) { … }

bool QuicConnection::OnAckTimestamp(QuicPacketNumber packet_number,
                                    QuicTime timestamp) { … }

bool QuicConnection::OnAckFrameEnd(
    QuicPacketNumber start, const std::optional<QuicEcnCounts>& ecn_counts) { … }

bool QuicConnection::OnStopWaitingFrame(const QuicStopWaitingFrame& /*frame*/) { … }

bool QuicConnection::OnPaddingFrame(const QuicPaddingFrame& frame) { … }

bool QuicConnection::OnPingFrame(const QuicPingFrame& frame) { … }

bool QuicConnection::OnRstStreamFrame(const QuicRstStreamFrame& frame) { … }

bool QuicConnection::OnStopSendingFrame(const QuicStopSendingFrame& frame) { … }

class ReversePathValidationContext : public QuicPathValidationContext { … };

bool QuicConnection::OnPathChallengeFrame(const QuicPathChallengeFrame& frame) { … }

bool QuicConnection::OnPathResponseFrame(const QuicPathResponseFrame& frame) { … }

bool QuicConnection::OnConnectionCloseFrame(
    const QuicConnectionCloseFrame& frame) { … }

bool QuicConnection::OnMaxStreamsFrame(const QuicMaxStreamsFrame& frame) { … }

bool QuicConnection::OnStreamsBlockedFrame(
    const QuicStreamsBlockedFrame& frame) { … }

bool QuicConnection::OnGoAwayFrame(const QuicGoAwayFrame& frame) { … }

bool QuicConnection::OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) { … }

void QuicConnection::OnClientConnectionIdAvailable() { … }

NewConnectionIdResult QuicConnection::OnNewConnectionIdFrameInner(
    const QuicNewConnectionIdFrame& frame) { … }

bool QuicConnection::OnNewConnectionIdFrame(
    const QuicNewConnectionIdFrame& frame) { … }

bool QuicConnection::OnRetireConnectionIdFrame(
    const QuicRetireConnectionIdFrame& frame) { … }

bool QuicConnection::OnNewTokenFrame(const QuicNewTokenFrame& frame) { … }

bool QuicConnection::OnMessageFrame(const QuicMessageFrame& frame) { … }

bool QuicConnection::OnHandshakeDoneFrame(const QuicHandshakeDoneFrame& frame) { … }

bool QuicConnection::OnAckFrequencyFrame(const QuicAckFrequencyFrame& frame) { … }

bool QuicConnection::OnResetStreamAtFrame(const QuicResetStreamAtFrame& frame) { … }

bool QuicConnection::OnBlockedFrame(const QuicBlockedFrame& frame) { … }

void QuicConnection::OnPacketComplete() { … }

void QuicConnection::MaybeRespondToConnectivityProbingOrMigration() { … }

bool QuicConnection::IsValidStatelessResetToken(
    const StatelessResetToken& token) const { … }

void QuicConnection::OnAuthenticatedIetfStatelessResetPacket(
    const QuicIetfStatelessResetPacket& /*packet*/) { … }

void QuicConnection::OnKeyUpdate(KeyUpdateReason reason) { … }

void QuicConnection::OnDecryptedFirstPacketInKeyPhase() { … }

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

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

void QuicConnection::ClearLastFrames() { … }

void QuicConnection::CloseIfTooManyOutstandingSentPackets() { … }

const QuicFrame QuicConnection::GetUpdatedAckFrame() { … }

QuicPacketNumber QuicConnection::GetLeastUnacked() const { … }

bool QuicConnection::HandleWriteBlocked() { … }

void QuicConnection::MaybeSendInResponseToPacket() { … }

size_t QuicConnection::SendCryptoData(EncryptionLevel level,
                                      size_t write_length,
                                      QuicStreamOffset offset) { … }

QuicConsumedData QuicConnection::SendStreamData(QuicStreamId id,
                                                size_t write_length,
                                                QuicStreamOffset offset,
                                                StreamSendingState state) { … }

bool QuicConnection::SendControlFrame(const QuicFrame& frame) { … }

void QuicConnection::OnStreamReset(QuicStreamId id,
                                   QuicRstStreamErrorCode error) { … }

const QuicConnectionStats& QuicConnection::GetStats() { … }

void QuicConnection::OnCoalescedPacket(const QuicEncryptedPacket& packet) { … }

void QuicConnection::OnUndecryptablePacket(const QuicEncryptedPacket& packet,
                                           EncryptionLevel decryption_level,
                                           bool has_decryption_key) { … }

bool QuicConnection::ShouldEnqueueUnDecryptablePacket(
    EncryptionLevel decryption_level, bool has_decryption_key) const { … }

std::string QuicConnection::UndecryptablePacketsInfo() const { … }

void QuicConnection::ProcessUdpPacket(const QuicSocketAddress& self_address,
                                      const QuicSocketAddress& peer_address,
                                      const QuicReceivedPacket& packet) { … }

void QuicConnection::OnBlockedWriterCanWrite() { … }

void QuicConnection::OnCanWrite() { … }

void QuicConnection::OnSendAlarm() { … }

void QuicConnection::WriteIfNotBlocked() { … }

void QuicConnection::MaybeClearQueuedPacketsOnPathChange() { … }

void QuicConnection::ReplaceInitialServerConnectionId(
    const QuicConnectionId& new_server_connection_id) { … }

void QuicConnection::FindMatchingOrNewClientConnectionIdOrToken(
    const PathState& default_path, const PathState& alternative_path,
    const QuicConnectionId& server_connection_id,
    QuicConnectionId* client_connection_id,
    std::optional<StatelessResetToken>* stateless_reset_token) { … }

bool QuicConnection::FindOnPathConnectionIds(
    const QuicSocketAddress& self_address,
    const QuicSocketAddress& peer_address,
    QuicConnectionId* client_connection_id,
    QuicConnectionId* server_connection_id) const { … }

void QuicConnection::SetDefaultPathState(PathState new_path_state) { … }

// TODO(wub): Inline this function when deprecating
// --quic_test_peer_addr_change_after_normalize.
bool QuicConnection::PeerAddressChanged() const { … }

bool QuicConnection::ProcessValidatedPacket(const QuicPacketHeader& header) { … }

bool QuicConnection::ValidateReceivedPacketNumber(
    QuicPacketNumber packet_number) { … }

void QuicConnection::WriteQueuedPackets() { … }

void QuicConnection::MarkZeroRttPacketsForRetransmission(int reject_reason) { … }

void QuicConnection::NeuterUnencryptedPackets() { … }

bool QuicConnection::IsMissingDestinationConnectionID() const { … }

bool QuicConnection::ShouldGeneratePacket(
    HasRetransmittableData retransmittable, IsHandshake handshake) { … }

void QuicConnection::MaybeBundleOpportunistically(
    TransmissionType transmission_type) { … }

bool QuicConnection::CanWrite(HasRetransmittableData retransmittable) { … }

QuicTime QuicConnection::CalculatePacketSentTime() { … }

bool QuicConnection::WritePacket(SerializedPacket* packet) { … }

bool QuicConnection::MaybeHandleAeadConfidentialityLimits(
    const SerializedPacket& packet) { … }

void QuicConnection::FlushPackets() { … }

bool QuicConnection::IsMsgTooBig(const QuicPacketWriter* writer,
                                 const WriteResult& result) { … }

bool QuicConnection::ShouldDiscardPacket(EncryptionLevel encryption_level) { … }

QuicTime QuicConnection::GetPathMtuReductionDeadline() const { … }

bool QuicConnection::MaybeRevertToPreviousMtu() { … }

void QuicConnection::OnWriteError(int error_code) { … }

QuicPacketBuffer QuicConnection::GetPacketBuffer() { … }

void QuicConnection::OnSerializedPacket(SerializedPacket serialized_packet) { … }

void QuicConnection::OnUnrecoverableError(QuicErrorCode error,
                                          const std::string& error_details) { … }

void QuicConnection::OnCongestionChange() { … }

void QuicConnection::OnPathMtuIncreased(QuicPacketLength packet_size) { … }

void QuicConnection::OnInFlightEcnPacketAcked() { … }

void QuicConnection::OnInvalidEcnFeedback() { … }

std::unique_ptr<QuicSelfIssuedConnectionIdManager>
QuicConnection::MakeSelfIssuedConnectionIdManager() { … }

void QuicConnection::MaybeSendConnectionIdToClient() { … }

void QuicConnection::OnHandshakeComplete() { … }

void QuicConnection::MaybeCreateMultiPortPath() { … }

void QuicConnection::SendOrQueuePacket(SerializedPacket packet) { … }

void QuicConnection::OnAckAlarm() { … }

void QuicConnection::SendAck() { … }

EncryptionLevel QuicConnection::GetEncryptionLevelToSendPingForSpace(
    PacketNumberSpace space) const { … }

bool QuicConnection::IsKnownServerAddress(
    const QuicSocketAddress& address) const { … }

QuicEcnCodepoint QuicConnection::GetEcnCodepointToSend(
    const QuicSocketAddress& destination_address) const { … }

WriteResult QuicConnection::SendPacketToWriter(
    const char* buffer, size_t buf_len, const QuicIpAddress& self_address,
    const QuicSocketAddress& destination_address, QuicPacketWriter* writer,
    const QuicEcnCodepoint ecn_codepoint) { … }

void QuicConnection::OnRetransmissionAlarm() { … }

void QuicConnection::SetEncrypter(EncryptionLevel level,
                                  std::unique_ptr<QuicEncrypter> encrypter) { … }

void QuicConnection::RemoveEncrypter(EncryptionLevel level) { … }

void QuicConnection::SetDiversificationNonce(
    const DiversificationNonce& nonce) { … }

void QuicConnection::SetDefaultEncryptionLevel(EncryptionLevel level) { … }

void QuicConnection::SetDecrypter(EncryptionLevel level,
                                  std::unique_ptr<QuicDecrypter> decrypter) { … }

void QuicConnection::SetAlternativeDecrypter(
    EncryptionLevel level, std::unique_ptr<QuicDecrypter> decrypter,
    bool latch_once_used) { … }

void QuicConnection::InstallDecrypter(
    EncryptionLevel level, std::unique_ptr<QuicDecrypter> decrypter) { … }

void QuicConnection::RemoveDecrypter(EncryptionLevel level) { … }

void QuicConnection::OnDiscardPreviousOneRttKeysAlarm() { … }

bool QuicConnection::IsKeyUpdateAllowed() const { … }

bool QuicConnection::HaveSentPacketsInCurrentKeyPhaseButNoneAcked() const { … }

QuicPacketCount QuicConnection::PotentialPeerKeyUpdateAttemptCount() const { … }

bool QuicConnection::InitiateKeyUpdate(KeyUpdateReason reason) { … }

const QuicDecrypter* QuicConnection::decrypter() const { … }

const QuicDecrypter* QuicConnection::alternative_decrypter() const { … }

void QuicConnection::QueueUndecryptablePacket(
    const QuicEncryptedPacket& packet, EncryptionLevel decryption_level) { … }

void QuicConnection::OnProcessUndecryptablePacketsAlarm() { … }

void QuicConnection::MaybeProcessUndecryptablePackets() { … }

void QuicConnection::QueueCoalescedPacket(const QuicEncryptedPacket& packet) { … }

bool QuicConnection::MaybeProcessCoalescedPackets() { … }

void QuicConnection::CloseConnection(
    QuicErrorCode error, const std::string& details,
    ConnectionCloseBehavior connection_close_behavior) { … }

void QuicConnection::CloseConnection(
    QuicErrorCode error, QuicIetfTransportErrorCodes ietf_error,
    const std::string& error_details,
    ConnectionCloseBehavior connection_close_behavior) { … }

void QuicConnection::SendConnectionClosePacket(
    QuicErrorCode error, QuicIetfTransportErrorCodes ietf_error,
    const std::string& details) { … }

void QuicConnection::TearDownLocalConnectionState(
    QuicErrorCode error, QuicIetfTransportErrorCodes ietf_error,
    const std::string& error_details, ConnectionCloseSource source) { … }

void QuicConnection::TearDownLocalConnectionState(
    const QuicConnectionCloseFrame& frame, ConnectionCloseSource source) { … }

void QuicConnection::CancelAllAlarms() { … }

QuicByteCount QuicConnection::max_packet_length() const { … }

void QuicConnection::SetMaxPacketLength(QuicByteCount length) { … }

bool QuicConnection::HasQueuedData() const { … }

void QuicConnection::SetNetworkTimeouts(QuicTime::Delta handshake_timeout,
                                        QuicTime::Delta idle_timeout) { … }

void QuicConnection::SetPingAlarm() { … }

void QuicConnection::SetRetransmissionAlarm() { … }

void QuicConnection::MaybeSetMtuAlarm(QuicPacketNumber sent_packet_number) { … }

QuicConnection::ScopedPacketFlusher::ScopedPacketFlusher(
    QuicConnection* connection)
    : … { … }

QuicConnection::ScopedPacketFlusher::~ScopedPacketFlusher() { … }

QuicConnection::ScopedEncryptionLevelContext::ScopedEncryptionLevelContext(
    QuicConnection* connection, EncryptionLevel encryption_level)
    : … { … }

QuicConnection::ScopedEncryptionLevelContext::~ScopedEncryptionLevelContext() { … }

QuicConnection::BufferedPacket::BufferedPacket(
    const SerializedPacket& packet, const QuicSocketAddress& self_address,
    const QuicSocketAddress& peer_address, const QuicEcnCodepoint ecn_codepoint)
    : … { … }

QuicConnection::BufferedPacket::BufferedPacket(
    const char* encrypted_buffer, QuicPacketLength encrypted_length,
    const QuicSocketAddress& self_address,
    const QuicSocketAddress& peer_address, const QuicEcnCodepoint ecn_codepoint)
    : … { … }

QuicConnection::BufferedPacket::BufferedPacket(
    QuicRandom& random, QuicPacketLength encrypted_length,
    const QuicSocketAddress& self_address,
    const QuicSocketAddress& peer_address)
    : … { … }

QuicConnection::ReceivedPacketInfo::ReceivedPacketInfo(QuicTime receipt_time)
    : … { … }
QuicConnection::ReceivedPacketInfo::ReceivedPacketInfo(
    const QuicSocketAddress& destination_address,
    const QuicSocketAddress& source_address, QuicTime receipt_time,
    QuicByteCount length, QuicEcnCodepoint ecn_codepoint)
    : … { … }

std::ostream& operator<<(std::ostream& os,
                         const QuicConnection::ReceivedPacketInfo& info) { … }

HasRetransmittableData QuicConnection::IsRetransmittable(
    const SerializedPacket& packet) { … }

bool QuicConnection::IsTerminationPacket(const SerializedPacket& packet,
                                         QuicErrorCode* error_code) { … }

void QuicConnection::SetMtuDiscoveryTarget(QuicByteCount target) { … }

QuicByteCount QuicConnection::GetLimitedMaxPacketSize(
    QuicByteCount suggested_max_packet_size) { … }

void QuicConnection::SendMtuDiscoveryPacket(QuicByteCount target_mtu) { … }

// TODO(zhongyi): change this method to generate a connectivity probing packet
// and let the caller to call writer to write the packet and handle write
// status.
bool QuicConnection::SendConnectivityProbingPacket(
    QuicPacketWriter* probing_writer, const QuicSocketAddress& peer_address) { … }

bool QuicConnection::WritePacketUsingWriter(
    std::unique_ptr<SerializedPacket> packet, QuicPacketWriter* writer,
    const QuicSocketAddress& self_address,
    const QuicSocketAddress& peer_address, bool measure_rtt) { … }

void QuicConnection::DisableMtuDiscovery() { … }

void QuicConnection::OnMtuDiscoveryAlarm() { … }

void QuicConnection::OnEffectivePeerMigrationValidated(
    bool /*is_migration_linkable*/) { … }

void QuicConnection::StartEffectivePeerMigration(AddressChangeType type) { … }

void QuicConnection::OnConnectionMigration() { … }

bool QuicConnection::IsCurrentPacketConnectivityProbing() const { … }

bool QuicConnection::ack_frame_updated() const { … }

absl::string_view QuicConnection::GetCurrentPacket() { … }

bool QuicConnection::MaybeConsiderAsMemoryCorruption(
    const QuicStreamFrame& frame) { … }

void QuicConnection::CheckIfApplicationLimited() { … }

bool QuicConnection::UpdatePacketContent(QuicFrameType type) { … }

void QuicConnection::MaybeStartIetfPeerMigration() { … }

void QuicConnection::PostProcessAfterAckFrame(bool acked_new_packet) { … }

void QuicConnection::SetSessionNotifier(
    SessionNotifierInterface* session_notifier) { … }

void QuicConnection::SetDataProducer(
    QuicStreamFrameDataProducer* data_producer) { … }

void QuicConnection::SetTransmissionType(TransmissionType type) { … }

void QuicConnection::UpdateReleaseTimeIntoFuture() { … }

void QuicConnection::ResetAckStates() { … }

MessageStatus QuicConnection::SendMessage(
    QuicMessageId message_id, absl::Span<quiche::QuicheMemSlice> message,
    bool flush) { … }

QuicPacketLength QuicConnection::GetCurrentLargestMessagePayload() const { … }

QuicPacketLength QuicConnection::GetGuaranteedLargestMessagePayload() const { … }

uint32_t QuicConnection::cipher_id() const { … }

EncryptionLevel QuicConnection::GetConnectionCloseEncryptionLevel() const { … }

void QuicConnection::MaybeBundleCryptoDataWithAcks() { … }

void QuicConnection::SendAllPendingAcks() { … }

bool QuicConnection::ShouldBundleRetransmittableFrameWithAck() const { … }

void QuicConnection::MaybeCoalescePacketOfHigherSpace() { … }

bool QuicConnection::FlushCoalescedPacket() { … }

void QuicConnection::MaybeEnableMultiplePacketNumberSpacesSupport() { … }

bool QuicConnection::SupportsMultiplePacketNumberSpaces() const { … }

void QuicConnection::SetLargestReceivedPacketWithAck(
    QuicPacketNumber new_value) { … }

void QuicConnection::OnForwardProgressMade() { … }

QuicPacketNumber QuicConnection::GetLargestReceivedPacketWithAck() const { … }

QuicPacketNumber QuicConnection::GetLargestAckedPacket() const { … }

QuicPacketNumber QuicConnection::GetLargestReceivedPacket() const { … }

bool QuicConnection::EnforceAntiAmplificationLimit() const { … }

// TODO(danzh) Pass in path object or its reference of some sort to use this
// method to check anti-amplification limit on non-default path.
bool QuicConnection::LimitedByAmplificationFactor(QuicByteCount bytes) const { … }

SerializedPacketFate QuicConnection::GetSerializedPacketFate(
    bool is_mtu_discovery, EncryptionLevel encryption_level) { … }

bool QuicConnection::IsHandshakeComplete() const { … }

bool QuicConnection::IsHandshakeConfirmed() const { … }

size_t QuicConnection::min_received_before_ack_decimation() const { … }

void QuicConnection::set_min_received_before_ack_decimation(size_t new_value) { … }

const QuicAckFrame& QuicConnection::ack_frame() const { … }

void QuicConnection::set_client_connection_id(
    QuicConnectionId client_connection_id) { … }

void QuicConnection::OnPathDegradingDetected() { … }

void QuicConnection::MaybeMigrateToMultiPortPath() { … }

void QuicConnection::OnBlackholeDetected() { … }

void QuicConnection::OnPathMtuReductionDetected() { … }

void QuicConnection::OnHandshakeTimeout() { … }

void QuicConnection::OnIdleNetworkDetected() { … }

void QuicConnection::OnKeepAliveTimeout() { … }

void QuicConnection::OnRetransmittableOnWireTimeout() { … }

void QuicConnection::OnPeerIssuedConnectionIdRetired() { … }

bool QuicConnection::SendNewConnectionId(
    const QuicNewConnectionIdFrame& frame) { … }

bool QuicConnection::MaybeReserveConnectionId(
    const QuicConnectionId& connection_id) { … }

void QuicConnection::OnSelfIssuedConnectionIdRetired(
    const QuicConnectionId& connection_id) { … }

void QuicConnection::MaybeUpdateAckTimeout() { … }

QuicTime QuicConnection::GetPathDegradingDeadline() const { … }

bool QuicConnection::ShouldDetectPathDegrading() const { … }

QuicTime QuicConnection::GetNetworkBlackholeDeadline() const { … }

// static
QuicTime::Delta QuicConnection::CalculateNetworkBlackholeDelay(
    QuicTime::Delta blackhole_delay, QuicTime::Delta path_degrading_delay,
    QuicTime::Delta pto_delay) { … }

void QuicConnection::AddKnownServerAddress(const QuicSocketAddress& address) { … }

std::optional<QuicNewConnectionIdFrame>
QuicConnection::MaybeIssueNewConnectionIdForPreferredAddress() { … }

bool QuicConnection::ShouldDetectBlackhole() const { … }

QuicTime QuicConnection::GetRetransmissionDeadline() const { … }

bool QuicConnection::SendPathChallenge(
    const QuicPathFrameBuffer& data_buffer,
    const QuicSocketAddress& self_address,
    const QuicSocketAddress& peer_address,
    const QuicSocketAddress& effective_peer_address, QuicPacketWriter* writer) { … }

QuicTime QuicConnection::GetRetryTimeout(
    const QuicSocketAddress& peer_address_to_use,
    QuicPacketWriter* writer_to_use) const { … }

void QuicConnection::ValidatePath(
    std::unique_ptr<QuicPathValidationContext> context,
    std::unique_ptr<QuicPathValidator::ResultDelegate> result_delegate,
    PathValidationReason reason) { … }

bool QuicConnection::SendPathResponse(
    const QuicPathFrameBuffer& data_buffer,
    const QuicSocketAddress& peer_address_to_send,
    const QuicSocketAddress& effective_peer_address) { … }

void QuicConnection::UpdatePeerAddress(QuicSocketAddress peer_address) { … }

void QuicConnection::SendPingAtLevel(EncryptionLevel level) { … }

bool QuicConnection::HasPendingPathValidation() const { … }

QuicPathValidationContext* QuicConnection::GetPathValidationContext() const { … }

void QuicConnection::CancelPathValidation() { … }

bool QuicConnection::UpdateConnectionIdsOnMigration(
    const QuicSocketAddress& self_address,
    const QuicSocketAddress& peer_address) { … }

void QuicConnection::RetirePeerIssuedConnectionIdsNoLongerOnPath() { … }

bool QuicConnection::MigratePath(const QuicSocketAddress& self_address,
                                 const QuicSocketAddress& peer_address,
                                 QuicPacketWriter* writer, bool owns_writer) { … }

void QuicConnection::OnPathValidationFailureAtClient(
    bool is_multi_port, const QuicPathValidationContext& context) { … }

QuicConnectionId QuicConnection::GetOneActiveServerConnectionId() const { … }

std::vector<QuicConnectionId> QuicConnection::GetActiveServerConnectionIds()
    const { … }

void QuicConnection::CreateConnectionIdManager() { … }

void QuicConnection::QuicBugIfHasPendingFrames(QuicStreamId id) const { … }

void QuicConnection::SetUnackedMapInitialCapacity() { … }

void QuicConnection::SetSourceAddressTokenToSend(absl::string_view token) { … }

void QuicConnection::MaybeUpdateBytesSentToAlternativeAddress(
    const QuicSocketAddress& peer_address, QuicByteCount sent_packet_size) { … }

void QuicConnection::MaybeUpdateBytesReceivedFromAlternativeAddress(
    QuicByteCount received_packet_size) { … }

bool QuicConnection::IsDefaultPath(
    const QuicSocketAddress& self_address,
    const QuicSocketAddress& peer_address) const { … }

bool QuicConnection::IsAlternativePath(
    const QuicSocketAddress& self_address,
    const QuicSocketAddress& peer_address) const { … }

void QuicConnection::PathState::Clear() { … }

QuicConnection::PathState::PathState(PathState&& other) { … }

QuicConnection::PathState& QuicConnection::PathState::operator=(
    QuicConnection::PathState&& other) { … }

bool QuicConnection::IsReceivedPeerAddressValidated() const { … }

void QuicConnection::OnMultiPortPathProbingSuccess(
    std::unique_ptr<QuicPathValidationContext> context, QuicTime start_time) { … }

void QuicConnection::MaybeProbeMultiPortPath() { … }

void QuicConnection::ContextObserver::OnMultiPortPathContextAvailable(
    std::unique_ptr<QuicPathValidationContext> path_context) { … }

QuicConnection::MultiPortPathValidationResultDelegate::
    MultiPortPathValidationResultDelegate(QuicConnection* connection)
    : … { … }

void QuicConnection::MultiPortPathValidationResultDelegate::
    OnPathValidationSuccess(std::unique_ptr<QuicPathValidationContext> context,
                            QuicTime start_time) { … }

void QuicConnection::MultiPortPathValidationResultDelegate::
    OnPathValidationFailure(
        std::unique_ptr<QuicPathValidationContext> context) { … }

QuicConnection::ReversePathValidationResultDelegate::
    ReversePathValidationResultDelegate(
        QuicConnection* connection,
        const QuicSocketAddress& direct_peer_address)
    : … { … }

void QuicConnection::ReversePathValidationResultDelegate::
    OnPathValidationSuccess(std::unique_ptr<QuicPathValidationContext> context,
                            QuicTime start_time) { … }

void QuicConnection::ReversePathValidationResultDelegate::
    OnPathValidationFailure(
        std::unique_ptr<QuicPathValidationContext> context) { … }

QuicConnection::ScopedRetransmissionTimeoutIndicator::
    ScopedRetransmissionTimeoutIndicator(QuicConnection* connection)
    : … { … }

QuicConnection::ScopedRetransmissionTimeoutIndicator::
    ~ScopedRetransmissionTimeoutIndicator() { … }

void QuicConnection::RestoreToLastValidatedPath(
    QuicSocketAddress original_direct_peer_address) { … }

std::unique_ptr<SendAlgorithmInterface>
QuicConnection::OnPeerIpAddressChanged() { … }

void QuicConnection::set_keep_alive_ping_timeout(
    QuicTime::Delta keep_alive_ping_timeout) { … }

void QuicConnection::set_initial_retransmittable_on_wire_timeout(
    QuicTime::Delta retransmittable_on_wire_timeout) { … }

bool QuicConnection::IsValidatingServerPreferredAddress() const { … }

void QuicConnection::OnServerPreferredAddressValidated(
    QuicPathValidationContext& context, bool owns_writer) { … }

bool QuicConnection::set_ecn_codepoint(QuicEcnCodepoint ecn_codepoint) { … }

void QuicConnection::OnIdleDetectorAlarm() { … }

void QuicConnection::OnPingAlarm() { … }

void QuicConnection::OnNetworkBlackholeDetectorAlarm() { … }

std::unique_ptr<SerializedPacket>
QuicConnection::SerializeLargePacketNumberConnectionClosePacket(
    QuicErrorCode error, const std::string& error_details) { … }

#undef ENDPOINT  // undef for jumbo builds

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