1 // Copyright (c) 2012 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 "net/quic/quic_stream_factory.h" 6 7 #include "base/run_loop.h" 8 #include "base/strings/string_util.h" 9 #include "net/base/test_data_directory.h" 10 #include "net/cert/cert_verifier.h" 11 #include "net/dns/mock_host_resolver.h" 12 #include "net/http/http_response_headers.h" 13 #include "net/http/http_response_info.h" 14 #include "net/http/http_util.h" 15 #include "net/http/transport_security_state.h" 16 #include "net/quic/crypto/crypto_handshake.h" 17 #include "net/quic/crypto/proof_verifier_chromium.h" 18 #include "net/quic/crypto/quic_decrypter.h" 19 #include "net/quic/crypto/quic_encrypter.h" 20 #include "net/quic/quic_http_stream.h" 21 #include "net/quic/quic_server_id.h" 22 #include "net/quic/test_tools/mock_clock.h" 23 #include "net/quic/test_tools/mock_crypto_client_stream_factory.h" 24 #include "net/quic/test_tools/mock_random.h" 25 #include "net/quic/test_tools/quic_test_packet_maker.h" 26 #include "net/quic/test_tools/quic_test_utils.h" 27 #include "net/socket/socket_test_util.h" 28 #include "net/test/cert_test_util.h" 29 #include "testing/gtest/include/gtest/gtest.h" 30 31 using base::StringPiece; 32 using std::string; 33 using std::vector; 34 35 namespace net { 36 namespace test { 37 38 namespace { 39 const char kDefaultServerHostName[] = "www.google.com"; 40 const int kDefaultServerPort = 443; 41 } // namespace anonymous 42 43 class QuicStreamFactoryPeer { 44 public: 45 static QuicCryptoClientConfig* GetCryptoConfig(QuicStreamFactory* factory) { 46 return &factory->crypto_config_; 47 } 48 49 static bool HasActiveSession(QuicStreamFactory* factory, 50 const HostPortPair& host_port_pair, 51 bool is_https) { 52 QuicServerId server_id(host_port_pair, is_https, PRIVACY_MODE_DISABLED); 53 return factory->HasActiveSession(server_id); 54 } 55 56 static QuicClientSession* GetActiveSession( 57 QuicStreamFactory* factory, 58 const HostPortPair& host_port_pair, 59 bool is_https) { 60 QuicServerId server_id(host_port_pair, is_https, PRIVACY_MODE_DISABLED); 61 DCHECK(factory->HasActiveSession(server_id)); 62 return factory->active_sessions_[server_id]; 63 } 64 65 static scoped_ptr<QuicHttpStream> CreateIfSessionExists( 66 QuicStreamFactory* factory, 67 const HostPortPair& host_port_pair, 68 bool is_https, 69 const BoundNetLog& net_log) { 70 QuicServerId server_id(host_port_pair, is_https, PRIVACY_MODE_DISABLED); 71 return factory->CreateIfSessionExists(server_id, net_log); 72 } 73 74 static bool IsLiveSession(QuicStreamFactory* factory, 75 QuicClientSession* session) { 76 for (QuicStreamFactory::SessionIdMap::iterator it = 77 factory->all_sessions_.begin(); 78 it != factory->all_sessions_.end(); ++it) { 79 if (it->first == session) 80 return true; 81 } 82 return false; 83 } 84 }; 85 86 class QuicStreamFactoryTest : public ::testing::TestWithParam<QuicVersion> { 87 protected: 88 QuicStreamFactoryTest() 89 : random_generator_(0), 90 maker_(GetParam(), 0), 91 clock_(new MockClock()), 92 cert_verifier_(CertVerifier::CreateDefault()), 93 factory_(&host_resolver_, &socket_factory_, 94 base::WeakPtr<HttpServerProperties>(), cert_verifier_.get(), 95 &transport_security_state_, 96 &crypto_client_stream_factory_, &random_generator_, clock_, 97 kDefaultMaxPacketSize, std::string(), 98 SupportedVersions(GetParam()), true, true, true), 99 host_port_pair_(kDefaultServerHostName, kDefaultServerPort), 100 is_https_(false), 101 privacy_mode_(PRIVACY_MODE_DISABLED) { 102 factory_.set_require_confirmation(false); 103 } 104 105 scoped_ptr<QuicHttpStream> CreateIfSessionExists( 106 const HostPortPair& host_port_pair, 107 const BoundNetLog& net_log) { 108 return QuicStreamFactoryPeer::CreateIfSessionExists( 109 &factory_, host_port_pair, false, net_log_); 110 } 111 112 int GetSourcePortForNewSession(const HostPortPair& destination) { 113 return GetSourcePortForNewSessionInner(destination, false); 114 } 115 116 int GetSourcePortForNewSessionAndGoAway( 117 const HostPortPair& destination) { 118 return GetSourcePortForNewSessionInner(destination, true); 119 } 120 121 int GetSourcePortForNewSessionInner(const HostPortPair& destination, 122 bool goaway_received) { 123 // Should only be called if there is no active session for this destination. 124 EXPECT_EQ(NULL, CreateIfSessionExists(destination, net_log_).get()); 125 size_t socket_count = socket_factory_.udp_client_sockets().size(); 126 127 MockRead reads[] = { 128 MockRead(ASYNC, OK, 0) // EOF 129 }; 130 DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0); 131 socket_data.StopAfter(1); 132 socket_factory_.AddSocketDataProvider(&socket_data); 133 134 QuicStreamRequest request(&factory_); 135 EXPECT_EQ(ERR_IO_PENDING, 136 request.Request(destination, 137 is_https_, 138 privacy_mode_, 139 "GET", 140 net_log_, 141 callback_.callback())); 142 143 EXPECT_EQ(OK, callback_.WaitForResult()); 144 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 145 EXPECT_TRUE(stream.get()); 146 stream.reset(); 147 148 QuicClientSession* session = QuicStreamFactoryPeer::GetActiveSession( 149 &factory_, destination, is_https_); 150 151 if (socket_count + 1 != socket_factory_.udp_client_sockets().size()) { 152 EXPECT_TRUE(false); 153 return 0; 154 } 155 156 IPEndPoint endpoint; 157 socket_factory_. 158 udp_client_sockets()[socket_count]->GetLocalAddress(&endpoint); 159 int port = endpoint.port(); 160 if (goaway_received) { 161 QuicGoAwayFrame goaway(QUIC_NO_ERROR, 1, ""); 162 session->OnGoAway(goaway); 163 } 164 165 factory_.OnSessionClosed(session); 166 EXPECT_EQ(NULL, CreateIfSessionExists(destination, net_log_).get()); 167 EXPECT_TRUE(socket_data.at_read_eof()); 168 EXPECT_TRUE(socket_data.at_write_eof()); 169 return port; 170 } 171 172 scoped_ptr<QuicEncryptedPacket> ConstructRstPacket() { 173 QuicStreamId stream_id = kClientDataStreamId1; 174 return maker_.MakeRstPacket( 175 1, true, stream_id, 176 AdjustErrorForVersion(QUIC_RST_FLOW_CONTROL_ACCOUNTING, GetParam())); 177 } 178 179 MockHostResolver host_resolver_; 180 DeterministicMockClientSocketFactory socket_factory_; 181 MockCryptoClientStreamFactory crypto_client_stream_factory_; 182 MockRandom random_generator_; 183 QuicTestPacketMaker maker_; 184 MockClock* clock_; // Owned by factory_. 185 scoped_ptr<CertVerifier> cert_verifier_; 186 TransportSecurityState transport_security_state_; 187 QuicStreamFactory factory_; 188 HostPortPair host_port_pair_; 189 bool is_https_; 190 PrivacyMode privacy_mode_; 191 BoundNetLog net_log_; 192 TestCompletionCallback callback_; 193 }; 194 195 INSTANTIATE_TEST_CASE_P(Version, QuicStreamFactoryTest, 196 ::testing::ValuesIn(QuicSupportedVersions())); 197 198 TEST_P(QuicStreamFactoryTest, CreateIfSessionExists) { 199 EXPECT_EQ(NULL, CreateIfSessionExists(host_port_pair_, net_log_).get()); 200 } 201 202 TEST_P(QuicStreamFactoryTest, Create) { 203 MockRead reads[] = { 204 MockRead(ASYNC, OK, 0) // EOF 205 }; 206 DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0); 207 socket_factory_.AddSocketDataProvider(&socket_data); 208 socket_data.StopAfter(1); 209 210 QuicStreamRequest request(&factory_); 211 EXPECT_EQ(ERR_IO_PENDING, 212 request.Request(host_port_pair_, 213 is_https_, 214 privacy_mode_, 215 "GET", 216 net_log_, 217 callback_.callback())); 218 219 EXPECT_EQ(OK, callback_.WaitForResult()); 220 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 221 EXPECT_TRUE(stream.get()); 222 223 // Will reset stream 3. 224 stream = CreateIfSessionExists(host_port_pair_, net_log_); 225 EXPECT_TRUE(stream.get()); 226 227 // TODO(rtenneti): We should probably have a tests that HTTP and HTTPS result 228 // in streams on different sessions. 229 QuicStreamRequest request2(&factory_); 230 EXPECT_EQ(OK, 231 request2.Request(host_port_pair_, 232 is_https_, 233 privacy_mode_, 234 "GET", 235 net_log_, 236 callback_.callback())); 237 stream = request2.ReleaseStream(); // Will reset stream 5. 238 stream.reset(); // Will reset stream 7. 239 240 EXPECT_TRUE(socket_data.at_read_eof()); 241 EXPECT_TRUE(socket_data.at_write_eof()); 242 } 243 244 TEST_P(QuicStreamFactoryTest, CreateZeroRtt) { 245 MockRead reads[] = { 246 MockRead(ASYNC, OK, 0) // EOF 247 }; 248 DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0); 249 socket_factory_.AddSocketDataProvider(&socket_data); 250 socket_data.StopAfter(1); 251 252 crypto_client_stream_factory_.set_handshake_mode( 253 MockCryptoClientStream::ZERO_RTT); 254 host_resolver_.set_synchronous_mode(true); 255 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), 256 "192.168.0.1", ""); 257 258 QuicStreamRequest request(&factory_); 259 EXPECT_EQ(OK, 260 request.Request(host_port_pair_, 261 is_https_, 262 privacy_mode_, 263 "GET", 264 net_log_, 265 callback_.callback())); 266 267 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 268 EXPECT_TRUE(stream.get()); 269 EXPECT_TRUE(socket_data.at_read_eof()); 270 EXPECT_TRUE(socket_data.at_write_eof()); 271 } 272 273 TEST_P(QuicStreamFactoryTest, CreateZeroRttPost) { 274 MockRead reads[] = { 275 MockRead(ASYNC, OK, 0) // EOF 276 }; 277 DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0); 278 socket_factory_.AddSocketDataProvider(&socket_data); 279 socket_data.StopAfter(1); 280 281 crypto_client_stream_factory_.set_handshake_mode( 282 MockCryptoClientStream::ZERO_RTT); 283 host_resolver_.set_synchronous_mode(true); 284 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), 285 "192.168.0.1", ""); 286 287 QuicStreamRequest request(&factory_); 288 // Posts require handshake confirmation, so this will return asynchronously. 289 EXPECT_EQ(ERR_IO_PENDING, 290 request.Request(host_port_pair_, 291 is_https_, 292 privacy_mode_, 293 "POST", 294 net_log_, 295 callback_.callback())); 296 297 // Confirm the handshake and verify that the stream is created. 298 crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( 299 QuicSession::HANDSHAKE_CONFIRMED); 300 301 EXPECT_EQ(OK, callback_.WaitForResult()); 302 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 303 EXPECT_TRUE(stream.get()); 304 EXPECT_TRUE(socket_data.at_read_eof()); 305 EXPECT_TRUE(socket_data.at_write_eof()); 306 } 307 308 TEST_P(QuicStreamFactoryTest, CreateHttpVsHttps) { 309 MockRead reads[] = { 310 MockRead(ASYNC, OK, 0) // EOF 311 }; 312 DeterministicSocketData socket_data1(reads, arraysize(reads), NULL, 0); 313 DeterministicSocketData socket_data2(reads, arraysize(reads), NULL, 0); 314 socket_factory_.AddSocketDataProvider(&socket_data1); 315 socket_factory_.AddSocketDataProvider(&socket_data2); 316 socket_data1.StopAfter(1); 317 socket_data2.StopAfter(1); 318 319 QuicStreamRequest request(&factory_); 320 EXPECT_EQ(ERR_IO_PENDING, 321 request.Request(host_port_pair_, 322 is_https_, 323 privacy_mode_, 324 "GET", 325 net_log_, 326 callback_.callback())); 327 328 EXPECT_EQ(OK, callback_.WaitForResult()); 329 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 330 EXPECT_TRUE(stream.get()); 331 332 QuicStreamRequest request2(&factory_); 333 EXPECT_EQ(ERR_IO_PENDING, 334 request2.Request(host_port_pair_, 335 !is_https_, 336 privacy_mode_, 337 "GET", 338 net_log_, 339 callback_.callback())); 340 EXPECT_EQ(OK, callback_.WaitForResult()); 341 stream = request2.ReleaseStream(); 342 EXPECT_TRUE(stream.get()); 343 stream.reset(); 344 345 EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession( 346 &factory_, host_port_pair_, is_https_), 347 QuicStreamFactoryPeer::GetActiveSession( 348 &factory_, host_port_pair_, !is_https_)); 349 350 EXPECT_TRUE(socket_data1.at_read_eof()); 351 EXPECT_TRUE(socket_data1.at_write_eof()); 352 EXPECT_TRUE(socket_data2.at_read_eof()); 353 EXPECT_TRUE(socket_data2.at_write_eof()); 354 } 355 356 // TODO(rch): re-enable this. 357 TEST_P(QuicStreamFactoryTest, DISABLED_Pooling) { 358 MockRead reads[] = { 359 MockRead(ASYNC, OK, 0) // EOF 360 }; 361 DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0); 362 socket_factory_.AddSocketDataProvider(&socket_data); 363 socket_data.StopAfter(1); 364 365 HostPortPair server2("mail.google.com", kDefaultServerPort); 366 host_resolver_.set_synchronous_mode(true); 367 host_resolver_.rules()->AddIPLiteralRule( 368 kDefaultServerHostName, "192.168.0.1", ""); 369 host_resolver_.rules()->AddIPLiteralRule( 370 "mail.google.com", "192.168.0.1", ""); 371 372 QuicStreamRequest request(&factory_); 373 EXPECT_EQ(OK, 374 request.Request(host_port_pair_, 375 is_https_, 376 privacy_mode_, 377 "GET", 378 net_log_, 379 callback_.callback())); 380 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 381 EXPECT_TRUE(stream.get()); 382 383 TestCompletionCallback callback; 384 QuicStreamRequest request2(&factory_); 385 EXPECT_EQ(OK, 386 request2.Request(server2, 387 is_https_, 388 privacy_mode_, 389 "GET", 390 net_log_, 391 callback.callback())); 392 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 393 EXPECT_TRUE(stream2.get()); 394 395 EXPECT_EQ( 396 QuicStreamFactoryPeer::GetActiveSession( 397 &factory_, host_port_pair_, is_https_), 398 QuicStreamFactoryPeer::GetActiveSession(&factory_, server2, is_https_)); 399 400 EXPECT_TRUE(socket_data.at_read_eof()); 401 EXPECT_TRUE(socket_data.at_write_eof()); 402 } 403 404 TEST_P(QuicStreamFactoryTest, NoPoolingAfterGoAway) { 405 MockRead reads[] = { 406 MockRead(ASYNC, OK, 0) // EOF 407 }; 408 DeterministicSocketData socket_data1(reads, arraysize(reads), NULL, 0); 409 DeterministicSocketData socket_data2(reads, arraysize(reads), NULL, 0); 410 socket_factory_.AddSocketDataProvider(&socket_data1); 411 socket_factory_.AddSocketDataProvider(&socket_data2); 412 socket_data1.StopAfter(1); 413 socket_data2.StopAfter(1); 414 415 HostPortPair server2("mail.google.com", kDefaultServerPort); 416 host_resolver_.set_synchronous_mode(true); 417 host_resolver_.rules()->AddIPLiteralRule( 418 kDefaultServerHostName, "192.168.0.1", ""); 419 host_resolver_.rules()->AddIPLiteralRule( 420 "mail.google.com", "192.168.0.1", ""); 421 422 QuicStreamRequest request(&factory_); 423 EXPECT_EQ(OK, 424 request.Request(host_port_pair_, 425 is_https_, 426 privacy_mode_, 427 "GET", 428 net_log_, 429 callback_.callback())); 430 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 431 EXPECT_TRUE(stream.get()); 432 433 TestCompletionCallback callback; 434 QuicStreamRequest request2(&factory_); 435 EXPECT_EQ(OK, 436 request2.Request(server2, 437 is_https_, 438 privacy_mode_, 439 "GET", 440 net_log_, 441 callback.callback())); 442 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 443 EXPECT_TRUE(stream2.get()); 444 445 factory_.OnSessionGoingAway(QuicStreamFactoryPeer::GetActiveSession( 446 &factory_, host_port_pair_, is_https_)); 447 EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession( 448 &factory_, host_port_pair_, is_https_)); 449 EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession( 450 &factory_, server2, is_https_)); 451 452 TestCompletionCallback callback3; 453 QuicStreamRequest request3(&factory_); 454 EXPECT_EQ(OK, 455 request3.Request(server2, 456 is_https_, 457 privacy_mode_, 458 "GET", 459 net_log_, 460 callback3.callback())); 461 scoped_ptr<QuicHttpStream> stream3 = request3.ReleaseStream(); 462 EXPECT_TRUE(stream3.get()); 463 464 EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession( 465 &factory_, server2, is_https_)); 466 467 EXPECT_TRUE(socket_data1.at_read_eof()); 468 EXPECT_TRUE(socket_data1.at_write_eof()); 469 EXPECT_TRUE(socket_data2.at_read_eof()); 470 EXPECT_TRUE(socket_data2.at_write_eof()); 471 } 472 473 // TODO(rch): re-enable this. 474 TEST_P(QuicStreamFactoryTest, DISABLED_HttpsPooling) { 475 MockRead reads[] = { 476 MockRead(ASYNC, OK, 0) // EOF 477 }; 478 DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0); 479 socket_factory_.AddSocketDataProvider(&socket_data); 480 socket_data.StopAfter(1); 481 482 HostPortPair server1("www.example.org", 443); 483 HostPortPair server2("mail.example.org", 443); 484 485 // Load a cert that is valid for: 486 // www.example.org (server1) 487 // mail.example.org (server2) 488 // www.example.com 489 base::FilePath certs_dir = GetTestCertsDirectory(); 490 scoped_refptr<X509Certificate> test_cert( 491 ImportCertFromFile(certs_dir, "spdy_pooling.pem")); 492 ASSERT_NE(static_cast<X509Certificate*>(NULL), test_cert); 493 ProofVerifyDetailsChromium verify_details; 494 verify_details.cert_verify_result.verified_cert = test_cert; 495 crypto_client_stream_factory_.set_proof_verify_details(&verify_details); 496 497 host_resolver_.set_synchronous_mode(true); 498 host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", ""); 499 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); 500 501 QuicStreamRequest request(&factory_); 502 is_https_ = true; 503 EXPECT_EQ(OK, 504 request.Request(server1, 505 is_https_, 506 privacy_mode_, 507 "GET", 508 net_log_, 509 callback_.callback())); 510 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 511 EXPECT_TRUE(stream.get()); 512 513 TestCompletionCallback callback; 514 QuicStreamRequest request2(&factory_); 515 EXPECT_EQ(OK, 516 request2.Request(server2, 517 is_https_, 518 privacy_mode_, 519 "GET", 520 net_log_, 521 callback_.callback())); 522 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 523 EXPECT_TRUE(stream2.get()); 524 525 EXPECT_EQ(QuicStreamFactoryPeer::GetActiveSession( 526 &factory_, server1, is_https_), 527 QuicStreamFactoryPeer::GetActiveSession( 528 &factory_, server2, is_https_)); 529 530 EXPECT_TRUE(socket_data.at_read_eof()); 531 EXPECT_TRUE(socket_data.at_write_eof()); 532 } 533 534 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithCertMismatch) { 535 MockRead reads[] = { 536 MockRead(ASYNC, OK, 0) // EOF 537 }; 538 DeterministicSocketData socket_data1(reads, arraysize(reads), NULL, 0); 539 DeterministicSocketData socket_data2(reads, arraysize(reads), NULL, 0); 540 socket_factory_.AddSocketDataProvider(&socket_data1); 541 socket_factory_.AddSocketDataProvider(&socket_data2); 542 socket_data1.StopAfter(1); 543 socket_data2.StopAfter(1); 544 545 HostPortPair server1("www.example.org", 443); 546 HostPortPair server2("mail.google.com", 443); 547 548 // Load a cert that is valid for: 549 // www.example.org (server1) 550 // mail.example.org 551 // www.example.com 552 // But is not valid for mail.google.com (server2). 553 base::FilePath certs_dir = GetTestCertsDirectory(); 554 scoped_refptr<X509Certificate> test_cert( 555 ImportCertFromFile(certs_dir, "spdy_pooling.pem")); 556 ASSERT_NE(static_cast<X509Certificate*>(NULL), test_cert); 557 ProofVerifyDetailsChromium verify_details; 558 verify_details.cert_verify_result.verified_cert = test_cert; 559 crypto_client_stream_factory_.set_proof_verify_details(&verify_details); 560 561 562 host_resolver_.set_synchronous_mode(true); 563 host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", ""); 564 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); 565 566 QuicStreamRequest request(&factory_); 567 is_https_ = true; 568 EXPECT_EQ(OK, 569 request.Request(server1, 570 is_https_, 571 privacy_mode_, 572 "GET", 573 net_log_, 574 callback_.callback())); 575 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 576 EXPECT_TRUE(stream.get()); 577 578 TestCompletionCallback callback; 579 QuicStreamRequest request2(&factory_); 580 EXPECT_EQ(OK, 581 request2.Request(server2, 582 is_https_, 583 privacy_mode_, 584 "GET", 585 net_log_, 586 callback_.callback())); 587 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 588 EXPECT_TRUE(stream2.get()); 589 590 EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession( 591 &factory_, server1, is_https_), 592 QuicStreamFactoryPeer::GetActiveSession( 593 &factory_, server2, is_https_)); 594 595 EXPECT_TRUE(socket_data1.at_read_eof()); 596 EXPECT_TRUE(socket_data1.at_write_eof()); 597 EXPECT_TRUE(socket_data2.at_read_eof()); 598 EXPECT_TRUE(socket_data2.at_write_eof()); 599 } 600 601 TEST_P(QuicStreamFactoryTest, Goaway) { 602 MockRead reads[] = { 603 MockRead(ASYNC, OK, 0) // EOF 604 }; 605 DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0); 606 socket_data.StopAfter(1); 607 socket_factory_.AddSocketDataProvider(&socket_data); 608 DeterministicSocketData socket_data2(reads, arraysize(reads), NULL, 0); 609 socket_data2.StopAfter(1); 610 socket_factory_.AddSocketDataProvider(&socket_data2); 611 612 QuicStreamRequest request(&factory_); 613 EXPECT_EQ(ERR_IO_PENDING, 614 request.Request(host_port_pair_, 615 is_https_, 616 privacy_mode_, 617 "GET", 618 net_log_, 619 callback_.callback())); 620 621 EXPECT_EQ(OK, callback_.WaitForResult()); 622 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 623 EXPECT_TRUE(stream.get()); 624 625 // Mark the session as going away. Ensure that while it is still alive 626 // that it is no longer active. 627 QuicClientSession* session = QuicStreamFactoryPeer::GetActiveSession( 628 &factory_, host_port_pair_, is_https_); 629 factory_.OnSessionGoingAway(session); 630 EXPECT_EQ(true, QuicStreamFactoryPeer::IsLiveSession(&factory_, session)); 631 EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession( 632 &factory_, host_port_pair_, is_https_)); 633 EXPECT_EQ(NULL, CreateIfSessionExists(host_port_pair_, net_log_).get()); 634 635 // Create a new request for the same destination and verify that a 636 // new session is created. 637 QuicStreamRequest request2(&factory_); 638 EXPECT_EQ(ERR_IO_PENDING, 639 request2.Request(host_port_pair_, 640 is_https_, 641 privacy_mode_, 642 "GET", 643 net_log_, 644 callback_.callback())); 645 EXPECT_EQ(OK, callback_.WaitForResult()); 646 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 647 EXPECT_TRUE(stream2.get()); 648 649 EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession(&factory_, 650 host_port_pair_, 651 is_https_)); 652 EXPECT_NE(session, 653 QuicStreamFactoryPeer::GetActiveSession( 654 &factory_, host_port_pair_, is_https_)); 655 EXPECT_EQ(true, QuicStreamFactoryPeer::IsLiveSession(&factory_, session)); 656 657 stream2.reset(); 658 stream.reset(); 659 660 EXPECT_TRUE(socket_data.at_read_eof()); 661 EXPECT_TRUE(socket_data.at_write_eof()); 662 EXPECT_TRUE(socket_data2.at_read_eof()); 663 EXPECT_TRUE(socket_data2.at_write_eof()); 664 } 665 666 TEST_P(QuicStreamFactoryTest, MaxOpenStream) { 667 MockRead reads[] = { 668 MockRead(ASYNC, OK, 0) // EOF 669 }; 670 QuicStreamId stream_id = kClientDataStreamId1; 671 scoped_ptr<QuicEncryptedPacket> rst( 672 maker_.MakeRstPacket(1, true, stream_id, QUIC_STREAM_CANCELLED)); 673 MockWrite writes[] = { 674 MockWrite(ASYNC, rst->data(), rst->length(), 1), 675 }; 676 DeterministicSocketData socket_data(reads, arraysize(reads), 677 writes, arraysize(writes)); 678 socket_factory_.AddSocketDataProvider(&socket_data); 679 socket_data.StopAfter(1); 680 681 HttpRequestInfo request_info; 682 std::vector<QuicHttpStream*> streams; 683 // The MockCryptoClientStream sets max_open_streams to be 684 // 2 * kDefaultMaxStreamsPerConnection. 685 for (size_t i = 0; i < 2 * kDefaultMaxStreamsPerConnection; i++) { 686 QuicStreamRequest request(&factory_); 687 int rv = request.Request(host_port_pair_, 688 is_https_, 689 privacy_mode_, 690 "GET", 691 net_log_, 692 callback_.callback()); 693 if (i == 0) { 694 EXPECT_EQ(ERR_IO_PENDING, rv); 695 EXPECT_EQ(OK, callback_.WaitForResult()); 696 } else { 697 EXPECT_EQ(OK, rv); 698 } 699 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 700 EXPECT_TRUE(stream); 701 EXPECT_EQ(OK, stream->InitializeStream( 702 &request_info, DEFAULT_PRIORITY, net_log_, CompletionCallback())); 703 streams.push_back(stream.release()); 704 } 705 706 QuicStreamRequest request(&factory_); 707 EXPECT_EQ(OK, 708 request.Request(host_port_pair_, 709 is_https_, 710 privacy_mode_, 711 "GET", 712 net_log_, 713 CompletionCallback())); 714 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 715 EXPECT_TRUE(stream); 716 EXPECT_EQ(ERR_IO_PENDING, stream->InitializeStream( 717 &request_info, DEFAULT_PRIORITY, net_log_, callback_.callback())); 718 719 // Close the first stream. 720 streams.front()->Close(false); 721 722 ASSERT_TRUE(callback_.have_result()); 723 724 EXPECT_EQ(OK, callback_.WaitForResult()); 725 726 EXPECT_TRUE(socket_data.at_read_eof()); 727 EXPECT_TRUE(socket_data.at_write_eof()); 728 STLDeleteElements(&streams); 729 } 730 731 TEST_P(QuicStreamFactoryTest, ResolutionErrorInCreate) { 732 DeterministicSocketData socket_data(NULL, 0, NULL, 0); 733 socket_factory_.AddSocketDataProvider(&socket_data); 734 735 host_resolver_.rules()->AddSimulatedFailure(kDefaultServerHostName); 736 737 QuicStreamRequest request(&factory_); 738 EXPECT_EQ(ERR_IO_PENDING, 739 request.Request(host_port_pair_, 740 is_https_, 741 privacy_mode_, 742 "GET", 743 net_log_, 744 callback_.callback())); 745 746 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, callback_.WaitForResult()); 747 748 EXPECT_TRUE(socket_data.at_read_eof()); 749 EXPECT_TRUE(socket_data.at_write_eof()); 750 } 751 752 TEST_P(QuicStreamFactoryTest, ConnectErrorInCreate) { 753 MockConnect connect(SYNCHRONOUS, ERR_ADDRESS_IN_USE); 754 DeterministicSocketData socket_data(NULL, 0, NULL, 0); 755 socket_data.set_connect_data(connect); 756 socket_factory_.AddSocketDataProvider(&socket_data); 757 socket_data.StopAfter(1); 758 759 QuicStreamRequest request(&factory_); 760 EXPECT_EQ(ERR_IO_PENDING, 761 request.Request(host_port_pair_, 762 is_https_, 763 privacy_mode_, 764 "GET", 765 net_log_, 766 callback_.callback())); 767 768 EXPECT_EQ(ERR_ADDRESS_IN_USE, callback_.WaitForResult()); 769 770 EXPECT_TRUE(socket_data.at_read_eof()); 771 EXPECT_TRUE(socket_data.at_write_eof()); 772 } 773 774 TEST_P(QuicStreamFactoryTest, CancelCreate) { 775 MockRead reads[] = { 776 MockRead(ASYNC, OK, 0) // EOF 777 }; 778 DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0); 779 socket_factory_.AddSocketDataProvider(&socket_data); 780 { 781 QuicStreamRequest request(&factory_); 782 EXPECT_EQ(ERR_IO_PENDING, 783 request.Request(host_port_pair_, 784 is_https_, 785 privacy_mode_, 786 "GET", 787 net_log_, 788 callback_.callback())); 789 } 790 791 socket_data.StopAfter(1); 792 base::RunLoop run_loop; 793 run_loop.RunUntilIdle(); 794 795 scoped_ptr<QuicHttpStream> stream( 796 CreateIfSessionExists(host_port_pair_, net_log_)); 797 EXPECT_TRUE(stream.get()); 798 stream.reset(); 799 800 EXPECT_TRUE(socket_data.at_read_eof()); 801 EXPECT_TRUE(socket_data.at_write_eof()); 802 } 803 804 TEST_P(QuicStreamFactoryTest, CreateConsistentEphemeralPort) { 805 // Sequentially connect to the default host, then another host, and then the 806 // default host. Verify that the default host gets a consistent ephemeral 807 // port, that is different from the other host's connection. 808 809 std::string other_server_name = "other.google.com"; 810 EXPECT_NE(kDefaultServerHostName, other_server_name); 811 HostPortPair host_port_pair2(other_server_name, kDefaultServerPort); 812 813 int original_port = GetSourcePortForNewSession(host_port_pair_); 814 EXPECT_NE(original_port, GetSourcePortForNewSession(host_port_pair2)); 815 EXPECT_EQ(original_port, GetSourcePortForNewSession(host_port_pair_)); 816 } 817 818 TEST_P(QuicStreamFactoryTest, GoAwayDisablesConsistentEphemeralPort) { 819 // Get a session to the host using the port suggester. 820 int original_port = 821 GetSourcePortForNewSessionAndGoAway(host_port_pair_); 822 // Verify that the port is different after the goaway. 823 EXPECT_NE(original_port, GetSourcePortForNewSession(host_port_pair_)); 824 // Since the previous session did not goaway we should see the original port. 825 EXPECT_EQ(original_port, GetSourcePortForNewSession(host_port_pair_)); 826 } 827 828 TEST_P(QuicStreamFactoryTest, CloseAllSessions) { 829 MockRead reads[] = { 830 MockRead(ASYNC, 0, 0) // EOF 831 }; 832 scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket()); 833 std::vector<MockWrite> writes; 834 writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1)); 835 DeterministicSocketData socket_data(reads, arraysize(reads), 836 writes.empty() ? NULL : &writes[0], 837 writes.size()); 838 socket_factory_.AddSocketDataProvider(&socket_data); 839 socket_data.StopAfter(1); 840 841 MockRead reads2[] = { 842 MockRead(ASYNC, 0, 0) // EOF 843 }; 844 DeterministicSocketData socket_data2(reads2, arraysize(reads2), NULL, 0); 845 socket_factory_.AddSocketDataProvider(&socket_data2); 846 socket_data2.StopAfter(1); 847 848 QuicStreamRequest request(&factory_); 849 EXPECT_EQ(ERR_IO_PENDING, 850 request.Request(host_port_pair_, 851 is_https_, 852 privacy_mode_, 853 "GET", 854 net_log_, 855 callback_.callback())); 856 857 EXPECT_EQ(OK, callback_.WaitForResult()); 858 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 859 HttpRequestInfo request_info; 860 EXPECT_EQ(OK, stream->InitializeStream(&request_info, 861 DEFAULT_PRIORITY, 862 net_log_, CompletionCallback())); 863 864 // Close the session and verify that stream saw the error. 865 factory_.CloseAllSessions(ERR_INTERNET_DISCONNECTED); 866 EXPECT_EQ(ERR_INTERNET_DISCONNECTED, 867 stream->ReadResponseHeaders(callback_.callback())); 868 869 // Now attempting to request a stream to the same origin should create 870 // a new session. 871 872 QuicStreamRequest request2(&factory_); 873 EXPECT_EQ(ERR_IO_PENDING, 874 request2.Request(host_port_pair_, 875 is_https_, 876 privacy_mode_, 877 "GET", 878 net_log_, 879 callback_.callback())); 880 881 EXPECT_EQ(OK, callback_.WaitForResult()); 882 stream = request2.ReleaseStream(); 883 stream.reset(); // Will reset stream 3. 884 885 EXPECT_TRUE(socket_data.at_read_eof()); 886 EXPECT_TRUE(socket_data.at_write_eof()); 887 EXPECT_TRUE(socket_data2.at_read_eof()); 888 EXPECT_TRUE(socket_data2.at_write_eof()); 889 } 890 891 TEST_P(QuicStreamFactoryTest, OnIPAddressChanged) { 892 MockRead reads[] = { 893 MockRead(ASYNC, 0, 0) // EOF 894 }; 895 scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket()); 896 std::vector<MockWrite> writes; 897 writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1)); 898 DeterministicSocketData socket_data(reads, arraysize(reads), 899 writes.empty() ? NULL : &writes[0], 900 writes.size()); 901 socket_factory_.AddSocketDataProvider(&socket_data); 902 socket_data.StopAfter(1); 903 904 MockRead reads2[] = { 905 MockRead(ASYNC, 0, 0) // EOF 906 }; 907 DeterministicSocketData socket_data2(reads2, arraysize(reads2), NULL, 0); 908 socket_factory_.AddSocketDataProvider(&socket_data2); 909 socket_data2.StopAfter(1); 910 911 QuicStreamRequest request(&factory_); 912 EXPECT_EQ(ERR_IO_PENDING, 913 request.Request(host_port_pair_, 914 is_https_, 915 privacy_mode_, 916 "GET", 917 net_log_, 918 callback_.callback())); 919 920 EXPECT_EQ(OK, callback_.WaitForResult()); 921 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 922 HttpRequestInfo request_info; 923 EXPECT_EQ(OK, stream->InitializeStream(&request_info, 924 DEFAULT_PRIORITY, 925 net_log_, CompletionCallback())); 926 927 // Change the IP address and verify that stream saw the error. 928 factory_.OnIPAddressChanged(); 929 EXPECT_EQ(ERR_NETWORK_CHANGED, 930 stream->ReadResponseHeaders(callback_.callback())); 931 EXPECT_TRUE(factory_.require_confirmation()); 932 933 // Now attempting to request a stream to the same origin should create 934 // a new session. 935 936 QuicStreamRequest request2(&factory_); 937 EXPECT_EQ(ERR_IO_PENDING, 938 request2.Request(host_port_pair_, 939 is_https_, 940 privacy_mode_, 941 "GET", 942 net_log_, 943 callback_.callback())); 944 945 EXPECT_EQ(OK, callback_.WaitForResult()); 946 stream = request2.ReleaseStream(); 947 stream.reset(); // Will reset stream 3. 948 949 EXPECT_TRUE(socket_data.at_read_eof()); 950 EXPECT_TRUE(socket_data.at_write_eof()); 951 EXPECT_TRUE(socket_data2.at_read_eof()); 952 EXPECT_TRUE(socket_data2.at_write_eof()); 953 } 954 955 TEST_P(QuicStreamFactoryTest, OnCertAdded) { 956 MockRead reads[] = { 957 MockRead(ASYNC, 0, 0) // EOF 958 }; 959 scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket()); 960 std::vector<MockWrite> writes; 961 writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1)); 962 DeterministicSocketData socket_data(reads, arraysize(reads), 963 writes.empty() ? NULL : &writes[0], 964 writes.size()); 965 socket_factory_.AddSocketDataProvider(&socket_data); 966 socket_data.StopAfter(1); 967 968 MockRead reads2[] = { 969 MockRead(ASYNC, 0, 0) // EOF 970 }; 971 DeterministicSocketData socket_data2(reads2, arraysize(reads2), NULL, 0); 972 socket_factory_.AddSocketDataProvider(&socket_data2); 973 socket_data2.StopAfter(1); 974 975 QuicStreamRequest request(&factory_); 976 EXPECT_EQ(ERR_IO_PENDING, 977 request.Request(host_port_pair_, 978 is_https_, 979 privacy_mode_, 980 "GET", 981 net_log_, 982 callback_.callback())); 983 984 EXPECT_EQ(OK, callback_.WaitForResult()); 985 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 986 HttpRequestInfo request_info; 987 EXPECT_EQ(OK, stream->InitializeStream(&request_info, 988 DEFAULT_PRIORITY, 989 net_log_, CompletionCallback())); 990 991 // Add a cert and verify that stream saw the event. 992 factory_.OnCertAdded(NULL); 993 EXPECT_EQ(ERR_CERT_DATABASE_CHANGED, 994 stream->ReadResponseHeaders(callback_.callback())); 995 EXPECT_FALSE(factory_.require_confirmation()); 996 997 // Now attempting to request a stream to the same origin should create 998 // a new session. 999 1000 QuicStreamRequest request2(&factory_); 1001 EXPECT_EQ(ERR_IO_PENDING, 1002 request2.Request(host_port_pair_, 1003 is_https_, 1004 privacy_mode_, 1005 "GET", 1006 net_log_, 1007 callback_.callback())); 1008 1009 EXPECT_EQ(OK, callback_.WaitForResult()); 1010 stream = request2.ReleaseStream(); 1011 stream.reset(); // Will reset stream 3. 1012 1013 EXPECT_TRUE(socket_data.at_read_eof()); 1014 EXPECT_TRUE(socket_data.at_write_eof()); 1015 EXPECT_TRUE(socket_data2.at_read_eof()); 1016 EXPECT_TRUE(socket_data2.at_write_eof()); 1017 } 1018 1019 TEST_P(QuicStreamFactoryTest, OnCACertChanged) { 1020 MockRead reads[] = { 1021 MockRead(ASYNC, 0, 0) // EOF 1022 }; 1023 scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket()); 1024 std::vector<MockWrite> writes; 1025 writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1)); 1026 DeterministicSocketData socket_data(reads, arraysize(reads), 1027 writes.empty() ? NULL : &writes[0], 1028 writes.size()); 1029 socket_factory_.AddSocketDataProvider(&socket_data); 1030 socket_data.StopAfter(1); 1031 1032 MockRead reads2[] = { 1033 MockRead(ASYNC, 0, 0) // EOF 1034 }; 1035 DeterministicSocketData socket_data2(reads2, arraysize(reads2), NULL, 0); 1036 socket_factory_.AddSocketDataProvider(&socket_data2); 1037 socket_data2.StopAfter(1); 1038 1039 QuicStreamRequest request(&factory_); 1040 EXPECT_EQ(ERR_IO_PENDING, 1041 request.Request(host_port_pair_, 1042 is_https_, 1043 privacy_mode_, 1044 "GET", 1045 net_log_, 1046 callback_.callback())); 1047 1048 EXPECT_EQ(OK, callback_.WaitForResult()); 1049 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 1050 HttpRequestInfo request_info; 1051 EXPECT_EQ(OK, stream->InitializeStream(&request_info, 1052 DEFAULT_PRIORITY, 1053 net_log_, CompletionCallback())); 1054 1055 // Change the CA cert and verify that stream saw the event. 1056 factory_.OnCACertChanged(NULL); 1057 EXPECT_EQ(ERR_CERT_DATABASE_CHANGED, 1058 stream->ReadResponseHeaders(callback_.callback())); 1059 EXPECT_FALSE(factory_.require_confirmation()); 1060 1061 // Now attempting to request a stream to the same origin should create 1062 // a new session. 1063 1064 QuicStreamRequest request2(&factory_); 1065 EXPECT_EQ(ERR_IO_PENDING, 1066 request2.Request(host_port_pair_, 1067 is_https_, 1068 privacy_mode_, 1069 "GET", 1070 net_log_, 1071 callback_.callback())); 1072 1073 EXPECT_EQ(OK, callback_.WaitForResult()); 1074 stream = request2.ReleaseStream(); 1075 stream.reset(); // Will reset stream 3. 1076 1077 EXPECT_TRUE(socket_data.at_read_eof()); 1078 EXPECT_TRUE(socket_data.at_write_eof()); 1079 EXPECT_TRUE(socket_data2.at_read_eof()); 1080 EXPECT_TRUE(socket_data2.at_write_eof()); 1081 } 1082 1083 TEST_P(QuicStreamFactoryTest, SharedCryptoConfig) { 1084 vector<string> cannoncial_suffixes; 1085 cannoncial_suffixes.push_back(string(".c.youtube.com")); 1086 cannoncial_suffixes.push_back(string(".googlevideo.com")); 1087 1088 for (unsigned i = 0; i < cannoncial_suffixes.size(); ++i) { 1089 string r1_host_name("r1"); 1090 string r2_host_name("r2"); 1091 r1_host_name.append(cannoncial_suffixes[i]); 1092 r2_host_name.append(cannoncial_suffixes[i]); 1093 1094 HostPortPair host_port_pair1(r1_host_name, 80); 1095 QuicCryptoClientConfig* crypto_config = 1096 QuicStreamFactoryPeer::GetCryptoConfig(&factory_); 1097 QuicServerId server_id1(host_port_pair1, is_https_, privacy_mode_); 1098 QuicCryptoClientConfig::CachedState* cached1 = 1099 crypto_config->LookupOrCreate(server_id1); 1100 EXPECT_FALSE(cached1->proof_valid()); 1101 EXPECT_TRUE(cached1->source_address_token().empty()); 1102 1103 // Mutate the cached1 to have different data. 1104 // TODO(rtenneti): mutate other members of CachedState. 1105 cached1->set_source_address_token(r1_host_name); 1106 cached1->SetProofValid(); 1107 1108 HostPortPair host_port_pair2(r2_host_name, 80); 1109 QuicServerId server_id2(host_port_pair2, is_https_, privacy_mode_); 1110 QuicCryptoClientConfig::CachedState* cached2 = 1111 crypto_config->LookupOrCreate(server_id2); 1112 EXPECT_EQ(cached1->source_address_token(), cached2->source_address_token()); 1113 EXPECT_TRUE(cached2->proof_valid()); 1114 } 1115 } 1116 1117 TEST_P(QuicStreamFactoryTest, CryptoConfigWhenProofIsInvalid) { 1118 vector<string> cannoncial_suffixes; 1119 cannoncial_suffixes.push_back(string(".c.youtube.com")); 1120 cannoncial_suffixes.push_back(string(".googlevideo.com")); 1121 1122 for (unsigned i = 0; i < cannoncial_suffixes.size(); ++i) { 1123 string r3_host_name("r3"); 1124 string r4_host_name("r4"); 1125 r3_host_name.append(cannoncial_suffixes[i]); 1126 r4_host_name.append(cannoncial_suffixes[i]); 1127 1128 HostPortPair host_port_pair1(r3_host_name, 80); 1129 QuicCryptoClientConfig* crypto_config = 1130 QuicStreamFactoryPeer::GetCryptoConfig(&factory_); 1131 QuicServerId server_id1(host_port_pair1, is_https_, privacy_mode_); 1132 QuicCryptoClientConfig::CachedState* cached1 = 1133 crypto_config->LookupOrCreate(server_id1); 1134 EXPECT_FALSE(cached1->proof_valid()); 1135 EXPECT_TRUE(cached1->source_address_token().empty()); 1136 1137 // Mutate the cached1 to have different data. 1138 // TODO(rtenneti): mutate other members of CachedState. 1139 cached1->set_source_address_token(r3_host_name); 1140 cached1->SetProofInvalid(); 1141 1142 HostPortPair host_port_pair2(r4_host_name, 80); 1143 QuicServerId server_id2(host_port_pair2, is_https_, privacy_mode_); 1144 QuicCryptoClientConfig::CachedState* cached2 = 1145 crypto_config->LookupOrCreate(server_id2); 1146 EXPECT_NE(cached1->source_address_token(), cached2->source_address_token()); 1147 EXPECT_TRUE(cached2->source_address_token().empty()); 1148 EXPECT_FALSE(cached2->proof_valid()); 1149 } 1150 } 1151 1152 } // namespace test 1153 } // namespace net 1154
