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,FillTransportParamsNoV4PreferredAddress)540 TEST_P(QuicConfigTest, FillTransportParamsNoV4PreferredAddress) {
541 if (!version_.UsesTls()) {
542 // TransportParameters are only used for QUIC+TLS.
543 return;
544 }
545
546 QuicIpAddress host;
547 host.FromString("127.0.3.1");
548 QuicSocketAddress kTestServerAddress = QuicSocketAddress(host, 1234);
549 QuicConnectionId new_connection_id = TestConnectionId(5);
550 StatelessResetToken new_stateless_reset_token =
551 QuicUtils::GenerateStatelessResetToken(new_connection_id);
552 config_.SetIPv4AlternateServerAddressToSend(kTestServerAddress);
553 QuicSocketAddress kTestServerAddressV6 =
554 QuicSocketAddress(QuicIpAddress::Any6(), 1234);
555 config_.SetIPv6AlternateServerAddressToSend(kTestServerAddressV6);
556 config_.SetPreferredAddressConnectionIdAndTokenToSend(
557 new_connection_id, new_stateless_reset_token);
558 config_.ClearAlternateServerAddressToSend(quiche::IpAddressFamily::IP_V4);
559 EXPECT_FALSE(config_.GetPreferredAddressToSend(quiche::IpAddressFamily::IP_V4)
560 .has_value());
561 config_.ClearAlternateServerAddressToSend(quiche::IpAddressFamily::IP_V4);
562
563 TransportParameters params;
564 config_.FillTransportParameters(¶ms);
565 EXPECT_EQ(params.preferred_address->ipv4_socket_address,
566 QuicSocketAddress(QuicIpAddress::Any4(), 0));
567 EXPECT_EQ(params.preferred_address->ipv6_socket_address,
568 kTestServerAddressV6);
569 }
570
TEST_P(QuicConfigTest,ProcessTransportParametersServer)571 TEST_P(QuicConfigTest, ProcessTransportParametersServer) {
572 if (!version_.UsesTls()) {
573 // TransportParameters are only used for QUIC+TLS.
574 return;
575 }
576 const std::string kFakeGoogleHandshakeMessage = "Fake handshake message";
577 TransportParameters params;
578
579 params.initial_max_stream_data_bidi_local.set_value(
580 2 * kMinimumFlowControlSendWindow);
581 params.initial_max_stream_data_bidi_remote.set_value(
582 3 * kMinimumFlowControlSendWindow);
583 params.initial_max_stream_data_uni.set_value(4 *
584 kMinimumFlowControlSendWindow);
585 params.max_udp_payload_size.set_value(kMaxPacketSizeForTest);
586 params.max_datagram_frame_size.set_value(kMaxDatagramFrameSizeForTest);
587 params.initial_max_streams_bidi.set_value(kDefaultMaxStreamsPerConnection);
588 params.stateless_reset_token = CreateStatelessResetTokenForTest();
589 params.max_ack_delay.set_value(kMaxAckDelayForTest);
590 params.min_ack_delay_us.set_value(kMinAckDelayUsForTest);
591 params.ack_delay_exponent.set_value(kAckDelayExponentForTest);
592 params.active_connection_id_limit.set_value(kActiveConnectionIdLimitForTest);
593 params.original_destination_connection_id = TestConnectionId(0x1111);
594 params.initial_source_connection_id = TestConnectionId(0x2222);
595 params.retry_source_connection_id = TestConnectionId(0x3333);
596 params.google_handshake_message = kFakeGoogleHandshakeMessage;
597
598 std::string error_details;
599 EXPECT_THAT(config_.ProcessTransportParameters(
600 params, /* is_resumption = */ true, &error_details),
601 IsQuicNoError())
602 << error_details;
603
604 EXPECT_FALSE(config_.negotiated());
605
606 ASSERT_TRUE(
607 config_.HasReceivedInitialMaxStreamDataBytesIncomingBidirectional());
608 EXPECT_EQ(2 * kMinimumFlowControlSendWindow,
609 config_.ReceivedInitialMaxStreamDataBytesIncomingBidirectional());
610
611 ASSERT_TRUE(
612 config_.HasReceivedInitialMaxStreamDataBytesOutgoingBidirectional());
613 EXPECT_EQ(3 * kMinimumFlowControlSendWindow,
614 config_.ReceivedInitialMaxStreamDataBytesOutgoingBidirectional());
615
616 ASSERT_TRUE(config_.HasReceivedInitialMaxStreamDataBytesUnidirectional());
617 EXPECT_EQ(4 * kMinimumFlowControlSendWindow,
618 config_.ReceivedInitialMaxStreamDataBytesUnidirectional());
619
620 ASSERT_TRUE(config_.HasReceivedMaxPacketSize());
621 EXPECT_EQ(kMaxPacketSizeForTest, config_.ReceivedMaxPacketSize());
622
623 ASSERT_TRUE(config_.HasReceivedMaxDatagramFrameSize());
624 EXPECT_EQ(kMaxDatagramFrameSizeForTest,
625 config_.ReceivedMaxDatagramFrameSize());
626
627 ASSERT_TRUE(config_.HasReceivedMaxBidirectionalStreams());
628 EXPECT_EQ(kDefaultMaxStreamsPerConnection,
629 config_.ReceivedMaxBidirectionalStreams());
630
631 EXPECT_FALSE(config_.DisableConnectionMigration());
632
633 // The following config shouldn't be processed because of resumption.
634 EXPECT_FALSE(config_.HasReceivedStatelessResetToken());
635 EXPECT_FALSE(config_.HasReceivedMaxAckDelayMs());
636 EXPECT_FALSE(config_.HasReceivedAckDelayExponent());
637 EXPECT_FALSE(config_.HasReceivedMinAckDelayMs());
638 EXPECT_FALSE(config_.HasReceivedOriginalConnectionId());
639 EXPECT_FALSE(config_.HasReceivedInitialSourceConnectionId());
640 EXPECT_FALSE(config_.HasReceivedRetrySourceConnectionId());
641
642 // Let the config process another slightly tweaked transport paramters.
643 // Note that the values for flow control and stream limit cannot be smaller
644 // than before. This rule is enforced in QuicSession::OnConfigNegotiated().
645 params.initial_max_stream_data_bidi_local.set_value(
646 2 * kMinimumFlowControlSendWindow + 1);
647 params.initial_max_stream_data_bidi_remote.set_value(
648 4 * kMinimumFlowControlSendWindow);
649 params.initial_max_stream_data_uni.set_value(5 *
650 kMinimumFlowControlSendWindow);
651 params.max_udp_payload_size.set_value(2 * kMaxPacketSizeForTest);
652 params.max_datagram_frame_size.set_value(2 * kMaxDatagramFrameSizeForTest);
653 params.initial_max_streams_bidi.set_value(2 *
654 kDefaultMaxStreamsPerConnection);
655 params.disable_active_migration = true;
656
657 EXPECT_THAT(config_.ProcessTransportParameters(
658 params, /* is_resumption = */ false, &error_details),
659 IsQuicNoError())
660 << error_details;
661
662 EXPECT_TRUE(config_.negotiated());
663
664 ASSERT_TRUE(
665 config_.HasReceivedInitialMaxStreamDataBytesIncomingBidirectional());
666 EXPECT_EQ(2 * kMinimumFlowControlSendWindow + 1,
667 config_.ReceivedInitialMaxStreamDataBytesIncomingBidirectional());
668
669 ASSERT_TRUE(
670 config_.HasReceivedInitialMaxStreamDataBytesOutgoingBidirectional());
671 EXPECT_EQ(4 * kMinimumFlowControlSendWindow,
672 config_.ReceivedInitialMaxStreamDataBytesOutgoingBidirectional());
673
674 ASSERT_TRUE(config_.HasReceivedInitialMaxStreamDataBytesUnidirectional());
675 EXPECT_EQ(5 * kMinimumFlowControlSendWindow,
676 config_.ReceivedInitialMaxStreamDataBytesUnidirectional());
677
678 ASSERT_TRUE(config_.HasReceivedMaxPacketSize());
679 EXPECT_EQ(2 * kMaxPacketSizeForTest, config_.ReceivedMaxPacketSize());
680
681 ASSERT_TRUE(config_.HasReceivedMaxDatagramFrameSize());
682 EXPECT_EQ(2 * kMaxDatagramFrameSizeForTest,
683 config_.ReceivedMaxDatagramFrameSize());
684
685 ASSERT_TRUE(config_.HasReceivedMaxBidirectionalStreams());
686 EXPECT_EQ(2 * kDefaultMaxStreamsPerConnection,
687 config_.ReceivedMaxBidirectionalStreams());
688
689 EXPECT_TRUE(config_.DisableConnectionMigration());
690
691 ASSERT_TRUE(config_.HasReceivedStatelessResetToken());
692
693 ASSERT_TRUE(config_.HasReceivedMaxAckDelayMs());
694 EXPECT_EQ(config_.ReceivedMaxAckDelayMs(), kMaxAckDelayForTest);
695
696 ASSERT_TRUE(config_.HasReceivedMinAckDelayMs());
697 EXPECT_EQ(config_.ReceivedMinAckDelayMs(),
698 kMinAckDelayUsForTest / kNumMicrosPerMilli);
699
700 ASSERT_TRUE(config_.HasReceivedAckDelayExponent());
701 EXPECT_EQ(config_.ReceivedAckDelayExponent(), kAckDelayExponentForTest);
702
703 ASSERT_TRUE(config_.HasReceivedActiveConnectionIdLimit());
704 EXPECT_EQ(config_.ReceivedActiveConnectionIdLimit(),
705 kActiveConnectionIdLimitForTest);
706
707 ASSERT_TRUE(config_.HasReceivedOriginalConnectionId());
708 EXPECT_EQ(config_.ReceivedOriginalConnectionId(), TestConnectionId(0x1111));
709 ASSERT_TRUE(config_.HasReceivedInitialSourceConnectionId());
710 EXPECT_EQ(config_.ReceivedInitialSourceConnectionId(),
711 TestConnectionId(0x2222));
712 ASSERT_TRUE(config_.HasReceivedRetrySourceConnectionId());
713 EXPECT_EQ(config_.ReceivedRetrySourceConnectionId(),
714 TestConnectionId(0x3333));
715 EXPECT_EQ(kFakeGoogleHandshakeMessage,
716 config_.GetReceivedGoogleHandshakeMessage());
717 }
718
TEST_P(QuicConfigTest,DisableMigrationTransportParameter)719 TEST_P(QuicConfigTest, DisableMigrationTransportParameter) {
720 if (!version_.UsesTls()) {
721 // TransportParameters are only used for QUIC+TLS.
722 return;
723 }
724 TransportParameters params;
725 params.disable_active_migration = true;
726 std::string error_details;
727 EXPECT_THAT(config_.ProcessTransportParameters(
728 params, /* is_resumption = */ false, &error_details),
729 IsQuicNoError());
730 EXPECT_TRUE(config_.DisableConnectionMigration());
731 }
732
TEST_P(QuicConfigTest,SendPreferredIPv4Address)733 TEST_P(QuicConfigTest, SendPreferredIPv4Address) {
734 if (!version_.UsesTls()) {
735 // TransportParameters are only used for QUIC+TLS.
736 return;
737 }
738
739 EXPECT_FALSE(config_.HasReceivedPreferredAddressConnectionIdAndToken());
740
741 TransportParameters params;
742 QuicIpAddress host;
743 host.FromString("::ffff:192.0.2.128");
744 QuicSocketAddress kTestServerAddress = QuicSocketAddress(host, 1234);
745 QuicConnectionId new_connection_id = TestConnectionId(5);
746 StatelessResetToken new_stateless_reset_token =
747 QuicUtils::GenerateStatelessResetToken(new_connection_id);
748 auto preferred_address =
749 std::make_unique<TransportParameters::PreferredAddress>();
750 preferred_address->ipv6_socket_address = kTestServerAddress;
751 preferred_address->connection_id = new_connection_id;
752 preferred_address->stateless_reset_token.assign(
753 reinterpret_cast<const char*>(&new_stateless_reset_token),
754 reinterpret_cast<const char*>(&new_stateless_reset_token) +
755 sizeof(new_stateless_reset_token));
756 params.preferred_address = std::move(preferred_address);
757
758 std::string error_details;
759 EXPECT_THAT(config_.ProcessTransportParameters(
760 params, /* is_resumption = */ false, &error_details),
761 IsQuicNoError());
762
763 EXPECT_TRUE(config_.HasReceivedIPv6AlternateServerAddress());
764 EXPECT_EQ(config_.ReceivedIPv6AlternateServerAddress(), kTestServerAddress);
765 EXPECT_TRUE(config_.HasReceivedPreferredAddressConnectionIdAndToken());
766 const std::pair<QuicConnectionId, StatelessResetToken>&
767 preferred_address_connection_id_and_token =
768 config_.ReceivedPreferredAddressConnectionIdAndToken();
769 EXPECT_EQ(preferred_address_connection_id_and_token.first, new_connection_id);
770 EXPECT_EQ(preferred_address_connection_id_and_token.second,
771 new_stateless_reset_token);
772 }
773
774 } // namespace
775 } // namespace test
776 } // namespace quic
777