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_config.h"
6
7 #include <memory>
8 #include <string>
9
10 #include "quiche/quic/core/crypto/crypto_handshake_message.h"
11 #include "quiche/quic/core/crypto/crypto_protocol.h"
12 #include "quiche/quic/core/crypto/transport_parameters.h"
13 #include "quiche/quic/core/quic_constants.h"
14 #include "quiche/quic/core/quic_packets.h"
15 #include "quiche/quic/core/quic_time.h"
16 #include "quiche/quic/core/quic_utils.h"
17 #include "quiche/quic/platform/api/quic_expect_bug.h"
18 #include "quiche/quic/platform/api/quic_flags.h"
19 #include "quiche/quic/platform/api/quic_test.h"
20 #include "quiche/quic/test_tools/quic_config_peer.h"
21 #include "quiche/quic/test_tools/quic_test_utils.h"
22
23 namespace quic {
24 namespace test {
25 namespace {
26
27 class QuicConfigTest : public QuicTestWithParam<ParsedQuicVersion> {
28 public:
QuicConfigTest()29 QuicConfigTest() : version_(GetParam()) {}
30
31 protected:
32 ParsedQuicVersion version_;
33 QuicConfig config_;
34 };
35
36 // Run all tests with all versions of QUIC.
37 INSTANTIATE_TEST_SUITE_P(QuicConfigTests, QuicConfigTest,
38 ::testing::ValuesIn(AllSupportedVersions()),
39 ::testing::PrintToStringParamName());
40
TEST_P(QuicConfigTest,SetDefaults)41 TEST_P(QuicConfigTest, SetDefaults) {
42 EXPECT_EQ(kMinimumFlowControlSendWindow,
43 config_.GetInitialStreamFlowControlWindowToSend());
44 EXPECT_EQ(kMinimumFlowControlSendWindow,
45 config_.GetInitialMaxStreamDataBytesIncomingBidirectionalToSend());
46 EXPECT_EQ(kMinimumFlowControlSendWindow,
47 config_.GetInitialMaxStreamDataBytesOutgoingBidirectionalToSend());
48 EXPECT_EQ(kMinimumFlowControlSendWindow,
49 config_.GetInitialMaxStreamDataBytesUnidirectionalToSend());
50 EXPECT_FALSE(config_.HasReceivedInitialStreamFlowControlWindowBytes());
51 EXPECT_FALSE(
52 config_.HasReceivedInitialMaxStreamDataBytesIncomingBidirectional());
53 EXPECT_FALSE(
54 config_.HasReceivedInitialMaxStreamDataBytesOutgoingBidirectional());
55 EXPECT_FALSE(config_.HasReceivedInitialMaxStreamDataBytesUnidirectional());
56 EXPECT_EQ(kMaxIncomingPacketSize, config_.GetMaxPacketSizeToSend());
57 EXPECT_FALSE(config_.HasReceivedMaxPacketSize());
58 }
59
TEST_P(QuicConfigTest,AutoSetIetfFlowControl)60 TEST_P(QuicConfigTest, AutoSetIetfFlowControl) {
61 EXPECT_EQ(kMinimumFlowControlSendWindow,
62 config_.GetInitialStreamFlowControlWindowToSend());
63 EXPECT_EQ(kMinimumFlowControlSendWindow,
64 config_.GetInitialMaxStreamDataBytesIncomingBidirectionalToSend());
65 EXPECT_EQ(kMinimumFlowControlSendWindow,
66 config_.GetInitialMaxStreamDataBytesOutgoingBidirectionalToSend());
67 EXPECT_EQ(kMinimumFlowControlSendWindow,
68 config_.GetInitialMaxStreamDataBytesUnidirectionalToSend());
69 static const uint32_t kTestWindowSize = 1234567;
70 config_.SetInitialStreamFlowControlWindowToSend(kTestWindowSize);
71 EXPECT_EQ(kTestWindowSize, config_.GetInitialStreamFlowControlWindowToSend());
72 EXPECT_EQ(kTestWindowSize,
73 config_.GetInitialMaxStreamDataBytesIncomingBidirectionalToSend());
74 EXPECT_EQ(kTestWindowSize,
75 config_.GetInitialMaxStreamDataBytesOutgoingBidirectionalToSend());
76 EXPECT_EQ(kTestWindowSize,
77 config_.GetInitialMaxStreamDataBytesUnidirectionalToSend());
78 static const uint32_t kTestWindowSizeTwo = 2345678;
79 config_.SetInitialMaxStreamDataBytesIncomingBidirectionalToSend(
80 kTestWindowSizeTwo);
81 EXPECT_EQ(kTestWindowSize, config_.GetInitialStreamFlowControlWindowToSend());
82 EXPECT_EQ(kTestWindowSizeTwo,
83 config_.GetInitialMaxStreamDataBytesIncomingBidirectionalToSend());
84 EXPECT_EQ(kTestWindowSize,
85 config_.GetInitialMaxStreamDataBytesOutgoingBidirectionalToSend());
86 EXPECT_EQ(kTestWindowSize,
87 config_.GetInitialMaxStreamDataBytesUnidirectionalToSend());
88 }
89
TEST_P(QuicConfigTest,ToHandshakeMessage)90 TEST_P(QuicConfigTest, ToHandshakeMessage) {
91 if (version_.UsesTls()) {
92 // CryptoHandshakeMessage is only used for QUIC_CRYPTO.
93 return;
94 }
95 config_.SetInitialStreamFlowControlWindowToSend(
96 kInitialStreamFlowControlWindowForTest);
97 config_.SetInitialSessionFlowControlWindowToSend(
98 kInitialSessionFlowControlWindowForTest);
99 config_.SetIdleNetworkTimeout(QuicTime::Delta::FromSeconds(5));
100 CryptoHandshakeMessage msg;
101 config_.ToHandshakeMessage(&msg, version_.transport_version);
102
103 uint32_t value;
104 QuicErrorCode error = msg.GetUint32(kICSL, &value);
105 EXPECT_THAT(error, IsQuicNoError());
106 EXPECT_EQ(5u, value);
107
108 error = msg.GetUint32(kSFCW, &value);
109 EXPECT_THAT(error, IsQuicNoError());
110 EXPECT_EQ(kInitialStreamFlowControlWindowForTest, value);
111
112 error = msg.GetUint32(kCFCW, &value);
113 EXPECT_THAT(error, IsQuicNoError());
114 EXPECT_EQ(kInitialSessionFlowControlWindowForTest, value);
115 }
116
TEST_P(QuicConfigTest,ProcessClientHello)117 TEST_P(QuicConfigTest, ProcessClientHello) {
118 if (version_.UsesTls()) {
119 // CryptoHandshakeMessage is only used for QUIC_CRYPTO.
120 return;
121 }
122 const uint32_t kTestMaxAckDelayMs =
123 static_cast<uint32_t>(kDefaultDelayedAckTimeMs + 1);
124 QuicConfig client_config;
125 QuicTagVector cgst;
126 cgst.push_back(kQBIC);
127 client_config.SetIdleNetworkTimeout(
128 QuicTime::Delta::FromSeconds(2 * kMaximumIdleTimeoutSecs));
129 client_config.SetInitialRoundTripTimeUsToSend(10 * kNumMicrosPerMilli);
130 client_config.SetInitialStreamFlowControlWindowToSend(
131 2 * kInitialStreamFlowControlWindowForTest);
132 client_config.SetInitialSessionFlowControlWindowToSend(
133 2 * kInitialSessionFlowControlWindowForTest);
134 QuicTagVector copt;
135 copt.push_back(kTBBR);
136 client_config.SetConnectionOptionsToSend(copt);
137 client_config.SetMaxAckDelayToSendMs(kTestMaxAckDelayMs);
138 CryptoHandshakeMessage msg;
139 client_config.ToHandshakeMessage(&msg, version_.transport_version);
140
141 std::string error_details;
142 QuicTagVector initial_received_options;
143 initial_received_options.push_back(kIW50);
144 EXPECT_TRUE(
145 config_.SetInitialReceivedConnectionOptions(initial_received_options));
146 EXPECT_FALSE(
147 config_.SetInitialReceivedConnectionOptions(initial_received_options))
148 << "You can only set initial options once.";
149 const QuicErrorCode error =
150 config_.ProcessPeerHello(msg, CLIENT, &error_details);
151 EXPECT_FALSE(
152 config_.SetInitialReceivedConnectionOptions(initial_received_options))
153 << "You cannot set initial options after the hello.";
154 EXPECT_THAT(error, IsQuicNoError());
155 EXPECT_TRUE(config_.negotiated());
156 EXPECT_EQ(QuicTime::Delta::FromSeconds(kMaximumIdleTimeoutSecs),
157 config_.IdleNetworkTimeout());
158 EXPECT_EQ(10 * kNumMicrosPerMilli, config_.ReceivedInitialRoundTripTimeUs());
159 EXPECT_TRUE(config_.HasReceivedConnectionOptions());
160 EXPECT_EQ(2u, config_.ReceivedConnectionOptions().size());
161 EXPECT_EQ(config_.ReceivedConnectionOptions()[0], kIW50);
162 EXPECT_EQ(config_.ReceivedConnectionOptions()[1], kTBBR);
163 EXPECT_EQ(config_.ReceivedInitialStreamFlowControlWindowBytes(),
164 2 * kInitialStreamFlowControlWindowForTest);
165 EXPECT_EQ(config_.ReceivedInitialSessionFlowControlWindowBytes(),
166 2 * kInitialSessionFlowControlWindowForTest);
167 EXPECT_TRUE(config_.HasReceivedMaxAckDelayMs());
168 EXPECT_EQ(kTestMaxAckDelayMs, config_.ReceivedMaxAckDelayMs());
169
170 // IETF QUIC stream limits should not be received in QUIC crypto messages.
171 EXPECT_FALSE(
172 config_.HasReceivedInitialMaxStreamDataBytesIncomingBidirectional());
173 EXPECT_FALSE(
174 config_.HasReceivedInitialMaxStreamDataBytesOutgoingBidirectional());
175 EXPECT_FALSE(config_.HasReceivedInitialMaxStreamDataBytesUnidirectional());
176 }
177
TEST_P(QuicConfigTest,ProcessServerHello)178 TEST_P(QuicConfigTest, ProcessServerHello) {
179 if (version_.UsesTls()) {
180 // CryptoHandshakeMessage is only used for QUIC_CRYPTO.
181 return;
182 }
183 QuicIpAddress host;
184 host.FromString("127.0.3.1");
185 const QuicSocketAddress kTestServerAddress = QuicSocketAddress(host, 1234);
186 const StatelessResetToken kTestStatelessResetToken{
187 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
188 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f};
189 const uint32_t kTestMaxAckDelayMs =
190 static_cast<uint32_t>(kDefaultDelayedAckTimeMs + 1);
191 QuicConfig server_config;
192 QuicTagVector cgst;
193 cgst.push_back(kQBIC);
194 server_config.SetIdleNetworkTimeout(
195 QuicTime::Delta::FromSeconds(kMaximumIdleTimeoutSecs / 2));
196 server_config.SetInitialRoundTripTimeUsToSend(10 * kNumMicrosPerMilli);
197 server_config.SetInitialStreamFlowControlWindowToSend(
198 2 * kInitialStreamFlowControlWindowForTest);
199 server_config.SetInitialSessionFlowControlWindowToSend(
200 2 * kInitialSessionFlowControlWindowForTest);
201 server_config.SetIPv4AlternateServerAddressToSend(kTestServerAddress);
202 server_config.SetStatelessResetTokenToSend(kTestStatelessResetToken);
203 server_config.SetMaxAckDelayToSendMs(kTestMaxAckDelayMs);
204 CryptoHandshakeMessage msg;
205 server_config.ToHandshakeMessage(&msg, version_.transport_version);
206 std::string error_details;
207 const QuicErrorCode error =
208 config_.ProcessPeerHello(msg, SERVER, &error_details);
209 EXPECT_THAT(error, IsQuicNoError());
210 EXPECT_TRUE(config_.negotiated());
211 EXPECT_EQ(QuicTime::Delta::FromSeconds(kMaximumIdleTimeoutSecs / 2),
212 config_.IdleNetworkTimeout());
213 EXPECT_EQ(10 * kNumMicrosPerMilli, config_.ReceivedInitialRoundTripTimeUs());
214 EXPECT_EQ(config_.ReceivedInitialStreamFlowControlWindowBytes(),
215 2 * kInitialStreamFlowControlWindowForTest);
216 EXPECT_EQ(config_.ReceivedInitialSessionFlowControlWindowBytes(),
217 2 * kInitialSessionFlowControlWindowForTest);
218 EXPECT_TRUE(config_.HasReceivedIPv4AlternateServerAddress());
219 EXPECT_EQ(kTestServerAddress, config_.ReceivedIPv4AlternateServerAddress());
220 EXPECT_FALSE(config_.HasReceivedIPv6AlternateServerAddress());
221 EXPECT_TRUE(config_.HasReceivedStatelessResetToken());
222 EXPECT_EQ(kTestStatelessResetToken, config_.ReceivedStatelessResetToken());
223 EXPECT_TRUE(config_.HasReceivedMaxAckDelayMs());
224 EXPECT_EQ(kTestMaxAckDelayMs, config_.ReceivedMaxAckDelayMs());
225
226 // IETF QUIC stream limits should not be received in QUIC crypto messages.
227 EXPECT_FALSE(
228 config_.HasReceivedInitialMaxStreamDataBytesIncomingBidirectional());
229 EXPECT_FALSE(
230 config_.HasReceivedInitialMaxStreamDataBytesOutgoingBidirectional());
231 EXPECT_FALSE(config_.HasReceivedInitialMaxStreamDataBytesUnidirectional());
232 }
233
TEST_P(QuicConfigTest,MissingOptionalValuesInCHLO)234 TEST_P(QuicConfigTest, MissingOptionalValuesInCHLO) {
235 if (version_.UsesTls()) {
236 // CryptoHandshakeMessage is only used for QUIC_CRYPTO.
237 return;
238 }
239 CryptoHandshakeMessage msg;
240 msg.SetValue(kICSL, 1);
241
242 // Set all REQUIRED tags.
243 msg.SetValue(kICSL, 1);
244 msg.SetValue(kMIBS, 1);
245
246 // No error, as rest are optional.
247 std::string error_details;
248 const QuicErrorCode error =
249 config_.ProcessPeerHello(msg, CLIENT, &error_details);
250 EXPECT_THAT(error, IsQuicNoError());
251 EXPECT_TRUE(config_.negotiated());
252 }
253
TEST_P(QuicConfigTest,MissingOptionalValuesInSHLO)254 TEST_P(QuicConfigTest, MissingOptionalValuesInSHLO) {
255 if (version_.UsesTls()) {
256 // CryptoHandshakeMessage is only used for QUIC_CRYPTO.
257 return;
258 }
259 CryptoHandshakeMessage msg;
260
261 // Set all REQUIRED tags.
262 msg.SetValue(kICSL, 1);
263 msg.SetValue(kMIBS, 1);
264
265 // No error, as rest are optional.
266 std::string error_details;
267 const QuicErrorCode error =
268 config_.ProcessPeerHello(msg, SERVER, &error_details);
269 EXPECT_THAT(error, IsQuicNoError());
270 EXPECT_TRUE(config_.negotiated());
271 }
272
TEST_P(QuicConfigTest,MissingValueInCHLO)273 TEST_P(QuicConfigTest, MissingValueInCHLO) {
274 if (version_.UsesTls()) {
275 // CryptoHandshakeMessage is only used for QUIC_CRYPTO.
276 return;
277 }
278 // Server receives CHLO with missing kICSL.
279 CryptoHandshakeMessage msg;
280 std::string error_details;
281 const QuicErrorCode error =
282 config_.ProcessPeerHello(msg, CLIENT, &error_details);
283 EXPECT_THAT(error, IsError(QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND));
284 }
285
TEST_P(QuicConfigTest,MissingValueInSHLO)286 TEST_P(QuicConfigTest, MissingValueInSHLO) {
287 if (version_.UsesTls()) {
288 // CryptoHandshakeMessage is only used for QUIC_CRYPTO.
289 return;
290 }
291 // Client receives SHLO with missing kICSL.
292 CryptoHandshakeMessage msg;
293 std::string error_details;
294 const QuicErrorCode error =
295 config_.ProcessPeerHello(msg, SERVER, &error_details);
296 EXPECT_THAT(error, IsError(QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND));
297 }
298
TEST_P(QuicConfigTest,OutOfBoundSHLO)299 TEST_P(QuicConfigTest, OutOfBoundSHLO) {
300 if (version_.UsesTls()) {
301 // CryptoHandshakeMessage is only used for QUIC_CRYPTO.
302 return;
303 }
304 QuicConfig server_config;
305 server_config.SetIdleNetworkTimeout(
306 QuicTime::Delta::FromSeconds(2 * kMaximumIdleTimeoutSecs));
307
308 CryptoHandshakeMessage msg;
309 server_config.ToHandshakeMessage(&msg, version_.transport_version);
310 std::string error_details;
311 const QuicErrorCode error =
312 config_.ProcessPeerHello(msg, SERVER, &error_details);
313 EXPECT_THAT(error, IsError(QUIC_INVALID_NEGOTIATED_VALUE));
314 }
315
TEST_P(QuicConfigTest,InvalidFlowControlWindow)316 TEST_P(QuicConfigTest, InvalidFlowControlWindow) {
317 // QuicConfig should not accept an invalid flow control window to send to the
318 // peer: the receive window must be at least the default of 16 Kb.
319 QuicConfig config;
320 const uint64_t kInvalidWindow = kMinimumFlowControlSendWindow - 1;
321 EXPECT_QUIC_BUG(
322 config.SetInitialStreamFlowControlWindowToSend(kInvalidWindow),
323 "Initial stream flow control receive window");
324
325 EXPECT_EQ(kMinimumFlowControlSendWindow,
326 config.GetInitialStreamFlowControlWindowToSend());
327 }
328
TEST_P(QuicConfigTest,HasClientSentConnectionOption)329 TEST_P(QuicConfigTest, HasClientSentConnectionOption) {
330 if (version_.UsesTls()) {
331 // CryptoHandshakeMessage is only used for QUIC_CRYPTO.
332 return;
333 }
334 QuicConfig client_config;
335 QuicTagVector copt;
336 copt.push_back(kTBBR);
337 client_config.SetConnectionOptionsToSend(copt);
338 EXPECT_TRUE(client_config.HasClientSentConnectionOption(
339 kTBBR, Perspective::IS_CLIENT));
340
341 CryptoHandshakeMessage msg;
342 client_config.ToHandshakeMessage(&msg, version_.transport_version);
343
344 std::string error_details;
345 const QuicErrorCode error =
346 config_.ProcessPeerHello(msg, CLIENT, &error_details);
347 EXPECT_THAT(error, IsQuicNoError());
348 EXPECT_TRUE(config_.negotiated());
349
350 EXPECT_TRUE(config_.HasReceivedConnectionOptions());
351 EXPECT_EQ(1u, config_.ReceivedConnectionOptions().size());
352 EXPECT_TRUE(
353 config_.HasClientSentConnectionOption(kTBBR, Perspective::IS_SERVER));
354 }
355
TEST_P(QuicConfigTest,DontSendClientConnectionOptions)356 TEST_P(QuicConfigTest, DontSendClientConnectionOptions) {
357 if (version_.UsesTls()) {
358 // CryptoHandshakeMessage is only used for QUIC_CRYPTO.
359 return;
360 }
361 QuicConfig client_config;
362 QuicTagVector copt;
363 copt.push_back(kTBBR);
364 client_config.SetClientConnectionOptions(copt);
365
366 CryptoHandshakeMessage msg;
367 client_config.ToHandshakeMessage(&msg, version_.transport_version);
368
369 std::string error_details;
370 const QuicErrorCode error =
371 config_.ProcessPeerHello(msg, CLIENT, &error_details);
372 EXPECT_THAT(error, IsQuicNoError());
373 EXPECT_TRUE(config_.negotiated());
374
375 EXPECT_FALSE(config_.HasReceivedConnectionOptions());
376 }
377
TEST_P(QuicConfigTest,HasClientRequestedIndependentOption)378 TEST_P(QuicConfigTest, HasClientRequestedIndependentOption) {
379 if (version_.UsesTls()) {
380 // CryptoHandshakeMessage is only used for QUIC_CRYPTO.
381 return;
382 }
383 QuicConfig client_config;
384 QuicTagVector client_opt;
385 client_opt.push_back(kRENO);
386 QuicTagVector copt;
387 copt.push_back(kTBBR);
388 client_config.SetClientConnectionOptions(client_opt);
389 client_config.SetConnectionOptionsToSend(copt);
390 EXPECT_TRUE(client_config.HasClientSentConnectionOption(
391 kTBBR, Perspective::IS_CLIENT));
392 EXPECT_TRUE(client_config.HasClientRequestedIndependentOption(
393 kRENO, Perspective::IS_CLIENT));
394 EXPECT_FALSE(client_config.HasClientRequestedIndependentOption(
395 kTBBR, Perspective::IS_CLIENT));
396
397 CryptoHandshakeMessage msg;
398 client_config.ToHandshakeMessage(&msg, version_.transport_version);
399
400 std::string error_details;
401 const QuicErrorCode error =
402 config_.ProcessPeerHello(msg, CLIENT, &error_details);
403 EXPECT_THAT(error, IsQuicNoError());
404 EXPECT_TRUE(config_.negotiated());
405
406 EXPECT_TRUE(config_.HasReceivedConnectionOptions());
407 EXPECT_EQ(1u, config_.ReceivedConnectionOptions().size());
408 EXPECT_FALSE(config_.HasClientRequestedIndependentOption(
409 kRENO, Perspective::IS_SERVER));
410 EXPECT_TRUE(config_.HasClientRequestedIndependentOption(
411 kTBBR, Perspective::IS_SERVER));
412 }
413
TEST_P(QuicConfigTest,IncomingLargeIdleTimeoutTransportParameter)414 TEST_P(QuicConfigTest, IncomingLargeIdleTimeoutTransportParameter) {
415 if (!version_.UsesTls()) {
416 // TransportParameters are only used for QUIC+TLS.
417 return;
418 }
419 // Configure our idle timeout to 60s, then receive 120s from peer.
420 // Since the received value is above ours, we should then use ours.
421 config_.SetIdleNetworkTimeout(quic::QuicTime::Delta::FromSeconds(60));
422 TransportParameters params;
423 params.max_idle_timeout_ms.set_value(120000);
424
425 std::string error_details = "foobar";
426 EXPECT_THAT(config_.ProcessTransportParameters(
427 params, /* is_resumption = */ false, &error_details),
428 IsQuicNoError());
429 EXPECT_EQ("", error_details);
430 EXPECT_EQ(quic::QuicTime::Delta::FromSeconds(60),
431 config_.IdleNetworkTimeout());
432 }
433
TEST_P(QuicConfigTest,ReceivedInvalidMinAckDelayInTransportParameter)434 TEST_P(QuicConfigTest, ReceivedInvalidMinAckDelayInTransportParameter) {
435 if (!version_.UsesTls()) {
436 // TransportParameters are only used for QUIC+TLS.
437 return;
438 }
439 TransportParameters params;
440
441 params.max_ack_delay.set_value(25 /*ms*/);
442 params.min_ack_delay_us.set_value(25 * kNumMicrosPerMilli + 1);
443 std::string error_details = "foobar";
444 EXPECT_THAT(config_.ProcessTransportParameters(
445 params, /* is_resumption = */ false, &error_details),
446 IsError(IETF_QUIC_PROTOCOL_VIOLATION));
447 EXPECT_EQ("MinAckDelay is greater than MaxAckDelay.", error_details);
448
449 params.max_ack_delay.set_value(25 /*ms*/);
450 params.min_ack_delay_us.set_value(25 * kNumMicrosPerMilli);
451 EXPECT_THAT(config_.ProcessTransportParameters(
452 params, /* is_resumption = */ false, &error_details),
453 IsQuicNoError());
454 EXPECT_TRUE(error_details.empty());
455 }
456
TEST_P(QuicConfigTest,FillTransportParams)457 TEST_P(QuicConfigTest, FillTransportParams) {
458 if (!version_.UsesTls()) {
459 // TransportParameters are only used for QUIC+TLS.
460 return;
461 }
462 const std::string kFakeGoogleHandshakeMessage = "Fake handshake message";
463 config_.SetInitialMaxStreamDataBytesIncomingBidirectionalToSend(
464 2 * kMinimumFlowControlSendWindow);
465 config_.SetInitialMaxStreamDataBytesOutgoingBidirectionalToSend(
466 3 * kMinimumFlowControlSendWindow);
467 config_.SetInitialMaxStreamDataBytesUnidirectionalToSend(
468 4 * kMinimumFlowControlSendWindow);
469 config_.SetMaxPacketSizeToSend(kMaxPacketSizeForTest);
470 config_.SetMaxDatagramFrameSizeToSend(kMaxDatagramFrameSizeForTest);
471 config_.SetActiveConnectionIdLimitToSend(kActiveConnectionIdLimitForTest);
472
473 config_.SetOriginalConnectionIdToSend(TestConnectionId(0x1111));
474 config_.SetInitialSourceConnectionIdToSend(TestConnectionId(0x2222));
475 config_.SetRetrySourceConnectionIdToSend(TestConnectionId(0x3333));
476 config_.SetMinAckDelayMs(kDefaultMinAckDelayTimeMs);
477 config_.SetGoogleHandshakeMessageToSend(kFakeGoogleHandshakeMessage);
478
479 QuicIpAddress host;
480 host.FromString("127.0.3.1");
481 QuicSocketAddress kTestServerAddress = QuicSocketAddress(host, 1234);
482 QuicConnectionId new_connection_id = TestConnectionId(5);
483 StatelessResetToken new_stateless_reset_token =
484 QuicUtils::GenerateStatelessResetToken(new_connection_id);
485 config_.SetIPv4AlternateServerAddressToSend(kTestServerAddress);
486 QuicSocketAddress kTestServerAddressV6 =
487 QuicSocketAddress(QuicIpAddress::Any6(), 1234);
488 config_.SetIPv6AlternateServerAddressToSend(kTestServerAddressV6);
489 config_.SetPreferredAddressConnectionIdAndTokenToSend(
490 new_connection_id, new_stateless_reset_token);
491 config_.ClearAlternateServerAddressToSend(quiche::IpAddressFamily::IP_V6);
492 EXPECT_TRUE(config_.GetPreferredAddressToSend(quiche::IpAddressFamily::IP_V4)
493 .has_value());
494 EXPECT_FALSE(config_.GetPreferredAddressToSend(quiche::IpAddressFamily::IP_V6)
495 .has_value());
496
497 TransportParameters params;
498 config_.FillTransportParameters(¶ms);
499
500 EXPECT_EQ(2 * kMinimumFlowControlSendWindow,
501 params.initial_max_stream_data_bidi_remote.value());
502 EXPECT_EQ(3 * kMinimumFlowControlSendWindow,
503 params.initial_max_stream_data_bidi_local.value());
504 EXPECT_EQ(4 * kMinimumFlowControlSendWindow,
505 params.initial_max_stream_data_uni.value());
506
507 EXPECT_EQ(static_cast<uint64_t>(kMaximumIdleTimeoutSecs * 1000),
508 params.max_idle_timeout_ms.value());
509
510 EXPECT_EQ(kMaxPacketSizeForTest, params.max_udp_payload_size.value());
511 EXPECT_EQ(kMaxDatagramFrameSizeForTest,
512 params.max_datagram_frame_size.value());
513 EXPECT_EQ(kActiveConnectionIdLimitForTest,
514 params.active_connection_id_limit.value());
515
516 ASSERT_TRUE(params.original_destination_connection_id.has_value());
517 EXPECT_EQ(TestConnectionId(0x1111),
518 params.original_destination_connection_id.value());
519 ASSERT_TRUE(params.initial_source_connection_id.has_value());
520 EXPECT_EQ(TestConnectionId(0x2222),
521 params.initial_source_connection_id.value());
522 ASSERT_TRUE(params.retry_source_connection_id.has_value());
523 EXPECT_EQ(TestConnectionId(0x3333),
524 params.retry_source_connection_id.value());
525
526 EXPECT_EQ(
527 static_cast<uint64_t>(kDefaultMinAckDelayTimeMs) * kNumMicrosPerMilli,
528 params.min_ack_delay_us.value());
529
530 EXPECT_EQ(params.preferred_address->ipv4_socket_address, kTestServerAddress);
531 EXPECT_EQ(params.preferred_address->ipv6_socket_address,
532 QuicSocketAddress(QuicIpAddress::Any6(), 0));
533
534 EXPECT_EQ(*reinterpret_cast<StatelessResetToken*>(
535 ¶ms.preferred_address->stateless_reset_token.front()),
536 new_stateless_reset_token);
537 EXPECT_EQ(kFakeGoogleHandshakeMessage, params.google_handshake_message);
538 }
539
TEST_P(QuicConfigTest,DNATPreferredAddress)540 TEST_P(QuicConfigTest, DNATPreferredAddress) {
541 QuicIpAddress host_v4;
542 host_v4.FromString("127.0.3.1");
543 QuicSocketAddress server_address_v4 = QuicSocketAddress(host_v4, 1234);
544 QuicSocketAddress expected_server_address_v4 =
545 QuicSocketAddress(host_v4, 1235);
546
547 QuicIpAddress host_v6;
548 host_v6.FromString("2001:db8:0::1");
549 QuicSocketAddress server_address_v6 = QuicSocketAddress(host_v6, 1234);
550 QuicSocketAddress expected_server_address_v6 =
551 QuicSocketAddress(host_v6, 1235);
552
553 config_.SetIPv4AlternateServerAddressForDNat(server_address_v4,
554 expected_server_address_v4);
555 config_.SetIPv6AlternateServerAddressForDNat(server_address_v6,
556 expected_server_address_v6);
557
558 EXPECT_EQ(server_address_v4,
559 config_.GetPreferredAddressToSend(quiche::IpAddressFamily::IP_V4));
560 EXPECT_EQ(server_address_v6,
561 config_.GetPreferredAddressToSend(quiche::IpAddressFamily::IP_V6));
562
563 EXPECT_EQ(expected_server_address_v4,
564 config_.GetMappedAlternativeServerAddress(
565 quiche::IpAddressFamily::IP_V4));
566 EXPECT_EQ(expected_server_address_v6,
567 config_.GetMappedAlternativeServerAddress(
568 quiche::IpAddressFamily::IP_V6));
569 }
570
TEST_P(QuicConfigTest,FillTransportParamsNoV4PreferredAddress)571 TEST_P(QuicConfigTest, FillTransportParamsNoV4PreferredAddress) {
572 if (!version_.UsesTls()) {
573 // TransportParameters are only used for QUIC+TLS.
574 return;
575 }
576
577 QuicIpAddress host;
578 host.FromString("127.0.3.1");
579 QuicSocketAddress kTestServerAddress = QuicSocketAddress(host, 1234);
580 QuicConnectionId new_connection_id = TestConnectionId(5);
581 StatelessResetToken new_stateless_reset_token =
582 QuicUtils::GenerateStatelessResetToken(new_connection_id);
583 config_.SetIPv4AlternateServerAddressToSend(kTestServerAddress);
584 QuicSocketAddress kTestServerAddressV6 =
585 QuicSocketAddress(QuicIpAddress::Any6(), 1234);
586 config_.SetIPv6AlternateServerAddressToSend(kTestServerAddressV6);
587 config_.SetPreferredAddressConnectionIdAndTokenToSend(
588 new_connection_id, new_stateless_reset_token);
589 config_.ClearAlternateServerAddressToSend(quiche::IpAddressFamily::IP_V4);
590 EXPECT_FALSE(config_.GetPreferredAddressToSend(quiche::IpAddressFamily::IP_V4)
591 .has_value());
592 config_.ClearAlternateServerAddressToSend(quiche::IpAddressFamily::IP_V4);
593
594 TransportParameters params;
595 config_.FillTransportParameters(¶ms);
596 EXPECT_EQ(params.preferred_address->ipv4_socket_address,
597 QuicSocketAddress(QuicIpAddress::Any4(), 0));
598 EXPECT_EQ(params.preferred_address->ipv6_socket_address,
599 kTestServerAddressV6);
600 }
601
TEST_P(QuicConfigTest,SupportsServerPreferredAddress)602 TEST_P(QuicConfigTest, SupportsServerPreferredAddress) {
603 SetQuicFlag(quic_always_support_server_preferred_address, true);
604 EXPECT_TRUE(config_.SupportsServerPreferredAddress(Perspective::IS_CLIENT));
605 EXPECT_TRUE(config_.SupportsServerPreferredAddress(Perspective::IS_SERVER));
606
607 SetQuicFlag(quic_always_support_server_preferred_address, false);
608 EXPECT_FALSE(config_.SupportsServerPreferredAddress(Perspective::IS_CLIENT));
609 EXPECT_FALSE(config_.SupportsServerPreferredAddress(Perspective::IS_SERVER));
610
611 QuicTagVector copt;
612 copt.push_back(kSPAD);
613 config_.SetConnectionOptionsToSend(copt);
614 EXPECT_TRUE(config_.SupportsServerPreferredAddress(Perspective::IS_CLIENT));
615 EXPECT_FALSE(config_.SupportsServerPreferredAddress(Perspective::IS_SERVER));
616
617 config_.SetInitialReceivedConnectionOptions(copt);
618 EXPECT_TRUE(config_.SupportsServerPreferredAddress(Perspective::IS_CLIENT));
619 EXPECT_TRUE(config_.SupportsServerPreferredAddress(Perspective::IS_SERVER));
620 }
621
TEST_P(QuicConfigTest,ProcessTransportParametersServer)622 TEST_P(QuicConfigTest, ProcessTransportParametersServer) {
623 if (!version_.UsesTls()) {
624 // TransportParameters are only used for QUIC+TLS.
625 return;
626 }
627 const std::string kFakeGoogleHandshakeMessage = "Fake handshake message";
628 TransportParameters params;
629
630 params.initial_max_stream_data_bidi_local.set_value(
631 2 * kMinimumFlowControlSendWindow);
632 params.initial_max_stream_data_bidi_remote.set_value(
633 3 * kMinimumFlowControlSendWindow);
634 params.initial_max_stream_data_uni.set_value(4 *
635 kMinimumFlowControlSendWindow);
636 params.max_udp_payload_size.set_value(kMaxPacketSizeForTest);
637 params.max_datagram_frame_size.set_value(kMaxDatagramFrameSizeForTest);
638 params.initial_max_streams_bidi.set_value(kDefaultMaxStreamsPerConnection);
639 params.stateless_reset_token = CreateStatelessResetTokenForTest();
640 params.max_ack_delay.set_value(kMaxAckDelayForTest);
641 params.min_ack_delay_us.set_value(kMinAckDelayUsForTest);
642 params.ack_delay_exponent.set_value(kAckDelayExponentForTest);
643 params.active_connection_id_limit.set_value(kActiveConnectionIdLimitForTest);
644 params.original_destination_connection_id = TestConnectionId(0x1111);
645 params.initial_source_connection_id = TestConnectionId(0x2222);
646 params.retry_source_connection_id = TestConnectionId(0x3333);
647 params.google_handshake_message = kFakeGoogleHandshakeMessage;
648
649 std::string error_details;
650 EXPECT_THAT(config_.ProcessTransportParameters(
651 params, /* is_resumption = */ true, &error_details),
652 IsQuicNoError())
653 << error_details;
654
655 EXPECT_FALSE(config_.negotiated());
656
657 ASSERT_TRUE(
658 config_.HasReceivedInitialMaxStreamDataBytesIncomingBidirectional());
659 EXPECT_EQ(2 * kMinimumFlowControlSendWindow,
660 config_.ReceivedInitialMaxStreamDataBytesIncomingBidirectional());
661
662 ASSERT_TRUE(
663 config_.HasReceivedInitialMaxStreamDataBytesOutgoingBidirectional());
664 EXPECT_EQ(3 * kMinimumFlowControlSendWindow,
665 config_.ReceivedInitialMaxStreamDataBytesOutgoingBidirectional());
666
667 ASSERT_TRUE(config_.HasReceivedInitialMaxStreamDataBytesUnidirectional());
668 EXPECT_EQ(4 * kMinimumFlowControlSendWindow,
669 config_.ReceivedInitialMaxStreamDataBytesUnidirectional());
670
671 ASSERT_TRUE(config_.HasReceivedMaxPacketSize());
672 EXPECT_EQ(kMaxPacketSizeForTest, config_.ReceivedMaxPacketSize());
673
674 ASSERT_TRUE(config_.HasReceivedMaxDatagramFrameSize());
675 EXPECT_EQ(kMaxDatagramFrameSizeForTest,
676 config_.ReceivedMaxDatagramFrameSize());
677
678 ASSERT_TRUE(config_.HasReceivedMaxBidirectionalStreams());
679 EXPECT_EQ(kDefaultMaxStreamsPerConnection,
680 config_.ReceivedMaxBidirectionalStreams());
681
682 EXPECT_FALSE(config_.DisableConnectionMigration());
683
684 // The following config shouldn't be processed because of resumption.
685 EXPECT_FALSE(config_.HasReceivedStatelessResetToken());
686 EXPECT_FALSE(config_.HasReceivedMaxAckDelayMs());
687 EXPECT_FALSE(config_.HasReceivedAckDelayExponent());
688 EXPECT_FALSE(config_.HasReceivedMinAckDelayMs());
689 EXPECT_FALSE(config_.HasReceivedOriginalConnectionId());
690 EXPECT_FALSE(config_.HasReceivedInitialSourceConnectionId());
691 EXPECT_FALSE(config_.HasReceivedRetrySourceConnectionId());
692
693 // Let the config process another slightly tweaked transport paramters.
694 // Note that the values for flow control and stream limit cannot be smaller
695 // than before. This rule is enforced in QuicSession::OnConfigNegotiated().
696 params.initial_max_stream_data_bidi_local.set_value(
697 2 * kMinimumFlowControlSendWindow + 1);
698 params.initial_max_stream_data_bidi_remote.set_value(
699 4 * kMinimumFlowControlSendWindow);
700 params.initial_max_stream_data_uni.set_value(5 *
701 kMinimumFlowControlSendWindow);
702 params.max_udp_payload_size.set_value(2 * kMaxPacketSizeForTest);
703 params.max_datagram_frame_size.set_value(2 * kMaxDatagramFrameSizeForTest);
704 params.initial_max_streams_bidi.set_value(2 *
705 kDefaultMaxStreamsPerConnection);
706 params.disable_active_migration = true;
707
708 EXPECT_THAT(config_.ProcessTransportParameters(
709 params, /* is_resumption = */ false, &error_details),
710 IsQuicNoError())
711 << error_details;
712
713 EXPECT_TRUE(config_.negotiated());
714
715 ASSERT_TRUE(
716 config_.HasReceivedInitialMaxStreamDataBytesIncomingBidirectional());
717 EXPECT_EQ(2 * kMinimumFlowControlSendWindow + 1,
718 config_.ReceivedInitialMaxStreamDataBytesIncomingBidirectional());
719
720 ASSERT_TRUE(
721 config_.HasReceivedInitialMaxStreamDataBytesOutgoingBidirectional());
722 EXPECT_EQ(4 * kMinimumFlowControlSendWindow,
723 config_.ReceivedInitialMaxStreamDataBytesOutgoingBidirectional());
724
725 ASSERT_TRUE(config_.HasReceivedInitialMaxStreamDataBytesUnidirectional());
726 EXPECT_EQ(5 * kMinimumFlowControlSendWindow,
727 config_.ReceivedInitialMaxStreamDataBytesUnidirectional());
728
729 ASSERT_TRUE(config_.HasReceivedMaxPacketSize());
730 EXPECT_EQ(2 * kMaxPacketSizeForTest, config_.ReceivedMaxPacketSize());
731
732 ASSERT_TRUE(config_.HasReceivedMaxDatagramFrameSize());
733 EXPECT_EQ(2 * kMaxDatagramFrameSizeForTest,
734 config_.ReceivedMaxDatagramFrameSize());
735
736 ASSERT_TRUE(config_.HasReceivedMaxBidirectionalStreams());
737 EXPECT_EQ(2 * kDefaultMaxStreamsPerConnection,
738 config_.ReceivedMaxBidirectionalStreams());
739
740 EXPECT_TRUE(config_.DisableConnectionMigration());
741
742 ASSERT_TRUE(config_.HasReceivedStatelessResetToken());
743
744 ASSERT_TRUE(config_.HasReceivedMaxAckDelayMs());
745 EXPECT_EQ(config_.ReceivedMaxAckDelayMs(), kMaxAckDelayForTest);
746
747 ASSERT_TRUE(config_.HasReceivedMinAckDelayMs());
748 EXPECT_EQ(config_.ReceivedMinAckDelayMs(),
749 kMinAckDelayUsForTest / kNumMicrosPerMilli);
750
751 ASSERT_TRUE(config_.HasReceivedAckDelayExponent());
752 EXPECT_EQ(config_.ReceivedAckDelayExponent(), kAckDelayExponentForTest);
753
754 ASSERT_TRUE(config_.HasReceivedActiveConnectionIdLimit());
755 EXPECT_EQ(config_.ReceivedActiveConnectionIdLimit(),
756 kActiveConnectionIdLimitForTest);
757
758 ASSERT_TRUE(config_.HasReceivedOriginalConnectionId());
759 EXPECT_EQ(config_.ReceivedOriginalConnectionId(), TestConnectionId(0x1111));
760 ASSERT_TRUE(config_.HasReceivedInitialSourceConnectionId());
761 EXPECT_EQ(config_.ReceivedInitialSourceConnectionId(),
762 TestConnectionId(0x2222));
763 ASSERT_TRUE(config_.HasReceivedRetrySourceConnectionId());
764 EXPECT_EQ(config_.ReceivedRetrySourceConnectionId(),
765 TestConnectionId(0x3333));
766 EXPECT_EQ(kFakeGoogleHandshakeMessage,
767 config_.GetReceivedGoogleHandshakeMessage());
768 }
769
TEST_P(QuicConfigTest,DisableMigrationTransportParameter)770 TEST_P(QuicConfigTest, DisableMigrationTransportParameter) {
771 if (!version_.UsesTls()) {
772 // TransportParameters are only used for QUIC+TLS.
773 return;
774 }
775 TransportParameters params;
776 params.disable_active_migration = true;
777 std::string error_details;
778 EXPECT_THAT(config_.ProcessTransportParameters(
779 params, /* is_resumption = */ false, &error_details),
780 IsQuicNoError());
781 EXPECT_TRUE(config_.DisableConnectionMigration());
782 }
783
TEST_P(QuicConfigTest,SendPreferredIPv4Address)784 TEST_P(QuicConfigTest, SendPreferredIPv4Address) {
785 if (!version_.UsesTls()) {
786 // TransportParameters are only used for QUIC+TLS.
787 return;
788 }
789
790 EXPECT_FALSE(config_.HasReceivedPreferredAddressConnectionIdAndToken());
791
792 TransportParameters params;
793 QuicIpAddress host;
794 host.FromString("::ffff:192.0.2.128");
795 QuicSocketAddress kTestServerAddress = QuicSocketAddress(host, 1234);
796 QuicConnectionId new_connection_id = TestConnectionId(5);
797 StatelessResetToken new_stateless_reset_token =
798 QuicUtils::GenerateStatelessResetToken(new_connection_id);
799 auto preferred_address =
800 std::make_unique<TransportParameters::PreferredAddress>();
801 preferred_address->ipv6_socket_address = kTestServerAddress;
802 preferred_address->connection_id = new_connection_id;
803 preferred_address->stateless_reset_token.assign(
804 reinterpret_cast<const char*>(&new_stateless_reset_token),
805 reinterpret_cast<const char*>(&new_stateless_reset_token) +
806 sizeof(new_stateless_reset_token));
807 params.preferred_address = std::move(preferred_address);
808
809 std::string error_details;
810 EXPECT_THAT(config_.ProcessTransportParameters(
811 params, /* is_resumption = */ false, &error_details),
812 IsQuicNoError());
813
814 EXPECT_TRUE(config_.HasReceivedIPv6AlternateServerAddress());
815 EXPECT_EQ(config_.ReceivedIPv6AlternateServerAddress(), kTestServerAddress);
816 EXPECT_TRUE(config_.HasReceivedPreferredAddressConnectionIdAndToken());
817 const std::pair<QuicConnectionId, StatelessResetToken>&
818 preferred_address_connection_id_and_token =
819 config_.ReceivedPreferredAddressConnectionIdAndToken();
820 EXPECT_EQ(preferred_address_connection_id_and_token.first, new_connection_id);
821 EXPECT_EQ(preferred_address_connection_id_and_token.second,
822 new_stateless_reset_token);
823 }
824
825 } // namespace
826 } // namespace test
827 } // namespace quic
828