Remove QUIC_VERSION_43.
PiperOrigin-RevId: 533153414
diff --git a/quiche/quic/core/chlo_extractor.cc b/quiche/quic/core/chlo_extractor.cc
index e55df8a..a663432 100644
--- a/quiche/quic/core/chlo_extractor.cc
+++ b/quiche/quic/core/chlo_extractor.cc
@@ -33,7 +33,6 @@
void OnError(QuicFramer* /*framer*/) override {}
bool OnProtocolVersionMismatch(ParsedQuicVersion version) override;
void OnPacket() override {}
- void OnPublicResetPacket(const QuicPublicResetPacket& /*packet*/) override {}
void OnVersionNegotiationPacket(
const QuicVersionNegotiationPacket& /*packet*/) override {}
void OnRetryPacket(QuicConnectionId /*original_connection_id*/,
diff --git a/quiche/quic/core/crypto/crypto_utils.cc b/quiche/quic/core/crypto/crypto_utils.cc
index 01fb681..9ce176e 100644
--- a/quiche/quic/core/crypto/crypto_utils.cc
+++ b/quiche/quic/core/crypto/crypto_utils.cc
@@ -94,7 +94,7 @@
const std::string getLabelForVersion(const ParsedQuicVersion& version,
const absl::string_view& predicate) {
- static_assert(SupportedVersions().size() == 6u,
+ static_assert(SupportedVersions().size() == 5u,
"Supported versions out of sync with HKDF labels");
if (version == ParsedQuicVersion::V2Draft08()) {
return absl::StrCat("quicv2 ", predicate);
@@ -172,7 +172,7 @@
const uint8_t* InitialSaltForVersion(const ParsedQuicVersion& version,
size_t* out_len) {
- static_assert(SupportedVersions().size() == 6u,
+ static_assert(SupportedVersions().size() == 5u,
"Supported versions out of sync with initial encryption salts");
if (version == ParsedQuicVersion::V2Draft08()) {
*out_len = ABSL_ARRAYSIZE(kV2Draft08InitialSalt);
@@ -230,7 +230,7 @@
bool RetryIntegrityKeysForVersion(const ParsedQuicVersion& version,
absl::string_view* key,
absl::string_view* nonce) {
- static_assert(SupportedVersions().size() == 6u,
+ static_assert(SupportedVersions().size() == 5u,
"Supported versions out of sync with retry integrity keys");
if (!version.UsesTls()) {
QUIC_BUG(quic_bug_10699_2)
diff --git a/quiche/quic/core/http/end_to_end_test.cc b/quiche/quic/core/http/end_to_end_test.cc
index fd71300..44e3abe 100644
--- a/quiche/quic/core/http/end_to_end_test.cc
+++ b/quiche/quic/core/http/end_to_end_test.cc
@@ -679,8 +679,7 @@
}
bool SupportsIetfQuicWithTls(ParsedQuicVersion version) {
- return version.HasIetfInvariantHeader() &&
- version.handshake_protocol == PROTOCOL_TLS1_3;
+ return version.handshake_protocol == PROTOCOL_TLS1_3;
}
static void ExpectFlowControlsSynced(QuicSession* client,
@@ -2747,58 +2746,6 @@
server_thread_->Resume();
}
-TEST_P(EndToEndTest, 0ByteConnectionId) {
- if (version_.HasIetfInvariantHeader()) {
- // SetBytesForConnectionIdToSend only applies to Google QUIC encoding.
- ASSERT_TRUE(Initialize());
- return;
- }
- client_config_.SetBytesForConnectionIdToSend(0);
- ASSERT_TRUE(Initialize());
-
- SendSynchronousFooRequestAndCheckResponse();
- QuicConnection* client_connection = GetClientConnection();
- ASSERT_TRUE(client_connection);
- QuicPacketHeader* header =
- QuicConnectionPeer::GetLastHeader(client_connection);
- EXPECT_EQ(CONNECTION_ID_ABSENT, header->source_connection_id_included);
-}
-
-TEST_P(EndToEndTest, 8ByteConnectionId) {
- if (version_.HasIetfInvariantHeader()) {
- // SetBytesForConnectionIdToSend only applies to Google QUIC encoding.
- ASSERT_TRUE(Initialize());
- return;
- }
- client_config_.SetBytesForConnectionIdToSend(8);
- ASSERT_TRUE(Initialize());
-
- SendSynchronousFooRequestAndCheckResponse();
- QuicConnection* client_connection = GetClientConnection();
- ASSERT_TRUE(client_connection);
- QuicPacketHeader* header =
- QuicConnectionPeer::GetLastHeader(client_connection);
- EXPECT_EQ(CONNECTION_ID_PRESENT, header->destination_connection_id_included);
-}
-
-TEST_P(EndToEndTest, 15ByteConnectionId) {
- if (version_.HasIetfInvariantHeader()) {
- // SetBytesForConnectionIdToSend only applies to Google QUIC encoding.
- ASSERT_TRUE(Initialize());
- return;
- }
- client_config_.SetBytesForConnectionIdToSend(15);
- ASSERT_TRUE(Initialize());
-
- // Our server is permissive and allows for out of bounds values.
- SendSynchronousFooRequestAndCheckResponse();
- QuicConnection* client_connection = GetClientConnection();
- ASSERT_TRUE(client_connection);
- QuicPacketHeader* header =
- QuicConnectionPeer::GetLastHeader(client_connection);
- EXPECT_EQ(CONNECTION_ID_PRESENT, header->destination_connection_id_included);
-}
-
TEST_P(EndToEndTest, ResetConnection) {
ASSERT_TRUE(Initialize());
@@ -4039,17 +3986,11 @@
QuicConnection* client_connection = GetClientConnection();
ASSERT_TRUE(client_connection);
QuicConnectionId connection_id = client_connection->connection_id();
- QuicPublicResetPacket header;
- header.connection_id = connection_id;
QuicFramer framer(server_supported_versions_, QuicTime::Zero(),
Perspective::IS_SERVER, kQuicDefaultConnectionIdLength);
- std::unique_ptr<QuicEncryptedPacket> packet;
- if (version_.HasIetfInvariantHeader()) {
- packet = framer.BuildIetfStatelessResetPacket(
- connection_id, /*received_packet_length=*/100, stateless_reset_token);
- } else {
- packet = framer.BuildPublicResetPacket(header);
- }
+ std::unique_ptr<QuicEncryptedPacket> packet =
+ framer.BuildIetfStatelessResetPacket(
+ connection_id, /*received_packet_length=*/100, stateless_reset_token);
// We must pause the server's thread in order to call WritePacket without
// race conditions.
server_thread_->Pause();
@@ -4082,24 +4023,16 @@
ASSERT_TRUE(client_connection);
QuicConnectionId incorrect_connection_id = TestConnectionId(
TestConnectionIdToUInt64(client_connection->connection_id()) + 1);
- QuicPublicResetPacket header;
- header.connection_id = incorrect_connection_id;
QuicFramer framer(server_supported_versions_, QuicTime::Zero(),
Perspective::IS_SERVER, kQuicDefaultConnectionIdLength);
- std::unique_ptr<QuicEncryptedPacket> packet;
NiceMock<MockQuicConnectionDebugVisitor> visitor;
client_connection->set_debug_visitor(&visitor);
- if (version_.HasIetfInvariantHeader()) {
- packet = framer.BuildIetfStatelessResetPacket(
- incorrect_connection_id, /*received_packet_length=*/100,
- stateless_reset_token);
- EXPECT_CALL(visitor, OnIncorrectConnectionId(incorrect_connection_id))
- .Times(0);
- } else {
- packet = framer.BuildPublicResetPacket(header);
- EXPECT_CALL(visitor, OnIncorrectConnectionId(incorrect_connection_id))
- .Times(1);
- }
+ std::unique_ptr<QuicEncryptedPacket> packet =
+ framer.BuildIetfStatelessResetPacket(incorrect_connection_id,
+ /*received_packet_length=*/100,
+ stateless_reset_token);
+ EXPECT_CALL(visitor, OnIncorrectConnectionId(incorrect_connection_id))
+ .Times(0);
// We must pause the server's thread in order to call WritePacket without
// race conditions.
server_thread_->Pause();
@@ -4108,16 +4041,11 @@
server_address_.host(), client_address, nullptr);
server_thread_->Resume();
- if (version_.HasIetfInvariantHeader()) {
- // The request should fail. IETF stateless reset does not include connection
- // ID.
- EXPECT_EQ("", client_->SendSynchronousRequest("/foo"));
- EXPECT_TRUE(client_->response_headers()->empty());
- EXPECT_THAT(client_->connection_error(), IsError(QUIC_PUBLIC_RESET));
- } else {
- // The connection should be unaffected.
- SendSynchronousFooRequestAndCheckResponse();
- }
+ // The request should fail. IETF stateless reset does not include connection
+ // ID.
+ EXPECT_EQ("", client_->SendSynchronousRequest("/foo"));
+ EXPECT_TRUE(client_->response_headers()->empty());
+ EXPECT_THAT(client_->connection_error(), IsError(QUIC_PUBLIC_RESET));
client_connection->set_debug_visitor(nullptr);
}
@@ -4179,8 +4107,7 @@
TestConnectionIdToUInt64(client_connection->connection_id()) + 1);
std::unique_ptr<QuicEncryptedPacket> packet(
QuicFramer::BuildVersionNegotiationPacket(
- incorrect_connection_id, EmptyQuicConnectionId(),
- version_.HasIetfInvariantHeader(),
+ incorrect_connection_id, EmptyQuicConnectionId(), /*ietf_quic=*/true,
version_.HasLengthPrefixedConnectionIds(),
server_supported_versions_));
NiceMock<MockQuicConnectionDebugVisitor> visitor;
@@ -4255,9 +4182,8 @@
// Send a version negotiation packet.
std::unique_ptr<QuicEncryptedPacket> packet(
QuicFramer::BuildVersionNegotiationPacket(
- destination_connection_id, source_connection_id,
- parsed_version.HasIetfInvariantHeader(), has_length_prefix,
- supported_versions_));
+ destination_connection_id, source_connection_id, /*ietf_quic=*/true,
+ has_length_prefix, supported_versions_));
server_writer_->WritePacket(
packet->data(), packet->length(), peer_address.host(),
client_->client()->network_helper()->GetLatestClientAddress(), nullptr);
@@ -4834,49 +4760,6 @@
VerifyCleanConnection(true);
}
-// Regression test for b/111515567
-TEST_P(EndToEndTest, AgreeOnStopWaiting) {
- ASSERT_TRUE(Initialize());
- EXPECT_TRUE(client_->client()->WaitForOneRttKeysAvailable());
-
- QuicConnection* client_connection = GetClientConnection();
- ASSERT_TRUE(client_connection);
- server_thread_->Pause();
- QuicConnection* server_connection = GetServerConnection();
- if (server_connection != nullptr) {
- // Verify client and server connections agree on the value of
- // no_stop_waiting_frames.
- EXPECT_EQ(QuicConnectionPeer::GetNoStopWaitingFrames(client_connection),
- QuicConnectionPeer::GetNoStopWaitingFrames(server_connection));
- } else {
- ADD_FAILURE() << "Missing server connection";
- }
- server_thread_->Resume();
-}
-
-// Regression test for b/111515567
-TEST_P(EndToEndTest, AgreeOnStopWaitingWithNoStopWaitingOption) {
- QuicTagVector options;
- options.push_back(kNSTP);
- client_config_.SetConnectionOptionsToSend(options);
- ASSERT_TRUE(Initialize());
- EXPECT_TRUE(client_->client()->WaitForOneRttKeysAvailable());
-
- QuicConnection* client_connection = GetClientConnection();
- ASSERT_TRUE(client_connection);
- server_thread_->Pause();
- QuicConnection* server_connection = GetServerConnection();
- if (server_connection != nullptr) {
- // Verify client and server connections agree on the value of
- // no_stop_waiting_frames.
- EXPECT_EQ(QuicConnectionPeer::GetNoStopWaitingFrames(client_connection),
- QuicConnectionPeer::GetNoStopWaitingFrames(server_connection));
- } else {
- ADD_FAILURE() << "Missing server connection";
- }
- server_thread_->Resume();
-}
-
TEST_P(EndToEndTest, ReleaseHeadersStreamBufferWhenIdle) {
// Tests that when client side has no active request and no waiting
// PUSH_PROMISE, its headers stream's sequencer buffer should be released.
@@ -5243,10 +5126,6 @@
}
TEST_P(EndToEndTest, SendMessages) {
- if (!version_.SupportsMessageFrames()) {
- Initialize();
- return;
- }
ASSERT_TRUE(Initialize());
EXPECT_TRUE(client_->client()->WaitForOneRttKeysAvailable());
QuicSession* client_session = GetClientSession();
@@ -6001,11 +5880,6 @@
};
TEST_P(EndToEndTest, ConnectionCloseBeforeHandshakeComplete) {
- if (!version_.HasIetfInvariantHeader()) {
- // Only runs for IETF QUIC header.
- Initialize();
- return;
- }
// This test ensures ZERO_RTT_PROTECTED connection close could close a client
// which has switched to forward secure.
connect_to_server_on_initialize_ = false;
@@ -6076,12 +5950,8 @@
TEST_P(EndToEndTest, ForwardSecureConnectionClose) {
// This test ensures ZERO_RTT_PROTECTED connection close is sent to a client
// which has ZERO_RTT_PROTECTED encryption level.
- connect_to_server_on_initialize_ = !version_.HasIetfInvariantHeader();
+ connect_to_server_on_initialize_ = false;
ASSERT_TRUE(Initialize());
- if (!version_.HasIetfInvariantHeader()) {
- // Only runs for IETF QUIC header.
- return;
- }
server_thread_->Pause();
QuicDispatcher* dispatcher =
QuicServerPeer::GetDispatcher(server_thread_->server());
diff --git a/quiche/quic/core/http/quic_spdy_client_session_test.cc b/quiche/quic/core/http/quic_spdy_client_session_test.cc
index 2696f19..11df4a3 100644
--- a/quiche/quic/core/http/quic_spdy_client_session_test.cc
+++ b/quiche/quic/core/http/quic_spdy_client_session_test.cc
@@ -569,16 +569,11 @@
// Verify that a decryptable packet with bad frames does close the connection.
QuicConnectionId destination_connection_id =
session_->connection()->connection_id();
- QuicConnectionId source_connection_id = EmptyQuicConnectionId();
+ QuicConnectionId source_connection_id = destination_connection_id;
QuicFramerPeer::SetLastSerializedServerConnectionId(
QuicConnectionPeer::GetFramer(connection_), destination_connection_id);
- bool version_flag = false;
- QuicConnectionIdIncluded scid_included = CONNECTION_ID_ABSENT;
- if (version.HasIetfInvariantHeader()) {
- version_flag = true;
- source_connection_id = destination_connection_id;
- scid_included = CONNECTION_ID_PRESENT;
- }
+ bool version_flag = true;
+ QuicConnectionIdIncluded scid_included = CONNECTION_ID_PRESENT;
std::unique_ptr<QuicEncryptedPacket> packet(ConstructMisFramedEncryptedPacket(
destination_connection_id, source_connection_id, version_flag, false, 100,
"data", CONNECTION_ID_ABSENT, scid_included, PACKET_4BYTE_PACKET_NUMBER,
diff --git a/quiche/quic/core/quic_connection.cc b/quiche/quic/core/quic_connection.cc
index adb6e87..3e575f2 100644
--- a/quiche/quic/core/quic_connection.cc
+++ b/quiche/quic/core/quic_connection.cc
@@ -292,7 +292,6 @@
ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET),
num_rtos_for_blackhole_detection_(0),
uber_received_packet_manager_(&stats_),
- stop_waiting_count_(0),
pending_retransmission_alarm_(false),
defer_send_in_response_to_packets_(false),
arena_(),
@@ -328,7 +327,6 @@
peer_max_packet_size_(kDefaultMaxPacketSizeTransportParam),
largest_received_packet_size_(0),
write_error_occurred_(false),
- no_stop_waiting_frames_(version().HasIetfInvariantHeader()),
consecutive_num_packets_with_no_retransmittable_frames_(0),
max_consecutive_num_packets_with_no_retransmittable_frames_(
kMaxConsecutiveNonRetransmittablePackets),
@@ -627,9 +625,6 @@
config.HasClientSentConnectionOption(k8PTO, perspective_)) {
num_rtos_for_blackhole_detection_ = 5;
}
- if (config.HasClientSentConnectionOption(kNSTP, perspective_)) {
- no_stop_waiting_frames_ = true;
- }
if (config.HasReceivedStatelessResetToken()) {
default_path_.stateless_reset_token = config.ReceivedStatelessResetToken();
}
@@ -829,26 +824,6 @@
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
- // routed to this QuicConnection has been redirected before control reaches
- // here. (Check for a bug regression.)
- QUICHE_DCHECK_EQ(default_path_.server_connection_id, packet.connection_id);
- QUICHE_DCHECK_EQ(perspective_, Perspective::IS_CLIENT);
- QUICHE_DCHECK(!version().HasIetfInvariantHeader());
- if (debug_visitor_ != nullptr) {
- debug_visitor_->OnPublicResetPacket(packet);
- }
- std::string error_details = "Received public reset.";
- if (perspective_ == Perspective::IS_CLIENT && !packet.endpoint_id.empty()) {
- absl::StrAppend(&error_details, " From ", packet.endpoint_id, ".");
- }
- QUIC_DLOG(INFO) << ENDPOINT << error_details;
- QUIC_CODE_COUNT(quic_tear_down_local_connection_on_public_reset);
- TearDownLocalConnectionState(QUIC_PUBLIC_RESET, NO_IETF_QUIC_ERROR,
- error_details, ConnectionCloseSource::FROM_PEER);
-}
-
bool QuicConnection::OnProtocolVersionMismatch(
ParsedQuicVersion received_version) {
QUIC_DLOG(INFO) << ENDPOINT << "Received packet with mismatched version "
@@ -1578,21 +1553,12 @@
}
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.
- // If the incoming ack's packets set expresses received packets: peer is still
- // acking packets which we never care about.
- // Send an ack to raise the high water mark.
- const bool send_stop_waiting =
- no_stop_waiting_frames_ ? false : GetLeastUnacked() > start;
- PostProcessAfterAckFrame(send_stop_waiting,
- ack_result == PACKETS_NEWLY_ACKED);
+ PostProcessAfterAckFrame(ack_result == PACKETS_NEWLY_ACKED);
processing_ack_frame_ = false;
return connected_;
}
-bool QuicConnection::OnStopWaitingFrame(const QuicStopWaitingFrame& frame) {
+bool QuicConnection::OnStopWaitingFrame(const QuicStopWaitingFrame& /*frame*/) {
QUIC_BUG_IF(quic_bug_12714_8, !connected_)
<< "Processing STOP_WAITING frame when connection is closed. Received "
"packet info: "
@@ -1603,33 +1569,6 @@
if (!UpdatePacketContent(STOP_WAITING_FRAME)) {
return false;
}
-
- if (no_stop_waiting_frames_) {
- return true;
- }
- if (largest_seen_packet_with_stop_waiting_.IsInitialized() &&
- 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;
- }
-
- const char* error = ValidateStopWaitingFrame(frame);
- if (error != nullptr) {
- CloseConnection(QUIC_INVALID_STOP_WAITING_DATA, error,
- ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
- return false;
- }
-
- if (debug_visitor_ != nullptr) {
- debug_visitor_->OnStopWaitingFrame(frame);
- }
-
- largest_seen_packet_with_stop_waiting_ =
- last_received_packet_info_.header.packet_number;
- uber_received_packet_manager_.DontWaitForPacketsBefore(
- last_received_packet_info_.decrypted_level, frame.least_unacked);
return connected_;
}
@@ -1669,31 +1608,6 @@
return true;
}
-const char* QuicConnection::ValidateStopWaitingFrame(
- const QuicStopWaitingFrame& stop_waiting) {
- const QuicPacketNumber peer_least_packet_awaiting_ack =
- uber_received_packet_manager_.peer_least_packet_awaiting_ack();
- if (peer_least_packet_awaiting_ack.IsInitialized() &&
- stop_waiting.least_unacked < peer_least_packet_awaiting_ack) {
- QUIC_DLOG(ERROR) << ENDPOINT << "Peer's sent low least_unacked: "
- << stop_waiting.least_unacked << " vs "
- << peer_least_packet_awaiting_ack;
- // We never process old ack frames, so this number should only increase.
- return "Least unacked too small.";
- }
-
- 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_received_packet_info_.header.packet_number;
- return "Least unacked too large.";
- }
-
- return nullptr;
-}
-
bool QuicConnection::OnRstStreamFrame(const QuicRstStreamFrame& frame) {
QUIC_BUG_IF(quic_bug_12714_11, !connected_)
<< "Processing RST_STREAM frame when connection is closed. Received "
@@ -2334,7 +2248,6 @@
const QuicIetfStatelessResetPacket& /*packet*/) {
// TODO(fayang): Add OnAuthenticatedIetfStatelessResetPacket to
// debug_visitor_.
- QUICHE_DCHECK(version().HasIetfInvariantHeader());
QUICHE_DCHECK_EQ(perspective_, Perspective::IS_CLIENT);
if (!IsDefaultPath(last_received_packet_info_.destination_address,
@@ -2433,11 +2346,6 @@
clock_->ApproximateNow());
}
-void QuicConnection::PopulateStopWaitingFrame(
- QuicStopWaitingFrame* stop_waiting) {
- stop_waiting->least_unacked = GetLeastUnacked();
-}
-
QuicPacketNumber QuicConnection::GetLeastUnacked() const {
return sent_packet_manager_.GetLeastUnacked();
}
@@ -3083,13 +2991,6 @@
if (!version_negotiated_) {
if (perspective_ == Perspective::IS_CLIENT) {
QUICHE_DCHECK(!header.version_flag || header.form != GOOGLE_QUIC_PACKET);
- if (!version().HasIetfInvariantHeader()) {
- // If the client gets a packet without the version flag from the server
- // it should stop sending version since the version negotiation is done.
- // IETF QUIC stops sending version once encryption level switches to
- // forward secure.
- packet_creator_.StopSendingVersion();
- }
version_negotiated_ = true;
OnSuccessfulVersionNegotiation();
}
@@ -3244,7 +3145,7 @@
uber_received_packet_manager_
.GetAckTimeout(QuicUtils::GetPacketNumberSpace(encryption_level_))
.IsInitialized();
- if (!has_pending_ack && stop_waiting_count_ <= 1) {
+ if (!has_pending_ack) {
// No need to send an ACK.
return frames;
}
@@ -3255,14 +3156,8 @@
QUIC_BUG_IF(quic_bug_12714_23, updated_ack_frame.ack_frame->packets.Empty())
<< ENDPOINT << "Attempted to opportunistically bundle an empty "
<< encryption_level_ << " ACK, " << (has_pending_ack ? "" : "!")
- << "has_pending_ack, stop_waiting_count_ " << stop_waiting_count_;
+ << "has_pending_ack";
frames.push_back(updated_ack_frame);
-
- if (!no_stop_waiting_frames_) {
- QuicStopWaitingFrame stop_waiting;
- PopulateStopWaitingFrame(&stop_waiting);
- frames.push_back(QuicFrame(stop_waiting));
- }
return frames;
}
@@ -3938,11 +3833,7 @@
return;
}
// We can't send an error as the socket is presumably borked.
- if (version().HasIetfInvariantHeader()) {
- QUIC_CODE_COUNT(quic_tear_down_local_connection_on_write_error_ietf);
- } else {
- QUIC_CODE_COUNT(quic_tear_down_local_connection_on_write_error_non_ietf);
- }
+ QUIC_CODE_COUNT(quic_tear_down_local_connection_on_write_error_ietf);
CloseConnection(QUIC_PACKET_WRITE_ERROR, error_details,
ConnectionCloseBehavior::SILENT_CLOSE);
}
@@ -3963,13 +3854,7 @@
// loop here.
// TODO(ianswett): This is actually an internal error, not an
// encryption failure.
- if (version().HasIetfInvariantHeader()) {
- QUIC_CODE_COUNT(
- quic_tear_down_local_connection_on_serialized_packet_ietf);
- } else {
- QUIC_CODE_COUNT(
- quic_tear_down_local_connection_on_serialized_packet_non_ietf);
- }
+ QUIC_CODE_COUNT(quic_tear_down_local_connection_on_serialized_packet_ietf);
CloseConnection(QUIC_ENCRYPTION_FAILURE,
"Serialized packet does not have an encrypted buffer.",
ConnectionCloseBehavior::SILENT_CLOSE);
@@ -3997,13 +3882,7 @@
const std::string& error_details) {
// The packet creator or generator encountered an unrecoverable error: tear
// down local connection state immediately.
- if (version().HasIetfInvariantHeader()) {
- QUIC_CODE_COUNT(
- quic_tear_down_local_connection_on_unrecoverable_error_ietf);
- } else {
- QUIC_CODE_COUNT(
- quic_tear_down_local_connection_on_unrecoverable_error_non_ietf);
- }
+ QUIC_CODE_COUNT(quic_tear_down_local_connection_on_unrecoverable_error_ietf);
CloseConnection(error, error_details, ConnectionCloseBehavior::SILENT_CLOSE);
}
@@ -4152,11 +4031,6 @@
QUIC_DVLOG(1) << ENDPOINT << "Sending an ACK proactively";
QuicFrames frames;
frames.push_back(GetUpdatedAckFrame());
- if (!no_stop_waiting_frames_) {
- QuicStopWaitingFrame stop_waiting;
- PopulateStopWaitingFrame(&stop_waiting);
- frames.push_back(QuicFrame(stop_waiting));
- }
if (!packet_creator_.FlushAckFrame(frames)) {
return;
}
@@ -5750,9 +5624,8 @@
current_effective_peer_migration_type_ = NO_CHANGE;
}
-void QuicConnection::PostProcessAfterAckFrame(bool send_stop_waiting,
- bool acked_new_packet) {
- if (no_stop_waiting_frames_ && !packet_creator_.has_ack()) {
+void QuicConnection::PostProcessAfterAckFrame(bool acked_new_packet) {
+ if (!packet_creator_.has_ack()) {
uber_received_packet_manager_.DontWaitForPacketsBefore(
last_received_packet_info_.decrypted_level,
SupportsMultiplePacketNumberSpaces()
@@ -5773,12 +5646,6 @@
// detection if there is no packets in flight.
blackhole_detector_.StopDetection(/*permanent=*/false);
}
-
- if (send_stop_waiting) {
- ++stop_waiting_count_;
- } else {
- stop_waiting_count_ = 0;
- }
}
void QuicConnection::SetSessionNotifier(
@@ -5812,18 +5679,12 @@
void QuicConnection::ResetAckStates() {
ack_alarm_->Cancel();
- stop_waiting_count_ = 0;
uber_received_packet_manager_.ResetAckStates(encryption_level_);
}
MessageStatus QuicConnection::SendMessage(
QuicMessageId message_id, absl::Span<quiche::QuicheMemSlice> message,
bool flush) {
- if (!VersionSupportsMessageFrames(transport_version())) {
- QUIC_BUG(quic_bug_10511_38)
- << "MESSAGE frame is not supported for version " << transport_version();
- return MESSAGE_STATUS_UNSUPPORTED;
- }
if (MemSliceSpanTotalSize(message) > GetCurrentLargestMessagePayload()) {
return MESSAGE_STATUS_TOO_LARGE;
}
@@ -5864,11 +5725,7 @@
}
if (framer_.HasEncrypterOfEncryptionLevel(ENCRYPTION_ZERO_RTT)) {
if (encryption_level_ != ENCRYPTION_ZERO_RTT) {
- if (version().HasIetfInvariantHeader()) {
- QUIC_CODE_COUNT(quic_wrong_encryption_level_connection_close_ietf);
- } else {
- QUIC_CODE_COUNT(quic_wrong_encryption_level_connection_close);
- }
+ QUIC_CODE_COUNT(quic_wrong_encryption_level_connection_close_ietf);
}
return ENCRYPTION_ZERO_RTT;
}
diff --git a/quiche/quic/core/quic_connection.h b/quiche/quic/core/quic_connection.h
index f739644..8274be2 100644
--- a/quiche/quic/core/quic_connection.h
+++ b/quiche/quic/core/quic_connection.h
@@ -331,9 +331,6 @@
// Called when a CRYPTO frame containing handshake data is received.
virtual void OnCryptoFrame(const QuicCryptoFrame& /*frame*/) {}
- // Called when a StopWaitingFrame has been parsed.
- virtual void OnStopWaitingFrame(const QuicStopWaitingFrame& /*frame*/) {}
-
// Called when a QuicPaddingFrame has been parsed.
virtual void OnPaddingFrame(const QuicPaddingFrame& /*frame*/) {}
@@ -377,9 +374,6 @@
// Called when a HandshakeDoneFrame has been parsed.
virtual void OnHandshakeDoneFrame(const QuicHandshakeDoneFrame& /*frame*/) {}
- // Called when a public reset packet has been received.
- virtual void OnPublicResetPacket(const QuicPublicResetPacket& /*packet*/) {}
-
// Called when a version negotiation packet has been received.
virtual void OnVersionNegotiationPacket(
const QuicVersionNegotiationPacket& /*packet*/) {}
@@ -669,7 +663,6 @@
void OnError(QuicFramer* framer) override;
bool OnProtocolVersionMismatch(ParsedQuicVersion received_version) override;
void OnPacket() override;
- void OnPublicResetPacket(const QuicPublicResetPacket& packet) override;
void OnVersionNegotiationPacket(
const QuicVersionNegotiationPacket& packet) override;
void OnRetryPacket(QuicConnectionId original_connection_id,
@@ -1648,11 +1641,11 @@
// Notifies the visitor of the close and marks the connection as disconnected.
// Does not send a connection close frame to the peer. It should only be
- // called by CloseConnection or OnConnectionCloseFrame, OnPublicResetPacket,
- // and OnAuthenticatedIetfStatelessResetPacket.
- // |ietf_error| may optionally be be used to directly specify the wire
- // error code. Otherwise if |ietf_error| is NO_IETF_QUIC_ERROR, the
- // QuicErrorCodeToTransportErrorCode mapping of |error| will be used.
+ // called by CloseConnection or OnConnectionCloseFrame, and
+ // OnAuthenticatedIetfStatelessResetPacket. |ietf_error| may optionally be be
+ // used to directly specify the wire error code. Otherwise if |ietf_error| is
+ // NO_IETF_QUIC_ERROR, the QuicErrorCodeToTransportErrorCode mapping of
+ // |error| will be used.
void TearDownLocalConnectionState(QuicErrorCode error,
QuicIetfTransportErrorCodes ietf_error,
const std::string& details,
@@ -1721,11 +1714,6 @@
// Flush packets buffered in the writer, if any.
void FlushPackets();
- // Make sure a stop waiting we got from our peer is sane.
- // Returns nullptr if the frame is valid or an error string if it was invalid.
- const char* ValidateStopWaitingFrame(
- const QuicStopWaitingFrame& stop_waiting);
-
// Clears any accumulated frames from the last received packet.
void ClearLastFrames();
@@ -1799,9 +1787,8 @@
ABSL_MUST_USE_RESULT bool UpdatePacketContent(QuicFrameType type);
// Called when last received ack frame has been processed.
- // |send_stop_waiting| indicates whether a stop waiting needs to be sent.
// |acked_new_packet| is true if a previously-unacked packet was acked.
- void PostProcessAfterAckFrame(bool send_stop_waiting, bool acked_new_packet);
+ void PostProcessAfterAckFrame(bool acked_new_packet);
// Updates the release time into the future.
void UpdateReleaseTimeIntoFuture();
@@ -1819,8 +1806,6 @@
// Returns true if the ACK frame should be bundled with ACK-eliciting frame.
bool ShouldBundleRetransmittableFrameWithAck() const;
- void PopulateStopWaitingFrame(QuicStopWaitingFrame* stop_waiting);
-
// Enables multiple packet number spaces support based on handshake protocol
// and flags.
void MaybeEnableMultiplePacketNumberSpacesSupport();
@@ -2142,11 +2127,6 @@
UberReceivedPacketManager uber_received_packet_manager_;
- // Indicates how many consecutive times an ack has arrived which indicates
- // the peer needs to stop waiting for some packets.
- // TODO(fayang): remove this when deprecating Q043.
- int stop_waiting_count_;
-
// Indicates the retransmission alarm needs to be set.
bool pending_retransmission_alarm_;
@@ -2240,9 +2220,6 @@
// avoid infinite write errors.
bool write_error_occurred_;
- // Indicates not to send or process stop waiting frames.
- bool no_stop_waiting_frames_;
-
// Consecutive number of sent packets which have no retransmittable frames.
size_t consecutive_num_packets_with_no_retransmittable_frames_;
diff --git a/quiche/quic/core/quic_connection_test.cc b/quiche/quic/core/quic_connection_test.cc
index 88a9fd4..5db68ba 100644
--- a/quiche/quic/core/quic_connection_test.cc
+++ b/quiche/quic/core/quic_connection_test.cc
@@ -562,23 +562,18 @@
// Run tests with combinations of {ParsedQuicVersion, AckResponse}.
struct TestParams {
- TestParams(ParsedQuicVersion version, AckResponse ack_response,
- bool no_stop_waiting)
- : version(version),
- ack_response(ack_response),
- no_stop_waiting(no_stop_waiting) {}
+ TestParams(ParsedQuicVersion version, AckResponse ack_response)
+ : version(version), ack_response(ack_response) {}
ParsedQuicVersion version;
AckResponse ack_response;
- bool no_stop_waiting;
};
// Used by ::testing::PrintToStringParamName().
std::string PrintToString(const TestParams& p) {
return absl::StrCat(
ParsedQuicVersionToString(p.version), "_",
- (p.ack_response == AckResponse::kDefer ? "defer" : "immediate"), "_",
- (p.no_stop_waiting ? "No" : ""), "StopWaiting");
+ (p.ack_response == AckResponse::kDefer ? "defer" : "immediate"));
}
// Constructs various test permutations.
@@ -589,12 +584,7 @@
for (size_t i = 0; i < all_supported_versions.size(); ++i) {
for (AckResponse ack_response :
{AckResponse::kDefer, AckResponse::kImmediate}) {
- params.push_back(
- TestParams(all_supported_versions[i], ack_response, true));
- if (!all_supported_versions[i].HasIetfInvariantHeader()) {
- params.push_back(
- TestParams(all_supported_versions[i], ack_response, false));
- }
+ params.push_back(TestParams(all_supported_versions[i], ack_response));
}
}
return params;
@@ -665,12 +655,6 @@
QuicConnectionPeer::GetFramer(&connection_), connection_id_);
QuicFramerPeer::SetLastWrittenPacketNumberLength(
QuicConnectionPeer::GetFramer(&connection_), packet_number_length_);
- if (version().HasIetfInvariantHeader()) {
- EXPECT_TRUE(QuicConnectionPeer::GetNoStopWaitingFrames(&connection_));
- } else {
- QuicConnectionPeer::SetNoStopWaitingFrames(&connection_,
- GetParam().no_stop_waiting);
- }
QuicStreamId stream_id;
if (QuicVersionUsesCryptoFrames(version().transport_version)) {
stream_id = QuicUtils::GetFirstBidirectionalStreamId(
@@ -740,18 +724,6 @@
ParsedQuicVersion version() { return GetParam().version; }
- QuicStopWaitingFrame* stop_waiting() {
- QuicConnectionPeer::PopulateStopWaitingFrame(&connection_, &stop_waiting_);
- return &stop_waiting_;
- }
-
- QuicPacketNumber least_unacked() {
- if (writer_->stop_waiting_frames().empty()) {
- return QuicPacketNumber();
- }
- return writer_->stop_waiting_frames()[0].least_unacked;
- }
-
void SetClientConnectionId(const QuicConnectionId& client_connection_id) {
connection_.set_client_connection_id(client_connection_id);
writer_->framer()->framer()->SetExpectedClientConnectionIdLength(
@@ -1152,8 +1124,7 @@
QuicPacketHeader ConstructPacketHeader(uint64_t number,
EncryptionLevel level) {
QuicPacketHeader header;
- if (peer_framer_.version().HasIetfInvariantHeader() &&
- level < ENCRYPTION_FORWARD_SECURE) {
+ if (level < ENCRYPTION_FORWARD_SECURE) {
// Set long header type accordingly.
header.version_flag = true;
header.form = IETF_QUIC_LONG_HEADER_PACKET;
@@ -1177,8 +1148,7 @@
header.destination_connection_id = connection_id_;
header.destination_connection_id_included = connection_id_included_;
}
- if (peer_framer_.version().HasIetfInvariantHeader() &&
- peer_framer_.perspective() == Perspective::IS_SERVER) {
+ if (peer_framer_.perspective() == Perspective::IS_SERVER) {
if (!connection_.client_connection_id().IsEmpty()) {
header.destination_connection_id = connection_.client_connection_id();
header.destination_connection_id_included = CONNECTION_ID_PRESENT;
@@ -1194,12 +1164,6 @@
}
}
}
- if (!peer_framer_.version().HasIetfInvariantHeader() &&
- peer_framer_.perspective() == Perspective::IS_SERVER &&
- GetParam().version.handshake_protocol == PROTOCOL_QUIC_CRYPTO &&
- level == ENCRYPTION_ZERO_RTT) {
- header.nonce = &kTestDiversificationNonce;
- }
header.packet_number_length = packet_number_length_;
header.packet_number = QuicPacketNumber(number);
return header;
@@ -1244,14 +1208,9 @@
if (peer_framer_.perspective() == Perspective::IS_SERVER) {
header.source_connection_id = connection_id_;
header.destination_connection_id_included = CONNECTION_ID_ABSENT;
- if (!peer_framer_.version().HasIetfInvariantHeader()) {
- header.source_connection_id_included = CONNECTION_ID_PRESENT;
- }
} else {
header.destination_connection_id = connection_id_;
- if (peer_framer_.version().HasIetfInvariantHeader()) {
- header.destination_connection_id_included = CONNECTION_ID_ABSENT;
- }
+ header.destination_connection_id_included = CONNECTION_ID_ABSENT;
}
header.packet_number = QuicPacketNumber(number);
@@ -1375,7 +1334,7 @@
bool IsDefaultTestConfiguration() {
TestParams p = GetParam();
return p.ack_response == AckResponse::kImmediate &&
- p.version == AllSupportedVersions()[0] && p.no_stop_waiting;
+ p.version == AllSupportedVersions()[0];
}
void TestConnectionCloseQuicErrorCode(QuicErrorCode expected_code) {
@@ -3488,12 +3447,7 @@
QuicPacketNumber retransmission;
// Packet 1 is short header for IETF QUIC because the encryption level
// switched to ENCRYPTION_FORWARD_SECURE in SendStreamDataToPeer.
- EXPECT_CALL(*send_algorithm_,
- OnPacketSent(_, _, _,
- GetParam().version.HasIetfInvariantHeader()
- ? packet_size
- : packet_size - kQuicVersionSize,
- _))
+ EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, packet_size, _))
.WillOnce(SaveArg<2>(&retransmission));
ProcessAckPacket(&frame);
@@ -3522,18 +3476,10 @@
OnPacketSent(_, _, _, _, HAS_RETRANSMITTABLE_DATA));
connection_.SendStreamDataWithString(3, "foofoofoo", 9, NO_FIN);
// Ack bundled.
- if (GetParam().no_stop_waiting) {
- // Do not ACK acks.
- EXPECT_EQ(1u, writer_->frame_count());
- } else {
- EXPECT_EQ(3u, writer_->frame_count());
- }
+ // Do not ACK acks.
+ EXPECT_EQ(1u, writer_->frame_count());
EXPECT_EQ(1u, writer_->stream_frames().size());
- if (GetParam().no_stop_waiting) {
- EXPECT_TRUE(writer_->ack_frames().empty());
- } else {
- EXPECT_FALSE(writer_->ack_frames().empty());
- }
+ EXPECT_TRUE(writer_->ack_frames().empty());
// But an ack with no missing packets will not send an ack.
AckPacket(original, &frame2);
@@ -3680,46 +3626,6 @@
EXPECT_EQ(1u, writer_->window_update_frames().size());
}
-TEST_P(QuicConnectionTest, LeastUnackedLower) {
- if (GetParam().version.HasIetfInvariantHeader()) {
- return;
- }
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
- SendStreamDataToPeer(1, "foo", 0, NO_FIN, nullptr);
- SendStreamDataToPeer(1, "bar", 3, NO_FIN, nullptr);
- SendStreamDataToPeer(1, "eep", 6, NO_FIN, nullptr);
-
- // Start out saying the least unacked is 2.
- QuicPacketCreatorPeer::SetPacketNumber(&peer_creator_, 5);
- ProcessStopWaitingPacket(InitStopWaitingFrame(2));
-
- // Change it to 1, but lower the packet number to fake out-of-order packets.
- // This should be fine.
- QuicPacketCreatorPeer::SetPacketNumber(&peer_creator_, 1);
- // The scheduler will not process out of order acks, but all packet processing
- // causes the connection to try to write.
- if (!GetParam().no_stop_waiting) {
- EXPECT_CALL(visitor_, OnCanWrite());
- }
- ProcessStopWaitingPacket(InitStopWaitingFrame(1));
-
- // Now claim it's one, but set the ordering so it was sent "after" the first
- // one. This should cause a connection error.
- QuicPacketCreatorPeer::SetPacketNumber(&peer_creator_, 7);
- if (!GetParam().no_stop_waiting) {
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
- .Times(AtLeast(1));
- EXPECT_CALL(visitor_,
- OnConnectionClosed(_, ConnectionCloseSource::FROM_SELF))
- .Times(AtLeast(1));
- }
- ProcessStopWaitingPacket(InitStopWaitingFrame(1));
- if (!GetParam().no_stop_waiting) {
- TestConnectionCloseQuicErrorCode(QUIC_INVALID_STOP_WAITING_DATA);
- }
-}
-
TEST_P(QuicConnectionTest, TooManySentPackets) {
EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
@@ -3785,30 +3691,11 @@
EXPECT_EQ(QuicPacketNumber(1u), last_packet);
SendAckPacketToPeer(); // Packet 2
- if (GetParam().no_stop_waiting) {
- // Expect no stop waiting frame is sent.
- EXPECT_FALSE(least_unacked().IsInitialized());
- } else {
- EXPECT_EQ(QuicPacketNumber(1u), least_unacked());
- }
-
SendAckPacketToPeer(); // Packet 3
- if (GetParam().no_stop_waiting) {
- // Expect no stop waiting frame is sent.
- EXPECT_FALSE(least_unacked().IsInitialized());
- } else {
- EXPECT_EQ(QuicPacketNumber(1u), least_unacked());
- }
SendStreamDataToPeer(1, "bar", 3, NO_FIN, &last_packet); // Packet 4
EXPECT_EQ(QuicPacketNumber(4u), last_packet);
SendAckPacketToPeer(); // Packet 5
- if (GetParam().no_stop_waiting) {
- // Expect no stop waiting frame is sent.
- EXPECT_FALSE(least_unacked().IsInitialized());
- } else {
- EXPECT_EQ(QuicPacketNumber(1u), least_unacked());
- }
EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _, _, _));
@@ -3817,15 +3704,6 @@
ProcessAckPacket(&frame);
SendAckPacketToPeer(); // Packet 6
- // As soon as we've acked one, we skip ack packets 2 and 3 and note lack of
- // ack for 4.
- if (GetParam().no_stop_waiting) {
- // Expect no stop waiting frame is sent.
- EXPECT_FALSE(least_unacked().IsInitialized());
- } else {
- EXPECT_EQ(QuicPacketNumber(4u), least_unacked());
- }
-
EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _, _, _));
// Peer acks up to packet 4, the last packet.
@@ -3835,33 +3713,13 @@
// Verify that we did not send an ack.
EXPECT_EQ(QuicPacketNumber(6u), writer_->header().packet_number);
- // So the last ack has not changed.
- if (GetParam().no_stop_waiting) {
- // Expect no stop waiting frame is sent.
- EXPECT_FALSE(least_unacked().IsInitialized());
- } else {
- EXPECT_EQ(QuicPacketNumber(4u), least_unacked());
- }
-
// If we force an ack, we shouldn't change our retransmit state.
SendAckPacketToPeer(); // Packet 7
- if (GetParam().no_stop_waiting) {
- // Expect no stop waiting frame is sent.
- EXPECT_FALSE(least_unacked().IsInitialized());
- } else {
- EXPECT_EQ(QuicPacketNumber(7u), least_unacked());
- }
// But if we send more data it should.
SendStreamDataToPeer(1, "eep", 6, NO_FIN, &last_packet); // Packet 8
EXPECT_EQ(QuicPacketNumber(8u), last_packet);
SendAckPacketToPeer(); // Packet 9
- if (GetParam().no_stop_waiting) {
- // Expect no stop waiting frame is sent.
- EXPECT_FALSE(least_unacked().IsInitialized());
- } else {
- EXPECT_EQ(QuicPacketNumber(7u), least_unacked());
- }
EXPECT_EQ(QuicPacketNumber(1), stats.first_decrypted_packet);
}
@@ -3992,13 +3850,8 @@
// Parse the last packet and ensure it's an ack and two stream frames from
// two different streams.
- if (GetParam().no_stop_waiting) {
- EXPECT_EQ(2u, writer_->frame_count());
- EXPECT_TRUE(writer_->stop_waiting_frames().empty());
- } else {
- EXPECT_EQ(2u, writer_->frame_count());
- EXPECT_TRUE(writer_->stop_waiting_frames().empty());
- }
+ EXPECT_EQ(2u, writer_->frame_count());
+ EXPECT_TRUE(writer_->stop_waiting_frames().empty());
EXPECT_TRUE(writer_->ack_frames().empty());
@@ -4107,13 +3960,8 @@
// Parse the last packet and ensure it's an ack and two stream frames from
// two different streams.
- if (GetParam().no_stop_waiting) {
- EXPECT_EQ(3u, writer_->frame_count());
- EXPECT_TRUE(writer_->stop_waiting_frames().empty());
- } else {
- EXPECT_EQ(4u, writer_->frame_count());
- EXPECT_FALSE(writer_->stop_waiting_frames().empty());
- }
+ EXPECT_EQ(3u, writer_->frame_count());
+ EXPECT_TRUE(writer_->stop_waiting_frames().empty());
EXPECT_FALSE(writer_->ack_frames().empty());
ASSERT_EQ(2u, writer_->stream_frames().size());
EXPECT_EQ(GetNthClientInitiatedStreamId(1, connection_.transport_version()),
@@ -4555,12 +4403,7 @@
EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _, _, _));
// Packet 1 is short header for IETF QUIC because the encryption level
// switched to ENCRYPTION_FORWARD_SECURE in SendStreamDataToPeer.
- EXPECT_CALL(*send_algorithm_,
- OnPacketSent(_, _, _,
- GetParam().version.HasIetfInvariantHeader()
- ? packet_size
- : packet_size - kQuicVersionSize,
- _));
+ EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, packet_size, _));
ProcessAckPacket(&frame);
}
@@ -4826,29 +4669,14 @@
QuicAckFrame frame = InitAckFrame(1);
ProcessAckPacket(&frame);
- // Verify that our internal state has least-unacked as 2, because we're still
- // waiting for a potential ack for 2.
-
- EXPECT_EQ(QuicPacketNumber(2u), stop_waiting()->least_unacked);
-
EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _, _, _));
frame = InitAckFrame(2);
ProcessAckPacket(&frame);
- EXPECT_EQ(QuicPacketNumber(3u), stop_waiting()->least_unacked);
// When we send an ack, we make sure our least-unacked makes sense. In this
// case since we're not waiting on an ack for 2 and all packets are acked, we
// set it to 3.
SendAckPacketToPeer(); // Packet 3
- // Least_unacked remains at 3 until another ack is received.
- EXPECT_EQ(QuicPacketNumber(3u), stop_waiting()->least_unacked);
- if (GetParam().no_stop_waiting) {
- // Expect no stop waiting frame is sent.
- EXPECT_FALSE(least_unacked().IsInitialized());
- } else {
- // Check that the outgoing ack had its packet number as least_unacked.
- EXPECT_EQ(QuicPacketNumber(3u), least_unacked());
- }
// Ack the ack, which updates the rtt and raises the least unacked.
EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _, _, _));
@@ -4856,14 +4684,7 @@
ProcessAckPacket(&frame);
SendStreamDataToPeer(1, "bar", 3, NO_FIN, nullptr); // Packet 4
- EXPECT_EQ(QuicPacketNumber(4u), stop_waiting()->least_unacked);
SendAckPacketToPeer(); // Packet 5
- if (GetParam().no_stop_waiting) {
- // Expect no stop waiting frame is sent.
- EXPECT_FALSE(least_unacked().IsInitialized());
- } else {
- EXPECT_EQ(QuicPacketNumber(4u), least_unacked());
- }
// Send two data packets at the end, and ensure if the last one is acked,
// the least unacked is raised above the ack packets.
@@ -4874,8 +4695,6 @@
frame = InitAckFrame({{QuicPacketNumber(1), QuicPacketNumber(5)},
{QuicPacketNumber(7), QuicPacketNumber(8)}});
ProcessAckPacket(&frame);
-
- EXPECT_EQ(QuicPacketNumber(6u), stop_waiting()->least_unacked);
}
TEST_P(QuicConnectionTest, SendHandshakeMessages) {
@@ -6319,11 +6138,6 @@
TEST_P(QuicConnectionTest, LoopThroughSendingPacketsWithTruncation) {
set_perspective(Perspective::IS_SERVER);
- if (!GetParam().version.HasIetfInvariantHeader()) {
- // For IETF QUIC, encryption level will be switched to FORWARD_SECURE in
- // SendStreamDataWithString.
- QuicPacketCreatorPeer::SetSendVersionInPacket(creator_, false);
- }
// Set up a larger payload than will fit in one packet.
const std::string payload(connection_.max_packet_length(), 'a');
EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)).Times(AnyNumber());
@@ -6345,16 +6159,9 @@
EXPECT_EQ(payload.size(),
connection_.SendStreamDataWithString(3, payload, 1350, NO_FIN)
.bytes_consumed);
- if (connection_.version().HasIetfInvariantHeader()) {
- // Short header packets sent from server omit connection ID already, and
- // stream offset size increases from 0 to 2.
- EXPECT_EQ(non_truncated_packet_size, writer_->last_packet_size() - 2);
- } else {
- // Just like above, we save 8 bytes on payload, and 8 on truncation. -2
- // because stream offset size is 2 instead of 0.
- EXPECT_EQ(non_truncated_packet_size,
- writer_->last_packet_size() + 8 * 2 - 2);
- }
+ // Short header packets sent from server omit connection ID already, and
+ // stream offset size increases from 0 to 2.
+ EXPECT_EQ(non_truncated_packet_size, writer_->last_packet_size() - 2);
}
TEST_P(QuicConnectionTest, SendDelayedAck) {
@@ -6382,13 +6189,8 @@
connection_.GetAckAlarm()->Fire();
// Check that ack is sent and that delayed ack alarm is reset.
size_t padding_frame_count = writer_->padding_frames().size();
- if (GetParam().no_stop_waiting) {
- EXPECT_EQ(padding_frame_count + 1u, writer_->frame_count());
- EXPECT_TRUE(writer_->stop_waiting_frames().empty());
- } else {
- EXPECT_EQ(padding_frame_count + 2u, writer_->frame_count());
- EXPECT_FALSE(writer_->stop_waiting_frames().empty());
- }
+ EXPECT_EQ(padding_frame_count + 1u, writer_->frame_count());
+ EXPECT_TRUE(writer_->stop_waiting_frames().empty());
EXPECT_FALSE(writer_->ack_frames().empty());
EXPECT_FALSE(connection_.HasPendingAcks());
}
@@ -6440,13 +6242,8 @@
}
// Check that ack is sent and that delayed ack alarm is reset.
size_t padding_frame_count = writer_->padding_frames().size();
- if (GetParam().no_stop_waiting) {
- EXPECT_EQ(padding_frame_count + 1u, writer_->frame_count());
- EXPECT_TRUE(writer_->stop_waiting_frames().empty());
- } else {
- EXPECT_EQ(padding_frame_count + 2u, writer_->frame_count());
- EXPECT_FALSE(writer_->stop_waiting_frames().empty());
- }
+ EXPECT_EQ(padding_frame_count + 1u, writer_->frame_count());
+ EXPECT_TRUE(writer_->stop_waiting_frames().empty());
EXPECT_FALSE(writer_->ack_frames().empty());
EXPECT_FALSE(connection_.HasPendingAcks());
}
@@ -6557,13 +6354,8 @@
}
// Check that ack is sent and that delayed ack alarm is reset.
size_t padding_frame_count = writer_->padding_frames().size();
- if (GetParam().no_stop_waiting) {
- EXPECT_EQ(padding_frame_count + 1u, writer_->frame_count());
- EXPECT_TRUE(writer_->stop_waiting_frames().empty());
- } else {
- EXPECT_EQ(padding_frame_count + 2u, writer_->frame_count());
- EXPECT_FALSE(writer_->stop_waiting_frames().empty());
- }
+ EXPECT_EQ(padding_frame_count + 1u, writer_->frame_count());
+ EXPECT_TRUE(writer_->stop_waiting_frames().empty());
EXPECT_FALSE(writer_->ack_frames().empty());
EXPECT_FALSE(connection_.HasPendingAcks());
}
@@ -6600,13 +6392,8 @@
ProcessPacket(2);
// Check that ack is sent and that delayed ack alarm is reset.
size_t padding_frame_count = writer_->padding_frames().size();
- if (GetParam().no_stop_waiting) {
- EXPECT_EQ(padding_frame_count + 1u, writer_->frame_count());
- EXPECT_TRUE(writer_->stop_waiting_frames().empty());
- } else {
- EXPECT_EQ(padding_frame_count + 2u, writer_->frame_count());
- EXPECT_FALSE(writer_->stop_waiting_frames().empty());
- }
+ EXPECT_EQ(padding_frame_count + 1u, writer_->frame_count());
+ EXPECT_TRUE(writer_->stop_waiting_frames().empty());
EXPECT_FALSE(writer_->ack_frames().empty());
EXPECT_FALSE(connection_.HasPendingAcks());
}
@@ -6615,7 +6402,7 @@
EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0);
ProcessPacket(2);
- size_t frames_per_ack = GetParam().no_stop_waiting ? 1 : 2;
+ size_t frames_per_ack = 1;
EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
ProcessPacket(3);
@@ -6658,13 +6445,8 @@
0, NO_FIN);
// Check that ack is bundled with outgoing data and that delayed ack
// alarm is reset.
- if (GetParam().no_stop_waiting) {
- EXPECT_EQ(2u, writer_->frame_count());
- EXPECT_TRUE(writer_->stop_waiting_frames().empty());
- } else {
- EXPECT_EQ(3u, writer_->frame_count());
- EXPECT_FALSE(writer_->stop_waiting_frames().empty());
- }
+ EXPECT_EQ(2u, writer_->frame_count());
+ EXPECT_TRUE(writer_->stop_waiting_frames().empty());
EXPECT_FALSE(writer_->ack_frames().empty());
EXPECT_FALSE(connection_.HasPendingAcks());
}
@@ -6679,13 +6461,8 @@
ProcessCryptoPacketAtLevel(1, ENCRYPTION_INITIAL);
connection_.SendCryptoDataWithString("foo", 0);
// Check that ack is bundled with outgoing crypto data.
- if (GetParam().no_stop_waiting) {
- EXPECT_EQ(3u, writer_->frame_count());
- EXPECT_TRUE(writer_->stop_waiting_frames().empty());
- } else {
- EXPECT_EQ(4u, writer_->frame_count());
- EXPECT_FALSE(writer_->stop_waiting_frames().empty());
- }
+ EXPECT_EQ(3u, writer_->frame_count());
+ EXPECT_TRUE(writer_->stop_waiting_frames().empty());
EXPECT_FALSE(connection_.HasPendingAcks());
}
@@ -6728,13 +6505,8 @@
}
ProcessCryptoPacketAtLevel(2, ENCRYPTION_INITIAL);
// Check that ack is sent and that delayed ack alarm is reset.
- if (GetParam().no_stop_waiting) {
- EXPECT_EQ(3u, writer_->frame_count());
- EXPECT_TRUE(writer_->stop_waiting_frames().empty());
- } else {
- EXPECT_EQ(4u, writer_->frame_count());
- EXPECT_FALSE(writer_->stop_waiting_frames().empty());
- }
+ EXPECT_EQ(3u, writer_->frame_count());
+ EXPECT_TRUE(writer_->stop_waiting_frames().empty());
if (!QuicVersionUsesCryptoFrames(connection_.transport_version())) {
EXPECT_EQ(1u, writer_->stream_frames().size());
} else {
@@ -6772,13 +6544,8 @@
ProcessCryptoPacketAtLevel(2, ENCRYPTION_INITIAL);
}
// Check that ack is sent and that delayed ack alarm is reset.
- if (GetParam().no_stop_waiting) {
- EXPECT_EQ(3u, writer_->frame_count());
- EXPECT_TRUE(writer_->stop_waiting_frames().empty());
- } else {
- EXPECT_EQ(4u, writer_->frame_count());
- EXPECT_FALSE(writer_->stop_waiting_frames().empty());
- }
+ EXPECT_EQ(3u, writer_->frame_count());
+ EXPECT_TRUE(writer_->stop_waiting_frames().empty());
if (!QuicVersionUsesCryptoFrames(connection_.transport_version())) {
EXPECT_EQ(1u, writer_->stream_frames().size());
} else {
@@ -6835,20 +6602,9 @@
// Check that ack is bundled with outgoing data and the delayed ack
// alarm is reset.
- if (GetParam().no_stop_waiting) {
- // Do not ACK acks.
- EXPECT_EQ(1u, writer_->frame_count());
- } else {
- EXPECT_EQ(3u, writer_->frame_count());
- EXPECT_FALSE(writer_->stop_waiting_frames().empty());
- }
- if (GetParam().no_stop_waiting) {
- EXPECT_TRUE(writer_->ack_frames().empty());
- } else {
- EXPECT_FALSE(writer_->ack_frames().empty());
- EXPECT_EQ(QuicPacketNumber(3u),
- LargestAcked(writer_->ack_frames().front()));
- }
+ // Do not ACK acks.
+ EXPECT_EQ(1u, writer_->frame_count());
+ EXPECT_TRUE(writer_->ack_frames().empty());
EXPECT_EQ(1u, writer_->stream_frames().size());
EXPECT_FALSE(connection_.HasPendingAcks());
}
@@ -6976,29 +6732,7 @@
connection_.peer_address());
}
-TEST_P(QuicConnectionTest, PublicReset) {
- if (GetParam().version.HasIetfInvariantHeader()) {
- return;
- }
- QuicPublicResetPacket header;
- // Public reset packet in only built by server.
- header.connection_id = connection_id_;
- std::unique_ptr<QuicEncryptedPacket> packet(
- framer_.BuildPublicResetPacket(header));
- std::unique_ptr<QuicReceivedPacket> received(
- ConstructReceivedPacket(*packet, QuicTime::Zero()));
- EXPECT_CALL(visitor_, OnConnectionClosed(_, ConnectionCloseSource::FROM_PEER))
- .WillOnce(Invoke(this, &QuicConnectionTest::SaveConnectionCloseFrame));
- connection_.ProcessUdpPacket(kSelfAddress, kPeerAddress, *received);
- EXPECT_EQ(1, connection_close_frame_count_);
- EXPECT_THAT(saved_connection_close_frame_.quic_error_code,
- IsError(QUIC_PUBLIC_RESET));
-}
-
TEST_P(QuicConnectionTest, IetfStatelessReset) {
- if (!GetParam().version.HasIetfInvariantHeader()) {
- return;
- }
QuicConfig config;
QuicConfigPeer::SetReceivedStatelessResetToken(&config,
kTestStatelessResetToken);
@@ -7062,17 +6796,6 @@
connection_.ProcessUdpPacket(kSelfAddress, kPeerAddress, encrypted);
}
-TEST_P(QuicConnectionTest, MissingPacketsBeforeLeastUnacked) {
- if (GetParam().version.HasIetfInvariantHeader()) {
- return;
- }
- // Set the packet number of the ack packet to be least unacked (4).
- QuicPacketCreatorPeer::SetPacketNumber(&peer_creator_, 3);
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- ProcessStopWaitingPacket(InitStopWaitingFrame(4));
- EXPECT_FALSE(connection_.ack_frame().packets.Empty());
-}
-
TEST_P(QuicConnectionTest, ClientHandlesVersionNegotiation) {
// All supported versions except the one the connection supports.
ParsedQuicVersionVector versions;
@@ -7085,8 +6808,7 @@
// Send a version negotiation packet.
std::unique_ptr<QuicEncryptedPacket> encrypted(
QuicFramer::BuildVersionNegotiationPacket(
- connection_id_, EmptyQuicConnectionId(),
- connection_.version().HasIetfInvariantHeader(),
+ connection_id_, EmptyQuicConnectionId(), /*ietf_quic=*/true,
connection_.version().HasLengthPrefixedConnectionIds(), versions));
std::unique_ptr<QuicReceivedPacket> received(
ConstructReceivedPacket(*encrypted, QuicTime::Zero()));
@@ -7120,8 +6842,7 @@
// Send a version negotiation packet.
std::unique_ptr<QuicEncryptedPacket> encrypted(
QuicFramer::BuildVersionNegotiationPacket(
- connection_id_, EmptyQuicConnectionId(),
- connection_.version().HasIetfInvariantHeader(),
+ connection_id_, EmptyQuicConnectionId(), /*ietf_quic=*/true,
connection_.version().HasLengthPrefixedConnectionIds(), versions));
std::unique_ptr<QuicReceivedPacket> received(
ConstructReceivedPacket(*encrypted, QuicTime::Zero()));
@@ -7143,8 +6864,7 @@
.WillOnce(Invoke(this, &QuicConnectionTest::SaveConnectionCloseFrame));
std::unique_ptr<QuicEncryptedPacket> encrypted(
QuicFramer::BuildVersionNegotiationPacket(
- connection_id_, EmptyQuicConnectionId(),
- connection_.version().HasIetfInvariantHeader(),
+ connection_id_, EmptyQuicConnectionId(), /*ietf_quic=*/true,
connection_.version().HasLengthPrefixedConnectionIds(),
AllSupportedVersions()));
std::unique_ptr<QuicReceivedPacket> received(
@@ -7161,14 +6881,9 @@
if (peer_framer_.perspective() == Perspective::IS_SERVER) {
header.source_connection_id = connection_id_;
header.destination_connection_id_included = CONNECTION_ID_ABSENT;
- if (!peer_framer_.version().HasIetfInvariantHeader()) {
- header.source_connection_id_included = CONNECTION_ID_PRESENT;
- }
} else {
header.destination_connection_id = connection_id_;
- if (peer_framer_.version().HasIetfInvariantHeader()) {
- header.destination_connection_id_included = CONNECTION_ID_ABSENT;
- }
+ header.destination_connection_id_included = CONNECTION_ID_ABSENT;
}
header.packet_number = QuicPacketNumber(1);
header.version_flag = false;
@@ -7274,9 +6989,7 @@
TEST_P(QuicConnectionTest, OnPacketHeaderDebugVisitor) {
QuicPacketHeader header;
header.packet_number = QuicPacketNumber(1);
- if (GetParam().version.HasIetfInvariantHeader()) {
- header.form = IETF_QUIC_LONG_HEADER_PACKET;
- }
+ header.form = IETF_QUIC_LONG_HEADER_PACKET;
MockQuicConnectionDebugVisitor debug_visitor;
connection_.set_debug_visitor(&debug_visitor);
@@ -8384,11 +8097,7 @@
// Simulate the alarm firing and check that a PING is sent.
connection_.GetPingAlarm()->Fire();
size_t padding_frame_count = writer_->padding_frames().size();
- if (GetParam().no_stop_waiting) {
- EXPECT_EQ(padding_frame_count + 2u, writer_->frame_count());
- } else {
- EXPECT_EQ(padding_frame_count + 3u, writer_->frame_count());
- }
+ EXPECT_EQ(padding_frame_count + 2u, writer_->frame_count());
ASSERT_EQ(1u, writer_->ping_frames().size());
}
@@ -8454,12 +8163,8 @@
writer_->Reset();
connection_.GetPingAlarm()->Fire();
size_t padding_frame_count = writer_->padding_frames().size();
- if (GetParam().no_stop_waiting) {
- // Do not ACK acks.
- EXPECT_EQ(padding_frame_count + 1u, writer_->frame_count());
- } else {
- EXPECT_EQ(padding_frame_count + 3u, writer_->frame_count());
- }
+ // Do not ACK acks.
+ EXPECT_EQ(padding_frame_count + 1u, writer_->frame_count());
ASSERT_EQ(1u, writer_->ping_frames().size());
}
@@ -8773,9 +8478,6 @@
}
TEST_P(QuicConnectionTest, SendMessage) {
- if (!VersionSupportsMessageFrames(connection_.transport_version())) {
- return;
- }
if (connection_.version().UsesTls()) {
QuicConfig config;
QuicConfigPeer::SetReceivedMaxDatagramFrameSize(
@@ -8812,9 +8514,6 @@
}
TEST_P(QuicConnectionTest, GetCurrentLargestMessagePayload) {
- if (!connection_.version().SupportsMessageFrames()) {
- return;
- }
QuicPacketLength expected_largest_payload = 1215;
if (connection_.version().SendsVariableLengthPacketNumberInLongHeader()) {
expected_largest_payload += 3;
@@ -8843,9 +8542,6 @@
}
TEST_P(QuicConnectionTest, GetGuaranteedLargestMessagePayload) {
- if (!connection_.version().SupportsMessageFrames()) {
- return;
- }
QuicPacketLength expected_largest_payload = 1215;
if (connection_.version().HasLongHeaderLengths()) {
expected_largest_payload -= 2;
@@ -8871,8 +8567,7 @@
}
TEST_P(QuicConnectionTest, LimitedLargestMessagePayload) {
- if (!connection_.version().SupportsMessageFrames() ||
- !connection_.version().UsesTls()) {
+ if (!connection_.version().UsesTls()) {
return;
}
constexpr QuicPacketLength kFrameSizeLimit = 1000;
@@ -9171,41 +8866,6 @@
QuicConnectionPeer::GetCurrentPacketContent(&connection_));
}
-// Regression test for b/120791670
-TEST_P(QuicConnectionTest, StopProcessingGQuicPacketInIetfQuicConnection) {
- // This test mimics a problematic scenario where a QUIC connection using a
- // modern version received a Q043 packet and processed it incorrectly.
- // We can remove this test once Q043 is deprecated.
- if (!version().HasIetfInvariantHeader()) {
- return;
- }
- set_perspective(Perspective::IS_SERVER);
- if (QuicVersionUsesCryptoFrames(connection_.transport_version())) {
- EXPECT_CALL(visitor_, OnCryptoFrame(_)).Times(1);
- } else {
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
- }
- ProcessFramePacketWithAddresses(MakeCryptoFrame(), kSelfAddress, kPeerAddress,
- ENCRYPTION_INITIAL);
-
- // Let connection process a Google QUIC packet.
- peer_framer_.set_version_for_tests(ParsedQuicVersion::Q043());
- std::unique_ptr<QuicPacket> packet(
- ConstructDataPacket(2, !kHasStopWaiting, ENCRYPTION_INITIAL));
- char buffer[kMaxOutgoingPacketSize];
- size_t encrypted_length =
- peer_framer_.EncryptPayload(ENCRYPTION_INITIAL, QuicPacketNumber(2),
- *packet, buffer, kMaxOutgoingPacketSize);
- // Make sure no stream frame is processed.
- EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(0);
- connection_.ProcessUdpPacket(
- kSelfAddress, kPeerAddress,
- QuicReceivedPacket(buffer, encrypted_length, clock_.Now(), false));
-
- EXPECT_EQ(2u, connection_.GetStats().packets_received);
- EXPECT_EQ(1u, connection_.GetStats().packets_processed);
-}
-
TEST_P(QuicConnectionTest, AcceptPacketNumberZero) {
if (!VersionHasIetfQuicFrames(version().transport_version)) {
return;
@@ -10812,9 +10472,6 @@
// Regression test for b/151220135.
TEST_P(QuicConnectionTest, SendPingWhenSkipPacketNumberForPto) {
- if (!VersionSupportsMessageFrames(connection_.transport_version())) {
- return;
- }
QuicConfig config;
QuicTagVector connection_options;
connection_options.push_back(kPTOS);
diff --git a/quiche/quic/core/quic_crypto_stream.cc b/quiche/quic/core/quic_crypto_stream.cc
index 31c2180..925baa6 100644
--- a/quiche/quic/core/quic_crypto_stream.cc
+++ b/quiche/quic/core/quic_crypto_stream.cc
@@ -59,9 +59,7 @@
}
return QuicPacketCreator::StreamFramePacketOverhead(
version, connection_id.length(), 0, /*include_version=*/true,
- /*include_diversification_nonce=*/true,
- VersionHasIetfInvariantHeader(version) ? PACKET_4BYTE_PACKET_NUMBER
- : PACKET_1BYTE_PACKET_NUMBER,
+ /*include_diversification_nonce=*/true, PACKET_4BYTE_PACKET_NUMBER,
retry_token_length_length, length_length,
/*offset=*/0);
}
diff --git a/quiche/quic/core/quic_crypto_stream_test.cc b/quiche/quic/core/quic_crypto_stream_test.cc
index cd6d3cf..76f840b 100644
--- a/quiche/quic/core/quic_crypto_stream_test.cc
+++ b/quiche/quic/core/quic_crypto_stream_test.cc
@@ -639,10 +639,7 @@
for (const ParsedQuicVersion& version :
AllSupportedVersionsWithQuicCrypto()) {
SCOPED_TRACE(version);
- QuicByteCount expected_overhead = 48;
- if (version.HasIetfInvariantHeader()) {
- expected_overhead += 4;
- }
+ QuicByteCount expected_overhead = 52;
if (version.HasLongHeaderLengths()) {
expected_overhead += 3;
}
diff --git a/quiche/quic/core/quic_dispatcher.cc b/quiche/quic/core/quic_dispatcher.cc
index 9b1b470..d92ffff 100644
--- a/quiche/quic/core/quic_dispatcher.cc
+++ b/quiche/quic/core/quic_dispatcher.cc
@@ -703,19 +703,6 @@
return result;
}
- // We only apply this check for versions that do not use the IETF
- // invariant header because those versions are already checked in
- // QuicDispatcher::MaybeDispatchPacket.
- if (packet_info.version_flag &&
- !packet_info.version.HasIetfInvariantHeader() &&
- crypto_config()->validate_chlo_size() &&
- packet_info.packet.length() < kMinClientInitialPacketLength) {
- QUIC_DVLOG(1) << "Dropping CHLO packet which is too short, length: "
- << packet_info.packet.length();
- QUIC_CODE_COUNT(quic_drop_small_chlo_packets);
- return result;
- }
-
ParsedClientHello& parsed_chlo = result.parsed_chlo.emplace();
parsed_chlo.sni = alpn_extractor.ConsumeSni();
parsed_chlo.uaid = alpn_extractor.ConsumeUaid();
@@ -769,11 +756,7 @@
if (!connection->IsHandshakeComplete()) {
// TODO(fayang): Do not serialize connection close packet if the
// connection is closed by the client.
- if (!connection->version().HasIetfInvariantHeader()) {
- QUIC_CODE_COUNT(gquic_add_to_time_wait_list_with_handshake_failed);
- } else {
- QUIC_CODE_COUNT(quic_v44_add_to_time_wait_list_with_handshake_failed);
- }
+ QUIC_CODE_COUNT(quic_v44_add_to_time_wait_list_with_handshake_failed);
// This serializes a connection close termination packet and adds the
// connection to the time wait list.
StatelessConnectionTerminator terminator(
@@ -783,8 +766,7 @@
terminator.CloseConnection(
QUIC_HANDSHAKE_FAILED,
"Connection is closed by server before handshake confirmed",
- connection->version().HasIetfInvariantHeader(),
- connection->GetActiveServerConnectionIds());
+ /*ietf_quic=*/true, connection->GetActiveServerConnectionIds());
return;
}
QUIC_CODE_COUNT(quic_v44_add_to_time_wait_list_with_stateless_reset);
@@ -792,8 +774,7 @@
time_wait_list_manager_->AddConnectionIdToTimeWait(
action,
TimeWaitConnectionInfo(
- connection->version().HasIetfInvariantHeader(),
- connection->termination_packets(),
+ /*ietf_quic=*/true, connection->termination_packets(),
connection->GetActiveServerConnectionIds(),
connection->sent_packet_manager().GetRttStats()->smoothed_rtt()));
}
diff --git a/quiche/quic/core/quic_dispatcher_test.cc b/quiche/quic/core/quic_dispatcher_test.cc
index 12a62bb..ff2516a 100644
--- a/quiche/quic/core/quic_dispatcher_test.cc
+++ b/quiche/quic/core/quic_dispatcher_test.cc
@@ -953,14 +953,7 @@
uint8_t short_packet[22] = {0x70, 0xa7, 0x02, 0x6b};
uint8_t valid_size_packet[23] = {0x70, 0xa7, 0x02, 0x6c};
- size_t short_packet_len;
- if (version_.HasIetfInvariantHeader()) {
- short_packet_len = 21;
- } else {
- short_packet_len = 22;
- short_packet[0] = 0x0a;
- valid_size_packet[0] = 0x0a;
- }
+ size_t short_packet_len = 21;
QuicReceivedPacket packet(reinterpret_cast<char*>(short_packet),
short_packet_len, QuicTime::Zero());
QuicReceivedPacket packet2(reinterpret_cast<char*>(valid_size_packet),
@@ -971,21 +964,13 @@
EXPECT_CALL(*time_wait_list_manager_, AddConnectionIdToTimeWait(_, _))
.Times(0);
// Verify small packet is silently dropped.
- if (version_.HasIetfInvariantHeader()) {
- EXPECT_CALL(connection_id_generator_, ConnectionIdLength(0xa7))
- .WillOnce(Return(kQuicDefaultConnectionIdLength));
- } else {
- EXPECT_CALL(connection_id_generator_, ConnectionIdLength(_)).Times(0);
- }
+ EXPECT_CALL(connection_id_generator_, ConnectionIdLength(0xa7))
+ .WillOnce(Return(kQuicDefaultConnectionIdLength));
EXPECT_CALL(*time_wait_list_manager_, SendPublicReset(_, _, _, _, _, _))
.Times(0);
dispatcher_->ProcessPacket(server_address_, client_address, packet);
- if (version_.HasIetfInvariantHeader()) {
- EXPECT_CALL(connection_id_generator_, ConnectionIdLength(0xa7))
- .WillOnce(Return(kQuicDefaultConnectionIdLength));
- } else {
- EXPECT_CALL(connection_id_generator_, ConnectionIdLength(_)).Times(0);
- }
+ EXPECT_CALL(connection_id_generator_, ConnectionIdLength(0xa7))
+ .WillOnce(Return(kQuicDefaultConnectionIdLength));
EXPECT_CALL(*time_wait_list_manager_, SendPublicReset(_, _, _, _, _, _))
.Times(1);
dispatcher_->ProcessPacket(server_address_, client_address, packet2);
@@ -1521,7 +1506,7 @@
dispatcher_->ProcessPacket(server_address_, client_address, received_packet);
}
-static_assert(quic::SupportedVersions().size() == 6u,
+static_assert(quic::SupportedVersions().size() == 5u,
"Please add new RejectDeprecatedVersion tests above this assert "
"when deprecating versions");
diff --git a/quiche/quic/core/quic_flags_list.h b/quiche/quic/core/quic_flags_list.h
index 7f6ba62..39bb408 100644
--- a/quiche/quic/core/quic_flags_list.h
+++ b/quiche/quic/core/quic_flags_list.h
@@ -29,8 +29,6 @@
QUIC_FLAG(quic_reloadable_flag_quic_no_path_degrading_before_handshake_confirmed, true)
// If true, default-enable 5RTO blachole detection.
QUIC_FLAG(quic_reloadable_flag_quic_default_enable_5rto_blackhole_detection2, true)
-// If true, disable QUIC version Q043.
-QUIC_FLAG(quic_reloadable_flag_quic_disable_version_q043, true)
// If true, disable QUIC version Q046.
QUIC_FLAG(quic_reloadable_flag_quic_disable_version_q046, true)
// If true, disable QUIC version Q050.
diff --git a/quiche/quic/core/quic_framer.cc b/quiche/quic/core/quic_framer.cc
index f06f205..b2b1278 100644
--- a/quiche/quic/core/quic_framer.cc
+++ b/quiche/quic/core/quic_framer.cc
@@ -63,10 +63,6 @@
#define ENDPOINT \
(perspective_ == Perspective::IS_SERVER ? "Server: " : "Client: ")
-// Number of bits the packet number length bits are shifted from the right
-// edge of the header.
-const uint8_t kPublicHeaderSequenceNumberShift = 4;
-
// There are two interpretations for the Frame Type byte in the QUIC protocol,
// resulting in two Frame Types: Special Frame Types and Regular Frame Types.
//
@@ -89,7 +85,6 @@
// Masks to determine if the frame type is a special use
// and for specific special frame types.
-const uint8_t kQuicFrameTypeBrokenMask = 0xE0; // 0b 11100000
const uint8_t kQuicFrameTypeSpecialMask = 0xC0; // 0b 11000000
const uint8_t kQuicFrameTypeStreamMask = 0x80;
const uint8_t kQuicFrameTypeAckMask = 0x40;
@@ -160,22 +155,6 @@
return (Delta(target, a) < Delta(target, b)) ? a : b;
}
-QuicPacketNumberLength ReadSequenceNumberLength(uint8_t flags) {
- switch (flags & PACKET_FLAGS_8BYTE_PACKET) {
- case PACKET_FLAGS_8BYTE_PACKET:
- return PACKET_6BYTE_PACKET_NUMBER;
- case PACKET_FLAGS_4BYTE_PACKET:
- return PACKET_4BYTE_PACKET_NUMBER;
- case PACKET_FLAGS_2BYTE_PACKET:
- return PACKET_2BYTE_PACKET_NUMBER;
- case PACKET_FLAGS_1BYTE_PACKET:
- return PACKET_1BYTE_PACKET_NUMBER;
- default:
- QUIC_BUG(quic_bug_10850_1) << "Unreachable case statement.";
- return PACKET_6BYTE_PACKET_NUMBER;
- }
-}
-
QuicPacketNumberLength ReadAckPacketNumberLength(uint8_t flags) {
switch (flags & PACKET_FLAGS_8BYTE_PACKET) {
case PACKET_FLAGS_8BYTE_PACKET:
@@ -471,11 +450,8 @@
}
// static
-size_t QuicFramer::GetMessageFrameSize(QuicTransportVersion version,
- bool last_frame_in_packet,
+size_t QuicFramer::GetMessageFrameSize(bool last_frame_in_packet,
QuicByteCount length) {
- QUIC_BUG_IF(quic_bug_12975_1, !VersionSupportsMessageFrames(version))
- << "Try to serialize MESSAGE frame in " << version;
return kQuicFrameTypeSize +
(last_frame_in_packet ? 0 : QuicDataWriter::GetVarInt62Len(length)) +
length;
@@ -890,13 +866,13 @@
const QuicFrames& frames, char* buffer,
size_t packet_length,
EncryptionLevel level) {
- QUIC_BUG_IF(quic_bug_12975_2,
- header.version_flag && version().HasIetfInvariantHeader() &&
- header.long_packet_type == RETRY && !frames.empty())
+ QUIC_BUG_IF(quic_bug_12975_2, header.version_flag &&
+ header.long_packet_type == RETRY &&
+ !frames.empty())
<< "IETF RETRY packets cannot contain frames " << header;
QuicDataWriter writer(packet_length, buffer);
size_t length_field_offset = 0;
- if (!AppendPacketHeader(header, &writer, &length_field_offset)) {
+ if (!AppendIetfPacketHeader(header, &writer, &length_field_offset)) {
QUIC_BUG(quic_bug_10850_16) << "AppendPacketHeader failed";
return 0;
}
@@ -944,13 +920,6 @@
return 0;
}
break;
- case STOP_WAITING_FRAME:
- if (!AppendStopWaitingFrame(header, frame.stop_waiting_frame,
- &writer)) {
- QUIC_BUG(quic_bug_10850_21) << "AppendStopWaitingFrame failed";
- return 0;
- }
- break;
case MTU_DISCOVERY_FRAME:
// MTU discovery frames are serialized as ping frames.
ABSL_FALLTHROUGH_INTENDED;
@@ -1481,16 +1450,12 @@
bool QuicFramer::ProcessPacketInternal(const QuicEncryptedPacket& packet) {
QuicDataReader reader(packet.data(), packet.length());
-
- const bool packet_has_ietf_packet_header = version_.HasIetfInvariantHeader();
- if (packet_has_ietf_packet_header) {
- QUIC_DVLOG(1) << ENDPOINT << "Processing IETF QUIC packet.";
- }
+ QUIC_DVLOG(1) << ENDPOINT << "Processing IETF QUIC packet.";
visitor_->OnPacket();
QuicPacketHeader header;
- if (!ProcessPublicHeader(&reader, packet_has_ietf_packet_header, &header)) {
+ if (!ProcessIetfPacketHeader(&reader, &header)) {
QUICHE_DCHECK_NE("", detailed_error_);
QUIC_DVLOG(1) << ENDPOINT << "Unable to process public header. Error: "
<< detailed_error_;
@@ -1504,7 +1469,7 @@
return true;
}
- if (IsVersionNegotiation(header, packet_has_ietf_packet_header)) {
+ if (IsVersionNegotiation(header)) {
if (perspective_ == Perspective::IS_CLIENT) {
QUIC_DVLOG(1) << "Client received version negotiation packet";
return ProcessVersionNegotiationPacket(&reader, header);
@@ -1535,28 +1500,16 @@
bool rv;
if (header.long_packet_type == RETRY) {
rv = ProcessRetryPacket(&reader, header);
- } else if (header.reset_flag) {
- rv = ProcessPublicResetPacket(&reader, header);
} else if (packet.length() <= kMaxIncomingPacketSize) {
// The optimized decryption algorithm implementations run faster when
// operating on aligned memory.
ABSL_CACHELINE_ALIGNED char buffer[kMaxIncomingPacketSize];
- if (packet_has_ietf_packet_header) {
- rv = ProcessIetfDataPacket(&reader, &header, packet, buffer,
- ABSL_ARRAYSIZE(buffer));
- } else {
- rv = ProcessDataPacket(&reader, &header, packet, buffer,
- ABSL_ARRAYSIZE(buffer));
- }
+ rv = ProcessIetfDataPacket(&reader, &header, packet, buffer,
+ ABSL_ARRAYSIZE(buffer));
} else {
std::unique_ptr<char[]> large_buffer(new char[packet.length()]);
- if (packet_has_ietf_packet_header) {
- rv = ProcessIetfDataPacket(&reader, &header, packet, large_buffer.get(),
- packet.length());
- } else {
- rv = ProcessDataPacket(&reader, &header, packet, large_buffer.get(),
- packet.length());
- }
+ rv = ProcessIetfDataPacket(&reader, &header, packet, large_buffer.get(),
+ packet.length());
QUIC_BUG_IF(quic_bug_10850_53, rv)
<< "QUIC should never successfully process packets larger"
<< "than kMaxIncomingPacketSize. packet size:" << packet.length();
@@ -1969,130 +1922,6 @@
return true;
}
-bool QuicFramer::ProcessDataPacket(QuicDataReader* encrypted_reader,
- QuicPacketHeader* header,
- const QuicEncryptedPacket& packet,
- char* decrypted_buffer,
- size_t buffer_length) {
- if (!ProcessUnauthenticatedHeader(encrypted_reader, header)) {
- QUICHE_DCHECK_NE("", detailed_error_);
- QUIC_DVLOG(1)
- << ENDPOINT
- << "Unable to process packet header. Stopping parsing. Error: "
- << detailed_error_;
- RecordDroppedPacketReason(DroppedPacketReason::INVALID_PACKET_NUMBER);
- return false;
- }
-
- absl::string_view encrypted = encrypted_reader->ReadRemainingPayload();
- absl::string_view associated_data = GetAssociatedDataFromEncryptedPacket(
- version_.transport_version, packet,
- GetIncludedDestinationConnectionIdLength(*header),
- GetIncludedSourceConnectionIdLength(*header), header->version_flag,
- header->nonce != nullptr, header->packet_number_length,
- header->retry_token_length_length, header->retry_token.length(),
- header->length_length);
-
- size_t decrypted_length = 0;
- EncryptionLevel decrypted_level;
- if (!DecryptPayload(packet.length(), encrypted, associated_data, *header,
- decrypted_buffer, buffer_length, &decrypted_length,
- &decrypted_level)) {
- const EncryptionLevel decryption_level = decrypter_level_;
- // This version uses trial decryption so we always report to our visitor
- // that we are not certain we have the correct decryption key.
- const bool has_decryption_key = false;
- visitor_->OnUndecryptablePacket(
- QuicEncryptedPacket(encrypted_reader->FullPayload()), decryption_level,
- has_decryption_key);
- RecordDroppedPacketReason(DroppedPacketReason::DECRYPTION_FAILURE);
- set_detailed_error(absl::StrCat("Unable to decrypt ",
- EncryptionLevelToString(decryption_level),
- " payload."));
- return RaiseError(QUIC_DECRYPTION_FAILURE);
- }
-
- QuicDataReader reader(decrypted_buffer, decrypted_length);
-
- // Update the largest packet number after we have decrypted the packet
- // so we are confident is not attacker controlled.
- if (supports_multiple_packet_number_spaces_) {
- largest_decrypted_packet_numbers_[QuicUtils::GetPacketNumberSpace(
- decrypted_level)]
- .UpdateMax(header->packet_number);
- } else {
- largest_packet_number_.UpdateMax(header->packet_number);
- }
-
- if (!visitor_->OnPacketHeader(*header)) {
- // The visitor suppresses further processing of the packet.
- return true;
- }
-
- if (packet.length() > kMaxIncomingPacketSize) {
- set_detailed_error("Packet too large.");
- return RaiseError(QUIC_PACKET_TOO_LARGE);
- }
-
- // Handle the payload.
- if (!ProcessFrameData(&reader, *header)) {
- QUICHE_DCHECK_NE(QUIC_NO_ERROR,
- error_); // ProcessFrameData sets the error.
- QUICHE_DCHECK_NE("", detailed_error_);
- QUIC_DLOG(WARNING) << ENDPOINT << "Unable to process frame data. Error: "
- << detailed_error_;
- return false;
- }
-
- visitor_->OnPacketComplete();
- return true;
-}
-
-bool QuicFramer::ProcessPublicResetPacket(QuicDataReader* reader,
- const QuicPacketHeader& header) {
- QuicPublicResetPacket packet(
- GetServerConnectionIdAsRecipient(header, perspective_));
-
- std::unique_ptr<CryptoHandshakeMessage> reset(
- CryptoFramer::ParseMessage(reader->ReadRemainingPayload()));
- if (!reset) {
- set_detailed_error("Unable to read reset message.");
- RecordDroppedPacketReason(DroppedPacketReason::INVALID_PUBLIC_RESET_PACKET);
- return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET);
- }
- if (reset->tag() != kPRST) {
- set_detailed_error("Incorrect message tag.");
- RecordDroppedPacketReason(DroppedPacketReason::INVALID_PUBLIC_RESET_PACKET);
- return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET);
- }
-
- if (reset->GetUint64(kRNON, &packet.nonce_proof) != QUIC_NO_ERROR) {
- set_detailed_error("Unable to read nonce proof.");
- RecordDroppedPacketReason(DroppedPacketReason::INVALID_PUBLIC_RESET_PACKET);
- return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET);
- }
- // TODO(satyamshekhar): validate nonce to protect against DoS.
-
- absl::string_view address;
- if (reset->GetStringPiece(kCADR, &address)) {
- QuicSocketAddressCoder address_coder;
- if (address_coder.Decode(address.data(), address.length())) {
- packet.client_address =
- QuicSocketAddress(address_coder.ip(), address_coder.port());
- }
- }
-
- absl::string_view endpoint_id;
- if (perspective_ == Perspective::IS_CLIENT &&
- reset->GetStringPiece(kEPID, &endpoint_id)) {
- packet.endpoint_id = std::string(endpoint_id);
- packet.endpoint_id += '\0';
- }
-
- visitor_->OnPublicResetPacket(packet);
- return true;
-}
-
bool QuicFramer::IsIetfStatelessResetPacket(
const QuicPacketHeader& header) const {
QUIC_BUG_IF(quic_bug_12975_3, header.has_possible_stateless_reset_token &&
@@ -2144,89 +1973,6 @@
return ENCRYPTION_ZERO_RTT;
}
-bool QuicFramer::AppendPacketHeader(const QuicPacketHeader& header,
- QuicDataWriter* writer,
- size_t* length_field_offset) {
- if (version().HasIetfInvariantHeader()) {
- return AppendIetfPacketHeader(header, writer, length_field_offset);
- }
- QUIC_DVLOG(1) << ENDPOINT << "Appending header: " << header;
- uint8_t public_flags = 0;
- if (header.reset_flag) {
- public_flags |= PACKET_PUBLIC_FLAGS_RST;
- }
- if (header.version_flag) {
- public_flags |= PACKET_PUBLIC_FLAGS_VERSION;
- }
-
- public_flags |= GetPacketNumberFlags(header.packet_number_length)
- << kPublicHeaderSequenceNumberShift;
-
- if (header.nonce != nullptr) {
- QUICHE_DCHECK_EQ(Perspective::IS_SERVER, perspective_);
- public_flags |= PACKET_PUBLIC_FLAGS_NONCE;
- }
-
- QuicConnectionId server_connection_id =
- GetServerConnectionIdAsSender(header, perspective_);
- QuicConnectionIdIncluded server_connection_id_included =
- GetServerConnectionIdIncludedAsSender(header, perspective_);
- QUICHE_DCHECK_EQ(CONNECTION_ID_ABSENT,
- GetClientConnectionIdIncludedAsSender(header, perspective_))
- << ENDPOINT << ParsedQuicVersionToString(version_)
- << " invalid header: " << header;
-
- switch (server_connection_id_included) {
- case CONNECTION_ID_ABSENT:
- if (!writer->WriteUInt8(public_flags |
- PACKET_PUBLIC_FLAGS_0BYTE_CONNECTION_ID)) {
- return false;
- }
- break;
- case CONNECTION_ID_PRESENT:
- QUIC_BUG_IF(quic_bug_12975_5,
- !QuicUtils::IsConnectionIdValidForVersion(
- server_connection_id, transport_version()))
- << "AppendPacketHeader: attempted to use connection ID "
- << server_connection_id << " which is invalid with version "
- << version();
-
- public_flags |= PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID;
- if (perspective_ == Perspective::IS_CLIENT) {
- public_flags |= PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID_OLD;
- }
- if (!writer->WriteUInt8(public_flags) ||
- !writer->WriteConnectionId(server_connection_id)) {
- return false;
- }
- break;
- }
- last_serialized_server_connection_id_ = server_connection_id;
-
- if (header.version_flag) {
- QUICHE_DCHECK_EQ(Perspective::IS_CLIENT, perspective_);
- QuicVersionLabel version_label = CreateQuicVersionLabel(version_);
- if (!writer->WriteUInt32(version_label)) {
- return false;
- }
-
- QUIC_DVLOG(1) << ENDPOINT << "label = '"
- << QuicVersionLabelToString(version_label) << "'";
- }
-
- if (header.nonce != nullptr &&
- !writer->WriteBytes(header.nonce, kDiversificationNonceSize)) {
- return false;
- }
-
- if (!AppendPacketNumber(header.packet_number_length, header.packet_number,
- writer)) {
- return false;
- }
-
- return true;
-}
-
bool QuicFramer::AppendIetfHeaderTypeByte(const QuicPacketHeader& header,
QuicDataWriter* writer) {
uint8_t type = 0;
@@ -2388,97 +2134,6 @@
next_epoch + packet_number));
}
-bool QuicFramer::ProcessPublicHeader(QuicDataReader* reader,
- bool packet_has_ietf_packet_header,
- QuicPacketHeader* header) {
- if (packet_has_ietf_packet_header) {
- return ProcessIetfPacketHeader(reader, header);
- }
- uint8_t public_flags;
- if (!reader->ReadBytes(&public_flags, 1)) {
- set_detailed_error("Unable to read public flags.");
- return false;
- }
-
- header->reset_flag = (public_flags & PACKET_PUBLIC_FLAGS_RST) != 0;
- header->version_flag = (public_flags & PACKET_PUBLIC_FLAGS_VERSION) != 0;
-
- if (validate_flags_ && !header->version_flag &&
- public_flags > PACKET_PUBLIC_FLAGS_MAX) {
- set_detailed_error("Illegal public flags value.");
- return false;
- }
-
- if (header->reset_flag && header->version_flag) {
- set_detailed_error("Got version flag in reset packet");
- return false;
- }
-
- QuicConnectionId* header_connection_id = &header->destination_connection_id;
- QuicConnectionIdIncluded* header_connection_id_included =
- &header->destination_connection_id_included;
- if (perspective_ == Perspective::IS_CLIENT) {
- header_connection_id = &header->source_connection_id;
- header_connection_id_included = &header->source_connection_id_included;
- }
- switch (public_flags & PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID) {
- case PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID:
- if (!reader->ReadConnectionId(header_connection_id,
- kQuicDefaultConnectionIdLength)) {
- set_detailed_error("Unable to read ConnectionId.");
- return false;
- }
- *header_connection_id_included = CONNECTION_ID_PRESENT;
- break;
- case PACKET_PUBLIC_FLAGS_0BYTE_CONNECTION_ID:
- *header_connection_id_included = CONNECTION_ID_ABSENT;
- *header_connection_id = last_serialized_server_connection_id_;
- break;
- }
-
- header->packet_number_length = ReadSequenceNumberLength(
- public_flags >> kPublicHeaderSequenceNumberShift);
-
- // Read the version only if the packet is from the client.
- // version flag from the server means version negotiation packet.
- if (header->version_flag && perspective_ == Perspective::IS_SERVER) {
- QuicVersionLabel version_label;
- if (!ProcessVersionLabel(reader, &version_label)) {
- set_detailed_error("Unable to read protocol version.");
- return false;
- }
- // If the version from the new packet is the same as the version of this
- // framer, then the public flags should be set to something we understand.
- // If not, this raises an error.
- ParsedQuicVersion version = ParseQuicVersionLabel(version_label);
- if (version == version_ && public_flags > PACKET_PUBLIC_FLAGS_MAX) {
- set_detailed_error("Illegal public flags value.");
- return false;
- }
- header->version = version;
- }
-
- // A nonce should only be present in packets from the server to the client,
- // which are neither version negotiation nor public reset packets.
- if (public_flags & PACKET_PUBLIC_FLAGS_NONCE &&
- !(public_flags & PACKET_PUBLIC_FLAGS_VERSION) &&
- !(public_flags & PACKET_PUBLIC_FLAGS_RST) &&
- // The nonce flag from a client is ignored and is assumed to be an older
- // client indicating an eight-byte connection ID.
- perspective_ == Perspective::IS_CLIENT) {
- if (!reader->ReadBytes(reinterpret_cast<uint8_t*>(last_nonce_.data()),
- last_nonce_.size())) {
- set_detailed_error("Unable to read nonce.");
- return false;
- }
- header->nonce = &last_nonce_;
- } else {
- header->nonce = nullptr;
- }
-
- return true;
-}
-
// static
QuicPacketNumberLength QuicFramer::GetMinPacketNumberLength(
QuicPacketNumber packet_number) {
@@ -2547,57 +2202,6 @@
return new_ack_info;
}
-bool QuicFramer::ProcessUnauthenticatedHeader(QuicDataReader* encrypted_reader,
- QuicPacketHeader* header) {
- QuicPacketNumber base_packet_number;
- if (supports_multiple_packet_number_spaces_) {
- PacketNumberSpace pn_space = GetPacketNumberSpace(*header);
- if (pn_space == NUM_PACKET_NUMBER_SPACES) {
- set_detailed_error("Unable to determine packet number space.");
- return RaiseError(QUIC_INVALID_PACKET_HEADER);
- }
- base_packet_number = largest_decrypted_packet_numbers_[pn_space];
- } else {
- base_packet_number = largest_packet_number_;
- }
- uint64_t full_packet_number;
- if (!ProcessAndCalculatePacketNumber(
- encrypted_reader, header->packet_number_length, base_packet_number,
- &full_packet_number)) {
- set_detailed_error("Unable to read packet number.");
- return RaiseError(QUIC_INVALID_PACKET_HEADER);
- }
-
- if (!IsValidFullPacketNumber(full_packet_number, version())) {
- set_detailed_error("packet numbers cannot be 0.");
- return RaiseError(QUIC_INVALID_PACKET_HEADER);
- }
- header->packet_number = QuicPacketNumber(full_packet_number);
-
- if (!visitor_->OnUnauthenticatedHeader(*header)) {
- set_detailed_error(
- "Visitor asked to stop processing of unauthenticated header.");
- return false;
- }
- // The function we are in is called because the framer believes that it is
- // processing a packet that uses the non-IETF (i.e. Google QUIC) packet header
- // type. Usually, the framer makes that decision based on the framer's
- // version, but when the framer is used with Perspective::IS_SERVER, then
- // before version negotiation is complete (specifically, before
- // InferPacketHeaderTypeFromVersion is called), this decision is made based on
- // the type byte of the packet.
- //
- // If the framer's version KnowsWhichDecrypterToUse, then that version expects
- // to use the IETF packet header type. If that's the case and we're in this
- // function, then the packet received is invalid: the framer was expecting an
- // IETF packet header and didn't get one.
- if (version().KnowsWhichDecrypterToUse()) {
- set_detailed_error("Invalid public header type for expected version.");
- return RaiseError(QUIC_INVALID_PACKET_HEADER);
- }
- return true;
-}
-
bool QuicFramer::ProcessIetfHeaderTypeByte(QuicDataReader* reader,
QuicPacketHeader* header) {
uint8_t type;
@@ -2783,13 +2387,12 @@
bool has_length_prefix;
std::string detailed_error;
QuicErrorCode parse_result = QuicFramer::ParsePublicHeader(
- reader, expected_destination_connection_id_length,
- version_.HasIetfInvariantHeader(), &header->type_byte, &header->form,
- &header->version_flag, &has_length_prefix, &version_label,
- &header->version, &header->destination_connection_id,
- &header->source_connection_id, &header->long_packet_type,
- &header->retry_token_length_length, &header->retry_token,
- &detailed_error);
+ reader, expected_destination_connection_id_length, /*ietf_format=*/true,
+ &header->type_byte, &header->form, &header->version_flag,
+ &has_length_prefix, &version_label, &header->version,
+ &header->destination_connection_id, &header->source_connection_id,
+ &header->long_packet_type, &header->retry_token_length_length,
+ &header->retry_token, &detailed_error);
if (parse_result != QUIC_NO_ERROR) {
set_detailed_error(detailed_error);
return false;
@@ -2920,10 +2523,7 @@
set_detailed_error("Unable to read frame type.");
return RaiseError(QUIC_INVALID_FRAME_DATA);
}
- const uint8_t special_mask = version_.HasIetfInvariantHeader()
- ? kQuicFrameTypeSpecialMask
- : kQuicFrameTypeBrokenMask;
- if (frame_type & special_mask) {
+ if (frame_type & kQuicFrameTypeSpecialMask) {
// Stream Frame
if (frame_type & kQuicFrameTypeStreamMask) {
QuicStreamFrame frame;
@@ -5182,8 +4782,7 @@
// MTU discovery frames are serialized as ping frames.
return kQuicFrameTypeSize;
case MESSAGE_FRAME:
- return GetMessageFrameSize(version_.transport_version,
- last_frame_in_packet,
+ return GetMessageFrameSize(last_frame_in_packet,
frame.message_frame->message_length);
case PADDING_FRAME:
QUICHE_DCHECK(false);
@@ -5991,39 +5590,6 @@
return FrameAckTimestampRanges(frame, timestamp_ranges, writer) > 0;
}
-bool QuicFramer::AppendStopWaitingFrame(const QuicPacketHeader& header,
- const QuicStopWaitingFrame& frame,
- QuicDataWriter* writer) {
- QUICHE_DCHECK(!version_.HasIetfInvariantHeader());
- QUICHE_DCHECK(frame.least_unacked.IsInitialized());
- QUICHE_DCHECK_GE(header.packet_number, frame.least_unacked);
- const uint64_t least_unacked_delta =
- header.packet_number - frame.least_unacked;
- const uint64_t length_shift = header.packet_number_length * 8;
-
- if (least_unacked_delta >> length_shift > 0) {
- QUIC_BUG(quic_bug_10850_86)
- << "packet_number_length " << header.packet_number_length
- << " is too small for least_unacked_delta: " << least_unacked_delta
- << " packet_number:" << header.packet_number
- << " least_unacked:" << frame.least_unacked
- << " version:" << version_.transport_version;
- return false;
- }
- if (least_unacked_delta == 0) {
- return writer->WriteBytesToUInt64(header.packet_number_length,
- least_unacked_delta);
- }
- if (!AppendPacketNumber(header.packet_number_length,
- QuicPacketNumber(least_unacked_delta), writer)) {
- QUIC_BUG(quic_bug_10850_87)
- << " seq failed: " << header.packet_number_length;
- return false;
- }
-
- return true;
-}
-
bool QuicFramer::AppendIetfAckFrameAndTypeByte(const QuicAckFrame& frame,
QuicDataWriter* writer) {
uint8_t type = IETF_ACK;
@@ -6279,16 +5845,9 @@
return false;
}
-bool QuicFramer::IsVersionNegotiation(
- const QuicPacketHeader& header, bool packet_has_ietf_packet_header) const {
- if (!packet_has_ietf_packet_header &&
- perspective_ == Perspective::IS_CLIENT) {
- return header.version_flag;
- }
- if (header.form == IETF_QUIC_SHORT_HEADER_PACKET) {
- return false;
- }
- return header.long_packet_type == VERSION_NEGOTIATION;
+bool QuicFramer::IsVersionNegotiation(const QuicPacketHeader& header) const {
+ return header.form == IETF_QUIC_LONG_HEADER_PACKET &&
+ header.long_packet_type == VERSION_NEGOTIATION;
}
bool QuicFramer::AppendIetfConnectionCloseFrame(
diff --git a/quiche/quic/core/quic_framer.h b/quiche/quic/core/quic_framer.h
index b93667e..aaf7733 100644
--- a/quiche/quic/core/quic_framer.h
+++ b/quiche/quic/core/quic_framer.h
@@ -85,10 +85,6 @@
// has been validated or processed.
virtual void OnPacket() = 0;
- // Called when a public reset packet has been parsed but has not yet
- // been validated.
- virtual void OnPublicResetPacket(const QuicPublicResetPacket& packet) = 0;
-
// Called only when |perspective_| is IS_CLIENT and a version negotiation
// packet has been parsed.
virtual void OnVersionNegotiationPacket(
@@ -350,8 +346,7 @@
// data length provided, but not counting the size of the data payload.
static size_t GetMinCryptoFrameSize(QuicStreamOffset offset,
QuicPacketLength data_length);
- static size_t GetMessageFrameSize(QuicTransportVersion version,
- bool last_frame_in_packet,
+ static size_t GetMessageFrameSize(bool last_frame_in_packet,
QuicByteCount length);
// Size in bytes of all ack frame fields without the missing packets or ack
// blocks.
@@ -527,8 +522,6 @@
// If header.version_flag is set, the version in the
// packet will be set -- but it will be set from version_ not
// header.versions.
- bool AppendPacketHeader(const QuicPacketHeader& header,
- QuicDataWriter* writer, size_t* length_field_offset);
bool AppendIetfHeaderTypeByte(const QuicPacketHeader& header,
QuicDataWriter* writer);
bool AppendIetfPacketHeader(const QuicPacketHeader& header,
@@ -795,18 +788,11 @@
uint64_t* full_packet_number,
std::vector<char>* associated_data);
- bool ProcessDataPacket(QuicDataReader* reader, QuicPacketHeader* header,
- const QuicEncryptedPacket& packet,
- char* decrypted_buffer, size_t buffer_length);
-
bool ProcessIetfDataPacket(QuicDataReader* encrypted_reader,
QuicPacketHeader* header,
const QuicEncryptedPacket& packet,
char* decrypted_buffer, size_t buffer_length);
- bool ProcessPublicResetPacket(QuicDataReader* reader,
- const QuicPacketHeader& header);
-
bool ProcessVersionNegotiationPacket(QuicDataReader* reader,
const QuicPacketHeader& header);
@@ -820,15 +806,6 @@
bool MaybeProcessIetfLength(QuicDataReader* encrypted_reader,
QuicPacketHeader* header);
- bool ProcessPublicHeader(QuicDataReader* reader,
- bool packet_has_ietf_packet_header,
- QuicPacketHeader* header);
-
- // Processes the unauthenticated portion of the header into |header| from
- // the current QuicDataReader. Returns true on success, false on failure.
- bool ProcessUnauthenticatedHeader(QuicDataReader* encrypted_reader,
- QuicPacketHeader* header);
-
// Processes the version label in the packet header.
static bool ProcessVersionLabel(QuicDataReader* reader,
QuicVersionLabel* version_label);
@@ -1063,8 +1040,7 @@
bool RaiseError(QuicErrorCode error);
// Returns true if |header| indicates a version negotiation packet.
- bool IsVersionNegotiation(const QuicPacketHeader& header,
- bool packet_has_ietf_packet_header) const;
+ bool IsVersionNegotiation(const QuicPacketHeader& header) const;
// Calculates and returns type byte of stream frame.
uint8_t GetStreamFrameTypeByte(const QuicStreamFrame& frame,
diff --git a/quiche/quic/core/quic_framer_test.cc b/quiche/quic/core/quic_framer_test.cc
index 56f0fbc..48d4001 100644
--- a/quiche/quic/core/quic_framer_test.cc
+++ b/quiche/quic/core/quic_framer_test.cc
@@ -244,11 +244,6 @@
void OnPacket() override {}
- void OnPublicResetPacket(const QuicPublicResetPacket& packet) override {
- public_reset_packet_ = std::make_unique<QuicPublicResetPacket>((packet));
- EXPECT_EQ(0u, framer_->current_received_frame_type());
- }
-
void OnVersionNegotiationPacket(
const QuicVersionNegotiationPacket& packet) override {
version_negotiation_packet_ =
@@ -639,7 +634,6 @@
bool accept_public_header_;
std::unique_ptr<QuicPacketHeader> header_;
- std::unique_ptr<QuicPublicResetPacket> public_reset_packet_;
std::unique_ptr<QuicIetfStatelessResetPacket> stateless_reset_packet_;
std::unique_ptr<QuicVersionNegotiationPacket> version_negotiation_packet_;
std::unique_ptr<QuicConnectionId> retry_original_connection_id_;
@@ -1062,16 +1056,6 @@
SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
// clang-format off
unsigned char packet[kMaxIncomingPacketSize + 1] = {
- // public flags (8 byte connection_id)
- 0x28,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x78, 0x56, 0x34, 0x12,
- // private flags
- 0x00,
- };
- unsigned char packet46[kMaxIncomingPacketSize + 1] = {
// type (short header 4 byte packet number)
0x43,
// connection_id
@@ -1080,12 +1064,6 @@
0x78, 0x56, 0x34, 0x12,
};
// clang-format on
- unsigned char* p = packet;
- size_t p_size = ABSL_ARRAYSIZE(packet);
- if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- p_size = ABSL_ARRAYSIZE(packet46);
- }
const size_t header_size = GetPacketHeaderSize(
framer_.transport_version(), kPacket8ByteConnectionId,
@@ -1093,9 +1071,9 @@
PACKET_4BYTE_PACKET_NUMBER, quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0,
quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0);
- memset(p + header_size, 0, kMaxIncomingPacketSize - header_size);
+ memset(packet + header_size, 0, kMaxIncomingPacketSize - header_size);
- QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
+ QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
EXPECT_FALSE(framer_.ProcessPacket(encrypted));
ASSERT_TRUE(visitor_.header_.get());
@@ -1107,68 +1085,9 @@
EXPECT_EQ("Packet too large.", framer_.detailed_error());
}
-TEST_P(QuicFramerTest, PacketHeader) {
- if (framer_.version().HasIetfInvariantHeader()) {
- return;
- }
-
- // clang-format off
- PacketFragments packet = {
- // public flags (8 byte connection_id)
- {"Unable to read public flags.",
- {0x28}},
- // connection_id
- {"Unable to read ConnectionId.",
- {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
- // packet number
- {"Unable to read packet number.",
- {0x12, 0x34, 0x56, 0x78}},
- };
- // clang-format on
-
- PacketFragments& fragments = packet;
-
- std::unique_ptr<QuicEncryptedPacket> encrypted(
- AssemblePacketFromFragments(fragments));
-
- EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
- EXPECT_THAT(framer_.error(), IsError(QUIC_MISSING_PAYLOAD));
- ASSERT_TRUE(visitor_.header_.get());
- EXPECT_EQ(FramerTestConnectionId(),
- visitor_.header_->destination_connection_id);
- EXPECT_FALSE(visitor_.header_->reset_flag);
- EXPECT_FALSE(visitor_.header_->version_flag);
- EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
-
- CheckFramingBoundaries(fragments, QUIC_INVALID_PACKET_HEADER);
-
- PacketHeaderFormat format;
- QuicLongHeaderType long_packet_type = INVALID_PACKET_TYPE;
- bool version_flag;
- QuicConnectionId destination_connection_id, source_connection_id;
- QuicVersionLabel version_label;
- std::string detailed_error;
- bool use_length_prefix;
- absl::optional<absl::string_view> retry_token;
- ParsedQuicVersion parsed_version = UnsupportedQuicVersion();
- const QuicErrorCode error_code = QuicFramer::ParsePublicHeaderDispatcher(
- *encrypted, kQuicDefaultConnectionIdLength, &format, &long_packet_type,
- &version_flag, &use_length_prefix, &version_label, &parsed_version,
- &destination_connection_id, &source_connection_id, &retry_token,
- &detailed_error);
- EXPECT_FALSE(retry_token.has_value());
- EXPECT_FALSE(use_length_prefix);
- EXPECT_THAT(error_code, IsQuicNoError());
- EXPECT_EQ(GOOGLE_QUIC_PACKET, format);
- EXPECT_FALSE(version_flag);
- EXPECT_EQ(kQuicDefaultConnectionIdLength, destination_connection_id.length());
- EXPECT_EQ(FramerTestConnectionId(), destination_connection_id);
- EXPECT_EQ(EmptyQuicConnectionId(), source_connection_id);
-}
-
TEST_P(QuicFramerTest, LongPacketHeader) {
// clang-format off
- PacketFragments packet46 = {
+ PacketFragments packet = {
// type (long header with packet type ZERO_RTT)
{"Unable to read first byte.",
{0xD3}},
@@ -1187,14 +1106,13 @@
};
// clang-format on
- if (!framer_.version().HasIetfInvariantHeader() ||
- QuicVersionHasLongHeaderLengths(framer_.transport_version())) {
+ if (QuicVersionHasLongHeaderLengths(framer_.transport_version())) {
return;
}
SetDecrypterLevel(ENCRYPTION_ZERO_RTT);
std::unique_ptr<QuicEncryptedPacket> encrypted(
- AssemblePacketFromFragments(packet46));
+ AssemblePacketFromFragments(packet));
EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
EXPECT_THAT(framer_.error(), IsError(QUIC_MISSING_PAYLOAD));
@@ -1205,7 +1123,7 @@
EXPECT_TRUE(visitor_.header_->version_flag);
EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
- CheckFramingBoundaries(packet46, QUIC_INVALID_PACKET_HEADER);
+ CheckFramingBoundaries(packet, QUIC_INVALID_PACKET_HEADER);
PacketHeaderFormat format;
QuicLongHeaderType long_packet_type = INVALID_PACKET_TYPE;
@@ -1233,10 +1151,6 @@
}
TEST_P(QuicFramerTest, LongPacketHeaderWithBothConnectionIds) {
- if (!framer_.version().HasIetfInvariantHeader()) {
- // This test requires an IETF long header.
- return;
- }
SetDecrypterLevel(ENCRYPTION_ZERO_RTT);
// clang-format off
unsigned char packet[] = {
@@ -1337,19 +1251,6 @@
TEST_P(QuicFramerTest, ParsePublicHeader) {
// clang-format off
unsigned char packet[] = {
- // public flags (version included, 8-byte connection ID,
- // 4-byte packet number)
- 0x29,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // version
- QUIC_VERSION_BYTES,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
- // padding frame
- 0x00,
- };
- unsigned char packet46[] = {
// public flags (long header with packet type HANDSHAKE and
// 4-byte packet number)
0xE3,
@@ -1392,9 +1293,6 @@
ReviseFirstByteByVersion(packet49);
p = packet49;
p_length = ABSL_ARRAYSIZE(packet49);
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- p_length = ABSL_ARRAYSIZE(packet46);
}
uint8_t first_byte = 0x33;
@@ -1412,12 +1310,11 @@
QuicDataReader reader(AsChars(p), p_length);
const QuicErrorCode parse_error = QuicFramer::ParsePublicHeader(
- &reader, kQuicDefaultConnectionIdLength,
- /*ietf_format=*/
- framer_.version().HasIetfInvariantHeader(), &first_byte, &format,
- &version_present, &has_length_prefix, &version_label, &parsed_version,
- &destination_connection_id, &source_connection_id, &long_packet_type,
- &retry_token_length_length, &retry_token, &detailed_error);
+ &reader, kQuicDefaultConnectionIdLength, /*ietf_format=*/true,
+ &first_byte, &format, &version_present, &has_length_prefix,
+ &version_label, &parsed_version, &destination_connection_id,
+ &source_connection_id, &long_packet_type, &retry_token_length_length,
+ &retry_token, &detailed_error);
EXPECT_THAT(parse_error, IsQuicNoError());
EXPECT_EQ("", detailed_error);
EXPECT_EQ(p[0], first_byte);
@@ -1431,12 +1328,8 @@
EXPECT_EQ(quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0,
retry_token_length_length);
EXPECT_EQ(absl::string_view(), retry_token);
- if (framer_.version().HasIetfInvariantHeader()) {
- EXPECT_EQ(IETF_QUIC_LONG_HEADER_PACKET, format);
- EXPECT_EQ(HANDSHAKE, long_packet_type);
- } else {
- EXPECT_EQ(GOOGLE_QUIC_PACKET, format);
- }
+ EXPECT_EQ(IETF_QUIC_LONG_HEADER_PACKET, format);
+ EXPECT_EQ(HANDSHAKE, long_packet_type);
}
TEST_P(QuicFramerTest, ParsePublicHeaderProxBadSourceConnectionIdLength) {
@@ -1571,16 +1464,6 @@
// clang-format off
PacketFragments packet = {
- // public flags (0 byte connection_id)
- {"Unable to read public flags.",
- {0x20}},
- // connection_id
- // packet number
- {"Unable to read packet number.",
- {0x12, 0x34, 0x56, 0x78}},
- };
-
- PacketFragments packet46 = {
// type (short header, 4 byte packet number)
{"Unable to read first byte.",
{0x43}},
@@ -1602,9 +1485,7 @@
// clang-format on
PacketFragments& fragments =
- framer_.version().HasHeaderProtection()
- ? packet_hp
- : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+ framer_.version().HasHeaderProtection() ? packet_hp : packet;
std::unique_ptr<QuicEncryptedPacket> encrypted(
AssemblePacketFromFragments(fragments));
EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
@@ -1621,21 +1502,6 @@
SetDecrypterLevel(ENCRYPTION_ZERO_RTT);
// clang-format off
PacketFragments packet = {
- // public flags (0 byte connection_id)
- {"Unable to read public flags.",
- {0x29}},
- // connection_id
- {"Unable to read ConnectionId.",
- {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
- // version tag
- {"Unable to read protocol version.",
- {QUIC_VERSION_BYTES}},
- // packet number
- {"Unable to read packet number.",
- {0x12, 0x34, 0x56, 0x78}},
- };
-
- PacketFragments packet46 = {
// type (long header with packet type ZERO_RTT_PROTECTED and 4 bytes
// packet number)
{"Unable to read first byte.",
@@ -1682,9 +1548,7 @@
ReviseFirstByteByVersion(packet49);
PacketFragments& fragments =
- framer_.version().HasLongHeaderLengths()
- ? packet49
- : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+ framer_.version().HasLongHeaderLengths() ? packet49 : packet;
std::unique_ptr<QuicEncryptedPacket> encrypted(
AssemblePacketFromFragments(fragments));
EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
@@ -1706,18 +1570,6 @@
// clang-format off
PacketFragments packet = {
- // public flags (8 byte connection_id and 4 byte packet number)
- {"Unable to read public flags.",
- {0x28}},
- // connection_id
- {"Unable to read ConnectionId.",
- {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
- // packet number
- {"Unable to read packet number.",
- {0x12, 0x34, 0x56, 0x78}},
- };
-
- PacketFragments packet46 = {
// type (short header, 4 byte packet number)
{"Unable to read first byte.",
{0x43}},
@@ -1743,9 +1595,7 @@
// clang-format on
PacketFragments& fragments =
- framer_.version().HasHeaderProtection()
- ? packet_hp
- : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+ framer_.version().HasHeaderProtection() ? packet_hp : packet;
std::unique_ptr<QuicEncryptedPacket> encrypted(
AssemblePacketFromFragments(fragments));
EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
@@ -1766,18 +1616,6 @@
// clang-format off
PacketFragments packet = {
- // public flags (8 byte connection_id and 2 byte packet number)
- {"Unable to read public flags.",
- {0x18}},
- // connection_id
- {"Unable to read ConnectionId.",
- {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
- // packet number
- {"Unable to read packet number.",
- {0x56, 0x78}},
- };
-
- PacketFragments packet46 = {
// type (short header, 2 byte packet number)
{"Unable to read first byte.",
{0x41}},
@@ -1805,9 +1643,7 @@
// clang-format on
PacketFragments& fragments =
- framer_.version().HasHeaderProtection()
- ? packet_hp
- : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+ framer_.version().HasHeaderProtection() ? packet_hp : packet;
std::unique_ptr<QuicEncryptedPacket> encrypted(
AssemblePacketFromFragments(fragments));
if (framer_.version().HasHeaderProtection()) {
@@ -1834,18 +1670,6 @@
// clang-format off
PacketFragments packet = {
- // public flags (8 byte connection_id and 1 byte packet number)
- {"Unable to read public flags.",
- {0x08}},
- // connection_id
- {"Unable to read ConnectionId.",
- {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
- // packet number
- {"Unable to read packet number.",
- {0x78}},
- };
-
- PacketFragments packet46 = {
// type (8 byte connection_id and 1 byte packet number)
{"Unable to read first byte.",
{0x40}},
@@ -1874,9 +1698,7 @@
// clang-format on
PacketFragments& fragments =
- framer_.version().HasHeaderProtection()
- ? packet_hp
- : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+ framer_.version().HasHeaderProtection() ? packet_hp : packet;
std::unique_ptr<QuicEncryptedPacket> encrypted(
AssemblePacketFromFragments(fragments));
if (framer_.version().HasHeaderProtection()) {
@@ -1968,24 +1790,6 @@
SetDecrypterLevel(ENCRYPTION_ZERO_RTT);
// clang-format off
unsigned char packet[] = {
- // public flags: includes nonce flag
- 0x2C,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // nonce
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
- 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
- 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (padding)
- 0x00,
- 0x00, 0x00, 0x00, 0x00
- };
-
- unsigned char packet46[] = {
// type: Long header with packet type ZERO_RTT_PROTECTED and 1 byte packet
// number.
0xD0,
@@ -2045,9 +1849,6 @@
if (framer_.version().HasLongHeaderLengths()) {
p = packet49;
p_size = ABSL_ARRAYSIZE(packet49);
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- p_size = ABSL_ARRAYSIZE(packet46);
}
QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -2064,21 +1865,6 @@
TEST_P(QuicFramerTest, LargePublicFlagWithMismatchedVersions) {
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id, version flag and an unknown flag)
- 0x29,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // version tag
- 'Q', '0', '0', '0',
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (padding frame)
- 0x00,
- 0x00, 0x00, 0x00, 0x00
- };
-
- unsigned char packet46[] = {
// type (long header, ZERO_RTT_PROTECTED, 4-byte packet number)
0xD3,
// version tag
@@ -2120,9 +1906,6 @@
if (framer_.version().HasLongHeaderLengths()) {
p = packet49;
p_size = ABSL_ARRAYSIZE(packet49);
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- p_size = ABSL_ARRAYSIZE(packet46);
}
QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
@@ -2136,33 +1919,6 @@
SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x28,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // paddings
- 0x00, 0x00,
- // frame type (stream frame with fin)
- 0xFF,
- // stream id
- 0x01, 0x02, 0x03, 0x04,
- // offset
- 0x3A, 0x98, 0xFE, 0xDC,
- 0x32, 0x10, 0x76, 0x54,
- // data length
- 0x00, 0x0c,
- // data
- 'h', 'e', 'l', 'l',
- 'o', ' ', 'w', 'o',
- 'r', 'l', 'd', '!',
- // paddings
- 0x00, 0x00,
- };
-
- unsigned char packet46[] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -2223,9 +1979,6 @@
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet_ietf;
p_size = ABSL_ARRAYSIZE(packet_ietf);
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- p_size = ABSL_ARRAYSIZE(packet46);
}
QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -2251,36 +2004,6 @@
SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
// clang-format off
PacketFragments packet = {
- // public flags (8 byte connection_id)
- {"",
- {0x28}},
- // connection_id
- {"",
- {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
- // packet number
- {"",
- {0x12, 0x34, 0x56, 0x78}},
- // frame type (stream frame with fin)
- {"",
- {0xFF}},
- // stream id
- {"Unable to read stream_id.",
- {0x01, 0x02, 0x03, 0x04}},
- // offset
- {"Unable to read offset.",
- {0x3A, 0x98, 0xFE, 0xDC,
- 0x32, 0x10, 0x76, 0x54}},
- {"Unable to read frame data.",
- {
- // data length
- 0x00, 0x0c,
- // data
- 'h', 'e', 'l', 'l',
- 'o', ' ', 'w', 'o',
- 'r', 'l', 'd', '!'}},
- };
-
- PacketFragments packet46 = {
// type (short header, 4 byte packet number)
{"",
{0x43}},
@@ -2342,9 +2065,8 @@
// clang-format on
PacketFragments& fragments =
- VersionHasIetfQuicFrames(framer_.transport_version())
- ? packet_ietf
- : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+ VersionHasIetfQuicFrames(framer_.transport_version()) ? packet_ietf
+ : packet;
std::unique_ptr<QuicEncryptedPacket> encrypted(
AssemblePacketFromFragments(fragments));
EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -2442,17 +2164,6 @@
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x28,
- // connection_id
- 0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
- // padding frame
- 0x00,
- };
-
- unsigned char packet46[] = {
// type (long header, ZERO_RTT_PROTECTED, 4-byte packet number)
0xD3,
// version tag
@@ -2492,9 +2203,6 @@
if (framer_.version().HasLongHeaderLengths()) {
p = packet49;
p_length = ABSL_ARRAYSIZE(packet49);
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- p_length = ABSL_ARRAYSIZE(packet46);
}
QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
EXPECT_FALSE(framer_.ProcessPacket(encrypted));
@@ -2502,108 +2210,17 @@
EXPECT_THAT(framer_.error(), IsError(QUIC_DECRYPTION_FAILURE));
EXPECT_EQ("Unable to decrypt ENCRYPTION_ZERO_RTT header protection.",
framer_.detailed_error());
- } else if (framer_.version().HasIetfInvariantHeader()) {
+ } else {
// Cannot read diversification nonce.
EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_PACKET_HEADER));
EXPECT_EQ("Unable to read nonce.", framer_.detailed_error());
- } else {
- EXPECT_THAT(framer_.error(), IsError(QUIC_DECRYPTION_FAILURE));
}
}
-TEST_P(QuicFramerTest, StreamFrame3ByteStreamId) {
- if (framer_.version().HasIetfInvariantHeader()) {
- // This test is nonsensical for IETF Quic.
- return;
- }
- // clang-format off
- PacketFragments packet = {
- // public flags (8 byte connection_id)
- {"",
- {0x28}},
- // connection_id
- {"",
- {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
- // packet number
- {"",
- {0x12, 0x34, 0x56, 0x78}},
- // frame type (stream frame with fin)
- {"",
- {0xFE}},
- // stream id
- {"Unable to read stream_id.",
- {0x02, 0x03, 0x04}},
- // offset
- {"Unable to read offset.",
- {0x3A, 0x98, 0xFE, 0xDC,
- 0x32, 0x10, 0x76, 0x54}},
- {"Unable to read frame data.",
- {
- // data length
- 0x00, 0x0c,
- // data
- 'h', 'e', 'l', 'l',
- 'o', ' ', 'w', 'o',
- 'r', 'l', 'd', '!'}},
- };
- // clang-format on
-
- PacketFragments& fragments = packet;
- std::unique_ptr<QuicEncryptedPacket> encrypted(
- AssemblePacketFromFragments(fragments));
- EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
-
- EXPECT_THAT(framer_.error(), IsQuicNoError());
- ASSERT_TRUE(visitor_.header_.get());
- EXPECT_TRUE(CheckDecryption(
- *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
- kPacket8ByteConnectionId, kPacket0ByteConnectionId));
-
- ASSERT_EQ(1u, visitor_.stream_frames_.size());
- EXPECT_EQ(0u, visitor_.ack_frames_.size());
- // Stream ID should be the last 3 bytes of kStreamId.
- EXPECT_EQ(0x00FFFFFF & kStreamId, visitor_.stream_frames_[0]->stream_id);
- EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
- EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset);
- CheckStreamFrameData("hello world!", visitor_.stream_frames_[0].get());
-
- CheckFramingBoundaries(fragments, QUIC_INVALID_STREAM_DATA);
-}
-
TEST_P(QuicFramerTest, StreamFrame2ByteStreamId) {
SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
// clang-format off
PacketFragments packet = {
- // public flags (8 byte connection_id)
- {"",
- {0x28}},
- // connection_id
- {"",
- {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
- // packet number
- {"",
- {0x12, 0x34, 0x56, 0x78}},
- // frame type (stream frame with fin)
- {"",
- {0xFD}},
- // stream id
- {"Unable to read stream_id.",
- {0x03, 0x04}},
- // offset
- {"Unable to read offset.",
- {0x3A, 0x98, 0xFE, 0xDC,
- 0x32, 0x10, 0x76, 0x54}},
- {"Unable to read frame data.",
- {
- // data length
- 0x00, 0x0c,
- // data
- 'h', 'e', 'l', 'l',
- 'o', ' ', 'w', 'o',
- 'r', 'l', 'd', '!'}},
- };
-
- PacketFragments packet46 = {
// type (short header, 4 byte packet number)
{"",
{0x43}},
@@ -2665,9 +2282,8 @@
// clang-format on
PacketFragments& fragments =
- VersionHasIetfQuicFrames(framer_.transport_version())
- ? packet_ietf
- : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+ VersionHasIetfQuicFrames(framer_.transport_version()) ? packet_ietf
+ : packet;
std::unique_ptr<QuicEncryptedPacket> encrypted(
AssemblePacketFromFragments(fragments));
EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -2693,36 +2309,6 @@
SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
// clang-format off
PacketFragments packet = {
- // public flags (8 byte connection_id)
- {"",
- {0x28}},
- // connection_id
- {"",
- {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
- // packet number
- {"",
- {0x12, 0x34, 0x56, 0x78}},
- // frame type (stream frame with fin)
- {"",
- {0xFC}},
- // stream id
- {"Unable to read stream_id.",
- {0x04}},
- // offset
- {"Unable to read offset.",
- {0x3A, 0x98, 0xFE, 0xDC,
- 0x32, 0x10, 0x76, 0x54}},
- {"Unable to read frame data.",
- {
- // data length
- 0x00, 0x0c,
- // data
- 'h', 'e', 'l', 'l',
- 'o', ' ', 'w', 'o',
- 'r', 'l', 'd', '!'}},
- };
-
- PacketFragments packet46 = {
// type (short header, 4 byte packet number)
{"",
{0x43}},
@@ -2784,9 +2370,8 @@
// clang-format on
PacketFragments& fragments =
- VersionHasIetfQuicFrames(framer_.transport_version())
- ? packet_ietf
- : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+ VersionHasIetfQuicFrames(framer_.transport_version()) ? packet_ietf
+ : packet;
std::unique_ptr<QuicEncryptedPacket> encrypted(
AssemblePacketFromFragments(fragments));
EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -2809,48 +2394,9 @@
}
TEST_P(QuicFramerTest, StreamFrameWithVersion) {
- // If IETF frames are in use then we must also have the IETF
- // header invariants.
- if (VersionHasIetfQuicFrames(framer_.transport_version())) {
- QUICHE_DCHECK(framer_.version().HasIetfInvariantHeader());
- }
-
SetDecrypterLevel(ENCRYPTION_ZERO_RTT);
// clang-format off
PacketFragments packet = {
- // public flags (version, 8 byte connection_id)
- {"",
- {0x29}},
- // connection_id
- {"",
- {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
- // version tag
- {"",
- {QUIC_VERSION_BYTES}},
- // packet number
- {"",
- {0x12, 0x34, 0x56, 0x78}},
- // frame type (stream frame with fin)
- {"",
- {0xFE}},
- // stream id
- {"Unable to read stream_id.",
- {0x02, 0x03, 0x04}},
- // offset
- {"Unable to read offset.",
- {0x3A, 0x98, 0xFE, 0xDC,
- 0x32, 0x10, 0x76, 0x54}},
- {"Unable to read frame data.",
- {
- // data length
- 0x00, 0x0c,
- // data
- 'h', 'e', 'l', 'l',
- 'o', ' ', 'w', 'o',
- 'r', 'l', 'd', '!'}},
- };
-
- PacketFragments packet46 = {
// public flags (long header with packet type ZERO_RTT_PROTECTED and
// 4-byte packet number)
{"",
@@ -2986,10 +2532,7 @@
PacketFragments& fragments =
VersionHasIetfQuicFrames(framer_.transport_version())
? packet_ietf
- : (framer_.version().HasLongHeaderLengths()
- ? packet49
- : (framer_.version().HasIetfInvariantHeader() ? packet46
- : packet));
+ : (framer_.version().HasLongHeaderLengths() ? packet49 : packet);
std::unique_ptr<QuicEncryptedPacket> encrypted(
AssemblePacketFromFragments(fragments));
EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -3020,29 +2563,6 @@
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x28,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (stream frame with fin)
- 0xFF,
- // stream id
- 0x01, 0x02, 0x03, 0x04,
- // offset
- 0x3A, 0x98, 0xFE, 0xDC,
- 0x32, 0x10, 0x76, 0x54,
- // data length
- 0x00, 0x0c,
- // data
- 'h', 'e', 'l', 'l',
- 'o', ' ', 'w', 'o',
- 'r', 'l', 'd', '!',
- };
-
- unsigned char packet46[] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -3066,15 +2586,7 @@
};
// clang-format on
- unsigned char* p = packet;
- if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- }
- QuicEncryptedPacket encrypted(AsChars(p),
- framer_.version().HasIetfInvariantHeader()
- ? ABSL_ARRAYSIZE(packet46)
- : ABSL_ARRAYSIZE(packet),
- false);
+ QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -3092,13 +2604,6 @@
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x28,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- };
-
- unsigned char packet46[] = {
// type (short header, 1 byte packet number)
0x40,
// connection_id
@@ -3108,12 +2613,7 @@
};
// clang-format on
- QuicEncryptedPacket encrypted(
- framer_.version().HasIetfInvariantHeader() ? AsChars(packet46)
- : AsChars(packet),
- framer_.version().HasIetfInvariantHeader() ? ABSL_ARRAYSIZE(packet46)
- : ABSL_ARRAYSIZE(packet),
- false);
+ QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -3125,34 +2625,6 @@
SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
// clang-format off
PacketFragments packet = {
- // public flags (8 byte connection_id)
- {"",
- {0x2C}},
- // connection_id
- {"",
- {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
- // packet number
- {"",
- {0x12, 0x34, 0x56, 0x78}},
- // frame type (ack frame)
- // (one ack block, 2 byte largest observed, 2 byte block length)
- {"",
- {0x45}},
- // largest acked
- {"Unable to read largest acked.",
- {0x12, 0x34}},
- // Zero delta time.
- {"Unable to read ack delay time.",
- {0x00, 0x00}},
- // first ack block length.
- {"Unable to read first ack block length.",
- {0x12, 0x34}},
- // num timestamps.
- {"Unable to read num received packets.",
- {0x00}}
- };
-
- PacketFragments packet46 = {
// type (short packet, 4 byte packet number)
{"",
{0x43}},
@@ -3217,9 +2689,8 @@
// clang-format on
PacketFragments& fragments =
- VersionHasIetfQuicFrames(framer_.transport_version())
- ? packet_ietf
- : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+ VersionHasIetfQuicFrames(framer_.transport_version()) ? packet_ietf
+ : packet;
std::unique_ptr<QuicEncryptedPacket> encrypted(
AssemblePacketFromFragments(fragments));
EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -3246,34 +2717,6 @@
SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
// clang-format off
PacketFragments packet = {
- // public flags (8 byte connection_id)
- {"",
- {0x2C}},
- // connection_id
- {"",
- {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
- // packet number
- {"",
- {0x12, 0x34, 0x56, 0x78}},
- // frame type (ack frame)
- // (one ack block, 2 byte largest observed, 2 byte block length)
- {"",
- {0x45}},
- // largest acked
- {"Unable to read largest acked.",
- {0x12, 0x34}},
- // Zero delta time.
- {"Unable to read ack delay time.",
- {0x00, 0x00}},
- // first ack block length.
- {"Unable to read first ack block length.",
- {0x88, 0x88}},
- // num timestamps.
- {"Underflow with first ack block length 34952 largest acked is 4660.",
- {0x00}}
- };
-
- PacketFragments packet46 = {
// type (short header, 4 byte packet number)
{"",
{0x43}},
@@ -3330,9 +2773,8 @@
// clang-format on
PacketFragments& fragments =
- VersionHasIetfQuicFrames(framer_.transport_version())
- ? packet_ietf
- : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+ VersionHasIetfQuicFrames(framer_.transport_version()) ? packet_ietf
+ : packet;
std::unique_ptr<QuicEncryptedPacket> encrypted(
AssemblePacketFromFragments(fragments));
EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
@@ -3633,44 +3075,6 @@
// clang-format off
PacketFragments packet = {
- // public flags (8 byte connection_id)
- {"",
- { 0x2C }},
- // connection_id
- {"",
- { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 }},
- // packet number
- {"",
- { 0x12, 0x34, 0x56, 0x78 }},
-
- // frame type (ack frame)
- // (more than one ack block, 2 byte largest observed, 2 byte block length)
- {"",
- { 0x65 }},
- // largest acked
- {"Unable to read largest acked.",
- { 0x12, 0x34 }},
- // Zero delta time.
- {"Unable to read ack delay time.",
- { 0x00, 0x00 }},
- // num ack blocks ranges.
- {"Unable to read num of ack blocks.",
- { 0x01 }},
- // first ack block length.
- {"Unable to read first ack block length.",
- { 0x00, 0x00 }},
- // gap to next block.
- { "First block length is zero.",
- { 0x01 }},
- // ack block length.
- { "First block length is zero.",
- { 0x0e, 0xaf }},
- // Number of timestamps.
- { "First block length is zero.",
- { 0x00 }},
- };
-
- PacketFragments packet46 = {
// type (short header, 4 byte packet number)
{"",
{ 0x43 }},
@@ -3709,11 +3113,8 @@
};
// clang-format on
- PacketFragments& fragments =
- framer_.version().HasIetfInvariantHeader() ? packet46 : packet;
-
std::unique_ptr<QuicEncryptedPacket> encrypted(
- AssemblePacketFromFragments(fragments));
+ AssemblePacketFromFragments(packet));
EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_ACK_DATA));
@@ -3726,41 +3127,13 @@
EXPECT_EQ(0u, visitor_.stream_frames_.size());
ASSERT_EQ(1u, visitor_.ack_frames_.size());
- CheckFramingBoundaries(fragments, QUIC_INVALID_ACK_DATA);
+ CheckFramingBoundaries(packet, QUIC_INVALID_ACK_DATA);
}
TEST_P(QuicFramerTest, AckFrameOneAckBlockMaxLength) {
SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
// clang-format off
PacketFragments packet = {
- // public flags (8 byte connection_id)
- {"",
- {0x2C}},
- // connection_id
- {"",
- {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
- // packet number
- {"",
- {0x12, 0x34, 0x56, 0x78}},
- // frame type (ack frame)
- // (one ack block, 4 byte largest observed, 2 byte block length)
- {"",
- {0x49}},
- // largest acked
- {"Unable to read largest acked.",
- {0x12, 0x34, 0x56, 0x78}},
- // Zero delta time.
- {"Unable to read ack delay time.",
- {0x00, 0x00}},
- // first ack block length.
- {"Unable to read first ack block length.",
- {0x12, 0x34}},
- // num timestamps.
- {"Unable to read num received packets.",
- {0x00}}
- };
-
- PacketFragments packet46 = {
// type (short header, 4 byte packet number)
{"",
{0x43}},
@@ -3817,9 +3190,8 @@
// clang-format on
PacketFragments& fragments =
- VersionHasIetfQuicFrames(framer_.transport_version())
- ? packet_ietf
- : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+ VersionHasIetfQuicFrames(framer_.transport_version()) ? packet_ietf
+ : packet;
std::unique_ptr<QuicEncryptedPacket> encrypted(
AssemblePacketFromFragments(fragments));
EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -3845,74 +3217,6 @@
SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
// clang-format off
PacketFragments packet = {
- // public flags (8 byte connection_id)
- {"",
- { 0x2C }},
- // connection_id
- {"",
- { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 }},
- // packet number
- {"",
- { 0x12, 0x34, 0x56, 0x78 }},
-
- // frame type (ack frame)
- // (more than one ack block, 2 byte largest observed, 2 byte block length)
- {"",
- { 0x65 }},
- // largest acked
- {"Unable to read largest acked.",
- { 0x12, 0x34 }},
- // Zero delta time.
- {"Unable to read ack delay time.",
- { 0x00, 0x00 }},
- // num ack blocks ranges.
- {"Unable to read num of ack blocks.",
- { 0x04 }},
- // first ack block length.
- {"Unable to read first ack block length.",
- { 0x00, 0x01 }},
- // gap to next block.
- { "Unable to read gap to next ack block.",
- { 0x01 }},
- // ack block length.
- { "Unable to ack block length.",
- { 0x0e, 0xaf }},
- // gap to next block.
- { "Unable to read gap to next ack block.",
- { 0xff }},
- // ack block length.
- { "Unable to ack block length.",
- { 0x00, 0x00 }},
- // gap to next block.
- { "Unable to read gap to next ack block.",
- { 0x91 }},
- // ack block length.
- { "Unable to ack block length.",
- { 0x01, 0xea }},
- // gap to next block.
- { "Unable to read gap to next ack block.",
- { 0x05 }},
- // ack block length.
- { "Unable to ack block length.",
- { 0x00, 0x04 }},
- // Number of timestamps.
- { "Unable to read num received packets.",
- { 0x02 }},
- // Delta from largest observed.
- { "Unable to read sequence delta in received packets.",
- { 0x01 }},
- // Delta time.
- { "Unable to read time delta in received packets.",
- { 0x76, 0x54, 0x32, 0x10 }},
- // Delta from largest observed.
- { "Unable to read sequence delta in received packets.",
- { 0x02 }},
- // Delta time.
- { "Unable to read incremental time delta in received packets.",
- { 0x32, 0x10 }},
- };
-
- PacketFragments packet46 = {
// type (short header, 4 byte packet number)
{"",
{ 0x43 }},
@@ -4050,9 +3354,8 @@
// clang-format on
PacketFragments& fragments =
- VersionHasIetfQuicFrames(framer_.transport_version())
- ? packet_ietf
- : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+ VersionHasIetfQuicFrames(framer_.transport_version()) ? packet_ietf
+ : packet;
std::unique_ptr<QuicEncryptedPacket> encrypted(
AssemblePacketFromFragments(fragments));
@@ -4403,31 +3706,6 @@
SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x28,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (ack frame)
- // (no ack blocks, 1 byte largest observed, 1 byte block length)
- 0x40,
- // largest acked
- 0x01,
- // Zero delta time.
- 0x00, 0x00,
- // first ack block length.
- 0x01,
- // num timestamps.
- 0x01,
- // Delta from largest observed.
- 0x01,
- // Delta time.
- 0x10, 0x32, 0x54, 0x76,
- };
-
- unsigned char packet46[] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -4456,9 +3734,7 @@
// ACK Timestamp is not a feature of IETF QUIC.
return;
}
- QuicEncryptedPacket encrypted(
- AsChars(framer_.version().HasIetfInvariantHeader() ? packet46 : packet),
- ABSL_ARRAYSIZE(packet), false);
+ QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
EXPECT_FALSE(framer_.ProcessPacket(encrypted));
EXPECT_TRUE(absl::StartsWith(framer_.detailed_error(),
"delta_from_largest_observed too high"));
@@ -4468,35 +3744,6 @@
SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x28,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (ack frame)
- // (no ack blocks, 1 byte largest observed, 1 byte block length)
- 0x40,
- // largest acked
- 0x03,
- // Zero delta time.
- 0x00, 0x00,
- // first ack block length.
- 0x03,
- // num timestamps.
- 0x02,
- // Delta from largest observed.
- 0x01,
- // Delta time.
- 0x10, 0x32, 0x54, 0x76,
- // Delta from largest observed.
- 0x03,
- // Delta time.
- 0x10, 0x32,
- };
-
- unsigned char packet46[] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -4529,9 +3776,7 @@
// ACK Timestamp is not a feature of IETF QUIC.
return;
}
- QuicEncryptedPacket encrypted(
- AsChars(framer_.version().HasIetfInvariantHeader() ? packet46 : packet),
- ABSL_ARRAYSIZE(packet), false);
+ QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
EXPECT_FALSE(framer_.ProcessPacket(encrypted));
EXPECT_TRUE(absl::StartsWith(framer_.detailed_error(),
"delta_from_largest_observed too high"));
@@ -4545,24 +3790,6 @@
SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
// clang-format off
PacketFragments packet = {
- // public flags (8 byte connection_id)
- {"",
- {0x2C}},
- // connection_id
- {"",
- {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
- // packet number
- {"",
- {0x12, 0x34, 0x56, 0x78}},
- // frame type (stop waiting frame)
- {"",
- {0x06}},
- // least packet number awaiting an ack, delta from packet number.
- {"Unable to read least unacked delta.",
- {0x00, 0x00, 0x00, 0x08}}
- };
-
- PacketFragments packet46 = {
// type (short header, 4 byte packet number)
{"",
{0x43}},
@@ -4581,11 +3808,8 @@
};
// clang-format on
- PacketFragments& fragments =
- framer_.version().HasIetfInvariantHeader() ? packet46 : packet;
-
std::unique_ptr<QuicEncryptedPacket> encrypted(
- AssemblePacketFromFragments(fragments));
+ AssemblePacketFromFragments(packet));
EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -4599,32 +3823,17 @@
const QuicStopWaitingFrame& frame = *visitor_.stop_waiting_frames_[0];
EXPECT_EQ(kLeastUnacked, frame.least_unacked);
- CheckFramingBoundaries(fragments, QUIC_INVALID_STOP_WAITING_DATA);
+ CheckFramingBoundaries(packet, QUIC_INVALID_STOP_WAITING_DATA);
}
TEST_P(QuicFramerTest, InvalidNewStopWaitingFrame) {
// The Stop Waiting frame is not in IETF QUIC
- if (VersionHasIetfQuicFrames(version_.transport_version) &&
- framer_.version().HasIetfInvariantHeader()) {
+ if (VersionHasIetfQuicFrames(version_.transport_version)) {
return;
}
SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x2C,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
- // frame type (stop waiting frame)
- 0x06,
- // least packet number awaiting an ack, delta from packet number.
- 0x13, 0x34, 0x56, 0x78,
- 0x9A, 0xA8,
- };
-
- unsigned char packet46[] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -4638,11 +3847,7 @@
};
// clang-format on
- QuicEncryptedPacket encrypted(
- AsChars(framer_.version().HasIetfInvariantHeader() ? packet46 : packet),
- framer_.version().HasIetfInvariantHeader() ? ABSL_ARRAYSIZE(packet46)
- : ABSL_ARRAYSIZE(packet),
- false);
+ QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
EXPECT_FALSE(framer_.ProcessPacket(encrypted));
EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_STOP_WAITING_DATA));
EXPECT_EQ("Invalid unacked delta.", framer_.detailed_error());
@@ -4652,31 +3857,6 @@
SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
// clang-format off
PacketFragments packet = {
- // public flags (8 byte connection_id)
- {"",
- {0x28}},
- // connection_id
- {"",
- {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
- // packet number
- {"",
- {0x12, 0x34, 0x56, 0x78}},
- // frame type (rst stream frame)
- {"",
- {0x01}},
- // stream id
- {"Unable to read stream_id.",
- {0x01, 0x02, 0x03, 0x04}},
- // sent byte offset
- {"Unable to read rst stream sent byte offset.",
- {0x3A, 0x98, 0xFE, 0xDC,
- 0x32, 0x10, 0x76, 0x54}},
- // error code QUIC_STREAM_CANCELLED
- {"Unable to read rst stream error code.",
- {0x00, 0x00, 0x00, 0x06}}
- };
-
- PacketFragments packet46 = {
// type (short header, 4 byte packet number)
{"",
{0x43}},
@@ -4728,9 +3908,8 @@
// clang-format on
PacketFragments& fragments =
- VersionHasIetfQuicFrames(framer_.transport_version())
- ? packet_ietf
- : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+ VersionHasIetfQuicFrames(framer_.transport_version()) ? packet_ietf
+ : packet;
std::unique_ptr<QuicEncryptedPacket> encrypted(
AssemblePacketFromFragments(fragments));
EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -4751,34 +3930,6 @@
SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
// clang-format off
PacketFragments packet = {
- // public flags (8 byte connection_id)
- {"",
- {0x28}},
- // connection_id
- {"",
- {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
- // packet number
- {"",
- {0x12, 0x34, 0x56, 0x78}},
- // frame type (connection close frame)
- {"",
- {0x02}},
- // error code
- {"Unable to read connection close error code.",
- {0x00, 0x00, 0x00, 0x11}},
- {"Unable to read connection close error details.",
- {
- // error details length
- 0x0, 0x0d,
- // error details
- 'b', 'e', 'c', 'a',
- 'u', 's', 'e', ' ',
- 'I', ' ', 'c', 'a',
- 'n'}
- }
- };
-
- PacketFragments packet46 = {
// type (short header, 4 byte packet number)
{"",
{0x43}},
@@ -4839,9 +3990,8 @@
// clang-format on
PacketFragments& fragments =
- VersionHasIetfQuicFrames(framer_.transport_version())
- ? packet_ietf
- : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+ VersionHasIetfQuicFrames(framer_.transport_version()) ? packet_ietf
+ : packet;
std::unique_ptr<QuicEncryptedPacket> encrypted(
AssemblePacketFromFragments(fragments));
EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -4876,34 +4026,6 @@
SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
// clang-format off
PacketFragments packet = {
- // public flags (8 byte connection_id)
- {"",
- {0x28}},
- // connection_id
- {"",
- {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
- // packet number
- {"",
- {0x12, 0x34, 0x56, 0x78}},
- // frame type (connection close frame)
- {"",
- {0x02}},
- // error code larger than QUIC_LAST_ERROR
- {"Unable to read connection close error code.",
- {0x00, 0x00, 0xC0, 0xDE}},
- {"Unable to read connection close error details.",
- {
- // error details length
- 0x0, 0x0d,
- // error details
- 'b', 'e', 'c', 'a',
- 'u', 's', 'e', ' ',
- 'I', ' ', 'c', 'a',
- 'n'}
- }
- };
-
- PacketFragments packet46 = {
// type (short header, 4 byte packet number)
{"",
{0x43}},
@@ -4964,9 +4086,8 @@
// clang-format on
PacketFragments& fragments =
- VersionHasIetfQuicFrames(framer_.transport_version())
- ? packet_ietf
- : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+ VersionHasIetfQuicFrames(framer_.transport_version()) ? packet_ietf
+ : packet;
std::unique_ptr<QuicEncryptedPacket> encrypted(
AssemblePacketFromFragments(fragments));
EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -5004,35 +4125,6 @@
// clang-format off
PacketFragments packet = {
- // public flags (8 byte connection_id)
- {"",
- {0x28}},
- // connection_id
- {"",
- {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
- // packet number
- {"",
- {0x12, 0x34, 0x56, 0x78}},
- // frame type (connection close frame)
- {"",
- {0x02}},
- // error code
- {"Unable to read connection close error code.",
- {0x00, 0x00, 0x00, 0x11}},
- {"Unable to read connection close error details.",
- {
- // error details length
- 0x0, 0x13,
- // error details
- '1', '7', '7', '6',
- '7', ':', 'b', 'e',
- 'c', 'a', 'u', 's',
- 'e', ' ', 'I', ' ',
- 'c', 'a', 'n'}
- }
- };
-
- PacketFragments packet46 = {
// type (short header, 4 byte packet number)
{"",
{0x43}},
@@ -5094,9 +4186,8 @@
// clang-format on
PacketFragments& fragments =
- VersionHasIetfQuicFrames(framer_.transport_version())
- ? packet_ietf
- : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+ VersionHasIetfQuicFrames(framer_.transport_version()) ? packet_ietf
+ : packet;
std::unique_ptr<QuicEncryptedPacket> encrypted(
AssemblePacketFromFragments(fragments));
EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -5260,38 +4351,6 @@
SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
// clang-format off
PacketFragments packet = {
- // public flags (8 byte connection_id)
- {"",
- {0x28}},
- // connection_id
- {"",
- {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
- // packet number
- {"",
- {0x12, 0x34, 0x56, 0x78}},
- // frame type (go away frame)
- {"",
- {0x03}},
- // error code
- {"Unable to read go away error code.",
- {0x00, 0x00, 0x00, 0x09}},
- // stream id
- {"Unable to read last good stream id.",
- {0x01, 0x02, 0x03, 0x04}},
- // stream id
- {"Unable to read goaway reason.",
- {
- // error details length
- 0x0, 0x0d,
- // error details
- 'b', 'e', 'c', 'a',
- 'u', 's', 'e', ' ',
- 'I', ' ', 'c', 'a',
- 'n'}
- }
- };
-
- PacketFragments packet46 = {
// type (short header, 4 byte packet number)
{"",
{0x43}},
@@ -5324,10 +4383,8 @@
};
// clang-format on
- PacketFragments& fragments =
- framer_.version().HasIetfInvariantHeader() ? packet46 : packet;
std::unique_ptr<QuicEncryptedPacket> encrypted(
- AssemblePacketFromFragments(fragments));
+ AssemblePacketFromFragments(packet));
EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -5340,7 +4397,7 @@
EXPECT_EQ(0x9u, visitor_.goaway_frame_.error_code);
EXPECT_EQ("because I can", visitor_.goaway_frame_.reason_phrase);
- CheckFramingBoundaries(fragments, QUIC_INVALID_GOAWAY_DATA);
+ CheckFramingBoundaries(packet, QUIC_INVALID_GOAWAY_DATA);
}
TEST_P(QuicFramerTest, GoAwayFrameWithUnknownErrorCode) {
@@ -5351,38 +4408,6 @@
SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
// clang-format off
PacketFragments packet = {
- // public flags (8 byte connection_id)
- {"",
- {0x28}},
- // connection_id
- {"",
- {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
- // packet number
- {"",
- {0x12, 0x34, 0x56, 0x78}},
- // frame type (go away frame)
- {"",
- {0x03}},
- // error code larger than QUIC_LAST_ERROR
- {"Unable to read go away error code.",
- {0x00, 0x00, 0xC0, 0xDE}},
- // stream id
- {"Unable to read last good stream id.",
- {0x01, 0x02, 0x03, 0x04}},
- // stream id
- {"Unable to read goaway reason.",
- {
- // error details length
- 0x0, 0x0d,
- // error details
- 'b', 'e', 'c', 'a',
- 'u', 's', 'e', ' ',
- 'I', ' ', 'c', 'a',
- 'n'}
- }
- };
-
- PacketFragments packet46 = {
// type (short header, 4 byte packet number)
{"",
{0x43}},
@@ -5415,10 +4440,8 @@
};
// clang-format on
- PacketFragments& fragments =
- framer_.version().HasIetfInvariantHeader() ? packet46 : packet;
std::unique_ptr<QuicEncryptedPacket> encrypted(
- AssemblePacketFromFragments(fragments));
+ AssemblePacketFromFragments(packet));
EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -5431,7 +4454,7 @@
EXPECT_EQ(0xC0DE, visitor_.goaway_frame_.error_code);
EXPECT_EQ("because I can", visitor_.goaway_frame_.reason_phrase);
- CheckFramingBoundaries(fragments, QUIC_INVALID_GOAWAY_DATA);
+ CheckFramingBoundaries(packet, QUIC_INVALID_GOAWAY_DATA);
}
TEST_P(QuicFramerTest, WindowUpdateFrame) {
@@ -5443,28 +4466,6 @@
SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
// clang-format off
PacketFragments packet = {
- // public flags (8 byte connection_id)
- {"",
- {0x28}},
- // connection_id
- {"",
- {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
- // packet number
- {"",
- {0x12, 0x34, 0x56, 0x78}},
- // frame type (window update frame)
- {"",
- {0x04}},
- // stream id
- {"Unable to read stream_id.",
- {0x01, 0x02, 0x03, 0x04}},
- // byte offset
- {"Unable to read window byte_offset.",
- {0x3A, 0x98, 0xFE, 0xDC,
- 0x32, 0x10, 0x76, 0x54}},
- };
-
- PacketFragments packet46 = {
// type (short header, 4 byte packet number)
{"",
{0x43}},
@@ -5488,10 +4489,8 @@
// clang-format on
- PacketFragments& fragments =
- framer_.version().HasIetfInvariantHeader() ? packet46 : packet;
std::unique_ptr<QuicEncryptedPacket> encrypted(
- AssemblePacketFromFragments(fragments));
+ AssemblePacketFromFragments(packet));
EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -5503,7 +4502,7 @@
EXPECT_EQ(kStreamId, visitor_.window_update_frame_.stream_id);
EXPECT_EQ(kStreamOffset, visitor_.window_update_frame_.max_data);
- CheckFramingBoundaries(fragments, QUIC_INVALID_WINDOW_UPDATE_DATA);
+ CheckFramingBoundaries(packet, QUIC_INVALID_WINDOW_UPDATE_DATA);
}
TEST_P(QuicFramerTest, MaxDataFrame) {
@@ -5600,24 +4599,6 @@
SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
// clang-format off
PacketFragments packet = {
- // public flags (8 byte connection_id)
- {"",
- {0x28}},
- // connection_id
- {"",
- {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
- // packet number
- {"",
- {0x12, 0x34, 0x56, 0x78}},
- // frame type (blocked frame)
- {"",
- {0x05}},
- // stream id
- {"Unable to read stream_id.",
- {0x01, 0x02, 0x03, 0x04}},
- };
-
- PacketFragments packet46 = {
// type (short header, 4 byte packet number)
{"",
{0x43}},
@@ -5658,9 +4639,8 @@
// clang-format on
PacketFragments& fragments =
- VersionHasIetfQuicFrames(framer_.transport_version())
- ? packet_ietf
- : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+ VersionHasIetfQuicFrames(framer_.transport_version()) ? packet_ietf
+ : packet;
std::unique_ptr<QuicEncryptedPacket> encrypted(
AssemblePacketFromFragments(fragments));
EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -5689,18 +4669,6 @@
SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x28,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (ping frame)
- 0x07,
- };
-
- unsigned char packet46[] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -5728,13 +4696,10 @@
QuicEncryptedPacket encrypted(
AsChars(VersionHasIetfQuicFrames(framer_.transport_version())
? packet_ietf
- : (framer_.version().HasIetfInvariantHeader() ? packet46
- : packet)),
+ : packet),
VersionHasIetfQuicFrames(framer_.transport_version())
? ABSL_ARRAYSIZE(packet_ietf)
- : (framer_.version().HasIetfInvariantHeader()
- ? ABSL_ARRAYSIZE(packet46)
- : ABSL_ARRAYSIZE(packet)),
+ : ABSL_ARRAYSIZE(packet),
false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
@@ -5827,12 +4792,9 @@
}
TEST_P(QuicFramerTest, MessageFrame) {
- if (!VersionSupportsMessageFrames(framer_.transport_version())) {
- return;
- }
SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
// clang-format off
- PacketFragments packet46 = {
+ PacketFragments packet = {
// type (short header, 4 byte packet number)
{"",
{0x43}},
@@ -5890,7 +4852,7 @@
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
encrypted = AssemblePacketFromFragments(packet_ietf);
} else {
- encrypted = AssemblePacketFromFragments(packet46);
+ encrypted = AssemblePacketFromFragments(packet);
}
EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -5907,216 +4869,10 @@
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
CheckFramingBoundaries(packet_ietf, QUIC_INVALID_MESSAGE_DATA);
} else {
- CheckFramingBoundaries(packet46, QUIC_INVALID_MESSAGE_DATA);
+ CheckFramingBoundaries(packet, QUIC_INVALID_MESSAGE_DATA);
}
}
-TEST_P(QuicFramerTest, PublicResetPacketV33) {
- // clang-format off
- PacketFragments packet = {
- // public flags (public reset, 8 byte connection_id)
- {"",
- {0x0A}},
- // connection_id
- {"",
- {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
- {"Unable to read reset message.",
- {
- // message tag (kPRST)
- 'P', 'R', 'S', 'T',
- // num_entries (2) + padding
- 0x02, 0x00, 0x00, 0x00,
- // tag kRNON
- 'R', 'N', 'O', 'N',
- // end offset 8
- 0x08, 0x00, 0x00, 0x00,
- // tag kRSEQ
- 'R', 'S', 'E', 'Q',
- // end offset 16
- 0x10, 0x00, 0x00, 0x00,
- // nonce proof
- 0x89, 0x67, 0x45, 0x23,
- 0x01, 0xEF, 0xCD, 0xAB,
- // rejected packet number
- 0xBC, 0x9A, 0x78, 0x56,
- 0x34, 0x12, 0x00, 0x00,
- }
- }
- };
- // clang-format on
- if (framer_.version().HasIetfInvariantHeader()) {
- return;
- }
-
- std::unique_ptr<QuicEncryptedPacket> encrypted(
- AssemblePacketFromFragments(packet));
- EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
- ASSERT_THAT(framer_.error(), IsQuicNoError());
- ASSERT_TRUE(visitor_.public_reset_packet_.get());
- EXPECT_EQ(FramerTestConnectionId(),
- visitor_.public_reset_packet_->connection_id);
- EXPECT_EQ(kNonceProof, visitor_.public_reset_packet_->nonce_proof);
- EXPECT_EQ(
- IpAddressFamily::IP_UNSPEC,
- visitor_.public_reset_packet_->client_address.host().address_family());
-
- CheckFramingBoundaries(packet, QUIC_INVALID_PUBLIC_RST_PACKET);
-}
-
-TEST_P(QuicFramerTest, PublicResetPacket) {
- QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
-
- // clang-format off
- PacketFragments packet = {
- // public flags (public reset, 8 byte connection_id)
- {"",
- {0x0E}},
- // connection_id
- {"",
- {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
- {"Unable to read reset message.",
- {
- // message tag (kPRST)
- 'P', 'R', 'S', 'T',
- // num_entries (2) + padding
- 0x02, 0x00, 0x00, 0x00,
- // tag kRNON
- 'R', 'N', 'O', 'N',
- // end offset 8
- 0x08, 0x00, 0x00, 0x00,
- // tag kRSEQ
- 'R', 'S', 'E', 'Q',
- // end offset 16
- 0x10, 0x00, 0x00, 0x00,
- // nonce proof
- 0x89, 0x67, 0x45, 0x23,
- 0x01, 0xEF, 0xCD, 0xAB,
- // rejected packet number
- 0xBC, 0x9A, 0x78, 0x56,
- 0x34, 0x12, 0x00, 0x00,
- }
- }
- };
- // clang-format on
-
- if (framer_.version().HasIetfInvariantHeader()) {
- return;
- }
-
- std::unique_ptr<QuicEncryptedPacket> encrypted(
- AssemblePacketFromFragments(packet));
- EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
- ASSERT_THAT(framer_.error(), IsQuicNoError());
- ASSERT_TRUE(visitor_.public_reset_packet_.get());
- EXPECT_EQ(FramerTestConnectionId(),
- visitor_.public_reset_packet_->connection_id);
- EXPECT_EQ(kNonceProof, visitor_.public_reset_packet_->nonce_proof);
- EXPECT_EQ(
- IpAddressFamily::IP_UNSPEC,
- visitor_.public_reset_packet_->client_address.host().address_family());
-
- CheckFramingBoundaries(packet, QUIC_INVALID_PUBLIC_RST_PACKET);
-}
-
-TEST_P(QuicFramerTest, PublicResetPacketWithTrailingJunk) {
- // clang-format off
- unsigned char packet[] = {
- // public flags (public reset, 8 byte connection_id)
- 0x0A,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // message tag (kPRST)
- 'P', 'R', 'S', 'T',
- // num_entries (2) + padding
- 0x02, 0x00, 0x00, 0x00,
- // tag kRNON
- 'R', 'N', 'O', 'N',
- // end offset 8
- 0x08, 0x00, 0x00, 0x00,
- // tag kRSEQ
- 'R', 'S', 'E', 'Q',
- // end offset 16
- 0x10, 0x00, 0x00, 0x00,
- // nonce proof
- 0x89, 0x67, 0x45, 0x23,
- 0x01, 0xEF, 0xCD, 0xAB,
- // rejected packet number
- 0xBC, 0x9A, 0x78, 0x56,
- 0x34, 0x12, 0x00, 0x00,
- // trailing junk
- 'j', 'u', 'n', 'k',
- };
- // clang-format on
- if (framer_.version().HasIetfInvariantHeader()) {
- return;
- }
-
- QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
- EXPECT_FALSE(framer_.ProcessPacket(encrypted));
- ASSERT_THAT(framer_.error(), IsError(QUIC_INVALID_PUBLIC_RST_PACKET));
- EXPECT_EQ("Unable to read reset message.", framer_.detailed_error());
-}
-
-TEST_P(QuicFramerTest, PublicResetPacketWithClientAddress) {
- // clang-format off
- PacketFragments packet = {
- // public flags (public reset, 8 byte connection_id)
- {"",
- {0x0A}},
- // connection_id
- {"",
- {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
- {"Unable to read reset message.",
- {
- // message tag (kPRST)
- 'P', 'R', 'S', 'T',
- // num_entries (2) + padding
- 0x03, 0x00, 0x00, 0x00,
- // tag kRNON
- 'R', 'N', 'O', 'N',
- // end offset 8
- 0x08, 0x00, 0x00, 0x00,
- // tag kRSEQ
- 'R', 'S', 'E', 'Q',
- // end offset 16
- 0x10, 0x00, 0x00, 0x00,
- // tag kCADR
- 'C', 'A', 'D', 'R',
- // end offset 24
- 0x18, 0x00, 0x00, 0x00,
- // nonce proof
- 0x89, 0x67, 0x45, 0x23,
- 0x01, 0xEF, 0xCD, 0xAB,
- // rejected packet number
- 0xBC, 0x9A, 0x78, 0x56,
- 0x34, 0x12, 0x00, 0x00,
- // client address: 4.31.198.44:443
- 0x02, 0x00,
- 0x04, 0x1F, 0xC6, 0x2C,
- 0xBB, 0x01,
- }
- }
- };
- // clang-format on
- if (framer_.version().HasIetfInvariantHeader()) {
- return;
- }
-
- std::unique_ptr<QuicEncryptedPacket> encrypted(
- AssemblePacketFromFragments(packet));
- EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
- ASSERT_THAT(framer_.error(), IsQuicNoError());
- ASSERT_TRUE(visitor_.public_reset_packet_.get());
- EXPECT_EQ(FramerTestConnectionId(),
- visitor_.public_reset_packet_->connection_id);
- EXPECT_EQ(kNonceProof, visitor_.public_reset_packet_->nonce_proof);
- EXPECT_EQ("4.31.198.44",
- visitor_.public_reset_packet_->client_address.host().ToString());
- EXPECT_EQ(443, visitor_.public_reset_packet_->client_address.port());
-
- CheckFramingBoundaries(packet, QUIC_INVALID_PUBLIC_RST_PACKET);
-}
-
TEST_P(QuicFramerTest, IetfStatelessResetPacket) {
// clang-format off
unsigned char packet[] = {
@@ -6132,9 +4888,6 @@
0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
};
// clang-format on
- if (!framer_.version().HasIetfInvariantHeader()) {
- return;
- }
QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
QuicFramerPeer::SetLastSerializedServerConnectionId(&framer_,
TestConnectionId(0x33));
@@ -6175,9 +4928,6 @@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
// clang-format on
- if (!framer_.version().HasIetfInvariantHeader()) {
- return;
- }
QuicFramerPeer::SetLastSerializedServerConnectionId(&framer_,
TestConnectionId(0x33));
QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
@@ -6204,19 +4954,6 @@
TEST_P(QuicFramerTest, VersionNegotiationPacketClient) {
// clang-format off
PacketFragments packet = {
- // public flags (version, 8 byte connection_id)
- {"",
- {0x29}},
- // connection_id
- {"",
- {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
- // version tag
- {"Unable to read supported version in negotiation.",
- {QUIC_VERSION_BYTES,
- 'Q', '2', '.', '0'}},
- };
-
- PacketFragments packet46 = {
// type (long header)
{"",
{0x8F}},
@@ -6258,9 +4995,7 @@
QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
PacketFragments& fragments =
- framer_.version().HasLongHeaderLengths() ? packet49
- : framer_.version().HasIetfInvariantHeader() ? packet46
- : packet;
+ framer_.version().HasLongHeaderLengths() ? packet49 : packet;
std::unique_ptr<QuicEncryptedPacket> encrypted(
AssemblePacketFromFragments(fragments));
EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -6279,10 +5014,6 @@
}
TEST_P(QuicFramerTest, VersionNegotiationPacketServer) {
- if (!framer_.version().HasIetfInvariantHeader()) {
- return;
- }
-
QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_SERVER);
// clang-format off
unsigned char packet[] = {
@@ -6330,45 +5061,6 @@
EXPECT_FALSE(visitor_.version_negotiation_packet_.get());
}
-TEST_P(QuicFramerTest, OldVersionNegotiationPacket) {
- // clang-format off
- PacketFragments packet = {
- // public flags (version, 8 byte connection_id)
- {"",
- {0x2D}},
- // connection_id
- {"",
- {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
- // version tag
- {"Unable to read supported version in negotiation.",
- {QUIC_VERSION_BYTES,
- 'Q', '2', '.', '0'}},
- };
- // clang-format on
-
- if (framer_.version().HasIetfInvariantHeader()) {
- return;
- }
-
- QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
-
- std::unique_ptr<QuicEncryptedPacket> encrypted(
- AssemblePacketFromFragments(packet));
- EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
- ASSERT_THAT(framer_.error(), IsQuicNoError());
- ASSERT_TRUE(visitor_.version_negotiation_packet_.get());
- EXPECT_EQ(1u, visitor_.version_negotiation_packet_->versions.size());
- EXPECT_EQ(GetParam(), visitor_.version_negotiation_packet_->versions[0]);
-
- // Remove the last version from the packet so that every truncated
- // version of the packet is invalid, otherwise checking boundaries
- // is annoyingly complicated.
- for (size_t i = 0; i < 4; ++i) {
- packet.back().fragment.pop_back();
- }
- CheckFramingBoundaries(packet, QUIC_INVALID_VERSION_NEGOTIATION_PACKET);
-}
-
TEST_P(QuicFramerTest, ParseIetfRetryPacket) {
if (!framer_.version().SupportsRetry()) {
return;
@@ -6511,19 +5203,6 @@
// clang-format off
unsigned char packet[kMaxOutgoingPacketSize] = {
- // public flags (8 byte connection_id)
- 0x2C,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (padding frame)
- 0x00,
- 0x00, 0x00, 0x00, 0x00
- };
-
- unsigned char packet46[kMaxOutgoingPacketSize] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -6553,8 +5232,6 @@
unsigned char* p = packet;
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet_ietf;
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
}
uint64_t header_size = GetPacketHeaderSize(
@@ -6569,8 +5246,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(p),
- framer_.version().HasIetfInvariantHeader() ? ABSL_ARRAYSIZE(packet46)
- : ABSL_ARRAYSIZE(packet));
+ ABSL_ARRAYSIZE(packet));
}
TEST_P(QuicFramerTest, BuildStreamFramePacketWithNewPaddingFrame) {
@@ -6588,33 +5264,6 @@
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x2C,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // paddings
- 0x00, 0x00,
- // frame type (stream frame with fin)
- 0xFF,
- // stream id
- 0x01, 0x02, 0x03, 0x04,
- // offset
- 0x3A, 0x98, 0xFE, 0xDC,
- 0x32, 0x10, 0x76, 0x54,
- // data length
- 0x00, 0x0c,
- // data
- 'h', 'e', 'l', 'l',
- 'o', ' ', 'w', 'o',
- 'r', 'l', 'd', '!',
- // paddings
- 0x00, 0x00,
- };
-
- unsigned char packet46[] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -6677,9 +5326,6 @@
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet_ietf;
p_size = ABSL_ARRAYSIZE(packet_ietf);
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- p_size = ABSL_ARRAYSIZE(packet46);
}
QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -6700,19 +5346,6 @@
// clang-format off
unsigned char packet[kMaxOutgoingPacketSize] = {
- // public flags (8 byte connection_id and 4 byte packet number)
- 0x2C,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (padding frame)
- 0x00,
- 0x00, 0x00, 0x00, 0x00
- };
-
- unsigned char packet46[kMaxOutgoingPacketSize] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -6742,8 +5375,6 @@
unsigned char* p = packet;
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet_ietf;
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
}
uint64_t header_size = GetPacketHeaderSize(
@@ -6758,8 +5389,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(p),
- framer_.version().HasIetfInvariantHeader() ? ABSL_ARRAYSIZE(packet46)
- : ABSL_ARRAYSIZE(packet));
+ ABSL_ARRAYSIZE(packet));
}
TEST_P(QuicFramerTest, Build2ByteSequenceNumberPaddingFramePacket) {
@@ -6775,19 +5405,6 @@
// clang-format off
unsigned char packet[kMaxOutgoingPacketSize] = {
- // public flags (8 byte connection_id and 2 byte packet number)
- 0x1C,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x56, 0x78,
-
- // frame type (padding frame)
- 0x00,
- 0x00, 0x00, 0x00, 0x00
- };
-
- unsigned char packet46[kMaxOutgoingPacketSize] = {
// type (short header, 2 byte packet number)
0x41,
// connection_id
@@ -6817,8 +5434,6 @@
unsigned char* p = packet;
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet_ietf;
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
}
uint64_t header_size = GetPacketHeaderSize(
@@ -6833,8 +5448,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(p),
- framer_.version().HasIetfInvariantHeader() ? ABSL_ARRAYSIZE(packet46)
- : ABSL_ARRAYSIZE(packet));
+ ABSL_ARRAYSIZE(packet));
}
TEST_P(QuicFramerTest, Build1ByteSequenceNumberPaddingFramePacket) {
@@ -6850,19 +5464,6 @@
// clang-format off
unsigned char packet[kMaxOutgoingPacketSize] = {
- // public flags (8 byte connection_id and 1 byte packet number)
- 0x0C,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x78,
-
- // frame type (padding frame)
- 0x00,
- 0x00, 0x00, 0x00, 0x00
- };
-
- unsigned char packet46[kMaxOutgoingPacketSize] = {
// type (short header, 1 byte packet number)
0x40,
// connection_id
@@ -6892,8 +5493,6 @@
unsigned char* p = packet;
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet_ietf;
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
}
uint64_t header_size = GetPacketHeaderSize(
@@ -6908,8 +5507,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(p),
- framer_.version().HasIetfInvariantHeader() ? ABSL_ARRAYSIZE(packet46)
- : ABSL_ARRAYSIZE(packet));
+ ABSL_ARRAYSIZE(packet));
}
TEST_P(QuicFramerTest, BuildStreamFramePacket) {
@@ -6930,27 +5528,6 @@
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x2C,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (stream frame with fin and no length)
- 0xDF,
- // stream id
- 0x01, 0x02, 0x03, 0x04,
- // offset
- 0x3A, 0x98, 0xFE, 0xDC,
- 0x32, 0x10, 0x76, 0x54,
- // data
- 'h', 'e', 'l', 'l',
- 'o', ' ', 'w', 'o',
- 'r', 'l', 'd', '!',
- };
-
- unsigned char packet46[] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -7001,9 +5578,6 @@
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet_ietf;
p_size = ABSL_ARRAYSIZE(packet_ietf);
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- p_size = ABSL_ARRAYSIZE(packet46);
}
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(p), p_size);
@@ -7014,9 +5588,7 @@
header.destination_connection_id = FramerTestConnectionId();
header.reset_flag = false;
header.version_flag = true;
- if (framer_.version().HasIetfInvariantHeader()) {
- header.long_packet_type = ZERO_RTT_PROTECTED;
- }
+ header.long_packet_type = ZERO_RTT_PROTECTED;
header.packet_number = kPacketNumber;
if (QuicVersionHasLongHeaderLengths(framer_.transport_version())) {
header.length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_2;
@@ -7028,26 +5600,6 @@
// clang-format off
unsigned char packet[] = {
- // public flags (version, 8 byte connection_id)
- 0x2D,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // version tag
- QUIC_VERSION_BYTES,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (stream frame with fin and no length)
- 0xDF,
- // stream id
- 0x01, 0x02, 0x03, 0x04,
- // offset
- 0x3A, 0x98, 0xFE, 0xDC, 0x32, 0x10, 0x76, 0x54,
- // data
- 'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '!',
- };
-
- unsigned char packet46[] = {
// type (long header with packet type ZERO_RTT_PROTECTED)
0xD3,
// version tag
@@ -7135,9 +5687,6 @@
} else if (framer_.version().HasLongHeaderLengths()) {
p = packet49;
p_size = ABSL_ARRAYSIZE(packet49);
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- p_size = ABSL_ARRAYSIZE(packet46);
}
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(p), p_size);
@@ -7307,7 +5856,7 @@
CheckFramingBoundaries(fragments, QUIC_INVALID_FRAME_DATA);
}
-TEST_P(QuicFramerTest, BuildVersionNegotiationPacket) {
+TEST_P(QuicFramerTest, BuildOldVersionNegotiationPacket) {
SetQuicFlag(quic_disable_version_negotiation_grease_randomness, true);
// clang-format off
unsigned char packet[] = {
@@ -7319,7 +5868,21 @@
0xDA, 0x5A, 0x3A, 0x3A,
QUIC_VERSION_BYTES,
};
- unsigned char packet46[] = {
+ QuicConnectionId connection_id = FramerTestConnectionId();
+ std::unique_ptr<QuicEncryptedPacket> data(
+ QuicFramer::BuildVersionNegotiationPacket(
+ connection_id, EmptyQuicConnectionId(), /*ietf_quic=*/false,
+ /*use_length_prefix=*/false,
+ SupportedVersions(GetParam())));
+ quiche::test::CompareCharArraysWithHexError(
+ "constructed packet", data->data(), data->length(), AsChars(packet),
+ ABSL_ARRAYSIZE(packet));
+}
+
+TEST_P(QuicFramerTest, BuildVersionNegotiationPacket) {
+ SetQuicFlag(quic_disable_version_negotiation_grease_randomness, true);
+ // clang-format off
+ unsigned char packet[] = {
// type (long header)
0xC0,
// version tag
@@ -7353,16 +5916,12 @@
if (framer_.version().HasLongHeaderLengths()) {
p = packet49;
p_size = ABSL_ARRAYSIZE(packet49);
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- p_size = ABSL_ARRAYSIZE(packet46);
}
QuicConnectionId connection_id = FramerTestConnectionId();
std::unique_ptr<QuicEncryptedPacket> data(
QuicFramer::BuildVersionNegotiationPacket(
- connection_id, EmptyQuicConnectionId(),
- framer_.version().HasIetfInvariantHeader(),
+ connection_id, EmptyQuicConnectionId(), /*ietf_quic=*/true,
framer_.version().HasLengthPrefixedConnectionIds(),
SupportedVersions(GetParam())));
quiche::test::CompareCharArraysWithHexError(
@@ -7421,27 +5980,6 @@
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x2C,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (ack frame)
- // (no ack blocks, 2 byte largest observed, 2 byte block length)
- 0x45,
- // largest acked
- 0x12, 0x34,
- // Zero delta time.
- 0x00, 0x00,
- // first ack block length.
- 0x12, 0x34,
- // num timestamps.
- 0x00,
- };
-
- unsigned char packet46[] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -7487,9 +6025,6 @@
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet_ietf;
p_size = ABSL_ARRAYSIZE(packet_ietf);
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- p_size = ABSL_ARRAYSIZE(packet46);
}
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -8213,27 +6748,6 @@
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x2C,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (ack frame)
- // (no ack blocks, 4 byte largest observed, 4 byte block length)
- 0x4A,
- // largest acked
- 0x12, 0x34, 0x56, 0x78,
- // Zero delta time.
- 0x00, 0x00,
- // first ack block length.
- 0x12, 0x34, 0x56, 0x78,
- // num timestamps.
- 0x00,
- };
-
- unsigned char packet46[] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -8280,9 +6794,6 @@
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet_ietf;
p_size = ABSL_ARRAYSIZE(packet_ietf);
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- p_size = ABSL_ARRAYSIZE(packet46);
}
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -8311,45 +6822,6 @@
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x2C,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (ack frame)
- // (has ack blocks, 2 byte largest observed, 2 byte block length)
- 0x65,
- // largest acked
- 0x12, 0x34,
- // Zero delta time.
- 0x00, 0x00,
- // num ack blocks ranges.
- 0x04,
- // first ack block length.
- 0x00, 0x01,
- // gap to next block.
- 0x01,
- // ack block length.
- 0x0e, 0xaf,
- // gap to next block.
- 0xff,
- // ack block length.
- 0x00, 0x00,
- // gap to next block.
- 0x91,
- // ack block length.
- 0x01, 0xea,
- // gap to next block.
- 0x05,
- // ack block length.
- 0x00, 0x04,
- // num timestamps.
- 0x00,
- };
-
- unsigned char packet46[] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -8428,9 +6900,6 @@
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet_ietf;
p_size = ABSL_ARRAYSIZE(packet_ietf);
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- p_size = ABSL_ARRAYSIZE(packet46);
}
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -8462,99 +6931,6 @@
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x2C,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
- // frame type (ack frame)
- // (has ack blocks, 2 byte largest observed, 2 byte block length)
- 0x65,
- // largest acked
- 0x12, 0x34,
- // Zero delta time.
- 0x00, 0x00,
- // num ack blocks ranges.
- 0xff,
- // first ack block length.
- 0x0f, 0xdd,
- // 255 = 4 * 63 + 3
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
- // num timestamps.
- 0x00,
- };
-
- unsigned char packet46[] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -8737,9 +7113,6 @@
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet_ietf;
p_size = ABSL_ARRAYSIZE(packet_ietf);
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- p_size = ABSL_ARRAYSIZE(packet46);
}
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -8749,47 +7122,6 @@
"constructed packet", data->data(), data->length(), AsChars(p), p_size);
}
-TEST_P(QuicFramerTest, BuildNewStopWaitingPacket) {
- if (framer_.version().HasIetfInvariantHeader()) {
- return;
- }
- QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
- QuicPacketHeader header;
- header.destination_connection_id = FramerTestConnectionId();
- header.reset_flag = false;
- header.version_flag = false;
- header.packet_number = kPacketNumber;
-
- QuicStopWaitingFrame stop_waiting_frame;
- stop_waiting_frame.least_unacked = kLeastUnacked;
-
- QuicFrames frames = {QuicFrame(stop_waiting_frame)};
-
- // clang-format off
- unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x2C,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (stop waiting frame)
- 0x06,
- // least packet number awaiting an ack, delta from packet number.
- 0x00, 0x00, 0x00, 0x08,
- };
-
- // clang-format on
-
- std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
- ASSERT_TRUE(data != nullptr);
-
- quiche::test::CompareCharArraysWithHexError(
- "constructed packet", data->data(), data->length(), AsChars(packet),
- ABSL_ARRAYSIZE(packet));
-}
-
TEST_P(QuicFramerTest, BuildRstFramePacketQuic) {
QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
QuicPacketHeader header;
@@ -8809,25 +7141,6 @@
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x2C,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (rst stream frame)
- 0x01,
- // stream id
- 0x01, 0x02, 0x03, 0x04,
- // sent byte offset
- 0x08, 0x07, 0x06, 0x05,
- 0x04, 0x03, 0x02, 0x01,
- // error code
- 0x05, 0x06, 0x07, 0x08,
- };
-
- unsigned char packet46[] = {
// type (short packet, 4 byte packet number)
0x43,
// connection_id
@@ -8875,9 +7188,6 @@
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet_ietf;
p_size = ABSL_ARRAYSIZE(packet_ietf);
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- p_size = ABSL_ARRAYSIZE(packet46);
}
QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -8900,27 +7210,6 @@
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x2C,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (connection close frame)
- 0x02,
- // error code
- 0x00, 0x00, 0x00, 0x01,
- // error details length
- 0x00, 0x0d,
- // error details
- 'b', 'e', 'c', 'a',
- 'u', 's', 'e', ' ',
- 'I', ' ', 'c', 'a',
- 'n',
- };
-
- unsigned char packet46[] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -8970,9 +7259,6 @@
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet_ietf;
p_size = ABSL_ARRAYSIZE(packet_ietf);
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- p_size = ABSL_ARRAYSIZE(packet46);
}
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -9004,27 +7290,6 @@
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x2C,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (connection close frame)
- 0x02,
- // error code
- 0x05, 0x06, 0x07, 0x08,
- // error details length
- 0x00, 0x0d,
- // error details
- 'b', 'e', 'c', 'a',
- 'u', 's', 'e', ' ',
- 'I', ' ', 'c', 'a',
- 'n',
- };
-
- unsigned char packet46[] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -9076,9 +7341,6 @@
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet_ietf;
p_size = ABSL_ARRAYSIZE(packet_ietf);
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- p_size = ABSL_ARRAYSIZE(packet46);
}
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -9103,55 +7365,6 @@
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x2C,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (connection close frame)
- 0x02,
- // error code
- 0x00, 0x00, 0x00, 0x01,
- // error details length
- 0x01, 0x00,
- // error details (truncated to 256 bytes)
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- };
-
- unsigned char packet46[] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -9257,9 +7470,6 @@
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet_ietf;
p_size = ABSL_ARRAYSIZE(packet_ietf);
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- p_size = ABSL_ARRAYSIZE(packet46);
}
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -9422,29 +7632,6 @@
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x2C,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (go away frame)
- 0x03,
- // error code
- 0x05, 0x06, 0x07, 0x08,
- // stream id
- 0x01, 0x02, 0x03, 0x04,
- // error details length
- 0x00, 0x0d,
- // error details
- 'b', 'e', 'c', 'a',
- 'u', 's', 'e', ' ',
- 'I', ' ', 'c', 'a',
- 'n',
- };
-
- unsigned char packet46[] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -9468,19 +7655,12 @@
};
// clang-format on
-
- unsigned char* p = packet;
- size_t p_size = ABSL_ARRAYSIZE(packet);
- if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- p_size = ABSL_ARRAYSIZE(packet46);
- }
-
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
quiche::test::CompareCharArraysWithHexError(
- "constructed packet", data->data(), data->length(), AsChars(p), p_size);
+ "constructed packet", data->data(), data->length(), AsChars(packet),
+ ABSL_ARRAYSIZE(packet));
}
TEST_P(QuicFramerTest, BuildTruncatedGoAwayPacket) {
@@ -9504,57 +7684,6 @@
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x2C,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (go away frame)
- 0x03,
- // error code
- 0x05, 0x06, 0x07, 0x08,
- // stream id
- 0x01, 0x02, 0x03, 0x04,
- // error details length
- 0x01, 0x00,
- // error details (truncated to 256 bytes)
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
- };
-
- unsigned char packet46[] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -9606,18 +7735,12 @@
};
// clang-format on
- unsigned char* p = packet;
- size_t p_size = ABSL_ARRAYSIZE(packet);
- if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- p_size = ABSL_ARRAYSIZE(packet46);
- }
-
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
ASSERT_TRUE(data != nullptr);
quiche::test::CompareCharArraysWithHexError(
- "constructed packet", data->data(), data->length(), AsChars(p), p_size);
+ "constructed packet", data->data(), data->length(), AsChars(packet),
+ ABSL_ARRAYSIZE(packet));
}
TEST_P(QuicFramerTest, BuildWindowUpdatePacket) {
@@ -9636,23 +7759,6 @@
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x2C,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (window update frame)
- 0x04,
- // stream id
- 0x01, 0x02, 0x03, 0x04,
- // byte offset
- 0x11, 0x22, 0x33, 0x44,
- 0x55, 0x66, 0x77, 0x88,
- };
-
- unsigned char packet46[] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -9695,9 +7801,6 @@
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet_ietf;
p_size = ABSL_ARRAYSIZE(packet_ietf);
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- p_size = ABSL_ARRAYSIZE(packet46);
}
quiche::test::CompareCharArraysWithHexError(
@@ -9817,20 +7920,6 @@
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x2C,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (blocked frame)
- 0x05,
- // stream id
- 0x01, 0x02, 0x03, 0x04,
- };
-
- unsigned char packet46[] = {
// type (short packet, 4 byte packet number)
0x43,
// connection_id
@@ -9867,9 +7956,6 @@
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet_ietf;
p_size = ABSL_ARRAYSIZE(packet_ietf);
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- p_size = ABSL_ARRAYSIZE(packet46);
}
quiche::test::CompareCharArraysWithHexError(
@@ -9888,18 +7974,6 @@
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x2C,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (ping frame)
- 0x07,
- };
-
- unsigned char packet46[] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -9927,8 +8001,6 @@
unsigned char* p = packet;
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet_ietf;
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
}
std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -9936,8 +8008,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(p),
- framer_.version().HasIetfInvariantHeader() ? ABSL_ARRAYSIZE(packet46)
- : ABSL_ARRAYSIZE(packet));
+ ABSL_ARRAYSIZE(packet));
}
TEST_P(QuicFramerTest, BuildHandshakeDonePacket) {
@@ -10022,9 +8093,6 @@
}
TEST_P(QuicFramerTest, BuildMessagePacket) {
- if (!VersionSupportsMessageFrames(framer_.transport_version())) {
- return;
- }
QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
QuicPacketHeader header;
header.destination_connection_id = FramerTestConnectionId();
@@ -10037,7 +8105,7 @@
QuicFrames frames = {QuicFrame(&frame), QuicFrame(&frame2)};
// clang-format off
- unsigned char packet46[] = {
+ unsigned char packet[] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -10078,7 +8146,7 @@
};
// clang-format on
- unsigned char* p = packet46;
+ unsigned char* p = packet;
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet_ietf;
}
@@ -10088,7 +8156,7 @@
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(p),
- ABSL_ARRAYSIZE(packet46));
+ ABSL_ARRAYSIZE(packet));
}
// Test that the MTU discovery packet is serialized correctly as a PING packet.
@@ -10104,18 +8172,6 @@
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x2C,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (ping frame)
- 0x07,
- };
-
- unsigned char packet46[] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -10146,14 +8202,11 @@
unsigned char* p = packet;
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet_ietf;
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
}
quiche::test::CompareCharArraysWithHexError(
"constructed packet", data->data(), data->length(), AsChars(p),
- framer_.version().HasIetfInvariantHeader() ? ABSL_ARRAYSIZE(packet46)
- : ABSL_ARRAYSIZE(packet));
+ ABSL_ARRAYSIZE(packet));
}
TEST_P(QuicFramerTest, BuildPublicResetPacket) {
@@ -10181,10 +8234,6 @@
};
// clang-format on
- if (framer_.version().HasIetfInvariantHeader()) {
- return;
- }
-
std::unique_ptr<QuicEncryptedPacket> data(
framer_.BuildPublicResetPacket(reset_packet));
ASSERT_TRUE(data != nullptr);
@@ -10229,10 +8278,6 @@
};
// clang-format on
- if (framer_.version().HasIetfInvariantHeader()) {
- return;
- }
-
std::unique_ptr<QuicEncryptedPacket> data(
framer_.BuildPublicResetPacket(reset_packet));
ASSERT_TRUE(data != nullptr);
@@ -10301,10 +8346,6 @@
};
// clang-format on
- if (framer_.version().HasIetfInvariantHeader()) {
- return;
- }
-
std::unique_ptr<QuicEncryptedPacket> data(
framer_.BuildPublicResetPacket(reset_packet));
ASSERT_TRUE(data != nullptr);
@@ -10414,21 +8455,6 @@
QuicPacketNumber packet_number = kPacketNumber;
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x28,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // redundancy
- 'a', 'b', 'c', 'd',
- 'e', 'f', 'g', 'h',
- 'i', 'j', 'k', 'l',
- 'm', 'n', 'o', 'p',
- };
-
- unsigned char packet46[] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -10465,8 +8491,6 @@
if (framer_.version().HasHeaderProtection()) {
p = packet50;
p_size = ABSL_ARRAYSIZE(packet50);
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
}
std::unique_ptr<QuicPacket> raw(new QuicPacket(
@@ -10508,23 +8532,6 @@
QuicPacketNumber packet_number = kPacketNumber;
// clang-format off
unsigned char packet[] = {
- // public flags (version, 8 byte connection_id)
- 0x29,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // version tag
- 'Q', '.', '1', '0',
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // redundancy
- 'a', 'b', 'c', 'd',
- 'e', 'f', 'g', 'h',
- 'i', 'j', 'k', 'l',
- 'm', 'n', 'o', 'p',
- };
-
- unsigned char packet46[] = {
// type (long header with packet type ZERO_RTT_PROTECTED)
0xD3,
// version tag
@@ -10572,9 +8579,6 @@
if (framer_.version().HasHeaderProtection()) {
p = packet50;
p_size = ABSL_ARRAYSIZE(packet50);
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- p_size = ABSL_ARRAYSIZE(packet46);
}
std::unique_ptr<QuicPacket> raw(new QuicPacket(
@@ -10774,43 +8778,6 @@
SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x28,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (stream frame with fin)
- 0xFF,
- // stream id
- 0x01, 0x02, 0x03, 0x04,
- // offset
- 0x3A, 0x98, 0xFE, 0xDC,
- 0x32, 0x10, 0x76, 0x54,
- // data length
- 0x00, 0x0c,
- // data
- 'h', 'e', 'l', 'l',
- 'o', ' ', 'w', 'o',
- 'r', 'l', 'd', '!',
-
- // frame type (ack frame)
- 0x40,
- // least packet number awaiting an ack
- 0x12, 0x34, 0x56, 0x78,
- 0x9A, 0xA0,
- // largest observed packet number
- 0x12, 0x34, 0x56, 0x78,
- 0x9A, 0xBF,
- // num missing packets
- 0x01,
- // missing packet
- 0x12, 0x34, 0x56, 0x78,
- 0x9A, 0xBE,
- };
-
- unsigned char packet46[] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -10901,9 +8868,6 @@
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet_ietf;
p_size = ABSL_ARRAYSIZE(packet_ietf);
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- p_size = ABSL_ARRAYSIZE(packet46);
}
QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
EXPECT_TRUE(framer_.ProcessPacket(encrypted));
@@ -13390,26 +11354,6 @@
SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x2C,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (ack frame)
- 0x45,
- // largest observed
- 0x00, 0x00,
- // Zero delta time.
- 0x00, 0x00,
- // first ack block length.
- 0x00, 0x00,
- // num timestamps.
- 0x00
- };
-
- unsigned char packet46[] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -13455,8 +11399,6 @@
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet_ietf;
p_size = ABSL_ARRAYSIZE(packet_ietf);
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
}
QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -13468,26 +11410,6 @@
SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x2C,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (ack frame)
- 0x45,
- // largest observed
- 0x00, 0x02,
- // Zero delta time.
- 0x00, 0x00,
- // first ack block length.
- 0x00, 0x03,
- // num timestamps.
- 0x00
- };
-
- unsigned char packet46[] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -13533,9 +11455,6 @@
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet_ietf;
p_size = ABSL_ARRAYSIZE(packet_ietf);
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- p_size = ABSL_ARRAYSIZE(packet46);
}
QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -13548,36 +11467,6 @@
SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x2C,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (ack frame)
- 0x60,
- // largest observed
- 0x0A,
- // Zero delta time.
- 0x00, 0x00,
- // Num of ack blocks
- 0x02,
- // first ack block length.
- 0x02,
- // gap to next block
- 0x01,
- // ack block length
- 0x01,
- // gap to next block
- 0x01,
- // ack block length
- 0x06,
- // num timestamps.
- 0x00
- };
-
- unsigned char packet46[] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -13641,9 +11530,6 @@
if (VersionHasIetfQuicFrames(framer_.transport_version())) {
p = packet_ietf;
p_size = ABSL_ARRAYSIZE(packet_ietf);
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- p_size = ABSL_ARRAYSIZE(packet46);
}
QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -14117,20 +12003,6 @@
// clang-format off
unsigned char packet[] = {
- // public flags (version included, 8-byte connection ID,
- // 4-byte packet number)
- 0x28,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x00,
- // padding frames
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- };
- unsigned char packet46[] = {
// public flags (long header with packet type HANDSHAKE and
// 4-byte packet number)
0xE3,
@@ -14179,9 +12051,6 @@
ReviseFirstByteByVersion(packet49);
p = packet49;
p_length = ABSL_ARRAYSIZE(packet49);
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- p_length = ABSL_ARRAYSIZE(packet46);
}
// First attempt decryption without the handshake crypter.
EXPECT_FALSE(
@@ -14220,20 +12089,6 @@
// clang-format off
unsigned char packet[] = {
- // public flags (version included, 8-byte connection ID,
- // 4-byte packet number)
- 0x28,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x00,
- // padding frames
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- };
- unsigned char packet46[] = {
// public flags (long header with packet type HANDSHAKE and
// 4-byte packet number)
0xE3,
@@ -14282,9 +12137,6 @@
ReviseFirstByteByVersion(packet49);
p = packet49;
p_length = ABSL_ARRAYSIZE(packet49);
- } else if (framer_.version().HasIetfInvariantHeader()) {
- p = packet46;
- p_length = ABSL_ARRAYSIZE(packet46);
}
EXPECT_FALSE(
@@ -14813,9 +12665,6 @@
}
TEST_P(QuicFramerTest, ClientReceivesWrongVersion) {
- if (!framer_.version().HasIetfInvariantHeader()) {
- return;
- }
QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
// clang-format off
@@ -14905,9 +12754,6 @@
}
TEST_P(QuicFramerTest, MultiplePacketNumberSpaces) {
- if (!framer_.version().HasIetfInvariantHeader()) {
- return;
- }
framer_.EnableMultiplePacketNumberSpacesSupport();
// clang-format off
@@ -15019,7 +12865,7 @@
}
// clang-format off
- PacketFragments packet46 = {
+ PacketFragments packet = {
// public flags (IETF Retry packet, 0-length original destination CID)
{"Unable to read first byte.",
{0xf0}},
@@ -15033,16 +12879,15 @@
// clang-format on
std::unique_ptr<QuicEncryptedPacket> encrypted(
- AssemblePacketFromFragments(packet46));
+ AssemblePacketFromFragments(packet));
EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_PACKET_HEADER));
- CheckFramingBoundaries(packet46, QUIC_INVALID_PACKET_HEADER);
+ CheckFramingBoundaries(packet, QUIC_INVALID_PACKET_HEADER);
}
TEST_P(QuicFramerTest, RetryPacketRejectedWithMultiplePacketNumberSpaces) {
- if (!framer_.version().HasIetfInvariantHeader() ||
- framer_.version().SupportsRetry()) {
+ if (framer_.version().SupportsRetry()) {
return;
}
framer_.EnableMultiplePacketNumberSpacesSupport();
@@ -15367,10 +13212,6 @@
}
TEST_P(QuicFramerTest, ClientConnectionIdFromLongHeaderToClient) {
- if (!framer_.version().HasIetfInvariantHeader()) {
- // This test requires an IETF long header.
- return;
- }
SetDecrypterLevel(ENCRYPTION_HANDSHAKE);
QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
// clang-format off
@@ -15436,10 +13277,6 @@
}
TEST_P(QuicFramerTest, ClientConnectionIdFromLongHeaderToServer) {
- if (!framer_.version().HasIetfInvariantHeader()) {
- // This test requires an IETF long header.
- return;
- }
SetDecrypterLevel(ENCRYPTION_HANDSHAKE);
QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_SERVER);
// clang-format off
@@ -15509,10 +13346,6 @@
}
TEST_P(QuicFramerTest, ProcessAndValidateIetfConnectionIdLengthClient) {
- if (!framer_.version().HasIetfInvariantHeader()) {
- // This test requires an IETF long header.
- return;
- }
char connection_id_lengths = 0x05;
QuicDataReader reader(&connection_id_lengths, 1);
@@ -15547,10 +13380,6 @@
}
TEST_P(QuicFramerTest, ProcessAndValidateIetfConnectionIdLengthServer) {
- if (!framer_.version().HasIetfInvariantHeader()) {
- // This test requires an IETF long header.
- return;
- }
char connection_id_lengths = 0x50;
QuicDataReader reader(&connection_id_lengths, 1);
@@ -16349,12 +14178,7 @@
0x00, 0x00, 0x00, 0x00
};
MockConnectionIdGenerator generator;
- if (version_.HasIetfInvariantHeader()) {
EXPECT_CALL(generator, ConnectionIdLength(0x28)).WillOnce(Return(9));
- } else {
- packet[0] = 0x0a;
- EXPECT_CALL(generator, ConnectionIdLength(_)).Times(0);
- }
unsigned char* p = packet;
size_t p_size = ABSL_ARRAYSIZE(packet);
@@ -16384,13 +14208,8 @@
&use_length_prefix, &version_label, &parsed_version,
&destination_connection_id, &source_connection_id, &retry_token,
&detailed_error, generator));
- if (version_.HasIetfInvariantHeader()) {
- EXPECT_EQ(format, IETF_QUIC_SHORT_HEADER_PACKET);
- EXPECT_EQ(destination_connection_id.length(), 9);
- } else {
- EXPECT_EQ(format, GOOGLE_QUIC_PACKET);
- EXPECT_EQ(destination_connection_id.length(), 8);
- }
+ EXPECT_EQ(format, IETF_QUIC_SHORT_HEADER_PACKET);
+ EXPECT_EQ(destination_connection_id.length(), 9);
EXPECT_EQ(long_packet_type, INVALID_PACKET_TYPE);
EXPECT_FALSE(version_flag);
EXPECT_FALSE(use_length_prefix);
diff --git a/quiche/quic/core/quic_packet_creator.cc b/quiche/quic/core/quic_packet_creator.cc
index c04a418..63c07b6 100644
--- a/quiche/quic/core/quic_packet_creator.cc
+++ b/quiche/quic/core/quic_packet_creator.cc
@@ -115,7 +115,6 @@
debug_delegate_(nullptr),
framer_(framer),
random_(random),
- send_version_in_packet_(framer->perspective() == Perspective::IS_CLIENT),
have_diversification_nonce_(false),
max_packet_length_(0),
server_connection_id_included_(CONNECTION_ID_PRESENT),
@@ -215,19 +214,6 @@
max_plaintext_size_ = framer_->GetMaxPlaintextSize(length);
}
-// Stops serializing version of the protocol in packets sent after this call.
-// A packet that is already open might send kQuicVersionSize bytes less than the
-// maximum packet size if we stop sending version before it is serialized.
-void QuicPacketCreator::StopSendingVersion() {
- QUICHE_DCHECK(send_version_in_packet_) << ENDPOINT;
- QUICHE_DCHECK(!version().HasIetfInvariantHeader()) << ENDPOINT;
- send_version_in_packet_ = false;
- if (packet_size_ > 0) {
- QUICHE_DCHECK_LT(kQuicVersionSize, packet_size_) << ENDPOINT;
- packet_size_ -= kQuicVersionSize;
- }
-}
-
void QuicPacketCreator::SetDiversificationNonce(
const DiversificationNonce& nonce) {
QUICHE_DCHECK(!have_diversification_nonce_) << ENDPOINT;
@@ -366,8 +352,8 @@
}
bool QuicPacketCreator::HasRoomForMessageFrame(QuicByteCount length) {
- const size_t message_frame_size = QuicFramer::GetMessageFrameSize(
- framer_->transport_version(), /*last_frame_in_packet=*/true, length);
+ const size_t message_frame_size =
+ QuicFramer::GetMessageFrameSize(/*last_frame_in_packet=*/true, length);
if (static_cast<QuicByteCount>(message_frame_size) >
max_datagram_frame_size_) {
return false;
@@ -609,7 +595,7 @@
QuicDataWriter writer(kMaxOutgoingPacketSize, encrypted_buffer);
size_t length_field_offset = 0;
- if (!framer_->AppendPacketHeader(header, &writer, &length_field_offset)) {
+ if (!framer_->AppendIetfPacketHeader(header, &writer, &length_field_offset)) {
QUIC_BUG(quic_bug_10752_9) << ENDPOINT << "AppendPacketHeader failed";
return;
}
@@ -1968,10 +1954,7 @@
}
bool QuicPacketCreator::IncludeVersionInHeader() const {
- if (version().HasIetfInvariantHeader()) {
- return packet_.encryption_level < ENCRYPTION_FORWARD_SECURE;
- }
- return send_version_in_packet_;
+ return packet_.encryption_level < ENCRYPTION_FORWARD_SECURE;
}
void QuicPacketCreator::AddPendingPadding(QuicByteCount size) {
@@ -2016,9 +1999,6 @@
}
QuicPacketLength QuicPacketCreator::GetCurrentLargestMessagePayload() const {
- if (!VersionSupportsMessageFrames(framer_->transport_version())) {
- return 0;
- }
const size_t packet_header_size = GetPacketHeaderSize(
framer_->transport_version(), GetDestinationConnectionIdLength(),
GetSourceConnectionIdLength(), IncludeVersionInHeader(),
@@ -2040,9 +2020,6 @@
}
QuicPacketLength QuicPacketCreator::GetGuaranteedLargestMessagePayload() const {
- if (!VersionSupportsMessageFrames(framer_->transport_version())) {
- return 0;
- }
// QUIC Crypto server packets may include a diversification nonce.
const bool may_include_nonce =
framer_->version().handshake_protocol == PROTOCOL_QUIC_CRYPTO &&
@@ -2097,8 +2074,7 @@
}
bool QuicPacketCreator::HasIetfLongHeader() const {
- return version().HasIetfInvariantHeader() &&
- packet_.encryption_level < ENCRYPTION_FORWARD_SECURE;
+ return packet_.encryption_level < ENCRYPTION_FORWARD_SECURE;
}
// static
diff --git a/quiche/quic/core/quic_packet_creator.h b/quiche/quic/core/quic_packet_creator.h
index 785efb1..8396b1c 100644
--- a/quiche/quic/core/quic_packet_creator.h
+++ b/quiche/quic/core/quic_packet_creator.h
@@ -119,9 +119,6 @@
~QuicPacketCreator();
- // Makes the framer not serialize the protocol version in sent packets.
- void StopSendingVersion();
-
// SetDiversificationNonce sets the nonce that will be sent in each public
// header of packets encrypted at the initial encryption level. Should only
// be called by servers.
@@ -622,10 +619,6 @@
QuicFramer* framer_;
QuicRandom* random_;
- // Controls whether version should be included while serializing the packet.
- // send_version_in_packet_ should never be read directly, use
- // IncludeVersionInHeader() instead.
- bool send_version_in_packet_;
// If true, then |diversification_nonce_| will be included in the header of
// all packets created at the initial encryption level.
bool have_diversification_nonce_;
diff --git a/quiche/quic/core/quic_packet_creator_test.cc b/quiche/quic/core/quic_packet_creator_test.cc
index b2fec7b..6ff1bc1 100644
--- a/quiche/quic/core/quic_packet_creator_test.cc
+++ b/quiche/quic/core/quic_packet_creator_test.cc
@@ -113,13 +113,7 @@
frame);
}
- void StopSendingVersion() {
- if (version_.HasIetfInvariantHeader()) {
- set_encryption_level(ENCRYPTION_FORWARD_SECURE);
- return;
- }
- QuicPacketCreator::StopSendingVersion();
- }
+ void StopSendingVersion() { set_encryption_level(ENCRYPTION_FORWARD_SECURE); }
SimpleDataProducer* producer_;
ParsedQuicVersion version_;
@@ -639,21 +633,6 @@
// clang-format off
unsigned char packet[] = {
- // public flags (8 byte connection_id)
- 0x2C,
- // connection_id
- 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
- // packet number
- 0x12, 0x34, 0x56, 0x78,
-
- // frame type (ping frame)
- 0x07,
- // frame type (padding frame)
- 0x00,
- 0x00, 0x00, 0x00, 0x00
- };
-
- unsigned char packet46[] = {
// type (short header, 4 byte packet number)
0x43,
// connection_id
@@ -689,9 +668,6 @@
if (creator_.version().HasIetfQuicFrames()) {
p = packet99;
packet_size = ABSL_ARRAYSIZE(packet99);
- } else if (creator_.version().HasIetfInvariantHeader()) {
- p = packet46;
- packet_size = ABSL_ARRAYSIZE(packet46);
}
std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
@@ -1162,8 +1138,7 @@
}
TEST_P(QuicPacketCreatorTest, UpdatePacketSequenceNumberLengthLeastAwaiting) {
- if (creator_.version().HasIetfInvariantHeader() &&
- !GetParam().version.SendsVariableLengthPacketNumberInLongHeader()) {
+ if (!GetParam().version.SendsVariableLengthPacketNumberInLongHeader()) {
EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
@@ -1200,8 +1175,7 @@
TEST_P(QuicPacketCreatorTest, UpdatePacketSequenceNumberLengthCwnd) {
QuicPacketCreatorPeer::SetPacketNumber(&creator_, 1);
- if (creator_.version().HasIetfInvariantHeader() &&
- !GetParam().version.SendsVariableLengthPacketNumberInLongHeader()) {
+ if (!GetParam().version.SendsVariableLengthPacketNumberInLongHeader()) {
EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
@@ -1234,8 +1208,7 @@
TEST_P(QuicPacketCreatorTest, SkipNPacketNumbers) {
QuicPacketCreatorPeer::SetPacketNumber(&creator_, 1);
- if (creator_.version().HasIetfInvariantHeader() &&
- !GetParam().version.SendsVariableLengthPacketNumberInLongHeader()) {
+ if (!GetParam().version.SendsVariableLengthPacketNumberInLongHeader()) {
EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
@@ -1741,9 +1714,6 @@
}
TEST_P(QuicPacketCreatorTest, AddMessageFrame) {
- if (!VersionSupportsMessageFrames(client_framer_.transport_version())) {
- return;
- }
if (client_framer_.version().UsesTls()) {
creator_.SetMaxDatagramFrameSize(kMaxAcceptedDatagramFrameSize);
}
@@ -1794,9 +1764,6 @@
}
TEST_P(QuicPacketCreatorTest, MessageFrameConsumption) {
- if (!VersionSupportsMessageFrames(client_framer_.transport_version())) {
- return;
- }
if (client_framer_.version().UsesTls()) {
creator_.SetMaxDatagramFrameSize(kMaxAcceptedDatagramFrameSize);
}
@@ -1839,9 +1806,6 @@
TEST_P(QuicPacketCreatorTest, GetGuaranteedLargestMessagePayload) {
ParsedQuicVersion version = GetParam().version;
- if (!version.SupportsMessageFrames()) {
- return;
- }
if (version.UsesTls()) {
creator_.SetMaxDatagramFrameSize(kMaxAcceptedDatagramFrameSize);
}
@@ -1890,9 +1854,6 @@
TEST_P(QuicPacketCreatorTest, GetCurrentLargestMessagePayload) {
ParsedQuicVersion version = GetParam().version;
- if (!version.SupportsMessageFrames()) {
- return;
- }
if (version.UsesTls()) {
creator_.SetMaxDatagramFrameSize(kMaxAcceptedDatagramFrameSize);
}
@@ -2358,19 +2319,17 @@
EXPECT_EQ(previous_max_packet_length, creator_.max_packet_length());
// Same for message frame.
- if (VersionSupportsMessageFrames(client_framer_.transport_version())) {
- creator_.SetSoftMaxPacketLength(overhead);
- if (client_framer_.version().UsesTls()) {
- creator_.SetMaxDatagramFrameSize(kMaxAcceptedDatagramFrameSize);
- }
- // Verify GetCurrentLargestMessagePayload is based on the actual
- // max_packet_length.
- EXPECT_LT(1u, creator_.GetCurrentLargestMessagePayload());
- EXPECT_EQ(overhead, creator_.max_packet_length());
- ASSERT_TRUE(creator_.HasRoomForMessageFrame(
- creator_.GetCurrentLargestMessagePayload()));
- EXPECT_EQ(previous_max_packet_length, creator_.max_packet_length());
+ creator_.SetSoftMaxPacketLength(overhead);
+ if (client_framer_.version().UsesTls()) {
+ creator_.SetMaxDatagramFrameSize(kMaxAcceptedDatagramFrameSize);
}
+ // Verify GetCurrentLargestMessagePayload is based on the actual
+ // max_packet_length.
+ EXPECT_LT(1u, creator_.GetCurrentLargestMessagePayload());
+ EXPECT_EQ(overhead, creator_.max_packet_length());
+ ASSERT_TRUE(creator_.HasRoomForMessageFrame(
+ creator_.GetCurrentLargestMessagePayload()));
+ EXPECT_EQ(previous_max_packet_length, creator_.max_packet_length());
// Verify creator can consume crypto data because max_packet_length_ gets
// restored.
@@ -3438,11 +3397,7 @@
for (size_t i = 1; i < 10; i++) {
creator_.SetServerConnectionIdLength(i);
- if (framer_.version().HasIetfInvariantHeader()) {
- EXPECT_EQ(0, creator_.GetDestinationConnectionIdLength());
- } else {
- EXPECT_EQ(8, creator_.GetDestinationConnectionIdLength());
- }
+ EXPECT_EQ(0, creator_.GetDestinationConnectionIdLength());
}
}
@@ -3729,27 +3684,6 @@
CheckPacketHasSingleStreamFrame(4);
}
-TEST_F(QuicPacketCreatorMultiplePacketsTest, DontCrashOnInvalidStopWaiting) {
- if (VersionSupportsMessageFrames(framer_.transport_version())) {
- return;
- }
- // Test added to ensure the creator does not crash when an invalid frame is
- // added. Because this is an indication of internal programming errors,
- // DFATALs are expected.
- // A 1 byte packet number length can't encode a gap of 1000.
- QuicPacketCreatorPeer::SetPacketNumber(&creator_, 1000);
-
- delegate_.SetCanNotWrite();
- delegate_.SetCanWriteAnything();
-
- // This will not serialize any packets, because of the invalid frame.
- EXPECT_CALL(delegate_,
- OnUnrecoverableError(QUIC_FAILED_TO_SERIALIZE_PACKET, _));
- EXPECT_QUIC_BUG(creator_.Flush(),
- "packet_number_length 1 is too small "
- "for least_unacked_delta: 1001");
-}
-
// Regression test for b/31486443.
TEST_F(QuicPacketCreatorMultiplePacketsTest,
ConnectionCloseFrameLargerThanPacketSize) {
@@ -3926,9 +3860,6 @@
}
TEST_F(QuicPacketCreatorMultiplePacketsTest, AddMessageFrame) {
- if (!VersionSupportsMessageFrames(framer_.transport_version())) {
- return;
- }
if (framer_.version().UsesTls()) {
creator_.SetMaxDatagramFrameSize(kMaxAcceptedDatagramFrameSize);
}
diff --git a/quiche/quic/core/quic_packets.cc b/quiche/quic/core/quic_packets.cc
index 39e7eaf..2262877 100644
--- a/quiche/quic/core/quic_packets.cc
+++ b/quiche/quic/core/quic_packets.cc
@@ -106,38 +106,29 @@
quiche::QuicheVariableLengthIntegerLength retry_token_length_length,
QuicByteCount retry_token_length,
quiche::QuicheVariableLengthIntegerLength length_length) {
- if (VersionHasIetfInvariantHeader(version)) {
- if (include_version) {
- // Long header.
- size_t size = kPacketHeaderTypeSize + kConnectionIdLengthSize +
- destination_connection_id_length +
- source_connection_id_length + packet_number_length +
- kQuicVersionSize;
- if (include_diversification_nonce) {
- size += kDiversificationNonceSize;
- }
- if (VersionHasLengthPrefixedConnectionIds(version)) {
- size += kConnectionIdLengthSize;
- }
- QUICHE_DCHECK(
- QuicVersionHasLongHeaderLengths(version) ||
- retry_token_length_length + retry_token_length + length_length == 0);
- if (QuicVersionHasLongHeaderLengths(version)) {
- size += retry_token_length_length + retry_token_length + length_length;
- }
- return size;
+ if (include_version) {
+ // Long header.
+ size_t size = kPacketHeaderTypeSize + kConnectionIdLengthSize +
+ destination_connection_id_length +
+ source_connection_id_length + packet_number_length +
+ kQuicVersionSize;
+ if (include_diversification_nonce) {
+ size += kDiversificationNonceSize;
}
- // Short header.
- return kPacketHeaderTypeSize + destination_connection_id_length +
- packet_number_length;
+ if (VersionHasLengthPrefixedConnectionIds(version)) {
+ size += kConnectionIdLengthSize;
+ }
+ QUICHE_DCHECK(
+ QuicVersionHasLongHeaderLengths(version) ||
+ retry_token_length_length + retry_token_length + length_length == 0);
+ if (QuicVersionHasLongHeaderLengths(version)) {
+ size += retry_token_length_length + retry_token_length + length_length;
+ }
+ return size;
}
- // Google QUIC versions <= 43 can only carry one connection ID.
- QUICHE_DCHECK(destination_connection_id_length == 0 ||
- source_connection_id_length == 0);
- return kPublicFlagsSize + destination_connection_id_length +
- source_connection_id_length +
- (include_version ? kQuicVersionSize : 0) + packet_number_length +
- (include_diversification_nonce ? kDiversificationNonceSize : 0);
+ // Short header.
+ return kPacketHeaderTypeSize + destination_connection_id_length +
+ packet_number_length;
}
size_t GetStartOfEncryptedData(QuicTransportVersion version,
diff --git a/quiche/quic/core/quic_received_packet_manager.h b/quiche/quic/core/quic_received_packet_manager.h
index ab298d4..0f80865 100644
--- a/quiche/quic/core/quic_received_packet_manager.h
+++ b/quiche/quic/core/quic_received_packet_manager.h
@@ -80,10 +80,6 @@
// packets of the largest observed.
virtual bool HasNewMissingPackets() const;
- QuicPacketNumber peer_least_packet_awaiting_ack() const {
- return peer_least_packet_awaiting_ack_;
- }
-
virtual bool ack_frame_updated() const;
QuicPacketNumber GetLargestObserved() const;
diff --git a/quiche/quic/core/quic_time_wait_list_manager_test.cc b/quiche/quic/core/quic_time_wait_list_manager_test.cc
index 9567519..eef0b99 100644
--- a/quiche/quic/core/quic_time_wait_list_manager_test.cc
+++ b/quiche/quic/core/quic_time_wait_list_manager_test.cc
@@ -49,14 +49,6 @@
: connection_id_(connection_id) {}
~FramerVisitorCapturingPublicReset() override = default;
- void OnPublicResetPacket(const QuicPublicResetPacket& public_reset) override {
- public_reset_packet_ = public_reset;
- }
-
- const QuicPublicResetPacket public_reset_packet() {
- return public_reset_packet_;
- }
-
bool IsValidStatelessResetToken(
const StatelessResetToken& token) const override {
return token == QuicUtils::GenerateStatelessResetToken(connection_id_);
@@ -72,7 +64,6 @@
}
private:
- QuicPublicResetPacket public_reset_packet_;
QuicIetfStatelessResetPacket stateless_reset_packet_;
QuicConnectionId connection_id_;
};
@@ -144,7 +135,7 @@
void AddConnectionId(QuicConnectionId connection_id,
QuicTimeWaitListManager::TimeWaitAction action) {
- AddConnectionId(connection_id, QuicVersionMax(), action, nullptr);
+ AddConnectionId(connection_id, action, nullptr);
}
void AddStatelessConnectionId(QuicConnectionId connection_id) {
@@ -157,12 +148,12 @@
}
void AddConnectionId(
- QuicConnectionId connection_id, ParsedQuicVersion version,
+ QuicConnectionId connection_id,
QuicTimeWaitListManager::TimeWaitAction action,
std::vector<std::unique_ptr<QuicEncryptedPacket>>* packets) {
time_wait_list_manager_.AddConnectionIdToTimeWait(
- action, TimeWaitConnectionInfo(version.HasIetfInvariantHeader(),
- packets, {connection_id}));
+ action,
+ TimeWaitConnectionInfo(/*ietf_quic=*/true, packets, {connection_id}));
}
bool IsConnectionIdInTimeWait(QuicConnectionId connection_id) {
@@ -204,11 +195,6 @@
QuicEncryptedPacket encrypted(std::get<0>(packet_buffer),
std::get<1>(packet_buffer));
framer.ProcessPacket(encrypted);
- QuicPublicResetPacket packet = visitor.public_reset_packet();
- bool public_reset_is_valid =
- expected_connection_id == packet.connection_id &&
- TestPeerIPAddress() == packet.client_address.host() &&
- kTestPort == packet.client_address.port();
QuicIetfStatelessResetPacket stateless_reset =
visitor.stateless_reset_packet();
@@ -216,10 +202,8 @@
StatelessResetToken expected_stateless_reset_token =
QuicUtils::GenerateStatelessResetToken(expected_connection_id);
- bool stateless_reset_is_valid =
- stateless_reset.stateless_reset_token == expected_stateless_reset_token;
-
- return public_reset_is_valid || stateless_reset_is_valid;
+ return stateless_reset.stateless_reset_token ==
+ expected_stateless_reset_token;
}
Matcher<const std::tuple<const char*, int>> PublicResetPacketEq(
@@ -319,7 +303,7 @@
termination_packets.push_back(
std::unique_ptr<QuicEncryptedPacket>(new QuicEncryptedPacket(
new char[kConnectionCloseLength], kConnectionCloseLength, true)));
- AddConnectionId(connection_id_, QuicVersionMax(),
+ AddConnectionId(connection_id_,
QuicTimeWaitListManager::SEND_CONNECTION_CLOSE_PACKETS,
&termination_packets);
EXPECT_CALL(writer_, WritePacket(_, kConnectionCloseLength,
@@ -339,7 +323,7 @@
termination_packets.push_back(
std::unique_ptr<QuicEncryptedPacket>(new QuicEncryptedPacket(
new char[kConnectionCloseLength], kConnectionCloseLength, true)));
- AddConnectionId(connection_id_, QuicVersionMax(),
+ AddConnectionId(connection_id_,
QuicTimeWaitListManager::SEND_CONNECTION_CLOSE_PACKETS,
&termination_packets);
EXPECT_CALL(writer_, WritePacket(_, kConnectionCloseLength,
@@ -536,7 +520,7 @@
termination_packets.push_back(
std::unique_ptr<QuicEncryptedPacket>(new QuicEncryptedPacket(
new char[kConnectionCloseLength], kConnectionCloseLength, true)));
- AddConnectionId(connection_id_, QuicVersionMax(),
+ AddConnectionId(connection_id_,
QuicTimeWaitListManager::SEND_TERMINATION_PACKETS,
&termination_packets);
EXPECT_TRUE(IsConnectionIdInTimeWait(connection_id_));
diff --git a/quiche/quic/core/quic_utils_test.cc b/quiche/quic/core/quic_utils_test.cc
index 543c8ea..a391cc2 100644
--- a/quiche/quic/core/quic_utils_test.cc
+++ b/quiche/quic/core/quic_utils_test.cc
@@ -204,17 +204,17 @@
}
TEST_F(QuicUtilsTest, VariableLengthConnectionId) {
- EXPECT_FALSE(VersionAllowsVariableLengthConnectionIds(QUIC_VERSION_43));
+ EXPECT_FALSE(VersionAllowsVariableLengthConnectionIds(QUIC_VERSION_46));
EXPECT_TRUE(QuicUtils::IsConnectionIdValidForVersion(
- QuicUtils::CreateZeroConnectionId(QUIC_VERSION_43), QUIC_VERSION_43));
+ QuicUtils::CreateZeroConnectionId(QUIC_VERSION_46), QUIC_VERSION_46));
EXPECT_TRUE(QuicUtils::IsConnectionIdValidForVersion(
QuicUtils::CreateZeroConnectionId(QUIC_VERSION_50), QUIC_VERSION_50));
- EXPECT_NE(QuicUtils::CreateZeroConnectionId(QUIC_VERSION_43),
+ EXPECT_NE(QuicUtils::CreateZeroConnectionId(QUIC_VERSION_46),
EmptyQuicConnectionId());
EXPECT_EQ(QuicUtils::CreateZeroConnectionId(QUIC_VERSION_50),
EmptyQuicConnectionId());
EXPECT_FALSE(QuicUtils::IsConnectionIdValidForVersion(EmptyQuicConnectionId(),
- QUIC_VERSION_43));
+ QUIC_VERSION_46));
}
TEST_F(QuicUtilsTest, StatelessResetToken) {
diff --git a/quiche/quic/core/quic_version_manager.cc b/quiche/quic/core/quic_version_manager.cc
index ec2b9ef..91404ed 100644
--- a/quiche/quic/core/quic_version_manager.cc
+++ b/quiche/quic/core/quic_version_manager.cc
@@ -36,7 +36,7 @@
}
void QuicVersionManager::MaybeRefilterSupportedVersions() {
- static_assert(SupportedVersions().size() == 6u,
+ static_assert(SupportedVersions().size() == 5u,
"Supported versions out of sync");
if (enable_version_2_draft_08_ !=
GetQuicReloadableFlag(quic_enable_version_2_draft_08) ||
@@ -47,9 +47,7 @@
disable_version_q050_ !=
GetQuicReloadableFlag(quic_disable_version_q050) ||
disable_version_q046_ !=
- GetQuicReloadableFlag(quic_disable_version_q046) ||
- disable_version_q043_ !=
- GetQuicReloadableFlag(quic_disable_version_q043)) {
+ GetQuicReloadableFlag(quic_disable_version_q046)) {
enable_version_2_draft_08_ =
GetQuicReloadableFlag(quic_enable_version_2_draft_08);
disable_version_rfcv1_ = GetQuicReloadableFlag(quic_disable_version_rfcv1);
@@ -57,7 +55,6 @@
GetQuicReloadableFlag(quic_disable_version_draft_29);
disable_version_q050_ = GetQuicReloadableFlag(quic_disable_version_q050);
disable_version_q046_ = GetQuicReloadableFlag(quic_disable_version_q046);
- disable_version_q043_ = GetQuicReloadableFlag(quic_disable_version_q043);
RefilterSupportedVersions();
}
diff --git a/quiche/quic/core/quic_version_manager.h b/quiche/quic/core/quic_version_manager.h
index c664fc4..5beee79 100644
--- a/quiche/quic/core/quic_version_manager.h
+++ b/quiche/quic/core/quic_version_manager.h
@@ -65,8 +65,6 @@
bool disable_version_q050_ = true;
// quic_disable_version_q046 flag
bool disable_version_q046_ = true;
- // quic_disable_version_q043 flag
- bool disable_version_q043_ = true;
// The list of versions that may be supported.
const ParsedQuicVersionVector allowed_supported_versions_;
diff --git a/quiche/quic/core/quic_version_manager_test.cc b/quiche/quic/core/quic_version_manager_test.cc
index 3c3a00e..d9ae2b6 100644
--- a/quiche/quic/core/quic_version_manager_test.cc
+++ b/quiche/quic/core/quic_version_manager_test.cc
@@ -18,7 +18,7 @@
class QuicVersionManagerTest : public QuicTest {};
TEST_F(QuicVersionManagerTest, QuicVersionManager) {
- static_assert(SupportedVersions().size() == 6u,
+ static_assert(SupportedVersions().size() == 5u,
"Supported versions out of sync");
for (const ParsedQuicVersion& version : AllSupportedVersions()) {
QuicEnableVersion(version);
@@ -31,15 +31,13 @@
ParsedQuicVersionVector expected_parsed_versions;
expected_parsed_versions.push_back(ParsedQuicVersion::Q050());
expected_parsed_versions.push_back(ParsedQuicVersion::Q046());
- expected_parsed_versions.push_back(ParsedQuicVersion::Q043());
EXPECT_EQ(expected_parsed_versions, manager.GetSupportedVersions());
EXPECT_EQ(FilterSupportedVersions(AllSupportedVersions()),
manager.GetSupportedVersions());
EXPECT_TRUE(manager.GetSupportedVersionsWithOnlyHttp3().empty());
- EXPECT_THAT(manager.GetSupportedAlpns(),
- ElementsAre("h3-Q050", "h3-Q046", "h3-Q043"));
+ EXPECT_THAT(manager.GetSupportedAlpns(), ElementsAre("h3-Q050", "h3-Q046"));
QuicEnableVersion(ParsedQuicVersion::Draft29());
expected_parsed_versions.insert(expected_parsed_versions.begin(),
@@ -51,7 +49,7 @@
EXPECT_EQ(CurrentSupportedHttp3Versions(),
manager.GetSupportedVersionsWithOnlyHttp3());
EXPECT_THAT(manager.GetSupportedAlpns(),
- ElementsAre("h3-29", "h3-Q050", "h3-Q046", "h3-Q043"));
+ ElementsAre("h3-29", "h3-Q050", "h3-Q046"));
QuicEnableVersion(ParsedQuicVersion::RFCv1());
expected_parsed_versions.insert(expected_parsed_versions.begin(),
@@ -63,7 +61,7 @@
EXPECT_EQ(CurrentSupportedHttp3Versions(),
manager.GetSupportedVersionsWithOnlyHttp3());
EXPECT_THAT(manager.GetSupportedAlpns(),
- ElementsAre("h3", "h3-29", "h3-Q050", "h3-Q046", "h3-Q043"));
+ ElementsAre("h3", "h3-29", "h3-Q050", "h3-Q046"));
QuicEnableVersion(ParsedQuicVersion::V2Draft08());
expected_parsed_versions.insert(expected_parsed_versions.begin(),
@@ -75,7 +73,7 @@
EXPECT_EQ(CurrentSupportedHttp3Versions(),
manager.GetSupportedVersionsWithOnlyHttp3());
EXPECT_THAT(manager.GetSupportedAlpns(),
- ElementsAre("h3", "h3-29", "h3-Q050", "h3-Q046", "h3-Q043"));
+ ElementsAre("h3", "h3-29", "h3-Q050", "h3-Q046"));
}
} // namespace
diff --git a/quiche/quic/core/quic_versions.cc b/quiche/quic/core/quic_versions.cc
index 1f03b70..fd3f6af 100644
--- a/quiche/quic/core/quic_versions.cc
+++ b/quiche/quic/core/quic_versions.cc
@@ -36,7 +36,7 @@
}
void SetVersionFlag(const ParsedQuicVersion& version, bool should_enable) {
- static_assert(SupportedVersions().size() == 6u,
+ static_assert(SupportedVersions().size() == 5u,
"Supported versions out of sync");
const bool enable = should_enable;
const bool disable = !should_enable;
@@ -50,8 +50,6 @@
SetQuicReloadableFlag(quic_disable_version_q050, disable);
} else if (version == ParsedQuicVersion::Q046()) {
SetQuicReloadableFlag(quic_disable_version_q046, disable);
- } else if (version == ParsedQuicVersion::Q043()) {
- SetQuicReloadableFlag(quic_disable_version_q043, disable);
} else {
QUIC_BUG(quic_bug_10589_1)
<< "Cannot " << (enable ? "en" : "dis") << "able version " << version;
@@ -133,16 +131,6 @@
return VersionSupportsGoogleAltSvcFormat(transport_version);
}
-bool ParsedQuicVersion::HasIetfInvariantHeader() const {
- QUICHE_DCHECK(IsKnown());
- return VersionHasIetfInvariantHeader(transport_version);
-}
-
-bool ParsedQuicVersion::SupportsMessageFrames() const {
- QUICHE_DCHECK(IsKnown());
- return VersionSupportsMessageFrames(transport_version);
-}
-
bool ParsedQuicVersion::UsesHttp3() const {
QUICHE_DCHECK(IsKnown());
return VersionUsesHttp3(transport_version);
@@ -223,7 +211,7 @@
}
QuicVersionLabel CreateQuicVersionLabel(ParsedQuicVersion parsed_version) {
- static_assert(SupportedVersions().size() == 6u,
+ static_assert(SupportedVersions().size() == 5u,
"Supported versions out of sync");
if (parsed_version == ParsedQuicVersion::V2Draft08()) {
return MakeVersionLabel(0x6b, 0x33, 0x43, 0xcf);
@@ -235,8 +223,6 @@
return MakeVersionLabel('Q', '0', '5', '0');
} else if (parsed_version == ParsedQuicVersion::Q046()) {
return MakeVersionLabel('Q', '0', '4', '6');
- } else if (parsed_version == ParsedQuicVersion::Q043()) {
- return MakeVersionLabel('Q', '0', '4', '3');
} else if (parsed_version == ParsedQuicVersion::ReservedForNegotiation()) {
return CreateRandomVersionLabelForNegotiation();
}
@@ -424,7 +410,7 @@
ParsedQuicVersionVector FilterSupportedVersions(
ParsedQuicVersionVector versions) {
- static_assert(SupportedVersions().size() == 6u,
+ static_assert(SupportedVersions().size() == 5u,
"Supported versions out of sync");
ParsedQuicVersionVector filtered_versions;
filtered_versions.reserve(versions.size());
@@ -449,10 +435,6 @@
if (!GetQuicReloadableFlag(quic_disable_version_q046)) {
filtered_versions.push_back(version);
}
- } else if (version == ParsedQuicVersion::Q043()) {
- if (!GetQuicReloadableFlag(quic_disable_version_q043)) {
- filtered_versions.push_back(version);
- }
} else {
QUIC_BUG(quic_bug_10589_7)
<< "QUIC version " << version << " has no flag protection";
@@ -514,7 +496,6 @@
std::string QuicVersionToString(QuicTransportVersion transport_version) {
switch (transport_version) {
- RETURN_STRING_LITERAL(QUIC_VERSION_43);
RETURN_STRING_LITERAL(QUIC_VERSION_46);
RETURN_STRING_LITERAL(QUIC_VERSION_50);
RETURN_STRING_LITERAL(QUIC_VERSION_IETF_DRAFT_29);
@@ -538,7 +519,7 @@
}
std::string ParsedQuicVersionToString(ParsedQuicVersion version) {
- static_assert(SupportedVersions().size() == 6u,
+ static_assert(SupportedVersions().size() == 5u,
"Supported versions out of sync");
if (version == UnsupportedQuicVersion()) {
return "0";
@@ -604,8 +585,8 @@
// and Google QUIC 49 and later use the new length prefixed encoding.
// Similarly, only IETF drafts 11 to 21 used this encoding.
- // Check Q044, Q045, Q046, Q047 and Q048.
- for (uint8_t c = '4'; c <= '8'; ++c) {
+ // Check Q043, Q044, Q045, Q046, Q047 and Q048.
+ for (uint8_t c = '3'; c <= '8'; ++c) {
if (version_label == MakeVersionLabel('Q', '0', '4', c)) {
return true;
}
diff --git a/quiche/quic/core/quic_versions.h b/quiche/quic/core/quic_versions.h
index a8cfab3..8129d9a 100644
--- a/quiche/quic/core/quic_versions.h
+++ b/quiche/quic/core/quic_versions.h
@@ -106,8 +106,7 @@
// or v41 are present in subsequent versions.
// Version 42 allowed receiving overlapping stream data.
- QUIC_VERSION_43 = 43, // PRIORITY frames are sent by client and accepted by
- // server.
+ // Version 43 PRIORITY frames are sent by client and accepted by server.
// Version 44 used IETF header format from draft-ietf-quic-invariants-05.
// Version 45 added MESSAGE frame.
@@ -166,8 +165,8 @@
}
// Returns whether this combination of handshake protocol and transport
-// version is allowed. For example, {PROTOCOL_TLS1_3, QUIC_VERSION_43} is NOT
-// allowed as TLS requires crypto frames which v43 does not support. Note that
+// version is allowed. For example, {PROTOCOL_TLS1_3, QUIC_VERSION_46} is NOT
+// allowed as TLS requires crypto frames which v46 does not support. Note that
// UnsupportedQuicVersion is a valid version.
QUIC_EXPORT_PRIVATE constexpr bool ParsedQuicVersionIsValid(
HandshakeProtocol handshake_protocol,
@@ -179,7 +178,6 @@
QUIC_VERSION_IETF_DRAFT_29,
QUIC_VERSION_50,
QUIC_VERSION_46,
- QUIC_VERSION_43,
QUIC_VERSION_RESERVED_FOR_NEGOTIATION,
QUIC_VERSION_UNSUPPORTED,
};
@@ -270,10 +268,6 @@
return ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_46);
}
- static constexpr ParsedQuicVersion Q043() {
- return ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_43);
- }
-
static constexpr ParsedQuicVersion Unsupported() {
return ParsedQuicVersion(PROTOCOL_UNSUPPORTED, QUIC_VERSION_UNSUPPORTED);
}
@@ -333,12 +327,6 @@
// advertisement format.
bool SupportsGoogleAltSvcFormat() const;
- // Returns true if |transport_version| uses IETF invariant headers.
- bool HasIetfInvariantHeader() const;
-
- // Returns true if |transport_version| supports MESSAGE frames.
- bool SupportsMessageFrames() const;
-
// If true, HTTP/3 instead of gQUIC will be used at the HTTP layer.
// Notable changes are:
// * Headers stream no longer exists.
@@ -410,11 +398,11 @@
return {PROTOCOL_TLS1_3, PROTOCOL_QUIC_CRYPTO};
}
-constexpr std::array<ParsedQuicVersion, 6> SupportedVersions() {
+constexpr std::array<ParsedQuicVersion, 5> SupportedVersions() {
return {
ParsedQuicVersion::V2Draft08(), ParsedQuicVersion::RFCv1(),
ParsedQuicVersion::Draft29(), ParsedQuicVersion::Q050(),
- ParsedQuicVersion::Q046(), ParsedQuicVersion::Q043(),
+ ParsedQuicVersion::Q046(),
};
}
@@ -563,19 +551,6 @@
std::numeric_limits<size_t>::max());
}
-// Returns true if |transport_version| uses IETF invariant headers.
-QUIC_EXPORT_PRIVATE constexpr bool VersionHasIetfInvariantHeader(
- QuicTransportVersion transport_version) {
- return transport_version > QUIC_VERSION_43;
-}
-
-// Returns true if |transport_version| supports MESSAGE frames.
-QUIC_EXPORT_PRIVATE constexpr bool VersionSupportsMessageFrames(
- QuicTransportVersion transport_version) {
- // MESSAGE frames were added in version 45.
- return transport_version > QUIC_VERSION_43;
-}
-
// If true, HTTP/3 instead of gQUIC will be used at the HTTP layer.
// Notable changes are:
// * Headers stream no longer exists.
diff --git a/quiche/quic/core/quic_versions_test.cc b/quiche/quic/core/quic_versions_test.cc
index 745b58a..49335e3 100644
--- a/quiche/quic/core/quic_versions_test.cc
+++ b/quiche/quic/core/quic_versions_test.cc
@@ -38,7 +38,7 @@
EXPECT_TRUE(ParsedQuicVersionIsValid(reserved.handshake_protocol,
reserved.transport_version));
// Check that invalid combinations are not valid.
- EXPECT_FALSE(ParsedQuicVersionIsValid(PROTOCOL_TLS1_3, QUIC_VERSION_43));
+ EXPECT_FALSE(ParsedQuicVersionIsValid(PROTOCOL_TLS1_3, QUIC_VERSION_46));
EXPECT_FALSE(ParsedQuicVersionIsValid(PROTOCOL_QUIC_CRYPTO,
QUIC_VERSION_IETF_DRAFT_29));
// Check that deprecated versions are not valid.
@@ -51,31 +51,29 @@
}
TEST(QuicVersionsTest, Features) {
- ParsedQuicVersion parsed_version_q043 = ParsedQuicVersion::Q043();
+ ParsedQuicVersion parsed_version_q046 = ParsedQuicVersion::Q046();
ParsedQuicVersion parsed_version_draft_29 = ParsedQuicVersion::Draft29();
- EXPECT_TRUE(parsed_version_q043.IsKnown());
- EXPECT_FALSE(parsed_version_q043.KnowsWhichDecrypterToUse());
- EXPECT_FALSE(parsed_version_q043.UsesInitialObfuscators());
- EXPECT_FALSE(parsed_version_q043.AllowsLowFlowControlLimits());
- EXPECT_FALSE(parsed_version_q043.HasHeaderProtection());
- EXPECT_FALSE(parsed_version_q043.SupportsRetry());
+ EXPECT_TRUE(parsed_version_q046.IsKnown());
+ EXPECT_FALSE(parsed_version_q046.KnowsWhichDecrypterToUse());
+ EXPECT_FALSE(parsed_version_q046.UsesInitialObfuscators());
+ EXPECT_FALSE(parsed_version_q046.AllowsLowFlowControlLimits());
+ EXPECT_FALSE(parsed_version_q046.HasHeaderProtection());
+ EXPECT_FALSE(parsed_version_q046.SupportsRetry());
EXPECT_FALSE(
- parsed_version_q043.SendsVariableLengthPacketNumberInLongHeader());
- EXPECT_FALSE(parsed_version_q043.AllowsVariableLengthConnectionIds());
- EXPECT_FALSE(parsed_version_q043.SupportsClientConnectionIds());
- EXPECT_FALSE(parsed_version_q043.HasLengthPrefixedConnectionIds());
- EXPECT_FALSE(parsed_version_q043.SupportsAntiAmplificationLimit());
- EXPECT_FALSE(parsed_version_q043.CanSendCoalescedPackets());
- EXPECT_TRUE(parsed_version_q043.SupportsGoogleAltSvcFormat());
- EXPECT_FALSE(parsed_version_q043.HasIetfInvariantHeader());
- EXPECT_FALSE(parsed_version_q043.SupportsMessageFrames());
- EXPECT_FALSE(parsed_version_q043.UsesHttp3());
- EXPECT_FALSE(parsed_version_q043.HasLongHeaderLengths());
- EXPECT_FALSE(parsed_version_q043.UsesCryptoFrames());
- EXPECT_FALSE(parsed_version_q043.HasIetfQuicFrames());
- EXPECT_FALSE(parsed_version_q043.UsesTls());
- EXPECT_TRUE(parsed_version_q043.UsesQuicCrypto());
+ parsed_version_q046.SendsVariableLengthPacketNumberInLongHeader());
+ EXPECT_FALSE(parsed_version_q046.AllowsVariableLengthConnectionIds());
+ EXPECT_FALSE(parsed_version_q046.SupportsClientConnectionIds());
+ EXPECT_FALSE(parsed_version_q046.HasLengthPrefixedConnectionIds());
+ EXPECT_FALSE(parsed_version_q046.SupportsAntiAmplificationLimit());
+ EXPECT_FALSE(parsed_version_q046.CanSendCoalescedPackets());
+ EXPECT_TRUE(parsed_version_q046.SupportsGoogleAltSvcFormat());
+ EXPECT_FALSE(parsed_version_q046.UsesHttp3());
+ EXPECT_FALSE(parsed_version_q046.HasLongHeaderLengths());
+ EXPECT_FALSE(parsed_version_q046.UsesCryptoFrames());
+ EXPECT_FALSE(parsed_version_q046.HasIetfQuicFrames());
+ EXPECT_FALSE(parsed_version_q046.UsesTls());
+ EXPECT_TRUE(parsed_version_q046.UsesQuicCrypto());
EXPECT_TRUE(parsed_version_draft_29.IsKnown());
EXPECT_TRUE(parsed_version_draft_29.KnowsWhichDecrypterToUse());
@@ -91,8 +89,6 @@
EXPECT_TRUE(parsed_version_draft_29.SupportsAntiAmplificationLimit());
EXPECT_TRUE(parsed_version_draft_29.CanSendCoalescedPackets());
EXPECT_FALSE(parsed_version_draft_29.SupportsGoogleAltSvcFormat());
- EXPECT_TRUE(parsed_version_draft_29.HasIetfInvariantHeader());
- EXPECT_TRUE(parsed_version_draft_29.SupportsMessageFrames());
EXPECT_TRUE(parsed_version_draft_29.UsesHttp3());
EXPECT_TRUE(parsed_version_draft_29.HasLongHeaderLengths());
EXPECT_TRUE(parsed_version_draft_29.UsesCryptoFrames());
@@ -102,10 +98,8 @@
}
TEST(QuicVersionsTest, ParseQuicVersionLabel) {
- static_assert(SupportedVersions().size() == 6u,
+ static_assert(SupportedVersions().size() == 5u,
"Supported versions out of sync");
- EXPECT_EQ(ParsedQuicVersion::Q043(),
- ParseQuicVersionLabel(MakeVersionLabel('Q', '0', '4', '3')));
EXPECT_EQ(ParsedQuicVersion::Q046(),
ParseQuicVersionLabel(MakeVersionLabel('Q', '0', '4', '6')));
EXPECT_EQ(ParsedQuicVersion::Q050(),
@@ -131,9 +125,8 @@
}
TEST(QuicVersionsTest, ParseQuicVersionString) {
- static_assert(SupportedVersions().size() == 6u,
+ static_assert(SupportedVersions().size() == 5u,
"Supported versions out of sync");
- EXPECT_EQ(ParsedQuicVersion::Q043(), ParseQuicVersionString("Q043"));
EXPECT_EQ(ParsedQuicVersion::Q046(),
ParseQuicVersionString("QUIC_VERSION_46"));
EXPECT_EQ(ParsedQuicVersion::Q046(), ParseQuicVersionString("46"));
@@ -224,9 +217,8 @@
// CreateQuicVersionLabel() uses MakeVersionLabel() internally,
// in case it has a bug.
TEST(QuicVersionsTest, CreateQuicVersionLabel) {
- static_assert(SupportedVersions().size() == 6u,
+ static_assert(SupportedVersions().size() == 5u,
"Supported versions out of sync");
- EXPECT_EQ(0x51303433u, CreateQuicVersionLabel(ParsedQuicVersion::Q043()));
EXPECT_EQ(0x51303436u, CreateQuicVersionLabel(ParsedQuicVersion::Q046()));
EXPECT_EQ(0x51303530u, CreateQuicVersionLabel(ParsedQuicVersion::Q050()));
EXPECT_EQ(0xff00001du, CreateQuicVersionLabel(ParsedQuicVersion::Draft29()));
@@ -247,10 +239,8 @@
}
TEST(QuicVersionsTest, QuicVersionLabelToString) {
- static_assert(SupportedVersions().size() == 6u,
+ static_assert(SupportedVersions().size() == 5u,
"Supported versions out of sync");
- EXPECT_EQ("Q043", QuicVersionLabelToString(
- CreateQuicVersionLabel(ParsedQuicVersion::Q043())));
EXPECT_EQ("Q046", QuicVersionLabelToString(
CreateQuicVersionLabel(ParsedQuicVersion::Q046())));
EXPECT_EQ("Q050", QuicVersionLabelToString(
@@ -285,10 +275,9 @@
}
TEST(QuicVersionsTest, ParseQuicVersionLabelString) {
- static_assert(SupportedVersions().size() == 6u,
+ static_assert(SupportedVersions().size() == 5u,
"Supported versions out of sync");
// Explicitly test known QUIC version label strings.
- EXPECT_EQ(ParsedQuicVersion::Q043(), ParseQuicVersionLabelString("Q043"));
EXPECT_EQ(ParsedQuicVersion::Q046(), ParseQuicVersionLabelString("Q046"));
EXPECT_EQ(ParsedQuicVersion::Q050(), ParseQuicVersionLabelString("Q050"));
EXPECT_EQ(ParsedQuicVersion::Draft29(),
@@ -318,21 +307,21 @@
EXPECT_EQ("QUIC_VERSION_UNSUPPORTED",
QuicVersionToString(QUIC_VERSION_UNSUPPORTED));
- QuicTransportVersion single_version[] = {QUIC_VERSION_43};
+ QuicTransportVersion single_version[] = {QUIC_VERSION_46};
QuicTransportVersionVector versions_vector;
for (size_t i = 0; i < ABSL_ARRAYSIZE(single_version); ++i) {
versions_vector.push_back(single_version[i]);
}
- EXPECT_EQ("QUIC_VERSION_43",
+ EXPECT_EQ("QUIC_VERSION_46",
QuicTransportVersionVectorToString(versions_vector));
QuicTransportVersion multiple_versions[] = {QUIC_VERSION_UNSUPPORTED,
- QUIC_VERSION_43};
+ QUIC_VERSION_46};
versions_vector.clear();
for (size_t i = 0; i < ABSL_ARRAYSIZE(multiple_versions); ++i) {
versions_vector.push_back(multiple_versions[i]);
}
- EXPECT_EQ("QUIC_VERSION_UNSUPPORTED,QUIC_VERSION_43",
+ EXPECT_EQ("QUIC_VERSION_UNSUPPORTED,QUIC_VERSION_46",
QuicTransportVersionVectorToString(versions_vector));
// Make sure that all supported versions are present in QuicVersionToString.
@@ -343,12 +332,11 @@
std::ostringstream os;
os << versions_vector;
- EXPECT_EQ("QUIC_VERSION_UNSUPPORTED,QUIC_VERSION_43", os.str());
+ EXPECT_EQ("QUIC_VERSION_UNSUPPORTED,QUIC_VERSION_46", os.str());
}
TEST(QuicVersionsTest, ParsedQuicVersionToString) {
EXPECT_EQ("0", ParsedQuicVersionToString(ParsedQuicVersion::Unsupported()));
- EXPECT_EQ("Q043", ParsedQuicVersionToString(ParsedQuicVersion::Q043()));
EXPECT_EQ("Q046", ParsedQuicVersionToString(ParsedQuicVersion::Q046()));
EXPECT_EQ("Q050", ParsedQuicVersionToString(ParsedQuicVersion::Q050()));
EXPECT_EQ("draft29", ParsedQuicVersionToString(ParsedQuicVersion::Draft29()));
@@ -356,13 +344,13 @@
EXPECT_EQ("V2Draft08",
ParsedQuicVersionToString(ParsedQuicVersion::V2Draft08()));
- ParsedQuicVersionVector versions_vector = {ParsedQuicVersion::Q043()};
- EXPECT_EQ("Q043", ParsedQuicVersionVectorToString(versions_vector));
+ ParsedQuicVersionVector versions_vector = {ParsedQuicVersion::Q046()};
+ EXPECT_EQ("Q046", ParsedQuicVersionVectorToString(versions_vector));
versions_vector = {ParsedQuicVersion::Unsupported(),
- ParsedQuicVersion::Q043()};
- EXPECT_EQ("0,Q043", ParsedQuicVersionVectorToString(versions_vector));
- EXPECT_EQ("0:Q043", ParsedQuicVersionVectorToString(versions_vector, ":",
+ ParsedQuicVersion::Q046()};
+ EXPECT_EQ("0,Q046", ParsedQuicVersionVectorToString(versions_vector));
+ EXPECT_EQ("0:Q046", ParsedQuicVersionVectorToString(versions_vector, ":",
versions_vector.size()));
EXPECT_EQ("0|...", ParsedQuicVersionVectorToString(versions_vector, "|", 0));
@@ -374,7 +362,7 @@
std::ostringstream os;
os << versions_vector;
- EXPECT_EQ("0,Q043", os.str());
+ EXPECT_EQ("0,Q046", os.str());
}
TEST(QuicVersionsTest, FilterSupportedVersionsAllVersions) {
@@ -421,9 +409,8 @@
// yet a typo was made in doing the #defines and it was caught
// only in some test far removed from here... Better safe than sorry.
TEST(QuicVersionsTest, CheckTransportVersionNumbersForTypos) {
- static_assert(SupportedVersions().size() == 6u,
+ static_assert(SupportedVersions().size() == 5u,
"Supported versions out of sync");
- EXPECT_EQ(QUIC_VERSION_43, 43);
EXPECT_EQ(QUIC_VERSION_46, 46);
EXPECT_EQ(QUIC_VERSION_50, 50);
EXPECT_EQ(QUIC_VERSION_IETF_DRAFT_29, 73);
@@ -432,9 +419,8 @@
}
TEST(QuicVersionsTest, AlpnForVersion) {
- static_assert(SupportedVersions().size() == 6u,
+ static_assert(SupportedVersions().size() == 5u,
"Supported versions out of sync");
- EXPECT_EQ("h3-Q043", AlpnForVersion(ParsedQuicVersion::Q043()));
EXPECT_EQ("h3-Q046", AlpnForVersion(ParsedQuicVersion::Q046()));
EXPECT_EQ("h3-Q050", AlpnForVersion(ParsedQuicVersion::Q050()));
EXPECT_EQ("h3-29", AlpnForVersion(ParsedQuicVersion::Draft29()));
diff --git a/quiche/quic/core/tls_chlo_extractor.h b/quiche/quic/core/tls_chlo_extractor.h
index d8c6b55..f24023b 100644
--- a/quiche/quic/core/tls_chlo_extractor.h
+++ b/quiche/quic/core/tls_chlo_extractor.h
@@ -77,7 +77,6 @@
void OnError(QuicFramer* /*framer*/) override {}
bool OnProtocolVersionMismatch(ParsedQuicVersion version) override;
void OnPacket() override {}
- void OnPublicResetPacket(const QuicPublicResetPacket& /*packet*/) override {}
void OnVersionNegotiationPacket(
const QuicVersionNegotiationPacket& /*packet*/) override {}
void OnRetryPacket(QuicConnectionId /*original_connection_id*/,
diff --git a/quiche/quic/core/uber_received_packet_manager.cc b/quiche/quic/core/uber_received_packet_manager.cc
index 4efe788..ccfbc28 100644
--- a/quiche/quic/core/uber_received_packet_manager.cc
+++ b/quiche/quic/core/uber_received_packet_manager.cc
@@ -185,12 +185,6 @@
return received_packet_managers_[packet_number_space].IsAckFrameEmpty();
}
-QuicPacketNumber UberReceivedPacketManager::peer_least_packet_awaiting_ack()
- const {
- QUICHE_DCHECK(!supports_multiple_packet_number_spaces_);
- return received_packet_managers_[0].peer_least_packet_awaiting_ack();
-}
-
size_t UberReceivedPacketManager::min_received_before_ack_decimation() const {
return received_packet_managers_[0].min_received_before_ack_decimation();
}
diff --git a/quiche/quic/core/uber_received_packet_manager.h b/quiche/quic/core/uber_received_packet_manager.h
index 0e436c0..d4d35bc 100644
--- a/quiche/quic/core/uber_received_packet_manager.h
+++ b/quiche/quic/core/uber_received_packet_manager.h
@@ -74,8 +74,6 @@
// Return true if ack frame of |packet_number_space| is empty.
bool IsAckFrameEmpty(PacketNumberSpace packet_number_space) const;
- QuicPacketNumber peer_least_packet_awaiting_ack() const;
-
size_t min_received_before_ack_decimation() const;
void set_min_received_before_ack_decimation(size_t new_value);
diff --git a/quiche/quic/qbone/qbone_client_test.cc b/quiche/quic/qbone/qbone_client_test.cc
index e893ddb..6429491 100644
--- a/quiche/quic/qbone/qbone_client_test.cc
+++ b/quiche/quic/qbone/qbone_client_test.cc
@@ -39,16 +39,7 @@
ParsedQuicVersionVector GetTestParams() {
ParsedQuicVersionVector test_versions;
SetQuicReloadableFlag(quic_disable_version_q046, false);
- // TODO(b/113130636): Make QBONE work with TLS.
- for (const auto& version : CurrentSupportedVersionsWithQuicCrypto()) {
- // QBONE requires MESSAGE frames
- if (!version.SupportsMessageFrames()) {
- continue;
- }
- test_versions.push_back(version);
- }
-
- return test_versions;
+ return CurrentSupportedVersionsWithQuicCrypto();
}
std::string TestPacketIn(const std::string& body) {
diff --git a/quiche/quic/qbone/qbone_session_test.cc b/quiche/quic/qbone/qbone_session_test.cc
index 3e2e8d1..1a9d023 100644
--- a/quiche/quic/qbone/qbone_session_test.cc
+++ b/quiche/quic/qbone/qbone_session_test.cc
@@ -49,18 +49,7 @@
ParsedQuicVersionVector GetTestParams() {
SetQuicReloadableFlag(quic_disable_version_q046, false);
- ParsedQuicVersionVector test_versions;
-
- // TODO(b/113130636): Make QBONE work with TLS.
- for (const auto& version : CurrentSupportedVersionsWithQuicCrypto()) {
- // QBONE requires MESSAGE frames
- if (!version.SupportsMessageFrames()) {
- continue;
- }
- test_versions.push_back(version);
- }
-
- return test_versions;
+ return CurrentSupportedVersionsWithQuicCrypto();
}
// Used by QuicCryptoServerConfig to provide server credentials, passes
diff --git a/quiche/quic/test_tools/fuzzing/quic_framer_process_data_packet_fuzzer.cc b/quiche/quic/test_tools/fuzzing/quic_framer_process_data_packet_fuzzer.cc
index 937708d..0ee8c23 100644
--- a/quiche/quic/test_tools/fuzzing/quic_framer_process_data_packet_fuzzer.cc
+++ b/quiche/quic/test_tools/fuzzing/quic_framer_process_data_packet_fuzzer.cc
@@ -47,11 +47,7 @@
using quic::test::NoOpFramerVisitor;
using quic::test::QuicFramerPeer;
-PacketHeaderFormat ConsumePacketHeaderFormat(FuzzedDataProvider* provider,
- ParsedQuicVersion version) {
- if (!version.HasIetfInvariantHeader()) {
- return quic::GOOGLE_QUIC_PACKET;
- }
+PacketHeaderFormat ConsumePacketHeaderFormat(FuzzedDataProvider* provider) {
return provider->ConsumeBool() ? quic::IETF_QUIC_LONG_HEADER_PACKET
: quic::IETF_QUIC_SHORT_HEADER_PACKET;
}
@@ -59,7 +55,6 @@
ParsedQuicVersion ConsumeParsedQuicVersion(FuzzedDataProvider* provider) {
// TODO(wub): Add support for v49+.
const QuicTransportVersion transport_versions[] = {
- quic::QUIC_VERSION_43,
quic::QUIC_VERSION_46,
};
@@ -84,7 +79,7 @@
header.version = ConsumeParsedQuicVersion(provider);
- header.form = ConsumePacketHeaderFormat(provider, header.version);
+ header.form = ConsumePacketHeaderFormat(provider);
const std::string cid_bytes =
provider->ConsumeBytesAsString(kQuicDefaultConnectionIdLength);
@@ -235,8 +230,8 @@
// Serialize the null-encrypted packet into |packet_buffer|.
QuicDataWriter writer(packet_buffer.size(), packet_buffer.data());
size_t length_field_offset = 0;
- QUICHE_CHECK(sender_framer.AppendPacketHeader(header, &writer,
- &length_field_offset));
+ QUICHE_CHECK(sender_framer.AppendIetfPacketHeader(header, &writer,
+ &length_field_offset));
QUICHE_CHECK(
writer.WriteBytes(payload_buffer.data(), payload_buffer.size()));
diff --git a/quiche/quic/test_tools/quic_connection_peer.cc b/quiche/quic/test_tools/quic_connection_peer.cc
index fbecdd3..8ac35d5 100644
--- a/quiche/quic/test_tools/quic_connection_peer.cc
+++ b/quiche/quic/test_tools/quic_connection_peer.cc
@@ -30,12 +30,6 @@
}
// static
-void QuicConnectionPeer::PopulateStopWaitingFrame(
- QuicConnection* connection, QuicStopWaitingFrame* stop_waiting) {
- connection->PopulateStopWaitingFrame(stop_waiting);
-}
-
-// static
QuicPacketCreator* QuicConnectionPeer::GetPacketCreator(
QuicConnection* connection) {
return &connection->packet_creator_;
@@ -276,17 +270,6 @@
}
// static
-bool QuicConnectionPeer::GetNoStopWaitingFrames(QuicConnection* connection) {
- return connection->no_stop_waiting_frames_;
-}
-
-// static
-void QuicConnectionPeer::SetNoStopWaitingFrames(QuicConnection* connection,
- bool no_stop_waiting_frames) {
- connection->no_stop_waiting_frames_ = no_stop_waiting_frames;
-}
-
-// static
void QuicConnectionPeer::SetMaxTrackedPackets(
QuicConnection* connection, QuicPacketCount max_tracked_packets) {
connection->max_tracked_packets_ = max_tracked_packets;
diff --git a/quiche/quic/test_tools/quic_connection_peer.h b/quiche/quic/test_tools/quic_connection_peer.h
index cf8a5a6..3c8e068 100644
--- a/quiche/quic/test_tools/quic_connection_peer.h
+++ b/quiche/quic/test_tools/quic_connection_peer.h
@@ -42,9 +42,6 @@
static void SetLossAlgorithm(QuicConnection* connection,
LossDetectionInterface* loss_algorithm);
- static void PopulateStopWaitingFrame(QuicConnection* connection,
- QuicStopWaitingFrame* stop_waiting);
-
static QuicPacketCreator* GetPacketCreator(QuicConnection* connection);
static QuicSentPacketManager* GetSentPacketManager(
@@ -122,9 +119,6 @@
float ack_decimation_delay);
static bool HasRetransmittableFrames(QuicConnection* connection,
uint64_t packet_number);
- static bool GetNoStopWaitingFrames(QuicConnection* connection);
- static void SetNoStopWaitingFrames(QuicConnection* connection,
- bool no_stop_waiting_frames);
static void SetMaxTrackedPackets(QuicConnection* connection,
QuicPacketCount max_tracked_packets);
static void SetNegotiatedVersion(QuicConnection* connection);
diff --git a/quiche/quic/test_tools/quic_packet_creator_peer.cc b/quiche/quic/test_tools/quic_packet_creator_peer.cc
index 2ab9fb0..f7f75ba 100644
--- a/quiche/quic/test_tools/quic_packet_creator_peer.cc
+++ b/quiche/quic/test_tools/quic_packet_creator_peer.cc
@@ -19,12 +19,6 @@
// static
void QuicPacketCreatorPeer::SetSendVersionInPacket(
QuicPacketCreator* creator, bool send_version_in_packet) {
- ParsedQuicVersion version = creator->framer_->version();
- if (!VersionHasIetfQuicFrames(version.transport_version) &&
- version.handshake_protocol != PROTOCOL_TLS1_3) {
- creator->send_version_in_packet_ = send_version_in_packet;
- return;
- }
if (!send_version_in_packet) {
creator->packet_.encryption_level = ENCRYPTION_FORWARD_SECURE;
return;
diff --git a/quiche/quic/test_tools/quic_test_utils.h b/quiche/quic/test_tools/quic_test_utils.h
index 25cc2d4..7b5667a 100644
--- a/quiche/quic/test_tools/quic_test_utils.h
+++ b/quiche/quic/test_tools/quic_test_utils.h
@@ -277,8 +277,6 @@
MOCK_METHOD(bool, OnProtocolVersionMismatch, (ParsedQuicVersion version),
(override));
MOCK_METHOD(void, OnPacket, (), (override));
- MOCK_METHOD(void, OnPublicResetPacket, (const QuicPublicResetPacket& header),
- (override));
MOCK_METHOD(void, OnVersionNegotiationPacket,
(const QuicVersionNegotiationPacket& packet), (override));
MOCK_METHOD(void, OnRetryPacket,
@@ -371,7 +369,6 @@
void OnError(QuicFramer* /*framer*/) override {}
void OnPacket() override {}
- void OnPublicResetPacket(const QuicPublicResetPacket& /*packet*/) override {}
void OnVersionNegotiationPacket(
const QuicVersionNegotiationPacket& /*packet*/) override {}
void OnRetryPacket(QuicConnectionId /*original_connection_id*/,
@@ -1348,9 +1345,6 @@
MOCK_METHOD(void, OnCryptoFrame, (const QuicCryptoFrame&), (override));
- MOCK_METHOD(void, OnStopWaitingFrame, (const QuicStopWaitingFrame&),
- (override));
-
MOCK_METHOD(void, OnRstStreamFrame, (const QuicRstStreamFrame&), (override));
MOCK_METHOD(void, OnConnectionCloseFrame, (const QuicConnectionCloseFrame&),
@@ -1377,9 +1371,6 @@
MOCK_METHOD(void, OnPathResponseFrame, (const QuicPathResponseFrame&),
(override));
- MOCK_METHOD(void, OnPublicResetPacket, (const QuicPublicResetPacket&),
- (override));
-
MOCK_METHOD(void, OnVersionNegotiationPacket,
(const QuicVersionNegotiationPacket&), (override));
diff --git a/quiche/quic/test_tools/simple_quic_framer.cc b/quiche/quic/test_tools/simple_quic_framer.cc
index 33a56ef..b13fec4 100644
--- a/quiche/quic/test_tools/simple_quic_framer.cc
+++ b/quiche/quic/test_tools/simple_quic_framer.cc
@@ -31,9 +31,6 @@
}
void OnPacket() override {}
- void OnPublicResetPacket(const QuicPublicResetPacket& packet) override {
- public_reset_packet_ = std::make_unique<QuicPublicResetPacket>((packet));
- }
void OnVersionNegotiationPacket(
const QuicVersionNegotiationPacket& packet) override {
version_negotiation_packet_ =
@@ -292,7 +289,6 @@
bool has_header_;
QuicPacketHeader header_;
std::unique_ptr<QuicVersionNegotiationPacket> version_negotiation_packet_;
- std::unique_ptr<QuicPublicResetPacket> public_reset_packet_;
std::unique_ptr<QuicIetfStatelessResetPacket> stateless_reset_packet_;
std::vector<QuicAckFrame> ack_frames_;
std::vector<QuicStopWaitingFrame> stop_waiting_frames_;
diff --git a/quiche/quic/tools/quic_packet_printer_bin.cc b/quiche/quic/tools/quic_packet_printer_bin.cc
index 92a3c4c..ca1b433 100644
--- a/quiche/quic/tools/quic_packet_printer_bin.cc
+++ b/quiche/quic/tools/quic_packet_printer_bin.cc
@@ -57,9 +57,6 @@
return true;
}
void OnPacket() override { std::cerr << "OnPacket\n"; }
- void OnPublicResetPacket(const QuicPublicResetPacket& /*packet*/) override {
- std::cerr << "OnPublicResetPacket\n";
- }
void OnVersionNegotiationPacket(
const QuicVersionNegotiationPacket& /*packet*/) override {
std::cerr << "OnVersionNegotiationPacket\n";
