1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "quiche/quic/core/quic_utils.h"
6
7 #include <string>
8
9 #include "absl/base/macros.h"
10 #include "absl/numeric/int128.h"
11 #include "absl/strings/string_view.h"
12 #include "quiche/quic/core/quic_connection_id.h"
13 #include "quiche/quic/core/quic_types.h"
14 #include "quiche/quic/platform/api/quic_test.h"
15 #include "quiche/quic/test_tools/quic_test_utils.h"
16
17 namespace quic {
18 namespace test {
19 namespace {
20
21 class QuicUtilsTest : public QuicTest {};
22
TEST_F(QuicUtilsTest,DetermineAddressChangeType)23 TEST_F(QuicUtilsTest, DetermineAddressChangeType) {
24 const std::string kIPv4String1 = "1.2.3.4";
25 const std::string kIPv4String2 = "1.2.3.5";
26 const std::string kIPv4String3 = "1.1.3.5";
27 const std::string kIPv6String1 = "2001:700:300:1800::f";
28 const std::string kIPv6String2 = "2001:700:300:1800:1:1:1:f";
29 QuicSocketAddress old_address;
30 QuicSocketAddress new_address;
31 QuicIpAddress address;
32
33 EXPECT_EQ(NO_CHANGE,
34 QuicUtils::DetermineAddressChangeType(old_address, new_address));
35 ASSERT_TRUE(address.FromString(kIPv4String1));
36 old_address = QuicSocketAddress(address, 1234);
37 EXPECT_EQ(NO_CHANGE,
38 QuicUtils::DetermineAddressChangeType(old_address, new_address));
39 new_address = QuicSocketAddress(address, 1234);
40 EXPECT_EQ(NO_CHANGE,
41 QuicUtils::DetermineAddressChangeType(old_address, new_address));
42
43 new_address = QuicSocketAddress(address, 5678);
44 EXPECT_EQ(PORT_CHANGE,
45 QuicUtils::DetermineAddressChangeType(old_address, new_address));
46 ASSERT_TRUE(address.FromString(kIPv6String1));
47 old_address = QuicSocketAddress(address, 1234);
48 new_address = QuicSocketAddress(address, 5678);
49 EXPECT_EQ(PORT_CHANGE,
50 QuicUtils::DetermineAddressChangeType(old_address, new_address));
51
52 ASSERT_TRUE(address.FromString(kIPv4String1));
53 old_address = QuicSocketAddress(address, 1234);
54 ASSERT_TRUE(address.FromString(kIPv6String1));
55 new_address = QuicSocketAddress(address, 1234);
56 EXPECT_EQ(IPV4_TO_IPV6_CHANGE,
57 QuicUtils::DetermineAddressChangeType(old_address, new_address));
58
59 old_address = QuicSocketAddress(address, 1234);
60 ASSERT_TRUE(address.FromString(kIPv4String1));
61 new_address = QuicSocketAddress(address, 1234);
62 EXPECT_EQ(IPV6_TO_IPV4_CHANGE,
63 QuicUtils::DetermineAddressChangeType(old_address, new_address));
64
65 ASSERT_TRUE(address.FromString(kIPv6String2));
66 new_address = QuicSocketAddress(address, 1234);
67 EXPECT_EQ(IPV6_TO_IPV6_CHANGE,
68 QuicUtils::DetermineAddressChangeType(old_address, new_address));
69
70 ASSERT_TRUE(address.FromString(kIPv4String1));
71 old_address = QuicSocketAddress(address, 1234);
72 ASSERT_TRUE(address.FromString(kIPv4String2));
73 new_address = QuicSocketAddress(address, 1234);
74 EXPECT_EQ(IPV4_SUBNET_CHANGE,
75 QuicUtils::DetermineAddressChangeType(old_address, new_address));
76 ASSERT_TRUE(address.FromString(kIPv4String3));
77 new_address = QuicSocketAddress(address, 1234);
78 EXPECT_EQ(IPV4_TO_IPV4_CHANGE,
79 QuicUtils::DetermineAddressChangeType(old_address, new_address));
80 }
81
IncrementalHashReference(const void * data,size_t len)82 absl::uint128 IncrementalHashReference(const void* data, size_t len) {
83 // The two constants are defined as part of the hash algorithm.
84 // see http://www.isthe.com/chongo/tech/comp/fnv/
85 // hash = 144066263297769815596495629667062367629
86 absl::uint128 hash = absl::MakeUint128(UINT64_C(7809847782465536322),
87 UINT64_C(7113472399480571277));
88 // kPrime = 309485009821345068724781371
89 const absl::uint128 kPrime = absl::MakeUint128(16777216, 315);
90 const uint8_t* octets = reinterpret_cast<const uint8_t*>(data);
91 for (size_t i = 0; i < len; ++i) {
92 hash = hash ^ absl::MakeUint128(0, octets[i]);
93 hash = hash * kPrime;
94 }
95 return hash;
96 }
97
TEST_F(QuicUtilsTest,ReferenceTest)98 TEST_F(QuicUtilsTest, ReferenceTest) {
99 std::vector<uint8_t> data(32);
100 for (size_t i = 0; i < data.size(); ++i) {
101 data[i] = i % 255;
102 }
103 EXPECT_EQ(IncrementalHashReference(data.data(), data.size()),
104 QuicUtils::FNV1a_128_Hash(absl::string_view(
105 reinterpret_cast<const char*>(data.data()), data.size())));
106 }
107
TEST_F(QuicUtilsTest,IsUnackable)108 TEST_F(QuicUtilsTest, IsUnackable) {
109 for (size_t i = FIRST_PACKET_STATE; i <= LAST_PACKET_STATE; ++i) {
110 if (i == NEVER_SENT || i == ACKED || i == UNACKABLE) {
111 EXPECT_FALSE(QuicUtils::IsAckable(static_cast<SentPacketState>(i)));
112 } else {
113 EXPECT_TRUE(QuicUtils::IsAckable(static_cast<SentPacketState>(i)));
114 }
115 }
116 }
117
TEST_F(QuicUtilsTest,RetransmissionTypeToPacketState)118 TEST_F(QuicUtilsTest, RetransmissionTypeToPacketState) {
119 for (size_t i = FIRST_TRANSMISSION_TYPE; i <= LAST_TRANSMISSION_TYPE; ++i) {
120 if (i == NOT_RETRANSMISSION) {
121 continue;
122 }
123 SentPacketState state = QuicUtils::RetransmissionTypeToPacketState(
124 static_cast<TransmissionType>(i));
125 if (i == HANDSHAKE_RETRANSMISSION) {
126 EXPECT_EQ(HANDSHAKE_RETRANSMITTED, state);
127 } else if (i == LOSS_RETRANSMISSION) {
128 EXPECT_EQ(LOST, state);
129 } else if (i == ALL_ZERO_RTT_RETRANSMISSION) {
130 EXPECT_EQ(UNACKABLE, state);
131 } else if (i == PTO_RETRANSMISSION) {
132 EXPECT_EQ(PTO_RETRANSMITTED, state);
133 } else if (i == PATH_RETRANSMISSION) {
134 EXPECT_EQ(NOT_CONTRIBUTING_RTT, state);
135 } else if (i == ALL_INITIAL_RETRANSMISSION) {
136 EXPECT_EQ(UNACKABLE, state);
137 } else {
138 QUICHE_DCHECK(false)
139 << "No corresponding packet state according to transmission type: "
140 << i;
141 }
142 }
143 }
144
TEST_F(QuicUtilsTest,IsIetfPacketHeader)145 TEST_F(QuicUtilsTest, IsIetfPacketHeader) {
146 // IETF QUIC short header
147 uint8_t first_byte = 0;
148 EXPECT_TRUE(QuicUtils::IsIetfPacketHeader(first_byte));
149 EXPECT_TRUE(QuicUtils::IsIetfPacketShortHeader(first_byte));
150
151 // IETF QUIC long header
152 first_byte |= (FLAGS_LONG_HEADER | FLAGS_DEMULTIPLEXING_BIT);
153 EXPECT_TRUE(QuicUtils::IsIetfPacketHeader(first_byte));
154 EXPECT_FALSE(QuicUtils::IsIetfPacketShortHeader(first_byte));
155
156 // IETF QUIC long header, version negotiation.
157 first_byte = 0;
158 first_byte |= FLAGS_LONG_HEADER;
159 EXPECT_TRUE(QuicUtils::IsIetfPacketHeader(first_byte));
160 EXPECT_FALSE(QuicUtils::IsIetfPacketShortHeader(first_byte));
161
162 // GQUIC
163 first_byte = 0;
164 first_byte |= PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID;
165 EXPECT_FALSE(QuicUtils::IsIetfPacketHeader(first_byte));
166 EXPECT_FALSE(QuicUtils::IsIetfPacketShortHeader(first_byte));
167 }
168
TEST_F(QuicUtilsTest,RandomConnectionId)169 TEST_F(QuicUtilsTest, RandomConnectionId) {
170 MockRandom random(33);
171 QuicConnectionId connection_id = QuicUtils::CreateRandomConnectionId(&random);
172 EXPECT_EQ(connection_id.length(), sizeof(uint64_t));
173 char connection_id_bytes[sizeof(uint64_t)];
174 random.RandBytes(connection_id_bytes, ABSL_ARRAYSIZE(connection_id_bytes));
175 EXPECT_EQ(connection_id,
176 QuicConnectionId(static_cast<char*>(connection_id_bytes),
177 ABSL_ARRAYSIZE(connection_id_bytes)));
178 EXPECT_NE(connection_id, EmptyQuicConnectionId());
179 EXPECT_NE(connection_id, TestConnectionId());
180 EXPECT_NE(connection_id, TestConnectionId(1));
181 EXPECT_NE(connection_id, TestConnectionIdNineBytesLong(1));
182 EXPECT_EQ(QuicUtils::CreateRandomConnectionId().length(),
183 kQuicDefaultConnectionIdLength);
184 }
185
TEST_F(QuicUtilsTest,RandomConnectionIdVariableLength)186 TEST_F(QuicUtilsTest, RandomConnectionIdVariableLength) {
187 MockRandom random(1337);
188 const uint8_t connection_id_length = 9;
189 QuicConnectionId connection_id =
190 QuicUtils::CreateRandomConnectionId(connection_id_length, &random);
191 EXPECT_EQ(connection_id.length(), connection_id_length);
192 char connection_id_bytes[connection_id_length];
193 random.RandBytes(connection_id_bytes, ABSL_ARRAYSIZE(connection_id_bytes));
194 EXPECT_EQ(connection_id,
195 QuicConnectionId(static_cast<char*>(connection_id_bytes),
196 ABSL_ARRAYSIZE(connection_id_bytes)));
197 EXPECT_NE(connection_id, EmptyQuicConnectionId());
198 EXPECT_NE(connection_id, TestConnectionId());
199 EXPECT_NE(connection_id, TestConnectionId(1));
200 EXPECT_NE(connection_id, TestConnectionIdNineBytesLong(1));
201 EXPECT_EQ(QuicUtils::CreateRandomConnectionId(connection_id_length).length(),
202 connection_id_length);
203 }
204
TEST_F(QuicUtilsTest,VariableLengthConnectionId)205 TEST_F(QuicUtilsTest, VariableLengthConnectionId) {
206 EXPECT_FALSE(VersionAllowsVariableLengthConnectionIds(QUIC_VERSION_46));
207 EXPECT_TRUE(QuicUtils::IsConnectionIdValidForVersion(
208 QuicUtils::CreateZeroConnectionId(QUIC_VERSION_46), QUIC_VERSION_46));
209 EXPECT_NE(QuicUtils::CreateZeroConnectionId(QUIC_VERSION_46),
210 EmptyQuicConnectionId());
211 EXPECT_FALSE(QuicUtils::IsConnectionIdValidForVersion(EmptyQuicConnectionId(),
212 QUIC_VERSION_46));
213 }
214
TEST_F(QuicUtilsTest,StatelessResetToken)215 TEST_F(QuicUtilsTest, StatelessResetToken) {
216 QuicConnectionId connection_id1a = test::TestConnectionId(1);
217 QuicConnectionId connection_id1b = test::TestConnectionId(1);
218 QuicConnectionId connection_id2 = test::TestConnectionId(2);
219 StatelessResetToken token1a =
220 QuicUtils::GenerateStatelessResetToken(connection_id1a);
221 StatelessResetToken token1b =
222 QuicUtils::GenerateStatelessResetToken(connection_id1b);
223 StatelessResetToken token2 =
224 QuicUtils::GenerateStatelessResetToken(connection_id2);
225 EXPECT_EQ(token1a, token1b);
226 EXPECT_NE(token1a, token2);
227 EXPECT_TRUE(QuicUtils::AreStatelessResetTokensEqual(token1a, token1b));
228 EXPECT_FALSE(QuicUtils::AreStatelessResetTokensEqual(token1a, token2));
229 }
230
TEST_F(QuicUtilsTest,EcnCodepointToString)231 TEST_F(QuicUtilsTest, EcnCodepointToString) {
232 EXPECT_EQ(EcnCodepointToString(ECN_NOT_ECT), "Not-ECT");
233 EXPECT_EQ(EcnCodepointToString(ECN_ECT0), "ECT(0)");
234 EXPECT_EQ(EcnCodepointToString(ECN_ECT1), "ECT(1)");
235 EXPECT_EQ(EcnCodepointToString(ECN_CE), "CE");
236 }
237
238 enum class TestEnumClassBit : uint8_t {
239 BIT_ZERO = 0,
240 BIT_ONE,
241 BIT_TWO,
242 };
243
244 enum TestEnumBit {
245 TEST_BIT_0 = 0,
246 TEST_BIT_1,
247 TEST_BIT_2,
248 };
249
TEST(QuicBitMaskTest,EnumClass)250 TEST(QuicBitMaskTest, EnumClass) {
251 BitMask<TestEnumClassBit> mask(
252 {TestEnumClassBit::BIT_ZERO, TestEnumClassBit::BIT_TWO});
253 EXPECT_TRUE(mask.IsSet(TestEnumClassBit::BIT_ZERO));
254 EXPECT_FALSE(mask.IsSet(TestEnumClassBit::BIT_ONE));
255 EXPECT_TRUE(mask.IsSet(TestEnumClassBit::BIT_TWO));
256
257 mask.ClearAll();
258 EXPECT_FALSE(mask.IsSet(TestEnumClassBit::BIT_ZERO));
259 EXPECT_FALSE(mask.IsSet(TestEnumClassBit::BIT_ONE));
260 EXPECT_FALSE(mask.IsSet(TestEnumClassBit::BIT_TWO));
261 }
262
TEST(QuicBitMaskTest,Enum)263 TEST(QuicBitMaskTest, Enum) {
264 BitMask<TestEnumBit> mask({TEST_BIT_1, TEST_BIT_2});
265 EXPECT_FALSE(mask.IsSet(TEST_BIT_0));
266 EXPECT_TRUE(mask.IsSet(TEST_BIT_1));
267 EXPECT_TRUE(mask.IsSet(TEST_BIT_2));
268
269 mask.ClearAll();
270 EXPECT_FALSE(mask.IsSet(TEST_BIT_0));
271 EXPECT_FALSE(mask.IsSet(TEST_BIT_1));
272 EXPECT_FALSE(mask.IsSet(TEST_BIT_2));
273 }
274
TEST(QuicBitMaskTest,Integer)275 TEST(QuicBitMaskTest, Integer) {
276 BitMask<int> mask({1, 3});
277 EXPECT_EQ(mask.Max(), 3);
278 mask.Set(3);
279 mask.Set({5, 7, 9});
280 EXPECT_EQ(mask.Max(), 9);
281 EXPECT_FALSE(mask.IsSet(0));
282 EXPECT_TRUE(mask.IsSet(1));
283 EXPECT_FALSE(mask.IsSet(2));
284 EXPECT_TRUE(mask.IsSet(3));
285 EXPECT_FALSE(mask.IsSet(4));
286 EXPECT_TRUE(mask.IsSet(5));
287 EXPECT_FALSE(mask.IsSet(6));
288 EXPECT_TRUE(mask.IsSet(7));
289 EXPECT_FALSE(mask.IsSet(8));
290 EXPECT_TRUE(mask.IsSet(9));
291 }
292
TEST(QuicBitMaskTest,NumBits)293 TEST(QuicBitMaskTest, NumBits) {
294 EXPECT_EQ(64u, BitMask<int>::NumBits());
295 EXPECT_EQ(32u, (BitMask<int, uint32_t>::NumBits()));
296 }
297
TEST(QuicBitMaskTest,Constructor)298 TEST(QuicBitMaskTest, Constructor) {
299 BitMask<int> empty_mask;
300 for (size_t bit = 0; bit < empty_mask.NumBits(); ++bit) {
301 EXPECT_FALSE(empty_mask.IsSet(bit));
302 }
303
304 BitMask<int> mask({1, 3});
305 BitMask<int> mask2 = mask;
306 BitMask<int> mask3(mask2);
307
308 for (size_t bit = 0; bit < mask.NumBits(); ++bit) {
309 EXPECT_EQ(mask.IsSet(bit), mask2.IsSet(bit));
310 EXPECT_EQ(mask.IsSet(bit), mask3.IsSet(bit));
311 }
312
313 EXPECT_TRUE(std::is_trivially_copyable<BitMask<int>>::value);
314 }
315
TEST(QuicBitMaskTest,Any)316 TEST(QuicBitMaskTest, Any) {
317 BitMask<int> mask;
318 EXPECT_FALSE(mask.Any());
319 mask.Set(3);
320 EXPECT_TRUE(mask.Any());
321 mask.Set(2);
322 EXPECT_TRUE(mask.Any());
323 mask.ClearAll();
324 EXPECT_FALSE(mask.Any());
325 }
326
TEST(QuicBitMaskTest,And)327 TEST(QuicBitMaskTest, And) {
328 using Mask = BitMask<int>;
329 EXPECT_EQ(Mask({1, 3, 6}) & Mask({3, 5, 6}), Mask({3, 6}));
330 EXPECT_EQ(Mask({1, 2, 4}) & Mask({3, 5}), Mask({}));
331 EXPECT_EQ(Mask({1, 2, 3, 4, 5}) & Mask({}), Mask({}));
332 }
333
334 } // namespace
335 } // namespace test
336 } // namespace quic
337