Move more information of last received packet to QuicConnection::ReceivedPacketInfo, and log received packet info if there is pending frames of a closed stream. PiperOrigin-RevId: 443719083
diff --git a/quiche/quic/core/quic_connection.cc b/quiche/quic/core/quic_connection.cc index 34f6b74..4ce6658 100644 --- a/quiche/quic/core/quic_connection.cc +++ b/quiche/quic/core/quic_connection.cc
@@ -260,10 +260,7 @@ /*stateless_reset_token=*/absl::nullopt), active_effective_peer_migration_type_(NO_CHANGE), support_key_update_for_connection_(false), - last_packet_decrypted_(false), - last_size_(0), current_packet_data_(nullptr), - last_decrypted_packet_level_(ENCRYPTION_INITIAL), should_last_packet_instigate_acks_(false), max_undecryptable_packets_(0), max_tracked_packets_(GetQuicFlag(FLAGS_quic_max_tracked_packet_count)), @@ -328,7 +325,6 @@ alarm_factory_, &context_), path_validator_(alarm_factory_, &arena_, this, random_generator_, &context_), - most_recent_frame_type_(NUM_FRAME_TYPES), ping_manager_(perspective, this, &arena_, alarm_factory_, &context_) { QUICHE_DCHECK(perspective_ == Perspective::IS_CLIENT || default_path_.self_address.IsInitialized()); @@ -814,14 +810,16 @@ void QuicConnection::OnError(QuicFramer* framer) { // Packets that we can not or have not decrypted are dropped. // TODO(rch): add stats to measure this. - if (!connected_ || last_packet_decrypted_ == false) { + if (!connected_ || !last_received_packet_info_.decrypted) { return; } CloseConnection(framer->error(), framer->detailed_error(), ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET); } -void QuicConnection::OnPacket() { last_packet_decrypted_ = false; } +void QuicConnection::OnPacket() { + last_received_packet_info_.decrypted = false; +} void QuicConnection::OnPublicResetPacket(const QuicPublicResetPacket& packet) { // Check that any public reset packet with a different connection ID that was @@ -1012,15 +1010,16 @@ bool QuicConnection::OnUnauthenticatedPublicHeader( const QuicPacketHeader& header) { - last_packet_destination_connection_id_ = header.destination_connection_id; + last_received_packet_info_.destination_connection_id = + header.destination_connection_id; // If last packet destination connection ID is the original server // connection ID chosen by client, replaces it with the connection ID chosen // by server. if (perspective_ == Perspective::IS_SERVER && original_destination_connection_id_.has_value() && - last_packet_destination_connection_id_ == + last_received_packet_info_.destination_connection_id == *original_destination_connection_id_) { - last_packet_destination_connection_id_ = + last_received_packet_info_.destination_connection_id = original_destination_connection_id_replacement_; } @@ -1163,8 +1162,8 @@ void QuicConnection::OnDecryptedPacket(size_t /*length*/, EncryptionLevel level) { - last_decrypted_packet_level_ = level; - last_packet_decrypted_ = true; + last_received_packet_info_.decrypted_level = level; + last_received_packet_info_.decrypted = true; if (level == ENCRYPTION_FORWARD_SECURE && !have_decrypted_first_one_rtt_packet_) { have_decrypted_first_one_rtt_packet_ = true; @@ -1180,8 +1179,7 @@ } } if (EnforceAntiAmplificationLimit() && !IsHandshakeConfirmed() && - (last_decrypted_packet_level_ == ENCRYPTION_HANDSHAKE || - last_decrypted_packet_level_ == ENCRYPTION_FORWARD_SECURE)) { + (level == ENCRYPTION_HANDSHAKE || level == ENCRYPTION_FORWARD_SECURE)) { // Address is validated by successfully processing a HANDSHAKE or 1-RTT // packet. default_path_.validated = true; @@ -1203,7 +1201,7 @@ bool QuicConnection::OnPacketHeader(const QuicPacketHeader& header) { if (debug_visitor_ != nullptr) { debug_visitor_->OnPacketHeader(header, clock_->ApproximateNow(), - last_decrypted_packet_level_); + last_received_packet_info_.decrypted_level); } // Will be decremented below if we fall through to return true. @@ -1214,7 +1212,6 @@ } // Initialize the current packet content state. - most_recent_frame_type_ = NUM_FRAME_TYPES; current_packet_content_ = NO_FRAMES_RECEIVED; is_current_packet_connectivity_probing_ = false; has_path_challenge_in_current_packet_ = false; @@ -1257,30 +1254,30 @@ // connection ID set on path. // 1) If client uses 1 unique server connection ID per path and the packet // is received from an existing path, then - // last_packet_destination_connection_id_ will always be the same as the - // server connection ID on path. Server side will maintain the 1-to-1 - // mapping from server connection ID to path. - // 2) If client uses multiple server connection IDs on the same path, - // compared to the server_connection_id on path, - // last_packet_destination_connection_id_ has the advantage that it is - // still present in the session map since the packet can be routed here - // regardless of packet reordering. + // last_received_packet_info_.destination_connection_id will always be the + // same as the server connection ID on path. Server side will maintain the + // 1-to-1 mapping from server connection ID to path. 2) If client uses + // multiple server connection IDs on the same path, compared to the + // server_connection_id on path, + // last_received_packet_info_.destination_connection_id has the advantage + // that it is still present in the session map since the packet can be + // routed here regardless of packet reordering. if (IsDefaultPath(last_received_packet_info_.destination_address, effective_peer_address)) { default_path_.server_connection_id = - last_packet_destination_connection_id_; + last_received_packet_info_.destination_connection_id; } else if (IsAlternativePath( last_received_packet_info_.destination_address, effective_peer_address)) { alternative_path_.server_connection_id = - last_packet_destination_connection_id_; + last_received_packet_info_.destination_connection_id; } } - if (last_packet_destination_connection_id_ != + if (last_received_packet_info_.destination_connection_id != default_path_.server_connection_id && (!original_destination_connection_id_.has_value() || - last_packet_destination_connection_id_ != + last_received_packet_info_.destination_connection_id != *original_destination_connection_id_)) { QUIC_CODE_COUNT(quic_connection_id_change); } @@ -1295,9 +1292,10 @@ --stats_.packets_dropped; QUIC_DVLOG(1) << ENDPOINT << "Received packet header: " << header; - last_header_ = header; + last_received_packet_info_.header = header; if (!stats_.first_decrypted_packet.IsInitialized()) { - stats_.first_decrypted_packet = last_header_.packet_number; + stats_.first_decrypted_packet = + last_received_packet_info_.header.packet_number; } // Record packet receipt to populate ack info before processing stream @@ -1307,7 +1305,8 @@ receipt_time = last_received_packet_info_.receipt_time; } uber_received_packet_manager_.RecordPacketReceived( - last_decrypted_packet_level_, last_header_, receipt_time); + last_received_packet_info_.decrypted_level, + last_received_packet_info_.header, receipt_time); if (EnforceAntiAmplificationLimit() && !IsHandshakeConfirmed() && !header.retry_token.empty() && visitor_->ValidateToken(header.retry_token)) { @@ -1322,8 +1321,9 @@ bool QuicConnection::OnStreamFrame(const QuicStreamFrame& frame) { QUIC_BUG_IF(quic_bug_12714_3, !connected_) - << "Processing STREAM frame when connection is closed. Last frame: " - << most_recent_frame_type_; + << "Processing STREAM frame when connection is closed. Received packet " + "info: " + << last_received_packet_info_; // Since a stream frame was received, this is not a connectivity probe. // A probe only contains a PING and full padding. @@ -1335,7 +1335,7 @@ debug_visitor_->OnStreamFrame(frame); } if (!QuicUtils::IsCryptoStreamId(transport_version(), frame.stream_id) && - last_decrypted_packet_level_ == ENCRYPTION_INITIAL) { + last_received_packet_info_.decrypted_level == ENCRYPTION_INITIAL) { if (MaybeConsiderAsMemoryCorruption(frame)) { CloseConnection(QUIC_MAYBE_CORRUPTED_MEMORY, "Received crypto frame on non crypto stream.", @@ -1345,7 +1345,7 @@ QUIC_PEER_BUG(quic_peer_bug_10511_6) << ENDPOINT << "Received an unencrypted data frame: closing connection" - << " packet_number:" << last_header_.packet_number + << " packet_number:" << last_received_packet_info_.header.packet_number << " stream_id:" << frame.stream_id << " received_packets:" << ack_frame(); CloseConnection(QUIC_UNENCRYPTED_STREAM_DATA, @@ -1369,8 +1369,9 @@ bool QuicConnection::OnCryptoFrame(const QuicCryptoFrame& frame) { QUIC_BUG_IF(quic_bug_12714_4, !connected_) - << "Processing CRYPTO frame when connection is closed. Last frame: " - << most_recent_frame_type_; + << "Processing CRYPTO frame when connection is closed. Received packet " + "info: " + << last_received_packet_info_; // Since a CRYPTO frame was received, this is not a connectivity probe. // A probe only contains a PING and full padding. @@ -1389,8 +1390,9 @@ bool QuicConnection::OnAckFrameStart(QuicPacketNumber largest_acked, QuicTime::Delta ack_delay_time) { QUIC_BUG_IF(quic_bug_12714_5, !connected_) - << "Processing ACK frame start when connection is closed. Last frame: " - << most_recent_frame_type_; + << "Processing ACK frame start when connection is closed. Received " + "packet info: " + << last_received_packet_info_; if (processing_ack_frame_) { CloseConnection(QUIC_INVALID_ACK_DATA, @@ -1409,7 +1411,8 @@ << "OnAckFrameStart, largest_acked: " << largest_acked; if (GetLargestReceivedPacketWithAck().IsInitialized() && - last_header_.packet_number <= GetLargestReceivedPacketWithAck()) { + last_received_packet_info_.header.packet_number <= + GetLargestReceivedPacketWithAck()) { QUIC_DLOG(INFO) << ENDPOINT << "Received an old ack frame: ignoring"; return true; } @@ -1421,8 +1424,8 @@ << " vs " << sent_packet_manager_.GetLargestSentPacket() << ". SupportsMultiplePacketNumberSpaces():" << SupportsMultiplePacketNumberSpaces() - << ", last_decrypted_packet_level_:" - << last_decrypted_packet_level_; + << ", last_received_packet_info_.decrypted_level:" + << last_received_packet_info_.decrypted_level; // We got an ack for data we have not sent. CloseConnection(QUIC_INVALID_ACK_DATA, "Largest observed too high.", ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET); @@ -1437,12 +1440,14 @@ bool QuicConnection::OnAckRange(QuicPacketNumber start, QuicPacketNumber end) { QUIC_BUG_IF(quic_bug_12714_6, !connected_) - << "Processing ACK frame range when connection is closed. Last frame: " - << most_recent_frame_type_; + << "Processing ACK frame range when connection is closed. Received " + "packet info: " + << last_received_packet_info_; QUIC_DVLOG(1) << ENDPOINT << "OnAckRange: [" << start << ", " << end << ")"; if (GetLargestReceivedPacketWithAck().IsInitialized() && - last_header_.packet_number <= GetLargestReceivedPacketWithAck()) { + last_received_packet_info_.header.packet_number <= + GetLargestReceivedPacketWithAck()) { QUIC_DLOG(INFO) << ENDPOINT << "Received an old ack frame: ignoring"; return true; } @@ -1454,14 +1459,15 @@ bool QuicConnection::OnAckTimestamp(QuicPacketNumber packet_number, QuicTime timestamp) { QUIC_BUG_IF(quic_bug_10511_7, !connected_) - << "Processing ACK frame time stamp when connection " - "is closed. Last frame: " - << most_recent_frame_type_; + << "Processing ACK frame time stamp when connection is closed. Received " + "packet info: " + << last_received_packet_info_; QUIC_DVLOG(1) << ENDPOINT << "OnAckTimestamp: [" << packet_number << ", " << timestamp.ToDebuggingValue() << ")"; if (GetLargestReceivedPacketWithAck().IsInitialized() && - last_header_.packet_number <= GetLargestReceivedPacketWithAck()) { + last_received_packet_info_.header.packet_number <= + GetLargestReceivedPacketWithAck()) { QUIC_DLOG(INFO) << ENDPOINT << "Received an old ack frame: ignoring"; return true; } @@ -1472,12 +1478,14 @@ bool QuicConnection::OnAckFrameEnd(QuicPacketNumber start) { QUIC_BUG_IF(quic_bug_12714_7, !connected_) - << "Processing ACK frame end when connection is closed. Last frame: " - << most_recent_frame_type_; + << "Processing ACK frame end when connection is closed. Received packet " + "info: " + << last_received_packet_info_; QUIC_DVLOG(1) << ENDPOINT << "OnAckFrameEnd, start: " << start; if (GetLargestReceivedPacketWithAck().IsInitialized() && - last_header_.packet_number <= GetLargestReceivedPacketWithAck()) { + last_received_packet_info_.header.packet_number <= + GetLargestReceivedPacketWithAck()) { QUIC_DLOG(INFO) << ENDPOINT << "Received an old ack frame: ignoring"; return true; } @@ -1487,7 +1495,8 @@ sent_packet_manager_.zero_rtt_packet_acked(); const AckResult ack_result = sent_packet_manager_.OnAckFrameEnd( idle_network_detector_.time_of_last_received_packet(), - last_header_.packet_number, last_decrypted_packet_level_); + last_received_packet_info_.header.packet_number, + last_received_packet_info_.decrypted_level); if (ack_result != PACKETS_NEWLY_ACKED && ack_result != NO_PACKETS_NEWLY_ACKED) { // Error occurred (e.g., this ACK tries to ack packets in wrong packet @@ -1516,7 +1525,8 @@ // Update pace time into future because smoothed RTT is likely updated. UpdateReleaseTimeIntoFuture(); } - SetLargestReceivedPacketWithAck(last_header_.packet_number); + SetLargestReceivedPacketWithAck( + last_received_packet_info_.header.packet_number); // If the incoming ack's packets set expresses missing packets: peer is still // waiting for a packet lower than a packet that we are no longer planning to // send. @@ -1533,8 +1543,9 @@ bool QuicConnection::OnStopWaitingFrame(const QuicStopWaitingFrame& frame) { QUIC_BUG_IF(quic_bug_12714_8, !connected_) - << "Processing STOP_WAITING frame when connection is closed. Last frame: " - << most_recent_frame_type_; + << "Processing STOP_WAITING frame when connection is closed. Received " + "packet info: " + << last_received_packet_info_; // Since a stop waiting frame was received, this is not a connectivity probe. // A probe only contains a PING and full padding. @@ -1546,7 +1557,8 @@ return true; } if (largest_seen_packet_with_stop_waiting_.IsInitialized() && - last_header_.packet_number <= largest_seen_packet_with_stop_waiting_) { + last_received_packet_info_.header.packet_number <= + largest_seen_packet_with_stop_waiting_) { QUIC_DLOG(INFO) << ENDPOINT << "Received an old stop waiting frame: ignoring"; return true; @@ -1563,16 +1575,18 @@ debug_visitor_->OnStopWaitingFrame(frame); } - largest_seen_packet_with_stop_waiting_ = last_header_.packet_number; + largest_seen_packet_with_stop_waiting_ = + last_received_packet_info_.header.packet_number; uber_received_packet_manager_.DontWaitForPacketsBefore( - last_decrypted_packet_level_, frame.least_unacked); + last_received_packet_info_.decrypted_level, frame.least_unacked); return connected_; } bool QuicConnection::OnPaddingFrame(const QuicPaddingFrame& frame) { QUIC_BUG_IF(quic_bug_12714_9, !connected_) - << "Processing PADDING frame when connection is closed. Last frame: " - << most_recent_frame_type_; + << "Processing PADDING frame when connection is closed. Received packet " + "info: " + << last_received_packet_info_; if (!UpdatePacketContent(PADDING_FRAME)) { return false; } @@ -1585,8 +1599,9 @@ bool QuicConnection::OnPingFrame(const QuicPingFrame& frame) { QUIC_BUG_IF(quic_bug_12714_10, !connected_) - << "Processing PING frame when connection is closed. Last frame: " - << most_recent_frame_type_; + << "Processing PING frame when connection is closed. Received packet " + "info: " + << last_received_packet_info_; if (!UpdatePacketContent(PING_FRAME)) { return false; } @@ -1616,11 +1631,12 @@ return "Least unacked too small."; } - if (stop_waiting.least_unacked > last_header_.packet_number) { + if (stop_waiting.least_unacked > + last_received_packet_info_.header.packet_number) { QUIC_DLOG(ERROR) << ENDPOINT << "Peer sent least_unacked:" << stop_waiting.least_unacked << " greater than the enclosing packet number:" - << last_header_.packet_number; + << last_received_packet_info_.header.packet_number; return "Least unacked too large."; } @@ -1629,8 +1645,9 @@ bool QuicConnection::OnRstStreamFrame(const QuicRstStreamFrame& frame) { QUIC_BUG_IF(quic_bug_12714_11, !connected_) - << "Processing RST_STREAM frame when connection is closed. Last frame: " - << most_recent_frame_type_; + << "Processing RST_STREAM frame when connection is closed. Received " + "packet info: " + << last_received_packet_info_; // Since a reset stream frame was received, this is not a connectivity probe. // A probe only contains a PING and full padding. @@ -1652,8 +1669,9 @@ bool QuicConnection::OnStopSendingFrame(const QuicStopSendingFrame& frame) { QUIC_BUG_IF(quic_bug_12714_12, !connected_) - << "Processing STOP_SENDING frame when connection is closed. Last frame: " - << most_recent_frame_type_; + << "Processing STOP_SENDING frame when connection is closed. Received " + "packet info: " + << last_received_packet_info_; // Since a reset stream frame was received, this is not a connectivity probe. // A probe only contains a PING and full padding. @@ -1691,9 +1709,9 @@ bool QuicConnection::OnPathChallengeFrame(const QuicPathChallengeFrame& frame) { QUIC_BUG_IF(quic_bug_10511_8, !connected_) - << "Processing PATH_CHALLENGE frame when connection " - "is closed. Last frame: " - << most_recent_frame_type_; + << "Processing PATH_CHALLENGE frame when connection is closed. Received " + "packet info: " + << last_received_packet_info_; if (has_path_challenge_in_current_packet_) { // Only respond to the 1st PATH_CHALLENGE in the packet. return true; @@ -1767,9 +1785,9 @@ bool QuicConnection::OnPathResponseFrame(const QuicPathResponseFrame& frame) { QUIC_BUG_IF(quic_bug_10511_9, !connected_) - << "Processing PATH_RESPONSE frame when connection " - "is closed. Last frame: " - << most_recent_frame_type_; + << "Processing PATH_RESPONSE frame when connection is closed. Received " + "packet info: " + << last_received_packet_info_; if (!UpdatePacketContent(PATH_RESPONSE_FRAME)) { return false; } @@ -1785,9 +1803,9 @@ bool QuicConnection::OnConnectionCloseFrame( const QuicConnectionCloseFrame& frame) { QUIC_BUG_IF(quic_bug_10511_10, !connected_) - << "Processing CONNECTION_CLOSE frame when " - "connection is closed. Last frame: " - << most_recent_frame_type_; + << "Processing CONNECTION_CLOSE frame when connection is closed. " + "Received packet info: " + << last_received_packet_info_; // Since a connection close frame was received, this is not a connectivity // probe. A probe only contains a PING and full padding. @@ -1829,9 +1847,10 @@ } if (frame.quic_error_code == QUIC_BAD_MULTIPATH_FLAG) { - QUIC_LOG_FIRST_N(ERROR, 10) << "Unexpected QUIC_BAD_MULTIPATH_FLAG error." - << " last_received_header: " << last_header_ - << " encryption_level: " << encryption_level_; + QUIC_LOG_FIRST_N(ERROR, 10) + << "Unexpected QUIC_BAD_MULTIPATH_FLAG error." + << " last_received_header: " << last_received_packet_info_.header + << " encryption_level: " << encryption_level_; } TearDownLocalConnectionState(frame, ConnectionCloseSource::FROM_PEER); return connected_; @@ -1839,8 +1858,9 @@ bool QuicConnection::OnMaxStreamsFrame(const QuicMaxStreamsFrame& frame) { QUIC_BUG_IF(quic_bug_12714_13, !connected_) - << "Processing MAX_STREAMS frame when connection is closed. Last frame: " - << most_recent_frame_type_; + << "Processing MAX_STREAMS frame when connection is closed. Received " + "packet info: " + << last_received_packet_info_; if (!UpdatePacketContent(MAX_STREAMS_FRAME)) { return false; } @@ -1855,9 +1875,9 @@ bool QuicConnection::OnStreamsBlockedFrame( const QuicStreamsBlockedFrame& frame) { QUIC_BUG_IF(quic_bug_10511_11, !connected_) - << "Processing STREAMS_BLOCKED frame when " - "connection is closed. Last frame: " - << most_recent_frame_type_; + << "Processing STREAMS_BLOCKED frame when connection is closed. Received " + "packet info: " + << last_received_packet_info_; if (!UpdatePacketContent(STREAMS_BLOCKED_FRAME)) { return false; } @@ -1871,8 +1891,9 @@ bool QuicConnection::OnGoAwayFrame(const QuicGoAwayFrame& frame) { QUIC_BUG_IF(quic_bug_12714_14, !connected_) - << "Processing GOAWAY frame when connection is closed. Last frame: " - << most_recent_frame_type_; + << "Processing GOAWAY frame when connection is closed. Received packet " + "info: " + << last_received_packet_info_; // Since a go away frame was received, this is not a connectivity probe. // A probe only contains a PING and full padding. @@ -1894,9 +1915,9 @@ bool QuicConnection::OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) { QUIC_BUG_IF(quic_bug_10511_12, !connected_) - << "Processing WINDOW_UPDATE frame when connection " - "is closed. Last frame: " - << most_recent_frame_type_; + << "Processing WINDOW_UPDATE frame when connection is closed. Received " + "packet info: " + << last_received_packet_info_; // Since a window update frame was received, this is not a connectivity probe. // A probe only contains a PING and full padding. @@ -2001,9 +2022,9 @@ const QuicNewConnectionIdFrame& frame) { QUICHE_DCHECK(version().HasIetfQuicFrames()); QUIC_BUG_IF(quic_bug_10511_13, !connected_) - << "Processing NEW_CONNECTION_ID frame when " - "connection is closed. Last frame: " - << most_recent_frame_type_; + << "Processing NEW_CONNECTION_ID frame when connection is closed. " + "Received packet info: " + << last_received_packet_info_; if (!UpdatePacketContent(NEW_CONNECTION_ID_FRAME)) { return false; } @@ -2018,9 +2039,9 @@ const QuicRetireConnectionIdFrame& frame) { QUICHE_DCHECK(version().HasIetfQuicFrames()); QUIC_BUG_IF(quic_bug_10511_14, !connected_) - << "Processing RETIRE_CONNECTION_ID frame when " - "connection is closed. Last frame: " - << most_recent_frame_type_; + << "Processing RETIRE_CONNECTION_ID frame when connection is closed. " + "Received packet info: " + << last_received_packet_info_; if (!UpdatePacketContent(RETIRE_CONNECTION_ID_FRAME)) { return false; } @@ -2055,8 +2076,9 @@ bool QuicConnection::OnNewTokenFrame(const QuicNewTokenFrame& frame) { QUIC_BUG_IF(quic_bug_12714_15, !connected_) - << "Processing NEW_TOKEN frame when connection is closed. Last frame: " - << most_recent_frame_type_; + << "Processing NEW_TOKEN frame when connection is closed. Received " + "packet info: " + << last_received_packet_info_; if (!UpdatePacketContent(NEW_TOKEN_FRAME)) { return false; } @@ -2077,8 +2099,9 @@ bool QuicConnection::OnMessageFrame(const QuicMessageFrame& frame) { QUIC_BUG_IF(quic_bug_12714_16, !connected_) - << "Processing MESSAGE frame when connection is closed. Last frame: " - << most_recent_frame_type_; + << "Processing MESSAGE frame when connection is closed. Received packet " + "info: " + << last_received_packet_info_; // Since a message frame was received, this is not a connectivity probe. // A probe only contains a PING and full padding. @@ -2098,8 +2121,9 @@ bool QuicConnection::OnHandshakeDoneFrame(const QuicHandshakeDoneFrame& frame) { QUIC_BUG_IF(quic_bug_10511_15, !connected_) << "Processing HANDSHAKE_DONE frame when connection " - "is closed. Last frame: " - << most_recent_frame_type_; + "is closed. Received packet " + "info: " + << last_received_packet_info_; if (!version().UsesTls()) { CloseConnection(IETF_QUIC_PROTOCOL_VIOLATION, "Handshake done frame is unsupported", @@ -2131,8 +2155,9 @@ bool QuicConnection::OnAckFrequencyFrame(const QuicAckFrequencyFrame& frame) { QUIC_BUG_IF(quic_bug_10511_16, !connected_) << "Processing ACK_FREQUENCY frame when connection " - "is closed. Last frame: " - << most_recent_frame_type_; + "is closed. Received packet " + "info: " + << last_received_packet_info_; if (debug_visitor_ != nullptr) { debug_visitor_->OnAckFrequencyFrame(frame); } @@ -2145,8 +2170,8 @@ return false; } if (auto packet_number_space = - QuicUtils::GetPacketNumberSpace(last_decrypted_packet_level_) == - APPLICATION_DATA) { + QuicUtils::GetPacketNumberSpace( + last_received_packet_info_.decrypted_level) == APPLICATION_DATA) { uber_received_packet_manager_.OnAckFrequencyFrame(frame); } else { QUIC_LOG_EVERY_N_SEC(ERROR, 120) @@ -2159,8 +2184,9 @@ bool QuicConnection::OnBlockedFrame(const QuicBlockedFrame& frame) { QUIC_BUG_IF(quic_bug_12714_17, !connected_) - << "Processing BLOCKED frame when connection is closed. Last frame was " - << most_recent_frame_type_; + << "Processing BLOCKED frame when connection is closed. Received packet " + "info: " + << last_received_packet_info_; // Since a blocked frame was received, this is not a connectivity probe. // A probe only contains a PING and full padding. @@ -2193,11 +2219,14 @@ QUIC_DVLOG(1) << ENDPOINT << "Got" << (SupportsMultiplePacketNumberSpaces() - ? (" " + EncryptionLevelToString( - last_decrypted_packet_level_)) + ? (" " + + EncryptionLevelToString( + last_received_packet_info_.decrypted_level)) : "") - << " packet " << last_header_.packet_number << " for " - << GetServerConnectionIdAsRecipient(last_header_, perspective_); + << " packet " << last_received_packet_info_.header.packet_number + << " for " + << GetServerConnectionIdAsRecipient( + last_received_packet_info_.header, perspective_); QUIC_DLOG_IF(INFO, current_packet_content_ == SECOND_FRAME_IS_PADDING) << ENDPOINT << "Received a padded PING packet. is_probing: " @@ -2214,9 +2243,11 @@ // never process a packet while an ACK for it cannot be encrypted. if (!should_last_packet_instigate_acks_) { uber_received_packet_manager_.MaybeUpdateAckTimeout( - should_last_packet_instigate_acks_, last_decrypted_packet_level_, - last_header_.packet_number, last_received_packet_info_.receipt_time, - clock_->ApproximateNow(), sent_packet_manager_.GetRttStats()); + should_last_packet_instigate_acks_, + last_received_packet_info_.decrypted_level, + last_received_packet_info_.header.packet_number, + last_received_packet_info_.receipt_time, clock_->ApproximateNow(), + sent_packet_manager_.GetRttStats()); } ClearLastFrames(); @@ -2236,8 +2267,8 @@ // packet has been received anyway. QUIC_DVLOG(1) << ENDPOINT << "Received a speculative connectivity probing packet for " - << GetServerConnectionIdAsRecipient(last_header_, - perspective_) + << GetServerConnectionIdAsRecipient( + last_received_packet_info_.header, perspective_) << " from ip:port: " << last_received_packet_info_.source_address.ToString() << " to ip:port: " @@ -2345,7 +2376,8 @@ sent_packet_manager_.GetLeastUnacked().ToUint64(), ", packets_processed: ", stats_.packets_processed, ", last_decrypted_packet_level: ", - EncryptionLevelToString(last_decrypted_packet_level_)), + EncryptionLevelToString( + last_received_packet_info_.decrypted_level)), ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET); } } @@ -2701,9 +2733,8 @@ if (debug_visitor_ != nullptr) { debug_visitor_->OnPacketReceived(self_address, peer_address, packet); } - last_received_packet_info_ = - ReceivedPacketInfo(self_address, peer_address, packet.receipt_time()); - last_size_ = packet.length(); + last_received_packet_info_ = ReceivedPacketInfo( + self_address, peer_address, packet.receipt_time(), packet.length()); current_packet_data_ = packet.data(); if (!default_path_.self_address.IsInitialized()) { @@ -2732,7 +2763,8 @@ last_received_packet_info_.source_address) && EnforceAntiAmplificationLimit()) { last_received_packet_info_.received_bytes_counted = true; - default_path_.bytes_received_before_address_validation += last_size_; + default_path_.bytes_received_before_address_validation += + last_received_packet_info_.length; } // Ensure the time coming from the packet reader is within 2 minutes of now. @@ -2753,7 +2785,7 @@ // because the CHLO or SHLO packet was lost. QUIC_DVLOG(1) << ENDPOINT << "Unable to process packet. Last packet processed: " - << last_header_.packet_number; + << last_received_packet_info_.header.packet_number; current_packet_data_ = nullptr; is_current_packet_connectivity_probing_ = false; @@ -2979,10 +3011,11 @@ default_path_.self_address.ToString(), ", received packet address: ", last_received_packet_info_.destination_address.ToString(), - ", size: ", last_size_, + ", size: ", last_received_packet_info_.length, ", packet number: ", header.packet_number.ToString(), ", encryption level: ", - EncryptionLevelToString(last_decrypted_packet_level_)); + EncryptionLevelToString( + last_received_packet_info_.decrypted_level)); if (GetQuicReloadableFlag( quic_drop_packets_with_changed_server_address)) { QUIC_LOG_EVERY_N_SEC(INFO, 100) << error_details; @@ -3036,17 +3069,18 @@ } } - if (last_size_ > largest_received_packet_size_) { - largest_received_packet_size_ = last_size_; + if (last_received_packet_info_.length > largest_received_packet_size_) { + largest_received_packet_size_ = last_received_packet_info_.length; } if (perspective_ == Perspective::IS_SERVER && encryption_level_ == ENCRYPTION_INITIAL && - last_size_ > packet_creator_.max_packet_length()) { + last_received_packet_info_.length > packet_creator_.max_packet_length()) { if (GetQuicFlag(FLAGS_quic_use_lower_server_response_mtu_for_test)) { - SetMaxPacketLength(std::min(last_size_, QuicByteCount(1250))); + SetMaxPacketLength( + std::min(last_received_packet_info_.length, QuicByteCount(1250))); } else { - SetMaxPacketLength(last_size_); + SetMaxPacketLength(last_received_packet_info_.length); } } return true; @@ -3057,10 +3091,11 @@ // If this packet has already been seen, or the sender has told us that it // will not be retransmitted, then stop processing the packet. if (!uber_received_packet_manager_.IsAwaitingPacket( - last_decrypted_packet_level_, packet_number)) { + last_received_packet_info_.decrypted_level, packet_number)) { QUIC_DLOG(INFO) << ENDPOINT << "Packet " << packet_number << " no longer being waited for at level " - << static_cast<int>(last_decrypted_packet_level_) + << static_cast<int>( + last_received_packet_info_.decrypted_level) << ". Discarding."; if (debug_visitor_ != nullptr) { debug_visitor_->OnDuplicatePacket(packet_number); @@ -4370,7 +4405,6 @@ undecryptable_packet->encryption_level); } last_received_packet_info_ = undecryptable_packet->packet_info; - last_size_ = undecryptable_packet->packet->length(); current_packet_data_ = undecryptable_packet->packet->data(); const bool processed = framer_.ProcessPacket(*undecryptable_packet->packet); current_packet_data_ = nullptr; @@ -4956,6 +4990,38 @@ random.RandBytes(data.get(), encrypted_length); } +QuicConnection::ReceivedPacketInfo::ReceivedPacketInfo(QuicTime receipt_time) + : receipt_time(receipt_time) {} +QuicConnection::ReceivedPacketInfo::ReceivedPacketInfo( + const QuicSocketAddress& destination_address, + const QuicSocketAddress& source_address, QuicTime receipt_time, + QuicByteCount length) + : destination_address(destination_address), + source_address(source_address), + receipt_time(receipt_time), + length(length) {} + +std::ostream& operator<<(std::ostream& os, + const QuicConnection::ReceivedPacketInfo& info) { + os << " { destination_address: " << info.destination_address.ToString() + << ", source_address: " << info.source_address.ToString() + << ", received_bytes_counted: " << info.received_bytes_counted + << ", length: " << info.length + << ", destination_connection_id: " << info.destination_connection_id; + if (!info.decrypted) { + os << " }\n"; + return os; + } + os << ", decrypted: " << info.decrypted + << ", decrypted_level: " << EncryptionLevelToString(info.decrypted_level) + << ", header: " << info.header << ", frames: "; + for (const auto frame : info.frames) { + os << frame; + } + os << " }\n"; + return os; +} + HasRetransmittableData QuicConnection::IsRetransmittable( const SerializedPacket& packet) { // Retransmitted packets retransmittable frames are owned by the unacked @@ -5305,12 +5371,13 @@ absl::optional<StatelessResetToken> stateless_reset_token; FindMatchingOrNewClientConnectionIdOrToken( previous_default_path, alternative_path_, - last_packet_destination_connection_id_, &client_connection_id, - &stateless_reset_token); - SetDefaultPathState(PathState( - last_received_packet_info_.destination_address, - current_effective_peer_address, client_connection_id, - last_packet_destination_connection_id_, stateless_reset_token)); + last_received_packet_info_.destination_connection_id, + &client_connection_id, &stateless_reset_token); + SetDefaultPathState( + PathState(last_received_packet_info_.destination_address, + current_effective_peer_address, client_connection_id, + last_received_packet_info_.destination_connection_id, + stateless_reset_token)); // The path is considered validated if its peer IP address matches any // validated path's peer IP address. default_path_.validated = @@ -5321,7 +5388,8 @@ } if (!last_received_packet_info_.received_bytes_counted) { // Increment bytes counting on the new default path. - default_path_.bytes_received_before_address_validation += last_size_; + default_path_.bytes_received_before_address_validation += + last_received_packet_info_.length; last_received_packet_info_.received_bytes_counted = true; } @@ -5423,13 +5491,14 @@ if (current_packet_data_ == nullptr) { return absl::string_view(); } - return absl::string_view(current_packet_data_, last_size_); + return absl::string_view(current_packet_data_, + last_received_packet_info_.length); } bool QuicConnection::MaybeConsiderAsMemoryCorruption( const QuicStreamFrame& frame) { if (QuicUtils::IsCryptoStreamId(transport_version(), frame.stream_id) || - last_decrypted_packet_level_ != ENCRYPTION_INITIAL) { + last_received_packet_info_.decrypted_level != ENCRYPTION_INITIAL) { return false; } @@ -5494,7 +5563,7 @@ } bool QuicConnection::UpdatePacketContent(QuicFrameType type) { - most_recent_frame_type_ = type; + last_received_packet_info_.frames.push_back(type); if (version().HasIetfQuicFrames()) { if (!QuicUtils::IsProbingFrame(type)) { MaybeStartIetfPeerMigration(); @@ -5519,12 +5588,13 @@ absl::optional<StatelessResetToken> stateless_reset_token; FindMatchingOrNewClientConnectionIdOrToken( default_path_, alternative_path_, - last_packet_destination_connection_id_, &client_cid, + last_received_packet_info_.destination_connection_id, &client_cid, &stateless_reset_token); - alternative_path_ = PathState( - last_received_packet_info_.destination_address, - current_effective_peer_address, client_cid, - last_packet_destination_connection_id_, stateless_reset_token); + alternative_path_ = + PathState(last_received_packet_info_.destination_address, + current_effective_peer_address, client_cid, + last_received_packet_info_.destination_connection_id, + stateless_reset_token); } else if (!default_path_.validated) { // Skip reverse path validation because either handshake hasn't // completed or the connection is validating the default path. Using @@ -5543,19 +5613,21 @@ absl::optional<StatelessResetToken> stateless_reset_token; FindMatchingOrNewClientConnectionIdOrToken( default_path_, alternative_path_, - last_packet_destination_connection_id_, &client_connection_id, - &stateless_reset_token); + last_received_packet_info_.destination_connection_id, + &client_connection_id, &stateless_reset_token); // Only override alternative path state upon receiving a PATH_CHALLENGE // from an unvalidated peer address, and the connection isn't validating // a recent peer migration. - alternative_path_ = PathState( - last_received_packet_info_.destination_address, - current_effective_peer_address, client_connection_id, - last_packet_destination_connection_id_, stateless_reset_token); + alternative_path_ = + PathState(last_received_packet_info_.destination_address, + current_effective_peer_address, client_connection_id, + last_received_packet_info_.destination_connection_id, + stateless_reset_token); should_proactively_validate_peer_address_on_path_challenge_ = true; } } - MaybeUpdateBytesReceivedFromAlternativeAddress(last_size_); + MaybeUpdateBytesReceivedFromAlternativeAddress( + last_received_packet_info_.length); return connected_; } // Packet content is tracked to identify connectivity probe in non-IETF @@ -5610,7 +5682,8 @@ current_packet_content_ = NOT_PADDED_PING; if (GetLargestReceivedPacket().IsInitialized() && - last_header_.packet_number == GetLargestReceivedPacket()) { + last_received_packet_info_.header.packet_number == + GetLargestReceivedPacket()) { UpdatePeerAddress(last_received_packet_info_.source_address); if (current_effective_peer_migration_type_ != NO_CHANGE) { // Start effective peer migration immediately when the current packet is @@ -5643,7 +5716,8 @@ } if (GetLargestReceivedPacket().IsInitialized() && - last_header_.packet_number == GetLargestReceivedPacket()) { + last_received_packet_info_.header.packet_number == + GetLargestReceivedPacket()) { if (current_effective_peer_migration_type_ != NO_CHANGE) { // Start effective peer migration when the current packet contains a // non-probing frame. @@ -5664,10 +5738,10 @@ bool acked_new_packet) { if (no_stop_waiting_frames_ && !packet_creator_.has_ack()) { uber_received_packet_manager_.DontWaitForPacketsBefore( - last_decrypted_packet_level_, + last_received_packet_info_.decrypted_level, SupportsMultiplePacketNumberSpaces() ? sent_packet_manager_.GetLargestPacketPeerKnowsIsAcked( - last_decrypted_packet_level_) + last_received_packet_info_.decrypted_level) : sent_packet_manager_.largest_packet_peer_knows_is_acked()); } // Always reset the retransmission alarm when an ack comes in, since we now @@ -5755,7 +5829,8 @@ uint32_t QuicConnection::cipher_id() const { if (version().KnowsWhichDecrypterToUse()) { - return framer_.GetDecrypter(last_decrypted_packet_level_)->cipher_id(); + return framer_.GetDecrypter(last_received_packet_info_.decrypted_level) + ->cipher_id(); } return framer_.decrypter()->cipher_id(); } @@ -6055,7 +6130,7 @@ QuicPacketNumber new_value) { if (SupportsMultiplePacketNumberSpaces()) { largest_seen_packets_with_ack_[QuicUtils::GetPacketNumberSpace( - last_decrypted_packet_level_)] = new_value; + last_received_packet_info_.decrypted_level)] = new_value; } else { largest_seen_packet_with_ack_ = new_value; } @@ -6090,7 +6165,7 @@ QuicPacketNumber QuicConnection::GetLargestReceivedPacketWithAck() const { if (SupportsMultiplePacketNumberSpaces()) { return largest_seen_packets_with_ack_[QuicUtils::GetPacketNumberSpace( - last_decrypted_packet_level_)]; + last_received_packet_info_.decrypted_level)]; } return largest_seen_packet_with_ack_; } @@ -6098,14 +6173,14 @@ QuicPacketNumber QuicConnection::GetLargestAckedPacket() const { if (SupportsMultiplePacketNumberSpaces()) { return sent_packet_manager_.GetLargestAckedPacket( - last_decrypted_packet_level_); + last_received_packet_info_.decrypted_level); } return sent_packet_manager_.GetLargestObserved(); } QuicPacketNumber QuicConnection::GetLargestReceivedPacket() const { return uber_received_packet_manager_.GetLargestObserved( - last_decrypted_packet_level_); + last_received_packet_info_.decrypted_level); } bool QuicConnection::EnforceAntiAmplificationLimit() const { @@ -6171,7 +6246,8 @@ const QuicAckFrame& QuicConnection::ack_frame() const { if (SupportsMultiplePacketNumberSpaces()) { return uber_received_packet_manager_.GetAckFrame( - QuicUtils::GetPacketNumberSpace(last_decrypted_packet_level_)); + QuicUtils::GetPacketNumberSpace( + last_received_packet_info_.decrypted_level)); } return uber_received_packet_manager_.ack_frame(); } @@ -6433,9 +6509,11 @@ } should_last_packet_instigate_acks_ = true; uber_received_packet_manager_.MaybeUpdateAckTimeout( - /*should_last_packet_instigate_acks=*/true, last_decrypted_packet_level_, - last_header_.packet_number, last_received_packet_info_.receipt_time, - clock_->ApproximateNow(), sent_packet_manager_.GetRttStats()); + /*should_last_packet_instigate_acks=*/true, + last_received_packet_info_.decrypted_level, + last_received_packet_info_.header.packet_number, + last_received_packet_info_.receipt_time, clock_->ApproximateNow(), + sent_packet_manager_.GetRttStats()); } QuicTime QuicConnection::GetPathDegradingDeadline() const { @@ -6896,6 +6974,14 @@ } } +void QuicConnection::QuicBugIfHasPendingFrames(QuicStreamId id) const { + QUIC_BUG_IF(quic_has_pending_frames_unexpectedly, + packet_creator_.HasPendingStreamFramesOfStream(id)) + << "Stream " << id + << " has pending frames unexpectedly. Received packet info: " + << last_received_packet_info_; +} + void QuicConnection::SetUnackedMapInitialCapacity() { sent_packet_manager_.ReserveUnackedPacketsInitialCapacity( GetUnackedMapInitialCapacity()); @@ -7067,7 +7153,8 @@ ", with active_effective_peer_migration_type_ = ", AddressChangeTypeToString(active_effective_peer_migration_type_), ". The last received packet number ", - connection_->last_header_.packet_number.ToString(), + connection_->last_received_packet_info_.header.packet_number + .ToString(), " Connection is connected: ", connection_->connected_); QUIC_BUG(quic_bug_10511_43) << connection_->quic_bug_10511_43_error_detail_;
diff --git a/quiche/quic/core/quic_connection.h b/quiche/quic/core/quic_connection.h index d7b83e5..e9e71aa 100644 --- a/quiche/quic/core/quic_connection.h +++ b/quiche/quic/core/quic_connection.h
@@ -1010,7 +1010,7 @@ EncryptionLevel encryption_level() const { return encryption_level_; } EncryptionLevel last_decrypted_level() const { - return last_decrypted_packet_level_; + return last_received_packet_info_.decrypted_level; } const QuicSocketAddress& last_packet_source_address() const { @@ -1220,6 +1220,9 @@ // Instantiates connection ID manager. void CreateConnectionIdManager(); + // Log QUIC_BUG if there is pending frames for the stream with |id|. + void QuicBugIfHasPendingFrames(QuicStreamId id) const; + QuicConnectionContext* context() { return &context_; } const QuicConnectionContext* context() const { return &context_; } @@ -1422,25 +1425,31 @@ const QuicSocketAddress peer_address; }; - // ReceivedPacketInfo comprises the received packet information, which can be - // retrieved before the packet gets successfully decrypted. + // ReceivedPacketInfo comprises the received packet information. + // TODO(fayang): move more fields to ReceivedPacketInfo. struct QUIC_EXPORT_PRIVATE ReceivedPacketInfo { - explicit ReceivedPacketInfo(QuicTime receipt_time) - : received_bytes_counted(false), receipt_time(receipt_time) {} + explicit ReceivedPacketInfo(QuicTime receipt_time); ReceivedPacketInfo(const QuicSocketAddress& destination_address, const QuicSocketAddress& source_address, - QuicTime receipt_time) - : received_bytes_counted(false), - destination_address(destination_address), - source_address(source_address), - receipt_time(receipt_time) {} + QuicTime receipt_time, QuicByteCount length); - bool received_bytes_counted; QuicSocketAddress destination_address; QuicSocketAddress source_address; - QuicTime receipt_time; + QuicTime receipt_time = QuicTime::Zero(); + bool received_bytes_counted = false; + QuicByteCount length = 0; + QuicConnectionId destination_connection_id; + // Fields below are only populated if packet gets decrypted successfully. + // TODO(fayang): consider using absl::optional for following fields. + bool decrypted = false; + EncryptionLevel decrypted_level = ENCRYPTION_INITIAL; + QuicPacketHeader header; + absl::InlinedVector<QuicFrameType, 1> frames; }; + QUIC_EXPORT_PRIVATE friend std::ostream& operator<<( + std::ostream& os, const QuicConnection::ReceivedPacketInfo& info); + // UndecrytablePacket comprises a undecryptable packet and related // information. struct QUIC_EXPORT_PRIVATE UndecryptablePacket { @@ -1918,15 +1927,9 @@ // key update but before the first packet has been sent. QuicPacketNumber lowest_packet_sent_in_current_key_phase_; - // True if the last packet has gotten far enough in the framer to be - // decrypted. - bool last_packet_decrypted_; - QuicByteCount last_size_; // Size of the last received packet. // TODO(rch): remove this when b/27221014 is fixed. const char* current_packet_data_; // UDP payload of packet currently being // parsed or nullptr. - EncryptionLevel last_decrypted_packet_level_; - QuicPacketHeader last_header_; bool should_last_packet_instigate_acks_; // Track some peer state so we can do less bookkeeping @@ -2054,12 +2057,6 @@ // close. bool connected_; - // Destination connection ID of the last received packet. If this ID is the - // original server connection ID chosen by client and server replaces it with - // a different ID, last_packet_destination_connection_id_ is set to the - // replacement connection ID on the server side. - QuicConnectionId last_packet_destination_connection_id_; - // Set to false if the connection should not send truncated connection IDs to // the peer, even if the peer supports it. bool can_truncate_connection_ids_; @@ -2240,9 +2237,6 @@ // 2), do not override it on receiving PATH_CHALLENGE (case 1). PathState alternative_path_; - // This field is used to debug b/177312785. - QuicFrameType most_recent_frame_type_; - // If true, upon seeing a new client address, validate the client address. bool validate_client_addresses_ = false;
diff --git a/quiche/quic/core/quic_session.cc b/quiche/quic/core/quic_session.cc index 223a811..6450da0 100644 --- a/quiche/quic/core/quic_session.cc +++ b/quiche/quic/core/quic_session.cc
@@ -1002,11 +1002,7 @@ closed_streams_clean_up_alarm_->Set( connection_->clock()->ApproximateNow()); } - QUIC_BUG_IF( - 364846171_1, - connection_->packet_creator().HasPendingStreamFramesOfStream(stream_id)) - << "Stream " << stream_id - << " gets closed while there are pending frames."; + connection_->QuicBugIfHasPendingFrames(stream_id); } if (!stream->HasReceivedFinalOffset()) { @@ -2177,9 +2173,7 @@ } // Do not retransmit data of a closed stream. streams_with_pending_retransmission_.erase(id); - QUIC_BUG_IF(364846171_2, - connection_->packet_creator().HasPendingStreamFramesOfStream(id)) - << "Stream " << id << " gets closed while there are pending frames."; + connection_->QuicBugIfHasPendingFrames(id); } QuicStream* QuicSession::GetStream(QuicStreamId id) const {
diff --git a/quiche/quic/test_tools/quic_connection_peer.cc b/quiche/quic/test_tools/quic_connection_peer.cc index c00d12f..686d0c8 100644 --- a/quiche/quic/test_tools/quic_connection_peer.cc +++ b/quiche/quic/test_tools/quic_connection_peer.cc
@@ -119,7 +119,7 @@ void QuicConnectionPeer::SetCurrentPacket(QuicConnection* connection, absl::string_view current_packet) { connection->current_packet_data_ = current_packet.data(); - connection->last_size_ = current_packet.size(); + connection->last_received_packet_info_.length = current_packet.size(); } // static @@ -240,7 +240,7 @@ // static QuicPacketHeader* QuicConnectionPeer::GetLastHeader( QuicConnection* connection) { - return &connection->last_header_; + return &connection->last_received_packet_info_.header; } // static @@ -324,12 +324,6 @@ } // static -void QuicConnectionPeer::SetLastHeaderFormat(QuicConnection* connection, - PacketHeaderFormat format) { - connection->last_header_.form = format; -} - -// static void QuicConnectionPeer::AddBytesReceived(QuicConnection* connection, size_t length) { if (connection->EnforceAntiAmplificationLimit()) { @@ -540,7 +534,7 @@ // static void QuicConnectionPeer::SetLastDecryptedLevel(QuicConnection* connection, EncryptionLevel level) { - connection->last_decrypted_packet_level_ = level; + connection->last_received_packet_info_.decrypted_level = level; } // static
diff --git a/quiche/quic/test_tools/quic_connection_peer.h b/quiche/quic/test_tools/quic_connection_peer.h index 1b85081..d1a41f9 100644 --- a/quiche/quic/test_tools/quic_connection_peer.h +++ b/quiche/quic/test_tools/quic_connection_peer.h
@@ -132,8 +132,6 @@ static bool SupportsReleaseTime(QuicConnection* connection); static QuicConnection::PacketContent GetCurrentPacketContent( QuicConnection* connection); - static void SetLastHeaderFormat(QuicConnection* connection, - PacketHeaderFormat format); static void AddBytesReceived(QuicConnection* connection, size_t length); static void SetAddressValidated(QuicConnection* connection);