Use std::array<char, 16> instead of uint128 for StatelessResetToken. Using absl::uint128 does not make much sense since this is an opaque piece of data with a fixed size of 16 octets (that happen to be the same as the size of uint128), no numerical operations are performed on it. Keep absl::uint128 within QuicUtils::GenerateStatelessResetToken(), necessary for the hash computations, but use the new alias StatelessResetToken elsewhere. This is a follow-up to a drive-by comment at cl/366984087. PiperOrigin-RevId: 367245431 Change-Id: Ie79796e22ed4b7c6862a55e0280e7943378d559a
diff --git a/quic/core/chlo_extractor.cc b/quic/core/chlo_extractor.cc index 0cce9f9..48fe9a8 100644 --- a/quic/core/chlo_extractor.cc +++ b/quic/core/chlo_extractor.cc
@@ -4,7 +4,6 @@ #include "quic/core/chlo_extractor.h" -#include "absl/numeric/int128.h" #include "absl/strings/match.h" #include "absl/strings/string_view.h" #include "quic/core/crypto/crypto_framer.h" @@ -16,6 +15,7 @@ #include "quic/core/crypto/quic_encrypter.h" #include "quic/core/frames/quic_ack_frequency_frame.h" #include "quic/core/quic_framer.h" +#include "quic/core/quic_types.h" #include "quic/core/quic_utils.h" #include "common/platform/api/quiche_text_utils.h" @@ -82,7 +82,8 @@ bool OnHandshakeDoneFrame(const QuicHandshakeDoneFrame& frame) override; bool OnAckFrequencyFrame(const QuicAckFrequencyFrame& farme) override; void OnPacketComplete() override {} - bool IsValidStatelessResetToken(absl::uint128 token) const override; + bool IsValidStatelessResetToken( + const StatelessResetToken& token) const override; void OnAuthenticatedIetfStatelessResetPacket( const QuicIetfStatelessResetPacket& /*packet*/) override {} void OnKeyUpdate(KeyUpdateReason /*reason*/) override; @@ -304,7 +305,7 @@ } bool ChloFramerVisitor::IsValidStatelessResetToken( - absl::uint128 /*token*/) const { + const StatelessResetToken& /*token*/) const { return false; }
diff --git a/quic/core/crypto/crypto_handshake_message.cc b/quic/core/crypto/crypto_handshake_message.cc index ec07791..6dcb989 100644 --- a/quic/core/crypto/crypto_handshake_message.cc +++ b/quic/core/crypto/crypto_handshake_message.cc
@@ -221,9 +221,10 @@ return GetPOD(tag, out, sizeof(uint64_t)); } -QuicErrorCode CryptoHandshakeMessage::GetUint128(QuicTag tag, - absl::uint128* out) const { - return GetPOD(tag, out, sizeof(absl::uint128)); +QuicErrorCode CryptoHandshakeMessage::GetStatelessResetToken( + QuicTag tag, + StatelessResetToken* out) const { + return GetPOD(tag, out, kStatelessResetTokenLength); } size_t CryptoHandshakeMessage::size() const {
diff --git a/quic/core/crypto/crypto_handshake_message.h b/quic/core/crypto/crypto_handshake_message.h index de02d6c..9550c15 100644 --- a/quic/core/crypto/crypto_handshake_message.h +++ b/quic/core/crypto/crypto_handshake_message.h
@@ -11,9 +11,9 @@ #include <string> #include <vector> -#include "absl/numeric/int128.h" #include "absl/strings/string_view.h" #include "quic/core/quic_packets.h" +#include "quic/core/quic_types.h" #include "quic/platform/api/quic_export.h" namespace quic { @@ -110,7 +110,9 @@ absl::string_view* out) const; QuicErrorCode GetUint32(QuicTag tag, uint32_t* out) const; QuicErrorCode GetUint64(QuicTag tag, uint64_t* out) const; - QuicErrorCode GetUint128(QuicTag tag, absl::uint128* out) const; + + QuicErrorCode GetStatelessResetToken(QuicTag tag, + StatelessResetToken* out) const; // size returns 4 (message tag) + 2 (uint16_t, number of entries) + // (4 (tag) + 4 (end offset))*tag_value_map_.size() + ∑ value sizes.
diff --git a/quic/core/crypto/transport_parameters.cc b/quic/core/crypto/transport_parameters.cc index 759f6f1..14df9c3 100644 --- a/quic/core/crypto/transport_parameters.cc +++ b/quic/core/crypto/transport_parameters.cc
@@ -74,7 +74,6 @@ constexpr uint64_t kDefaultAckDelayExponentTransportParam = 3; constexpr uint64_t kMaxMaxAckDelayTransportParam = 16383; constexpr uint64_t kDefaultMaxAckDelayTransportParam = 25; -constexpr size_t kStatelessResetTokenLength = 16; constexpr uint64_t kMinActiveConnectionIdLimitTransportParam = 2; constexpr uint64_t kDefaultActiveConnectionIdLimitTransportParam = 2;
diff --git a/quic/core/frames/quic_frames_test.cc b/quic/core/frames/quic_frames_test.cc index 82070f0..c11be9e 100644 --- a/quic/core/frames/quic_frames_test.cc +++ b/quic/core/frames/quic_frames_test.cc
@@ -2,7 +2,6 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#include "absl/numeric/int128.h" #include "quic/core/frames/quic_ack_frame.h" #include "quic/core/frames/quic_blocked_frame.h" #include "quic/core/frames/quic_connection_close_frame.h" @@ -117,7 +116,8 @@ new_connection_id_frame.connection_id = TestConnectionId(2); new_connection_id_frame.sequence_number = 2u; new_connection_id_frame.retire_prior_to = 1u; - new_connection_id_frame.stateless_reset_token = absl::MakeUint128(0, 1); + new_connection_id_frame.stateless_reset_token = + StatelessResetToken{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}; std::ostringstream stream; stream << new_connection_id_frame; EXPECT_EQ(
diff --git a/quic/core/frames/quic_new_connection_id_frame.cc b/quic/core/frames/quic_new_connection_id_frame.cc index 3d8787e..b4c68ff 100644 --- a/quic/core/frames/quic_new_connection_id_frame.cc +++ b/quic/core/frames/quic_new_connection_id_frame.cc
@@ -10,7 +10,7 @@ QuicControlFrameId control_frame_id, QuicConnectionId connection_id, QuicConnectionIdSequenceNumber sequence_number, - const absl::uint128 stateless_reset_token, + StatelessResetToken stateless_reset_token, uint64_t retire_prior_to) : control_frame_id(control_frame_id), connection_id(connection_id),
diff --git a/quic/core/frames/quic_new_connection_id_frame.h b/quic/core/frames/quic_new_connection_id_frame.h index 9cad262..9c3d205 100644 --- a/quic/core/frames/quic_new_connection_id_frame.h +++ b/quic/core/frames/quic_new_connection_id_frame.h
@@ -7,7 +7,6 @@ #include <ostream> -#include "absl/numeric/int128.h" #include "quic/core/quic_connection_id.h" #include "quic/core/quic_constants.h" #include "quic/core/quic_error_codes.h" @@ -20,7 +19,7 @@ QuicNewConnectionIdFrame(QuicControlFrameId control_frame_id, QuicConnectionId connection_id, QuicConnectionIdSequenceNumber sequence_number, - const absl::uint128 stateless_reset_token, + StatelessResetToken stateless_reset_token, uint64_t retire_prior_to); friend QUIC_EXPORT_PRIVATE std::ostream& operator<<( @@ -32,7 +31,7 @@ QuicControlFrameId control_frame_id = kInvalidControlFrameId; QuicConnectionId connection_id = EmptyQuicConnectionId(); QuicConnectionIdSequenceNumber sequence_number = 0; - absl::uint128 stateless_reset_token; + StatelessResetToken stateless_reset_token; uint64_t retire_prior_to; };
diff --git a/quic/core/frames/quic_retire_connection_id_frame.h b/quic/core/frames/quic_retire_connection_id_frame.h index cbfc7af..3a8a4da 100644 --- a/quic/core/frames/quic_retire_connection_id_frame.h +++ b/quic/core/frames/quic_retire_connection_id_frame.h
@@ -7,7 +7,6 @@ #include <ostream> -#include "absl/numeric/int128.h" #include "quic/core/quic_constants.h" #include "quic/core/quic_error_codes.h" #include "quic/core/quic_types.h"
diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc index 5e070dc..aceebe1 100644 --- a/quic/core/http/end_to_end_test.cc +++ b/quic/core/http/end_to_end_test.cc
@@ -11,7 +11,6 @@ #include <utility> #include <vector> -#include "absl/numeric/int128.h" #include "absl/strings/str_cat.h" #include "absl/strings/string_view.h" #include "quic/core/crypto/null_encrypter.h" @@ -3339,7 +3338,8 @@ QuicConfig* config = client_session->config(); ASSERT_TRUE(config); EXPECT_TRUE(config->HasReceivedStatelessResetToken()); - absl::uint128 stateless_reset_token = config->ReceivedStatelessResetToken(); + StatelessResetToken stateless_reset_token = + config->ReceivedStatelessResetToken(); // Send the public reset. QuicConnection* client_connection = GetClientConnection(); @@ -3381,7 +3381,8 @@ QuicConfig* config = client_session->config(); ASSERT_TRUE(config); EXPECT_TRUE(config->HasReceivedStatelessResetToken()); - absl::uint128 stateless_reset_token = config->ReceivedStatelessResetToken(); + StatelessResetToken stateless_reset_token = + config->ReceivedStatelessResetToken(); // Send the public reset. QuicConnection* client_connection = GetClientConnection(); ASSERT_TRUE(client_connection);
diff --git a/quic/core/quic_config.cc b/quic/core/quic_config.cc index 1f81daa..796c641 100644 --- a/quic/core/quic_config.cc +++ b/quic/core/quic_config.cc
@@ -11,7 +11,6 @@ #include <utility> #include "absl/base/attributes.h" -#include "absl/numeric/int128.h" #include "absl/strings/string_view.h" #include "quic/core/crypto/crypto_handshake_message.h" #include "quic/core/crypto/crypto_protocol.h" @@ -225,54 +224,61 @@ return error; } -QuicFixedUint128::QuicFixedUint128(QuicTag tag, QuicConfigPresence presence) +QuicFixedStatelessResetToken::QuicFixedStatelessResetToken( + QuicTag tag, + QuicConfigPresence presence) : QuicConfigValue(tag, presence), has_send_value_(false), has_receive_value_(false) {} -QuicFixedUint128::~QuicFixedUint128() {} +QuicFixedStatelessResetToken::~QuicFixedStatelessResetToken() {} -bool QuicFixedUint128::HasSendValue() const { +bool QuicFixedStatelessResetToken::HasSendValue() const { return has_send_value_; } -absl::uint128 QuicFixedUint128::GetSendValue() const { +const StatelessResetToken& QuicFixedStatelessResetToken::GetSendValue() const { QUIC_BUG_IF(quic_bug_12743_4, !has_send_value_) << "No send value to get for tag:" << QuicTagToString(tag_); return send_value_; } -void QuicFixedUint128::SetSendValue(absl::uint128 value) { +void QuicFixedStatelessResetToken::SetSendValue( + const StatelessResetToken& value) { has_send_value_ = true; send_value_ = value; } -bool QuicFixedUint128::HasReceivedValue() const { +bool QuicFixedStatelessResetToken::HasReceivedValue() const { return has_receive_value_; } -absl::uint128 QuicFixedUint128::GetReceivedValue() const { +const StatelessResetToken& QuicFixedStatelessResetToken::GetReceivedValue() + const { QUIC_BUG_IF(quic_bug_12743_5, !has_receive_value_) << "No receive value to get for tag:" << QuicTagToString(tag_); return receive_value_; } -void QuicFixedUint128::SetReceivedValue(absl::uint128 value) { +void QuicFixedStatelessResetToken::SetReceivedValue( + const StatelessResetToken& value) { has_receive_value_ = true; receive_value_ = value; } -void QuicFixedUint128::ToHandshakeMessage(CryptoHandshakeMessage* out) const { +void QuicFixedStatelessResetToken::ToHandshakeMessage( + CryptoHandshakeMessage* out) const { if (has_send_value_) { out->SetValue(tag_, send_value_); } } -QuicErrorCode QuicFixedUint128::ProcessPeerHello( +QuicErrorCode QuicFixedStatelessResetToken::ProcessPeerHello( const CryptoHandshakeMessage& peer_hello, HelloType /*hello_type*/, std::string* error_details) { QUICHE_DCHECK(error_details != nullptr); - QuicErrorCode error = peer_hello.GetUint128(tag_, &receive_value_); + QuicErrorCode error = + peer_hello.GetStatelessResetToken(tag_, &receive_value_); switch (error) { case QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND: if (presence_ == PRESENCE_OPTIONAL) { @@ -887,7 +893,7 @@ void QuicConfig::SetIPv6AlternateServerAddressToSend( const QuicSocketAddress& alternate_server_address_ipv6, const QuicConnectionId& connection_id, - absl::uint128 stateless_reset_token) { + const StatelessResetToken& stateless_reset_token) { if (!alternate_server_address_ipv6.host().IsIPv6()) { QUIC_BUG(quic_bug_10575_10) << "Cannot use SetIPv6AlternateServerAddressToSend with " @@ -922,7 +928,7 @@ void QuicConfig::SetIPv4AlternateServerAddressToSend( const QuicSocketAddress& alternate_server_address_ipv4, const QuicConnectionId& connection_id, - absl::uint128 stateless_reset_token) { + const StatelessResetToken& stateless_reset_token) { if (!alternate_server_address_ipv4.host().IsIPv4()) { QUIC_BUG(quic_bug_10575_12) << "Cannot use SetIPv4AlternateServerAddressToSend with " @@ -949,7 +955,7 @@ preferred_address_connection_id_and_token_.has_value(); } -const std::pair<QuicConnectionId, absl::uint128>& +const std::pair<QuicConnectionId, StatelessResetToken>& QuicConfig::ReceivedPreferredAddressConnectionIdAndToken() const { QUICHE_DCHECK(HasReceivedPreferredAddressConnectionIdAndToken()); return *preferred_address_connection_id_and_token_; @@ -1008,7 +1014,7 @@ } void QuicConfig::SetStatelessResetTokenToSend( - absl::uint128 stateless_reset_token) { + const StatelessResetToken& stateless_reset_token) { stateless_reset_token_.SetSendValue(stateless_reset_token); } @@ -1016,7 +1022,7 @@ return stateless_reset_token_.HasReceivedValue(); } -absl::uint128 QuicConfig::ReceivedStatelessResetToken() const { +const StatelessResetToken& QuicConfig::ReceivedStatelessResetToken() const { return stateless_reset_token_.GetReceivedValue(); } @@ -1204,7 +1210,8 @@ max_idle_timeout_to_send_.ToMilliseconds()); if (stateless_reset_token_.HasSendValue()) { - absl::uint128 stateless_reset_token = stateless_reset_token_.GetSendValue(); + StatelessResetToken stateless_reset_token = + stateless_reset_token_.GetSendValue(); params->stateless_reset_token.assign( reinterpret_cast<const char*>(&stateless_reset_token), reinterpret_cast<const char*>(&stateless_reset_token) + @@ -1319,7 +1326,7 @@ } if (!is_resumption && !params.stateless_reset_token.empty()) { - absl::uint128 stateless_reset_token; + StatelessResetToken stateless_reset_token; if (params.stateless_reset_token.size() != sizeof(stateless_reset_token)) { QUIC_BUG(quic_bug_10575_16) << "Bad stateless reset token length " << params.stateless_reset_token.size(); @@ -1385,7 +1392,7 @@ if (!params.preferred_address->connection_id.IsEmpty()) { preferred_address_connection_id_and_token_ = std::make_pair( params.preferred_address->connection_id, - *reinterpret_cast<const absl::uint128*>( + *reinterpret_cast<const StatelessResetToken*>( ¶ms.preferred_address->stateless_reset_token.front())); } }
diff --git a/quic/core/quic_config.h b/quic/core/quic_config.h index e196fc5..d122be7 100644 --- a/quic/core/quic_config.h +++ b/quic/core/quic_config.h
@@ -9,12 +9,12 @@ #include <cstdint> #include <string> -#include "absl/numeric/int128.h" #include "absl/types/optional.h" #include "quic/core/crypto/transport_parameters.h" #include "quic/core/quic_connection_id.h" #include "quic/core/quic_packets.h" #include "quic/core/quic_time.h" +#include "quic/core/quic_types.h" #include "quic/platform/api/quic_export.h" namespace quic { @@ -134,23 +134,25 @@ uint64_t receive_value_; }; -// Stores uint128 from CHLO or SHLO messages that are not negotiated. -class QUIC_EXPORT_PRIVATE QuicFixedUint128 : public QuicConfigValue { +// Stores StatelessResetToken from CHLO or SHLO messages that are not +// negotiated. +class QUIC_EXPORT_PRIVATE QuicFixedStatelessResetToken + : public QuicConfigValue { public: - QuicFixedUint128(QuicTag tag, QuicConfigPresence presence); - ~QuicFixedUint128() override; + QuicFixedStatelessResetToken(QuicTag tag, QuicConfigPresence presence); + ~QuicFixedStatelessResetToken() override; bool HasSendValue() const; - absl::uint128 GetSendValue() const; + const StatelessResetToken& GetSendValue() const; - void SetSendValue(absl::uint128 value); + void SetSendValue(const StatelessResetToken& value); bool HasReceivedValue() const; - absl::uint128 GetReceivedValue() const; + const StatelessResetToken& GetReceivedValue() const; - void SetReceivedValue(absl::uint128 value); + void SetReceivedValue(const StatelessResetToken& value); // If has_send_value is true, serialises |tag_| and |send_value_| to |out|. void ToHandshakeMessage(CryptoHandshakeMessage* out) const override; @@ -163,8 +165,8 @@ private: bool has_send_value_; bool has_receive_value_; - absl::uint128 send_value_; - absl::uint128 receive_value_; + StatelessResetToken send_value_; + StatelessResetToken receive_value_; }; // Stores tag from CHLO or SHLO messages that are not negotiated. @@ -394,7 +396,7 @@ void SetIPv6AlternateServerAddressToSend( const QuicSocketAddress& alternate_server_address_ipv6, const QuicConnectionId& connection_id, - absl::uint128 stateless_reset_token); + const StatelessResetToken& stateless_reset_token); bool HasReceivedIPv6AlternateServerAddress() const; const QuicSocketAddress& ReceivedIPv6AlternateServerAddress() const; @@ -404,13 +406,13 @@ void SetIPv4AlternateServerAddressToSend( const QuicSocketAddress& alternate_server_address_ipv4, const QuicConnectionId& connection_id, - absl::uint128 stateless_reset_token); + const StatelessResetToken& stateless_reset_token); bool HasReceivedIPv4AlternateServerAddress() const; const QuicSocketAddress& ReceivedIPv4AlternateServerAddress() const; // Preferred Address Connection ID and Token. bool HasReceivedPreferredAddressConnectionIdAndToken() const; - const std::pair<QuicConnectionId, absl::uint128>& + const std::pair<QuicConnectionId, StatelessResetToken>& ReceivedPreferredAddressConnectionIdAndToken() const; // Original destination connection ID. @@ -420,9 +422,10 @@ QuicConnectionId ReceivedOriginalConnectionId() const; // Stateless reset token. - void SetStatelessResetTokenToSend(absl::uint128 stateless_reset_token); + void SetStatelessResetTokenToSend( + const StatelessResetToken& stateless_reset_token); bool HasReceivedStatelessResetToken() const; - absl::uint128 ReceivedStatelessResetToken() const; + const StatelessResetToken& ReceivedStatelessResetToken() const; // Manage the IETF QUIC Max ACK Delay transport parameter. // The sent value is the delay that this node uses @@ -604,12 +607,12 @@ QuicFixedSocketAddress alternate_server_address_ipv4_; // Connection Id data to send from the server or receive at the client as part // of the preferred address transport parameter. - absl::optional<std::pair<QuicConnectionId, absl::uint128>> + absl::optional<std::pair<QuicConnectionId, StatelessResetToken>> preferred_address_connection_id_and_token_; // Stateless reset token used in IETF public reset packet. // Uses the stateless_reset_token transport parameter in IETF QUIC. - QuicFixedUint128 stateless_reset_token_; + QuicFixedStatelessResetToken stateless_reset_token_; // List of QuicTags whose presence immediately causes the session to // be created. This allows for CHLOs that are larger than a single
diff --git a/quic/core/quic_config_test.cc b/quic/core/quic_config_test.cc index 1253740..5124a97 100644 --- a/quic/core/quic_config_test.cc +++ b/quic/core/quic_config_test.cc
@@ -7,7 +7,6 @@ #include <memory> #include <string> -#include "absl/numeric/int128.h" #include "quic/core/crypto/crypto_handshake_message.h" #include "quic/core/crypto/crypto_protocol.h" #include "quic/core/crypto/transport_parameters.h" @@ -188,7 +187,9 @@ QuicIpAddress host; host.FromString("127.0.3.1"); const QuicSocketAddress kTestServerAddress = QuicSocketAddress(host, 1234); - const absl::uint128 kTestResetToken = absl::MakeUint128(0, 10111100001); + const StatelessResetToken kTestStatelessResetToken{ + 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, + 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f}; const uint32_t kTestMaxAckDelayMs = static_cast<uint32_t>(kDefaultDelayedAckTimeMs + 1); QuicConfig server_config; @@ -202,7 +203,7 @@ server_config.SetInitialSessionFlowControlWindowToSend( 2 * kInitialSessionFlowControlWindowForTest); server_config.SetIPv4AlternateServerAddressToSend(kTestServerAddress); - server_config.SetStatelessResetTokenToSend(kTestResetToken); + server_config.SetStatelessResetTokenToSend(kTestStatelessResetToken); server_config.SetMaxAckDelayToSendMs(kTestMaxAckDelayMs); CryptoHandshakeMessage msg; server_config.ToHandshakeMessage(&msg, version_.transport_version); @@ -222,7 +223,7 @@ EXPECT_EQ(kTestServerAddress, config_.ReceivedIPv4AlternateServerAddress()); EXPECT_FALSE(config_.HasReceivedIPv6AlternateServerAddress()); EXPECT_TRUE(config_.HasReceivedStatelessResetToken()); - EXPECT_EQ(kTestResetToken, config_.ReceivedStatelessResetToken()); + EXPECT_EQ(kTestStatelessResetToken, config_.ReceivedStatelessResetToken()); EXPECT_TRUE(config_.HasReceivedMaxAckDelayMs()); EXPECT_EQ(kTestMaxAckDelayMs, config_.ReceivedMaxAckDelayMs()); @@ -481,7 +482,7 @@ host.FromString("127.0.3.1"); QuicSocketAddress kTestServerAddress = QuicSocketAddress(host, 1234); QuicConnectionId new_connection_id = TestConnectionId(5); - absl::uint128 new_stateless_reset_token = + StatelessResetToken new_stateless_reset_token = QuicUtils::GenerateStatelessResetToken(new_connection_id); config_.SetIPv4AlternateServerAddressToSend( kTestServerAddress, new_connection_id, new_stateless_reset_token); @@ -521,8 +522,7 @@ EXPECT_TRUE(params.key_update_not_yet_supported); EXPECT_EQ(params.preferred_address->ipv4_socket_address, kTestServerAddress); - EXPECT_EQ(params.preferred_address->connection_id, new_connection_id); - EXPECT_EQ(*reinterpret_cast<absl::uint128*>( + EXPECT_EQ(*reinterpret_cast<StatelessResetToken*>( ¶ms.preferred_address->stateless_reset_token.front()), new_stateless_reset_token); } @@ -775,7 +775,7 @@ host.FromString("::ffff:192.0.2.128"); QuicSocketAddress kTestServerAddress = QuicSocketAddress(host, 1234); QuicConnectionId new_connection_id = TestConnectionId(5); - absl::uint128 new_stateless_reset_token = + StatelessResetToken new_stateless_reset_token = QuicUtils::GenerateStatelessResetToken(new_connection_id); auto preferred_address = std::make_unique<TransportParameters::PreferredAddress>(); @@ -795,7 +795,7 @@ EXPECT_TRUE(config_.HasReceivedIPv6AlternateServerAddress()); EXPECT_EQ(config_.ReceivedIPv6AlternateServerAddress(), kTestServerAddress); EXPECT_TRUE(config_.HasReceivedPreferredAddressConnectionIdAndToken()); - const std::pair<QuicConnectionId, absl::uint128>& + const std::pair<QuicConnectionId, StatelessResetToken>& preferred_address_connection_id_and_token = config_.ReceivedPreferredAddressConnectionIdAndToken(); EXPECT_EQ(preferred_address_connection_id_and_token.first, new_connection_id);
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc index 7f10238..9bd2140 100644 --- a/quic/core/quic_connection.cc +++ b/quic/core/quic_connection.cc
@@ -353,7 +353,7 @@ fill_up_link_during_probing_(false), probing_retransmission_pending_(false), stateless_reset_token_received_(false), - received_stateless_reset_token_(0), + received_stateless_reset_token_({}), last_control_frame_id_(kInvalidControlFrameId), is_path_degrading_(false), processing_ack_frame_(false), @@ -2194,7 +2194,8 @@ } } -bool QuicConnection::IsValidStatelessResetToken(absl::uint128 token) const { +bool QuicConnection::IsValidStatelessResetToken( + const StatelessResetToken& token) const { return stateless_reset_token_received_ && token == received_stateless_reset_token_; }
diff --git a/quic/core/quic_connection.h b/quic/core/quic_connection.h index 31ba053..e2ba17b 100644 --- a/quic/core/quic_connection.h +++ b/quic/core/quic_connection.h
@@ -24,7 +24,6 @@ #include <string> #include <vector> -#include "absl/numeric/int128.h" #include "absl/strings/string_view.h" #include "absl/types/optional.h" #include "quic/core/crypto/quic_decrypter.h" @@ -686,7 +685,8 @@ bool OnHandshakeDoneFrame(const QuicHandshakeDoneFrame& frame) override; bool OnAckFrequencyFrame(const QuicAckFrequencyFrame& frame) override; void OnPacketComplete() override; - bool IsValidStatelessResetToken(absl::uint128 token) const override; + bool IsValidStatelessResetToken( + const StatelessResetToken& token) const override; void OnAuthenticatedIetfStatelessResetPacket( const QuicIetfStatelessResetPacket& packet) override; void OnKeyUpdate(KeyUpdateReason reason) override; @@ -2004,7 +2004,7 @@ bool stateless_reset_token_received_; // Stores received stateless reset token from peer. Used to verify whether a // packet is a stateless reset packet. - absl::uint128 received_stateless_reset_token_; + StatelessResetToken received_stateless_reset_token_; // Id of latest sent control frame. 0 if no control frame has been sent. QuicControlFrameId last_control_frame_id_;
diff --git a/quic/core/quic_connection_id.h b/quic/core/quic_connection_id.h index 909d916..a0669d7 100644 --- a/quic/core/quic_connection_id.h +++ b/quic/core/quic_connection_id.h
@@ -8,7 +8,6 @@ #include <string> #include <vector> -#include "absl/numeric/int128.h" #include "quic/platform/api/quic_export.h" namespace quic {
diff --git a/quic/core/quic_connection_id_manager.cc b/quic/core/quic_connection_id_manager.cc index 5bf647a..a8e8c54 100644 --- a/quic/core/quic_connection_id_manager.cc +++ b/quic/core/quic_connection_id_manager.cc
@@ -5,7 +5,6 @@ #include "quic/core/quic_connection_id_manager.h" #include <cstdio> -#include "absl/numeric/int128.h" #include "quic/core/quic_clock.h" #include "quic/core/quic_connection_id.h" #include "quic/core/quic_error_codes.h" @@ -16,7 +15,7 @@ QuicConnectionIdData::QuicConnectionIdData( const QuicConnectionId& connection_id, uint64_t sequence_number, - absl::uint128 stateless_reset_token) + const StatelessResetToken& stateless_reset_token) : connection_id(connection_id), sequence_number(sequence_number), stateless_reset_token(stateless_reset_token) {} @@ -71,9 +70,10 @@ new RetirePeerIssuedConnectionIdAlarm(visitor))) { QUICHE_DCHECK_GE(active_connection_id_limit_, 2u); QUICHE_DCHECK(!initial_peer_issued_connection_id.IsEmpty()); - active_connection_id_data_.emplace_back(initial_peer_issued_connection_id, - /*sequence_number=*/0u, - absl::uint128()); + active_connection_id_data_.emplace_back<const QuicConnectionId&, uint64_t, + const StatelessResetToken&>( + initial_peer_issued_connection_id, + /*sequence_number=*/0u, {}); recent_new_connection_id_sequence_numbers_.Add(0u, 1u); }
diff --git a/quic/core/quic_connection_id_manager.h b/quic/core/quic_connection_id_manager.h index 91ff934..b933a69 100644 --- a/quic/core/quic_connection_id_manager.h +++ b/quic/core/quic_connection_id_manager.h
@@ -13,7 +13,6 @@ #include <cstddef> #include <memory> -#include "absl/numeric/int128.h" #include "quic/core/frames/quic_new_connection_id_frame.h" #include "quic/core/frames/quic_retire_connection_id_frame.h" #include "quic/core/quic_alarm.h" @@ -21,6 +20,7 @@ #include "quic/core/quic_clock.h" #include "quic/core/quic_connection_id.h" #include "quic/core/quic_interval_set.h" +#include "quic/core/quic_types.h" #include "quic/platform/api/quic_export.h" namespace quic { @@ -32,11 +32,11 @@ struct QUIC_EXPORT_PRIVATE QuicConnectionIdData { QuicConnectionIdData(const QuicConnectionId& connection_id, uint64_t sequence_number, - absl::uint128 stateless_reset_token); + const StatelessResetToken& stateless_reset_token); QuicConnectionId connection_id; uint64_t sequence_number; - absl::uint128 stateless_reset_token; + StatelessResetToken stateless_reset_token; }; // Used by QuicSelfIssuedConnectionIdManager
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc index 187ef66..c27f96c 100644 --- a/quic/core/quic_connection_test.cc +++ b/quic/core/quic_connection_test.cc
@@ -12,7 +12,6 @@ #include <utility> #include "absl/base/macros.h" -#include "absl/numeric/int128.h" #include "absl/strings/str_cat.h" #include "absl/strings/string_view.h" #include "quic/core/congestion_control/loss_detection_interface.h" @@ -84,6 +83,10 @@ 'a', 'b', 'a', 'b', 'a', 'b', 'a', 'b', 'a', 'b', }; +const StatelessResetToken kTestStatelessResetToken{ + 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, + 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f}; + const QuicSocketAddress kPeerAddress = QuicSocketAddress(QuicIpAddress::Loopback6(), /*port=*/12345); @@ -6900,7 +6903,6 @@ if (!GetParam().version.HasIetfInvariantHeader()) { return; } - const absl::uint128 kTestStatelessResetToken = 1010101; QuicConfig config; QuicConfigPeer::SetReceivedStatelessResetToken(&config, kTestStatelessResetToken); @@ -8612,8 +8614,10 @@ } TEST_P(QuicConnectionTest, ValidStatelessResetToken) { - const absl::uint128 kTestToken = 1010101; - const absl::uint128 kWrongTestToken = 1010100; + const StatelessResetToken kTestToken{0, 1, 0, 1, 0, 1, 0, 1, + 0, 1, 0, 1, 0, 1, 0, 1}; + const StatelessResetToken kWrongTestToken{0, 1, 0, 1, 0, 1, 0, 1, + 0, 1, 0, 1, 0, 1, 0, 2}; QuicConfig config; // No token has been received. EXPECT_FALSE(connection_.IsValidStatelessResetToken(kTestToken)); @@ -11846,7 +11850,6 @@ return; } PathProbeTestInit(Perspective::IS_CLIENT); - const absl::uint128 kTestStatelessResetToken = 1010101; QuicConfig config; QuicConfigPeer::SetReceivedStatelessResetToken(&config, kTestStatelessResetToken);
diff --git a/quic/core/quic_control_frame_manager.cc b/quic/core/quic_control_frame_manager.cc index 1a6d2aa..f41a356 100644 --- a/quic/core/quic_control_frame_manager.cc +++ b/quic/core/quic_control_frame_manager.cc
@@ -138,7 +138,7 @@ const QuicConnectionId& connection_id, uint64_t sequence_number, uint64_t retire_prior_to, - absl::uint128 stateless_reset_token) { + const StatelessResetToken& stateless_reset_token) { QUIC_DVLOG(1) << "Writing NEW_CONNECTION_ID frame"; WriteOrBufferQuicFrame(QuicFrame(new QuicNewConnectionIdFrame( ++last_control_frame_id_, connection_id, sequence_number,
diff --git a/quic/core/quic_control_frame_manager.h b/quic/core/quic_control_frame_manager.h index 1406872..1bb3703 100644 --- a/quic/core/quic_control_frame_manager.h +++ b/quic/core/quic_control_frame_manager.h
@@ -8,10 +8,10 @@ #include <cstdint> #include <string> -#include "absl/numeric/int128.h" #include "quic/core/frames/quic_frame.h" #include "quic/core/quic_circular_deque.h" #include "quic/core/quic_connection_id.h" +#include "quic/core/quic_types.h" namespace quic { @@ -93,10 +93,11 @@ // Tries to send a NEW_CONNECTION_ID frame. The frame is buffered if it cannot // be sent immediately. - void WriteOrBufferNewConnectionId(const QuicConnectionId& connection_id, - uint64_t sequence_number, - uint64_t retire_prior_to, - absl::uint128 stateless_reset_token); + void WriteOrBufferNewConnectionId( + const QuicConnectionId& connection_id, + uint64_t sequence_number, + uint64_t retire_prior_to, + const StatelessResetToken& stateless_reset_token); // Tries to send a RETIRE_CONNNECTION_ID frame. The frame is buffered if it // cannot be sent immediately.
diff --git a/quic/core/quic_control_frame_manager_test.cc b/quic/core/quic_control_frame_manager_test.cc index d077410..9d6b434 100644 --- a/quic/core/quic_control_frame_manager_test.cc +++ b/quic/core/quic_control_frame_manager_test.cc
@@ -6,7 +6,6 @@ #include <utility> -#include "absl/numeric/int128.h" #include "quic/core/crypto/null_encrypter.h" #include "quic/core/frames/quic_ack_frequency_frame.h" #include "quic/core/frames/quic_retire_connection_id_frame.h" @@ -251,7 +250,8 @@ // Send NewConnectionIdFrame as frame 6. manager_->WriteOrBufferNewConnectionId( TestConnectionId(3), /*sequence_number=*/2, /*retire_prior_to=*/1, - /*stateless_reset_token=*/absl::MakeUint128(1, 1)); + /*stateless_reset_token=*/ + {0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1}); // Send RetireConnectionIdFrame as frame 7. manager_->WriteOrBufferRetireConnectionId(/*sequence_number=*/0); manager_->OnCanWrite();
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc index ebaa091..c5de97b 100644 --- a/quic/core/quic_framer.cc +++ b/quic/core/quic_framer.cc
@@ -1300,14 +1300,14 @@ // static size_t QuicFramer::GetMinStatelessResetPacketLength() { // 5 bytes (40 bits) = 2 Fixed Bits (01) + 38 Unpredictable bits - return 5 + sizeof(absl::uint128); + return 5 + kStatelessResetTokenLength; } // static std::unique_ptr<QuicEncryptedPacket> QuicFramer::BuildIetfStatelessResetPacket( QuicConnectionId /*connection_id*/, size_t received_packet_length, - absl::uint128 stateless_reset_token) { + StatelessResetToken stateless_reset_token) { QUIC_DVLOG(1) << "Building IETF stateless reset packet."; if (GetQuicReloadableFlag(quic_fix_stateless_reset)) { if (received_packet_length <= GetMinStatelessResetPacketLength()) { @@ -1329,9 +1329,9 @@ // cryptographic use, and does not need a secure cryptographic pseudo-random // number generator. It's therefore safe to use WriteInsecureRandomBytes. if (!writer.WriteInsecureRandomBytes(QuicRandom::GetInstance(), - len - sizeof(absl::uint128))) { + len - kStatelessResetTokenLength)) { QUIC_BUG(362045737_2) << "Failed to append random bytes of length: " - << len - sizeof(absl::uint128); + << len - kStatelessResetTokenLength; return nullptr; } // Change first 2 fixed bits to 01.
diff --git a/quic/core/quic_framer.h b/quic/core/quic_framer.h index 5704cb5..e27c7f0 100644 --- a/quic/core/quic_framer.h +++ b/quic/core/quic_framer.h
@@ -10,7 +10,6 @@ #include <memory> #include <string> -#include "absl/numeric/int128.h" #include "absl/strings/string_view.h" #include "quic/core/crypto/quic_decrypter.h" #include "quic/core/crypto/quic_encrypter.h" @@ -226,7 +225,8 @@ virtual void OnPacketComplete() = 0; // Called to check whether |token| is a valid stateless reset token. - virtual bool IsValidStatelessResetToken(absl::uint128 token) const = 0; + virtual bool IsValidStatelessResetToken( + const StatelessResetToken& token) const = 0; // Called when an IETF stateless reset packet has been parsed and validated // with the stateless reset token. @@ -478,7 +478,7 @@ static std::unique_ptr<QuicEncryptedPacket> BuildIetfStatelessResetPacket( QuicConnectionId connection_id, size_t received_packet_length, - absl::uint128 stateless_reset_token); + StatelessResetToken stateless_reset_token); // Returns a new version negotiation packet. static std::unique_ptr<QuicEncryptedPacket> BuildVersionNegotiationPacket(
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc index f64e7a5..048a4b7 100644 --- a/quic/core/quic_framer_test.cc +++ b/quic/core/quic_framer_test.cc
@@ -47,7 +47,9 @@ const uint64_t kEpoch = UINT64_C(1) << 32; const uint64_t kMask = kEpoch - 1; -const absl::uint128 kTestStatelessResetToken = 1010101; // 0x0F69B5 +const StatelessResetToken kTestStatelessResetToken{ + 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, + 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f}; // Use fields in which each byte is distinct to ensure that every byte is // framed correctly. The values are otherwise arbitrary. @@ -571,7 +573,8 @@ return true; } - bool IsValidStatelessResetToken(absl::uint128 token) const override { + bool IsValidStatelessResetToken( + const StatelessResetToken& token) const override { EXPECT_EQ(0u, framer_->current_received_frame_type()); return token == kTestStatelessResetToken; } @@ -5752,8 +5755,8 @@ 0x01, 0x11, 0x02, 0x22, 0x03, 0x33, 0x04, 0x44, 0x01, 0x11, 0x02, 0x22, 0x03, 0x33, 0x04, 0x44, // stateless reset token - 0xB5, 0x69, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, + 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, }; // clang-format on if (!framer_.version().HasIetfInvariantHeader()) { @@ -9253,8 +9256,8 @@ // At least 4 bytes of random bytes. 0x00, 0x00, 0x00, 0x00, // stateless reset token - 0xB5, 0x69, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, + 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f }; // clang-format on @@ -9272,11 +9275,10 @@ // Verify stateless reset token. quiche::test::CompareCharArraysWithHexError( "constructed packet", - data->data() + data->length() - sizeof(kTestStatelessResetToken), - sizeof(kTestStatelessResetToken), - AsChars(packet) + ABSL_ARRAYSIZE(packet) - - sizeof(kTestStatelessResetToken), - sizeof(kTestStatelessResetToken)); + data->data() + data->length() - kStatelessResetTokenLength, + kStatelessResetTokenLength, + AsChars(packet) + ABSL_ARRAYSIZE(packet) - kStatelessResetTokenLength, + kStatelessResetTokenLength); // Packets with length <= minimal stateless reset does not trigger stateless // reset. @@ -9306,8 +9308,8 @@ // random packet number 0xFE, // stateless reset token - 0xB5, 0x69, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, + 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, }; // clang-format on @@ -9319,16 +9321,15 @@ quiche::test::CompareCharArraysWithHexError( "constructed packet", data->data(), 1, AsChars(packet), 1); const size_t random_bytes_length = - data->length() - kPacketHeaderTypeSize - sizeof(kTestStatelessResetToken); + data->length() - kPacketHeaderTypeSize - kStatelessResetTokenLength; EXPECT_EQ(kMinRandomBytesLengthInStatelessReset, random_bytes_length); // Verify stateless reset token is correct. quiche::test::CompareCharArraysWithHexError( "constructed packet", - data->data() + data->length() - sizeof(kTestStatelessResetToken), - sizeof(kTestStatelessResetToken), - AsChars(packet) + ABSL_ARRAYSIZE(packet) - - sizeof(kTestStatelessResetToken), - sizeof(kTestStatelessResetToken)); + data->data() + data->length() - kStatelessResetTokenLength, + kStatelessResetTokenLength, + AsChars(packet) + ABSL_ARRAYSIZE(packet) - kStatelessResetTokenLength, + kStatelessResetTokenLength); } TEST_P(QuicFramerTest, EncryptPacket) { @@ -10912,8 +10913,8 @@ {"Unable to read new connection ID frame connection id.", {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x11}}, {"Can not read new connection ID frame reset token.", - {0xb5, 0x69, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}} + {0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, + 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f}} }; // clang-format on @@ -10971,8 +10972,8 @@ {"Unable to read new connection ID frame connection id.", {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, 0x42}}, {"Can not read new connection ID frame reset token.", - {0xb5, 0x69, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}} + {0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, + 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f}} }; // clang-format on @@ -11138,8 +11139,8 @@ // new connection id 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x11, // stateless reset token - 0xb5, 0x69, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, + 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, }; // clang-format on @@ -11545,8 +11546,8 @@ return; } - QuicNewConnectionIdFrame new_connection_id(5, TestConnectionId(), 1, 101111, - 1); + QuicNewConnectionIdFrame new_connection_id(5, TestConnectionId(), 1, + kTestStatelessResetToken, 1); EXPECT_EQ(QuicFramer::GetNewConnectionIdFrameSize(new_connection_id), QuicFramer::GetRetransmittableControlFrameSize( framer_.transport_version(), QuicFrame(&new_connection_id)));
diff --git a/quic/core/quic_packets.cc b/quic/core/quic_packets.cc index a7599cf..5cc593f 100644 --- a/quic/core/quic_packets.cc +++ b/quic/core/quic_packets.cc
@@ -183,7 +183,7 @@ nonce(nullptr), form(GOOGLE_QUIC_PACKET), long_packet_type(INITIAL), - possible_stateless_reset_token(0), + possible_stateless_reset_token({}), retry_token_length_length(VARIABLE_LENGTH_INTEGER_LENGTH_0), retry_token(absl::string_view()), length_length(VARIABLE_LENGTH_INTEGER_LENGTH_0), @@ -215,11 +215,11 @@ QuicVersionNegotiationPacket::~QuicVersionNegotiationPacket() {} QuicIetfStatelessResetPacket::QuicIetfStatelessResetPacket() - : stateless_reset_token(0) {} + : stateless_reset_token({}) {} QuicIetfStatelessResetPacket::QuicIetfStatelessResetPacket( const QuicPacketHeader& header, - absl::uint128 token) + StatelessResetToken token) : header(header), stateless_reset_token(token) {} QuicIetfStatelessResetPacket::QuicIetfStatelessResetPacket(
diff --git a/quic/core/quic_packets.h b/quic/core/quic_packets.h index 338adae..a3fc59d 100644 --- a/quic/core/quic_packets.h +++ b/quic/core/quic_packets.h
@@ -7,14 +7,11 @@ #include <cstddef> #include <cstdint> -#include <limits> -#include <list> #include <memory> #include <ostream> +#include <string> #include <utility> -#include <vector> -#include "absl/numeric/int128.h" #include "absl/strings/string_view.h" #include "quic/core/frames/quic_frame.h" #include "quic/core/quic_ack_listener_interface.h" @@ -155,7 +152,7 @@ // Only valid if |has_possible_stateless_reset_token| is true. // Stores last 16 bytes of a this packet, used to check whether this packet is // a stateless reset packet on decryption failure. - absl::uint128 possible_stateless_reset_token; + StatelessResetToken possible_stateless_reset_token; // Length of the retry token length variable length integer field, // carried only by v99 IETF Initial packets. QuicVariableLengthIntegerLength retry_token_length_length; @@ -196,12 +193,12 @@ struct QUIC_EXPORT_PRIVATE QuicIetfStatelessResetPacket { QuicIetfStatelessResetPacket(); QuicIetfStatelessResetPacket(const QuicPacketHeader& header, - absl::uint128 token); + StatelessResetToken token); QuicIetfStatelessResetPacket(const QuicIetfStatelessResetPacket& other); ~QuicIetfStatelessResetPacket(); QuicPacketHeader header; - absl::uint128 stateless_reset_token; + StatelessResetToken stateless_reset_token; }; class QUIC_EXPORT_PRIVATE QuicData {
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc index 55a9c19..7c7aa4d 100644 --- a/quic/core/quic_session.cc +++ b/quic/core/quic_session.cc
@@ -2359,7 +2359,7 @@ writer); } -absl::uint128 QuicSession::GetStatelessResetToken() const { +StatelessResetToken QuicSession::GetStatelessResetToken() const { return QuicUtils::GenerateStatelessResetToken(connection_->connection_id()); }
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h index bd65bf3..cf366cf 100644 --- a/quic/core/quic_session.h +++ b/quic/core/quic_session.h
@@ -15,7 +15,6 @@ #include <vector> #include "absl/container/flat_hash_map.h" -#include "absl/numeric/int128.h" #include "absl/strings/string_view.h" #include "absl/types/optional.h" #include "quic/core/frames/quic_ack_frequency_frame.h" @@ -721,7 +720,7 @@ // Returns a stateless reset token which will be included in the public reset // packet. - virtual absl::uint128 GetStatelessResetToken() const; + virtual StatelessResetToken GetStatelessResetToken() const; QuicControlFrameManager& control_frame_manager() { return control_frame_manager_;
diff --git a/quic/core/quic_time_wait_list_manager.cc b/quic/core/quic_time_wait_list_manager.cc index 857b6c7..d6fa2da 100644 --- a/quic/core/quic_time_wait_list_manager.cc +++ b/quic/core/quic_time_wait_list_manager.cc
@@ -500,7 +500,7 @@ QuicTimeWaitListManager::ConnectionIdData::~ConnectionIdData() = default; -absl::uint128 QuicTimeWaitListManager::GetStatelessResetToken( +StatelessResetToken QuicTimeWaitListManager::GetStatelessResetToken( QuicConnectionId connection_id) const { return QuicUtils::GenerateStatelessResetToken(connection_id); }
diff --git a/quic/core/quic_time_wait_list_manager.h b/quic/core/quic_time_wait_list_manager.h index 5e097b5..2018f72 100644 --- a/quic/core/quic_time_wait_list_manager.h +++ b/quic/core/quic_time_wait_list_manager.h
@@ -12,13 +12,13 @@ #include <memory> #include "absl/container/flat_hash_map.h" -#include "absl/numeric/int128.h" #include "quic/core/quic_blocked_writer_interface.h" #include "quic/core/quic_connection_id.h" #include "quic/core/quic_framer.h" #include "quic/core/quic_packet_writer.h" #include "quic/core/quic_packets.h" #include "quic/core/quic_session.h" +#include "quic/core/quic_types.h" #include "quic/platform/api/quic_containers.h" #include "quic/platform/api/quic_flags.h" @@ -187,7 +187,7 @@ // Returns a stateless reset token which will be included in the public reset // packet. - virtual absl::uint128 GetStatelessResetToken( + virtual StatelessResetToken GetStatelessResetToken( QuicConnectionId connection_id) const; // Internal structure to store pending termination packets.
diff --git a/quic/core/quic_time_wait_list_manager_test.cc b/quic/core/quic_time_wait_list_manager_test.cc index b423713..d33e992 100644 --- a/quic/core/quic_time_wait_list_manager_test.cc +++ b/quic/core/quic_time_wait_list_manager_test.cc
@@ -9,7 +9,6 @@ #include <ostream> #include <utility> -#include "absl/numeric/int128.h" #include "quic/core/crypto/crypto_protocol.h" #include "quic/core/crypto/null_encrypter.h" #include "quic/core/crypto/quic_decrypter.h" @@ -57,7 +56,8 @@ return public_reset_packet_; } - bool IsValidStatelessResetToken(absl::uint128 token) const override { + bool IsValidStatelessResetToken( + const StatelessResetToken& token) const override { return token == QuicUtils::GenerateStatelessResetToken(connection_id_); } @@ -220,7 +220,7 @@ QuicIetfStatelessResetPacket stateless_reset = visitor.stateless_reset_packet(); - absl::uint128 expected_stateless_reset_token = + StatelessResetToken expected_stateless_reset_token = QuicUtils::GenerateStatelessResetToken(expected_connection_id); bool stateless_reset_is_valid =
diff --git a/quic/core/quic_types.cc b/quic/core/quic_types.cc index f818268..57163ab 100644 --- a/quic/core/quic_types.cc +++ b/quic/core/quic_types.cc
@@ -11,6 +11,9 @@ namespace quic { +static_assert(sizeof(StatelessResetToken) == kStatelessResetTokenLength, + "bad size"); + std::ostream& operator<<(std::ostream& os, const QuicConsumedData& s) { os << "bytes_consumed: " << s.bytes_consumed << " fin_consumed: " << s.fin_consumed;
diff --git a/quic/core/quic_types.h b/quic/core/quic_types.h index 83404c5..2e65e5f 100644 --- a/quic/core/quic_types.h +++ b/quic/core/quic_types.h
@@ -44,6 +44,9 @@ using DiversificationNonce = std::array<char, 32>; using PacketTimeVector = std::vector<std::pair<QuicPacketNumber, QuicTime>>; +enum : size_t { kStatelessResetTokenLength = 16 }; +using StatelessResetToken = std::array<char, kStatelessResetTokenLength>; + // WebTransport session IDs are stream IDs. using WebTransportSessionId = uint64_t;
diff --git a/quic/core/quic_utils.cc b/quic/core/quic_utils.cc index 7e3652e..27b74bb 100644 --- a/quic/core/quic_utils.cc +++ b/quic/core/quic_utils.cc
@@ -630,10 +630,15 @@ transport_version); } -absl::uint128 QuicUtils::GenerateStatelessResetToken( +StatelessResetToken QuicUtils::GenerateStatelessResetToken( QuicConnectionId connection_id) { - return FNV1a_128_Hash( + static_assert(sizeof(absl::uint128) == sizeof(StatelessResetToken), + "bad size"); + static_assert(alignof(absl::uint128) >= alignof(StatelessResetToken), + "bad alignment"); + absl::uint128 hash = FNV1a_128_Hash( absl::string_view(connection_id.data(), connection_id.length())); + return *reinterpret_cast<StatelessResetToken*>(&hash); } // static
diff --git a/quic/core/quic_utils.h b/quic/core/quic_utils.h index abef12b..0b089b4 100644 --- a/quic/core/quic_utils.h +++ b/quic/core/quic_utils.h
@@ -219,7 +219,7 @@ static QuicConnectionId CreateZeroConnectionId(QuicTransportVersion version); // Generates a 128bit stateless reset token based on a connection ID. - static absl::uint128 GenerateStatelessResetToken( + static StatelessResetToken GenerateStatelessResetToken( QuicConnectionId connection_id); // Determines packet number space from |encryption_level|.
diff --git a/quic/core/quic_utils_test.cc b/quic/core/quic_utils_test.cc index a178725..dc11652 100644 --- a/quic/core/quic_utils_test.cc +++ b/quic/core/quic_utils_test.cc
@@ -312,11 +312,12 @@ QuicConnectionId connection_id1a = test::TestConnectionId(1); QuicConnectionId connection_id1b = test::TestConnectionId(1); QuicConnectionId connection_id2 = test::TestConnectionId(2); - absl::uint128 token1a = + StatelessResetToken token1a = QuicUtils::GenerateStatelessResetToken(connection_id1a); - absl::uint128 token1b = + StatelessResetToken token1b = QuicUtils::GenerateStatelessResetToken(connection_id1b); - absl::uint128 token2 = QuicUtils::GenerateStatelessResetToken(connection_id2); + StatelessResetToken token2 = + QuicUtils::GenerateStatelessResetToken(connection_id2); EXPECT_EQ(token1a, token1b); EXPECT_NE(token1a, token2); }
diff --git a/quic/core/tls_chlo_extractor.h b/quic/core/tls_chlo_extractor.h index 8383af1..c6d0455 100644 --- a/quic/core/tls_chlo_extractor.h +++ b/quic/core/tls_chlo_extractor.h
@@ -8,12 +8,12 @@ #include <memory> #include <string> #include <vector> -#include "absl/numeric/int128.h" #include "third_party/boringssl/src/include/openssl/ssl.h" #include "quic/core/frames/quic_ack_frequency_frame.h" #include "quic/core/quic_framer.h" #include "quic/core/quic_packets.h" #include "quic/core/quic_stream_sequencer.h" +#include "quic/core/quic_types.h" #include "quic/platform/api/quic_export.h" namespace quic { @@ -157,7 +157,8 @@ return true; } void OnPacketComplete() override {} - bool IsValidStatelessResetToken(absl::uint128 /*token*/) const override { + bool IsValidStatelessResetToken( + const StatelessResetToken& /*token*/) const override { return true; } void OnAuthenticatedIetfStatelessResetPacket(
diff --git a/quic/test_tools/quic_config_peer.cc b/quic/test_tools/quic_config_peer.cc index 03a477e..243216b 100644 --- a/quic/test_tools/quic_config_peer.cc +++ b/quic/test_tools/quic_config_peer.cc
@@ -87,8 +87,9 @@ } // static -void QuicConfigPeer::SetReceivedStatelessResetToken(QuicConfig* config, - absl::uint128 token) { +void QuicConfigPeer::SetReceivedStatelessResetToken( + QuicConfig* config, + const StatelessResetToken& token) { config->stateless_reset_token_.SetReceivedValue(token); }
diff --git a/quic/test_tools/quic_config_peer.h b/quic/test_tools/quic_config_peer.h index 9f48a79..6ffc5ae 100644 --- a/quic/test_tools/quic_config_peer.h +++ b/quic/test_tools/quic_config_peer.h
@@ -5,10 +5,10 @@ #ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_CONFIG_PEER_H_ #define QUICHE_QUIC_TEST_TOOLS_QUIC_CONFIG_PEER_H_ -#include "absl/numeric/int128.h" #include "quic/core/quic_config.h" #include "quic/core/quic_connection_id.h" #include "quic/core/quic_packets.h" +#include "quic/core/quic_types.h" namespace quic { @@ -55,7 +55,7 @@ const QuicTagVector& options); static void SetReceivedStatelessResetToken(QuicConfig* config, - absl::uint128 token); + const StatelessResetToken& token); static void SetReceivedMaxPacketSize(QuicConfig* config, uint32_t max_udp_payload_size);
diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc index c247526..5feb646 100644 --- a/quic/test_tools/quic_test_utils.cc +++ b/quic/test_tools/quic_test_utils.cc
@@ -449,7 +449,7 @@ } bool NoOpFramerVisitor::IsValidStatelessResetToken( - absl::uint128 /*token*/) const { + const StatelessResetToken& /*token*/) const { return false; }
diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h index 763638f..2f16b1e 100644 --- a/quic/test_tools/quic_test_utils.h +++ b/quic/test_tools/quic_test_utils.h
@@ -14,7 +14,6 @@ #include <vector> #include "absl/container/flat_hash_map.h" -#include "absl/numeric/int128.h" #include "absl/strings/str_cat.h" #include "absl/strings/string_view.h" #include "quic/core/congestion_control/loss_detection_interface.h" @@ -432,7 +431,7 @@ MOCK_METHOD(void, OnPacketComplete, (), (override)); MOCK_METHOD(bool, IsValidStatelessResetToken, - (absl::uint128), + (const StatelessResetToken&), (const, override)); MOCK_METHOD(void, OnAuthenticatedIetfStatelessResetPacket, @@ -505,7 +504,8 @@ bool OnHandshakeDoneFrame(const QuicHandshakeDoneFrame& frame) override; bool OnAckFrequencyFrame(const QuicAckFrequencyFrame& frame) override; void OnPacketComplete() override {} - bool IsValidStatelessResetToken(absl::uint128 token) const override; + bool IsValidStatelessResetToken( + const StatelessResetToken& token) const override; void OnAuthenticatedIetfStatelessResetPacket( const QuicIetfStatelessResetPacket& /*packet*/) override {} void OnKeyUpdate(KeyUpdateReason /*reason*/) override {}
diff --git a/quic/test_tools/simple_quic_framer.cc b/quic/test_tools/simple_quic_framer.cc index 14d5b33..92363ec 100644 --- a/quic/test_tools/simple_quic_framer.cc +++ b/quic/test_tools/simple_quic_framer.cc
@@ -8,10 +8,10 @@ #include <utility> #include "absl/memory/memory.h" -#include "absl/numeric/int128.h" #include "absl/strings/string_view.h" #include "quic/core/crypto/quic_decrypter.h" #include "quic/core/crypto/quic_encrypter.h" +#include "quic/core/quic_types.h" namespace quic { namespace test { @@ -211,7 +211,8 @@ void OnPacketComplete() override {} - bool IsValidStatelessResetToken(absl::uint128 /*token*/) const override { + bool IsValidStatelessResetToken( + const StatelessResetToken& /*token*/) const override { return false; }
diff --git a/quic/tools/quic_packet_printer_bin.cc b/quic/tools/quic_packet_printer_bin.cc index 4fc82e4..97ca71e 100644 --- a/quic/tools/quic_packet_printer_bin.cc +++ b/quic/tools/quic_packet_printer_bin.cc
@@ -28,10 +28,10 @@ #include <iostream> -#include "absl/numeric/int128.h" #include "absl/strings/escaping.h" #include "absl/strings/string_view.h" #include "quic/core/quic_framer.h" +#include "quic/core/quic_types.h" #include "quic/core/quic_utils.h" #include "quic/platform/api/quic_flags.h" #include "common/platform/api/quiche_text_utils.h" @@ -214,7 +214,8 @@ return true; } void OnPacketComplete() override { std::cerr << "OnPacketComplete\n"; } - bool IsValidStatelessResetToken(absl::uint128 /*token*/) const override { + bool IsValidStatelessResetToken( + const StatelessResetToken& /*token*/) const override { std::cerr << "IsValidStatelessResetToken\n"; return false; }