Set client CID in the packets sent by QuicBufferedPacketStore. Protected by quic_reloadable_flag_quic_buffered_store_set_client_cid. PiperOrigin-RevId: 700077952
diff --git a/quiche/common/quiche_feature_flags_list.h b/quiche/common/quiche_feature_flags_list.h index 11b419d..ec1183e 100755 --- a/quiche/common/quiche_feature_flags_list.h +++ b/quiche/common/quiche_feature_flags_list.h
@@ -17,6 +17,7 @@ QUICHE_FLAG(bool, quiche_reloadable_flag_quic_bbr2_probe_two_rounds, true, true, "When true, the BB2U copt causes BBR2 to wait two rounds with out draining the queue before exiting PROBE_UP and BB2S has the same effect in STARTUP.") QUICHE_FLAG(bool, quiche_reloadable_flag_quic_bbr2_simplify_inflight_hi, true, true, "When true, the BBHI copt causes QUIC BBRv2 to use a simpler algorithm for raising inflight_hi in PROBE_UP.") QUICHE_FLAG(bool, quiche_reloadable_flag_quic_block_until_settings_received_copt, true, true, "If enabled and a BSUS connection is received, blocks server connections until SETTINGS frame is received.") +QUICHE_FLAG(bool, quiche_reloadable_flag_quic_buffered_store_set_client_cid, false, false, "If true, QuicBufferedPacketStore will set client CID in packets it generates.") QUICHE_FLAG(bool, quiche_reloadable_flag_quic_can_send_ack_frequency, true, true, "If true, ack frequency frame can be sent from server to client.") QUICHE_FLAG(bool, quiche_reloadable_flag_quic_conservative_bursts, false, false, "If true, set burst token to 2 in cwnd bootstrapping experiment.") QUICHE_FLAG(bool, quiche_reloadable_flag_quic_conservative_cwnd_and_pacing_gains, false, false, "If true, uses conservative cwnd gain and pacing gain when cwnd gets bootstrapped.")
diff --git a/quiche/quic/core/quic_buffered_packet_store.cc b/quiche/quic/core/quic_buffered_packet_store.cc index 4421b66..42d00ff 100644 --- a/quiche/quic/core/quic_buffered_packet_store.cc +++ b/quiche/quic/core/quic_buffered_packet_store.cc
@@ -313,6 +313,11 @@ PacketCollector collector(&send_buffer_allocator); QuicPacketCreator creator(server_connection_id, &framer, &collector); + if (GetQuicReloadableFlag(quic_buffered_store_set_client_cid)) { + QUIC_RELOADABLE_FLAG_COUNT(quic_buffered_store_set_client_cid); + creator.SetClientConnectionId(packet_info.source_connection_id); + } + if (!dispatcher_sent_packets.empty()) { // Sets the *last sent* packet number, creator will derive the next sending // packet number accordingly.
diff --git a/quiche/quic/core/quic_buffered_packet_store_test.cc b/quiche/quic/core/quic_buffered_packet_store_test.cc index 60495dc..d3400f0 100644 --- a/quiche/quic/core/quic_buffered_packet_store_test.cc +++ b/quiche/quic/core/quic_buffered_packet_store_test.cc
@@ -14,6 +14,9 @@ #include <utility> #include <vector> +#include "absl/status/status.h" +#include "absl/status/statusor.h" +#include "absl/strings/str_cat.h" #include "absl/strings/string_view.h" #include "quiche/quic/core/connection_id_generator.h" #include "quiche/quic/core/crypto/transport_parameters.h" @@ -117,13 +120,31 @@ packet_time_(QuicTime::Zero() + QuicTime::Delta::FromMicroseconds(42)), packet_(packet_content_.data(), packet_content_.size(), packet_time_), invalid_version_(UnsupportedQuicVersion()), - valid_version_(CurrentSupportedVersions().front()) {} + valid_version_(CurrentSupportedVersions().front()) { + store_.set_writer(&mock_packet_writer_); + + EXPECT_CALL(mock_packet_writer_, IsWriteBlocked()) + .WillRepeatedly(Return(false)); + EXPECT_CALL(mock_packet_writer_, WritePacket(_, _, _, _, _, _)) + .WillRepeatedly(testing::Invoke( + [&](const char* buffer, size_t buf_len, const QuicIpAddress&, + const QuicSocketAddress&, PerPacketOptions*, + const QuicPacketWriterParams&) { + // This packet is sent by the store and "received" by the client. + client_received_packets_.push_back( + std::make_unique<ClientReceivedPacket>( + buffer, buf_len, peer_address_, self_address_)); + return WriteResult(WRITE_STATUS_OK, buf_len); + })); + } protected: QuicDispatcherStats stats_; QuicBufferedPacketStoreVisitor visitor_; MockClock clock_; MockAlarmFactory alarm_factory_; + // Mock the sending of the INITIAL ACK packets. + MockPacketWriter mock_packet_writer_; QuicBufferedPacketStore store_; QuicSocketAddress self_address_; QuicSocketAddress peer_address_; @@ -133,6 +154,35 @@ const ParsedQuicVersion invalid_version_; const ParsedQuicVersion valid_version_; MockConnectionIdGenerator connection_id_generator_; + + // A packet that is sent by the store and "received" by the client. + struct ClientReceivedPacket { + ClientReceivedPacket(const char* buffer, size_t buf_len, + const QuicSocketAddress& client_address, + const QuicSocketAddress& server_address) + : self_address(client_address), + peer_address(server_address), + packet(QuicReceivedPacket(buffer, buf_len, QuicTime::Zero()).Clone()), + packet_info(self_address, peer_address, *packet) { + std::string detailed_error; + MockConnectionIdGenerator unused_generator; + if (QuicFramer::ParsePublicHeaderDispatcherShortHeaderLengthUnknown( + *packet, &packet_info.form, &packet_info.long_packet_type, + &packet_info.version_flag, &packet_info.use_length_prefix, + &packet_info.version_label, &packet_info.version, + &packet_info.destination_connection_id, + &packet_info.source_connection_id, &packet_info.retry_token, + &detailed_error, unused_generator) != QUIC_NO_ERROR) { + ADD_FAILURE() << "Failed to parse packet header: " << detailed_error; + } + } + + const QuicSocketAddress self_address; + const QuicSocketAddress peer_address; + std::unique_ptr<QuicReceivedPacket> packet; + ReceivedPacketInfo packet_info; + }; + std::vector<std::unique_ptr<ClientReceivedPacket>> client_received_packets_; }; TEST_F(QuicBufferedPacketStoreTest, SimpleEnqueueAndDeliverPacket) { @@ -837,6 +887,49 @@ } } +TEST_F(QuicBufferedPacketStoreTest, InitialAckHasClientConnectionId) { + const QuicConnectionId kDCID = TestConnectionId(1); + const QuicConnectionId kSCID = TestConnectionId(42); + const std::string crypto_data = "crypto_data"; + ParsedQuicVersionVector versions = {ParsedQuicVersion::RFCv1()}; + std::unique_ptr<QuicEncryptedPacket> client_initial_packet( + ConstructEncryptedPacket( + kDCID, kSCID, /*version_flag=*/true, /*reset_flag=*/false, + /*packet_number=*/1, crypto_data, /*full_padding=*/true, + CONNECTION_ID_PRESENT, CONNECTION_ID_PRESENT, + PACKET_4BYTE_PACKET_NUMBER, &versions, Perspective::IS_CLIENT)); + + QuicReceivedPacket received_client_initial(client_initial_packet->data(), + client_initial_packet->length(), + QuicTime::Zero()); + ReceivedPacketInfo packet_info(self_address_, peer_address_, + received_client_initial); + std::string detailed_error; + ASSERT_EQ(QuicFramer::ParsePublicHeaderDispatcherShortHeaderLengthUnknown( + received_client_initial, &packet_info.form, + &packet_info.long_packet_type, &packet_info.version_flag, + &packet_info.use_length_prefix, &packet_info.version_label, + &packet_info.version, &packet_info.destination_connection_id, + &packet_info.source_connection_id, &packet_info.retry_token, + &detailed_error, connection_id_generator_), + QUIC_NO_ERROR) + << detailed_error; + store_.EnqueuePacket(packet_info, kNoParsedChlo, connection_id_generator_); + ASSERT_EQ(client_received_packets_.size(), 1u); + + const ReceivedPacketInfo& client_received_packet_info = + client_received_packets_[0]->packet_info; + // From the client's perspective, the destination connection ID is kSCID and + // the source connection ID is kDCID. + if (GetQuicReloadableFlag(quic_buffered_store_set_client_cid)) { + EXPECT_EQ(client_received_packet_info.destination_connection_id, kSCID); + } else { + EXPECT_EQ(client_received_packet_info.destination_connection_id, + EmptyQuicConnectionId()); + } + EXPECT_EQ(client_received_packet_info.source_connection_id, kDCID); +} + TEST_F(QuicBufferedPacketStoreTest, EmptyBufferedPacketList) { BufferedPacketList packet_list; EXPECT_TRUE(packet_list.buffered_packets.empty());