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;
}
