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 <set> 8 9 #include "base/cpu.h" 10 #include "base/message_loop/message_loop.h" 11 #include "base/message_loop/message_loop_proxy.h" 12 #include "base/metrics/histogram.h" 13 #include "base/rand_util.h" 14 #include "base/stl_util.h" 15 #include "base/strings/string_util.h" 16 #include "base/values.h" 17 #include "net/base/net_errors.h" 18 #include "net/cert/cert_verifier.h" 19 #include "net/dns/host_resolver.h" 20 #include "net/dns/single_request_host_resolver.h" 21 #include "net/http/http_server_properties.h" 22 #include "net/quic/congestion_control/tcp_receiver.h" 23 #include "net/quic/crypto/proof_verifier_chromium.h" 24 #include "net/quic/crypto/quic_random.h" 25 #include "net/quic/crypto/quic_server_info.h" 26 #include "net/quic/port_suggester.h" 27 #include "net/quic/quic_client_session.h" 28 #include "net/quic/quic_clock.h" 29 #include "net/quic/quic_connection.h" 30 #include "net/quic/quic_connection_helper.h" 31 #include "net/quic/quic_crypto_client_stream_factory.h" 32 #include "net/quic/quic_default_packet_writer.h" 33 #include "net/quic/quic_http_stream.h" 34 #include "net/quic/quic_protocol.h" 35 #include "net/quic/quic_server_id.h" 36 #include "net/socket/client_socket_factory.h" 37 38 #if defined(OS_WIN) 39 #include "base/win/windows_version.h" 40 #endif 41 42 using std::string; 43 using std::vector; 44 45 namespace net { 46 47 namespace { 48 49 enum CreateSessionFailure { 50 CREATION_ERROR_CONNECTING_SOCKET, 51 CREATION_ERROR_SETTING_RECEIVE_BUFFER, 52 CREATION_ERROR_SETTING_SEND_BUFFER, 53 CREATION_ERROR_MAX 54 }; 55 56 // When a connection is idle for 30 seconds it will be closed. 57 const int kIdleConnectionTimeoutSeconds = 30; 58 59 // The initial receive window size for both streams and sessions. 60 const int32 kInitialReceiveWindowSize = 10 * 1024 * 1024; // 10MB 61 62 // The suggested initial congestion windows for a server to use. 63 // TODO: This should be tested and optimized, and even better, suggest a window 64 // that corresponds to historical bandwidth and min-RTT. 65 // Larger initial congestion windows can, if we don't overshoot, reduce latency 66 // by avoiding the RTT needed for slow start to double (and re-double) from a 67 // default of 10. 68 // We match SPDY's use of 32 when secure (since we'd compete with SPDY). 69 const int32 kServerSecureInitialCongestionWindow = 32; 70 // Be conservative, and just use double a typical TCP ICWND for HTTP. 71 const int32 kServerInecureInitialCongestionWindow = 20; 72 73 void HistogramCreateSessionFailure(enum CreateSessionFailure error) { 74 UMA_HISTOGRAM_ENUMERATION("Net.QuicSession.CreationError", error, 75 CREATION_ERROR_MAX); 76 } 77 78 bool IsEcdsaSupported() { 79 #if defined(OS_WIN) 80 if (base::win::GetVersion() < base::win::VERSION_VISTA) 81 return false; 82 #endif 83 84 return true; 85 } 86 87 QuicConfig InitializeQuicConfig(bool enable_pacing, 88 bool enable_time_based_loss_detection) { 89 QuicConfig config; 90 config.SetDefaults(); 91 config.EnablePacing(enable_pacing); 92 if (enable_time_based_loss_detection) 93 config.SetLossDetectionToSend(kTIME); 94 config.set_idle_connection_state_lifetime( 95 QuicTime::Delta::FromSeconds(kIdleConnectionTimeoutSeconds), 96 QuicTime::Delta::FromSeconds(kIdleConnectionTimeoutSeconds)); 97 return config; 98 } 99 100 } // namespace 101 102 QuicStreamFactory::IpAliasKey::IpAliasKey() {} 103 104 QuicStreamFactory::IpAliasKey::IpAliasKey(IPEndPoint ip_endpoint, 105 bool is_https) 106 : ip_endpoint(ip_endpoint), 107 is_https(is_https) {} 108 109 QuicStreamFactory::IpAliasKey::~IpAliasKey() {} 110 111 bool QuicStreamFactory::IpAliasKey::operator<( 112 const QuicStreamFactory::IpAliasKey& other) const { 113 if (!(ip_endpoint == other.ip_endpoint)) { 114 return ip_endpoint < other.ip_endpoint; 115 } 116 return is_https < other.is_https; 117 } 118 119 bool QuicStreamFactory::IpAliasKey::operator==( 120 const QuicStreamFactory::IpAliasKey& other) const { 121 return is_https == other.is_https && 122 ip_endpoint == other.ip_endpoint; 123 }; 124 125 // Responsible for creating a new QUIC session to the specified server, and 126 // for notifying any associated requests when complete. 127 class QuicStreamFactory::Job { 128 public: 129 Job(QuicStreamFactory* factory, 130 HostResolver* host_resolver, 131 const HostPortPair& host_port_pair, 132 bool is_https, 133 bool was_alternate_protocol_recently_broken, 134 PrivacyMode privacy_mode, 135 base::StringPiece method, 136 QuicServerInfo* server_info, 137 const BoundNetLog& net_log); 138 139 // Creates a new job to handle the resumption of for connecting an 140 // existing session. 141 Job(QuicStreamFactory* factory, 142 HostResolver* host_resolver, 143 QuicClientSession* session, 144 QuicServerId server_id); 145 146 ~Job(); 147 148 int Run(const CompletionCallback& callback); 149 150 int DoLoop(int rv); 151 int DoResolveHost(); 152 int DoResolveHostComplete(int rv); 153 int DoLoadServerInfo(); 154 int DoLoadServerInfoComplete(int rv); 155 int DoConnect(); 156 int DoResumeConnect(); 157 int DoConnectComplete(int rv); 158 159 void OnIOComplete(int rv); 160 161 CompletionCallback callback() { 162 return callback_; 163 } 164 165 const QuicServerId server_id() const { 166 return server_id_; 167 } 168 169 private: 170 enum IoState { 171 STATE_NONE, 172 STATE_RESOLVE_HOST, 173 STATE_RESOLVE_HOST_COMPLETE, 174 STATE_LOAD_SERVER_INFO, 175 STATE_LOAD_SERVER_INFO_COMPLETE, 176 STATE_CONNECT, 177 STATE_RESUME_CONNECT, 178 STATE_CONNECT_COMPLETE, 179 }; 180 IoState io_state_; 181 182 QuicStreamFactory* factory_; 183 SingleRequestHostResolver host_resolver_; 184 QuicServerId server_id_; 185 bool is_post_; 186 bool was_alternate_protocol_recently_broken_; 187 scoped_ptr<QuicServerInfo> server_info_; 188 const BoundNetLog net_log_; 189 QuicClientSession* session_; 190 CompletionCallback callback_; 191 AddressList address_list_; 192 base::TimeTicks disk_cache_load_start_time_; 193 base::WeakPtrFactory<Job> weak_factory_; 194 DISALLOW_COPY_AND_ASSIGN(Job); 195 }; 196 197 QuicStreamFactory::Job::Job(QuicStreamFactory* factory, 198 HostResolver* host_resolver, 199 const HostPortPair& host_port_pair, 200 bool is_https, 201 bool was_alternate_protocol_recently_broken, 202 PrivacyMode privacy_mode, 203 base::StringPiece method, 204 QuicServerInfo* server_info, 205 const BoundNetLog& net_log) 206 : io_state_(STATE_RESOLVE_HOST), 207 factory_(factory), 208 host_resolver_(host_resolver), 209 server_id_(host_port_pair, is_https, privacy_mode), 210 is_post_(method == "POST"), 211 was_alternate_protocol_recently_broken_( 212 was_alternate_protocol_recently_broken), 213 server_info_(server_info), 214 net_log_(net_log), 215 session_(NULL), 216 weak_factory_(this) {} 217 218 QuicStreamFactory::Job::Job(QuicStreamFactory* factory, 219 HostResolver* host_resolver, 220 QuicClientSession* session, 221 QuicServerId server_id) 222 : io_state_(STATE_RESUME_CONNECT), 223 factory_(factory), 224 host_resolver_(host_resolver), // unused 225 server_id_(server_id), 226 is_post_(false), // unused 227 was_alternate_protocol_recently_broken_(false), // unused 228 net_log_(session->net_log()), // unused 229 session_(session), 230 weak_factory_(this) {} 231 232 QuicStreamFactory::Job::~Job() { 233 } 234 235 int QuicStreamFactory::Job::Run(const CompletionCallback& callback) { 236 int rv = DoLoop(OK); 237 if (rv == ERR_IO_PENDING) 238 callback_ = callback; 239 240 return rv > 0 ? OK : rv; 241 } 242 243 int QuicStreamFactory::Job::DoLoop(int rv) { 244 do { 245 IoState state = io_state_; 246 io_state_ = STATE_NONE; 247 switch (state) { 248 case STATE_RESOLVE_HOST: 249 CHECK_EQ(OK, rv); 250 rv = DoResolveHost(); 251 break; 252 case STATE_RESOLVE_HOST_COMPLETE: 253 rv = DoResolveHostComplete(rv); 254 break; 255 case STATE_LOAD_SERVER_INFO: 256 CHECK_EQ(OK, rv); 257 rv = DoLoadServerInfo(); 258 break; 259 case STATE_LOAD_SERVER_INFO_COMPLETE: 260 rv = DoLoadServerInfoComplete(rv); 261 break; 262 case STATE_CONNECT: 263 CHECK_EQ(OK, rv); 264 rv = DoConnect(); 265 break; 266 case STATE_RESUME_CONNECT: 267 CHECK_EQ(OK, rv); 268 rv = DoResumeConnect(); 269 break; 270 case STATE_CONNECT_COMPLETE: 271 rv = DoConnectComplete(rv); 272 break; 273 default: 274 NOTREACHED() << "io_state_: " << io_state_; 275 break; 276 } 277 } while (io_state_ != STATE_NONE && rv != ERR_IO_PENDING); 278 return rv; 279 } 280 281 void QuicStreamFactory::Job::OnIOComplete(int rv) { 282 rv = DoLoop(rv); 283 284 if (rv != ERR_IO_PENDING && !callback_.is_null()) { 285 callback_.Run(rv); 286 } 287 } 288 289 int QuicStreamFactory::Job::DoResolveHost() { 290 // Start loading the data now, and wait for it after we resolve the host. 291 if (server_info_) { 292 disk_cache_load_start_time_ = base::TimeTicks::Now(); 293 server_info_->Start(); 294 } 295 296 io_state_ = STATE_RESOLVE_HOST_COMPLETE; 297 return host_resolver_.Resolve( 298 HostResolver::RequestInfo(server_id_.host_port_pair()), 299 DEFAULT_PRIORITY, 300 &address_list_, 301 base::Bind(&QuicStreamFactory::Job::OnIOComplete, 302 weak_factory_.GetWeakPtr()), 303 net_log_); 304 } 305 306 int QuicStreamFactory::Job::DoResolveHostComplete(int rv) { 307 if (rv != OK) 308 return rv; 309 310 DCHECK(!factory_->HasActiveSession(server_id_)); 311 312 // Inform the factory of this resolution, which will set up 313 // a session alias, if possible. 314 if (factory_->OnResolution(server_id_, address_list_)) { 315 return OK; 316 } 317 318 io_state_ = STATE_LOAD_SERVER_INFO; 319 return OK; 320 } 321 322 int QuicStreamFactory::Job::DoLoadServerInfo() { 323 io_state_ = STATE_LOAD_SERVER_INFO_COMPLETE; 324 325 if (!server_info_) 326 return OK; 327 328 return server_info_->WaitForDataReady( 329 base::Bind(&QuicStreamFactory::Job::OnIOComplete, 330 weak_factory_.GetWeakPtr())); 331 } 332 333 int QuicStreamFactory::Job::DoLoadServerInfoComplete(int rv) { 334 if (server_info_) { 335 UMA_HISTOGRAM_TIMES("Net.QuicServerInfo.DiskCacheReadTime", 336 base::TimeTicks::Now() - disk_cache_load_start_time_); 337 } 338 339 if (rv != OK) { 340 server_info_.reset(); 341 } 342 343 io_state_ = STATE_CONNECT; 344 return OK; 345 } 346 347 int QuicStreamFactory::Job::DoConnect() { 348 io_state_ = STATE_CONNECT_COMPLETE; 349 350 int rv = factory_->CreateSession(server_id_, server_info_.Pass(), 351 address_list_, net_log_, &session_); 352 if (rv != OK) { 353 DCHECK(rv != ERR_IO_PENDING); 354 DCHECK(!session_); 355 return rv; 356 } 357 358 session_->StartReading(); 359 if (!session_->connection()->connected()) { 360 return ERR_QUIC_PROTOCOL_ERROR; 361 } 362 bool require_confirmation = 363 factory_->require_confirmation() || is_post_ || 364 was_alternate_protocol_recently_broken_; 365 rv = session_->CryptoConnect( 366 require_confirmation, 367 base::Bind(&QuicStreamFactory::Job::OnIOComplete, 368 base::Unretained(this))); 369 return rv; 370 } 371 372 int QuicStreamFactory::Job::DoResumeConnect() { 373 io_state_ = STATE_CONNECT_COMPLETE; 374 375 int rv = session_->ResumeCryptoConnect( 376 base::Bind(&QuicStreamFactory::Job::OnIOComplete, 377 base::Unretained(this))); 378 379 return rv; 380 } 381 382 int QuicStreamFactory::Job::DoConnectComplete(int rv) { 383 if (rv != OK) 384 return rv; 385 386 DCHECK(!factory_->HasActiveSession(server_id_)); 387 // There may well now be an active session for this IP. If so, use the 388 // existing session instead. 389 AddressList address(session_->connection()->peer_address()); 390 if (factory_->OnResolution(server_id_, address)) { 391 session_->connection()->SendConnectionClose(QUIC_CONNECTION_IP_POOLED); 392 session_ = NULL; 393 return OK; 394 } 395 396 factory_->ActivateSession(server_id_, session_); 397 398 return OK; 399 } 400 401 QuicStreamRequest::QuicStreamRequest(QuicStreamFactory* factory) 402 : factory_(factory) {} 403 404 QuicStreamRequest::~QuicStreamRequest() { 405 if (factory_ && !callback_.is_null()) 406 factory_->CancelRequest(this); 407 } 408 409 int QuicStreamRequest::Request(const HostPortPair& host_port_pair, 410 bool is_https, 411 PrivacyMode privacy_mode, 412 base::StringPiece method, 413 const BoundNetLog& net_log, 414 const CompletionCallback& callback) { 415 DCHECK(!stream_); 416 DCHECK(callback_.is_null()); 417 DCHECK(factory_); 418 int rv = factory_->Create(host_port_pair, is_https, privacy_mode, method, 419 net_log, this); 420 if (rv == ERR_IO_PENDING) { 421 host_port_pair_ = host_port_pair; 422 is_https_ = is_https; 423 net_log_ = net_log; 424 callback_ = callback; 425 } else { 426 factory_ = NULL; 427 } 428 if (rv == OK) 429 DCHECK(stream_); 430 return rv; 431 } 432 433 void QuicStreamRequest::set_stream(scoped_ptr<QuicHttpStream> stream) { 434 DCHECK(stream); 435 stream_ = stream.Pass(); 436 } 437 438 void QuicStreamRequest::OnRequestComplete(int rv) { 439 factory_ = NULL; 440 callback_.Run(rv); 441 } 442 443 scoped_ptr<QuicHttpStream> QuicStreamRequest::ReleaseStream() { 444 DCHECK(stream_); 445 return stream_.Pass(); 446 } 447 448 QuicStreamFactory::QuicStreamFactory( 449 HostResolver* host_resolver, 450 ClientSocketFactory* client_socket_factory, 451 base::WeakPtr<HttpServerProperties> http_server_properties, 452 CertVerifier* cert_verifier, 453 TransportSecurityState* transport_security_state, 454 QuicCryptoClientStreamFactory* quic_crypto_client_stream_factory, 455 QuicRandom* random_generator, 456 QuicClock* clock, 457 size_t max_packet_length, 458 const std::string& user_agent_id, 459 const QuicVersionVector& supported_versions, 460 bool enable_port_selection, 461 bool enable_pacing, 462 bool enable_time_based_loss_detection) 463 : require_confirmation_(true), 464 host_resolver_(host_resolver), 465 client_socket_factory_(client_socket_factory), 466 http_server_properties_(http_server_properties), 467 cert_verifier_(cert_verifier), 468 quic_server_info_factory_(NULL), 469 quic_crypto_client_stream_factory_(quic_crypto_client_stream_factory), 470 random_generator_(random_generator), 471 clock_(clock), 472 max_packet_length_(max_packet_length), 473 config_(InitializeQuicConfig(enable_pacing, 474 enable_time_based_loss_detection)), 475 supported_versions_(supported_versions), 476 enable_port_selection_(enable_port_selection), 477 port_seed_(random_generator_->RandUint64()), 478 weak_factory_(this) { 479 crypto_config_.SetDefaults(); 480 crypto_config_.set_user_agent_id(user_agent_id); 481 crypto_config_.AddCanonicalSuffix(".c.youtube.com"); 482 crypto_config_.AddCanonicalSuffix(".googlevideo.com"); 483 crypto_config_.SetProofVerifier( 484 new ProofVerifierChromium(cert_verifier, transport_security_state)); 485 base::CPU cpu; 486 if (cpu.has_aesni() && cpu.has_avx()) 487 crypto_config_.PreferAesGcm(); 488 if (!IsEcdsaSupported()) 489 crypto_config_.DisableEcdsa(); 490 } 491 492 QuicStreamFactory::~QuicStreamFactory() { 493 CloseAllSessions(ERR_ABORTED); 494 while (!all_sessions_.empty()) { 495 delete all_sessions_.begin()->first; 496 all_sessions_.erase(all_sessions_.begin()); 497 } 498 STLDeleteValues(&active_jobs_); 499 } 500 501 int QuicStreamFactory::Create(const HostPortPair& host_port_pair, 502 bool is_https, 503 PrivacyMode privacy_mode, 504 base::StringPiece method, 505 const BoundNetLog& net_log, 506 QuicStreamRequest* request) { 507 QuicServerId server_id(host_port_pair, is_https, privacy_mode); 508 if (HasActiveSession(server_id)) { 509 request->set_stream(CreateIfSessionExists(server_id, net_log)); 510 return OK; 511 } 512 513 if (HasActiveJob(server_id)) { 514 Job* job = active_jobs_[server_id]; 515 active_requests_[request] = job; 516 job_requests_map_[job].insert(request); 517 return ERR_IO_PENDING; 518 } 519 520 QuicServerInfo* quic_server_info = NULL; 521 if (quic_server_info_factory_) { 522 QuicCryptoClientConfig::CachedState* cached = 523 crypto_config_.LookupOrCreate(server_id); 524 DCHECK(cached); 525 if (cached->IsEmpty()) { 526 quic_server_info = quic_server_info_factory_->GetForServer(server_id); 527 } 528 } 529 bool was_alternate_protocol_recently_broken = 530 http_server_properties_ && 531 http_server_properties_->WasAlternateProtocolRecentlyBroken( 532 server_id.host_port_pair()); 533 scoped_ptr<Job> job(new Job(this, host_resolver_, host_port_pair, is_https, 534 was_alternate_protocol_recently_broken, 535 privacy_mode, method, quic_server_info, net_log)); 536 int rv = job->Run(base::Bind(&QuicStreamFactory::OnJobComplete, 537 base::Unretained(this), job.get())); 538 539 if (rv == ERR_IO_PENDING) { 540 active_requests_[request] = job.get(); 541 job_requests_map_[job.get()].insert(request); 542 active_jobs_[server_id] = job.release(); 543 } 544 if (rv == OK) { 545 DCHECK(HasActiveSession(server_id)); 546 request->set_stream(CreateIfSessionExists(server_id, net_log)); 547 } 548 return rv; 549 } 550 551 bool QuicStreamFactory::OnResolution( 552 const QuicServerId& server_id, 553 const AddressList& address_list) { 554 DCHECK(!HasActiveSession(server_id)); 555 for (size_t i = 0; i < address_list.size(); ++i) { 556 const IPEndPoint& address = address_list[i]; 557 const IpAliasKey ip_alias_key(address, server_id.is_https()); 558 if (!ContainsKey(ip_aliases_, ip_alias_key)) 559 continue; 560 561 const SessionSet& sessions = ip_aliases_[ip_alias_key]; 562 for (SessionSet::const_iterator i = sessions.begin(); 563 i != sessions.end(); ++i) { 564 QuicClientSession* session = *i; 565 if (!session->CanPool(server_id.host())) 566 continue; 567 active_sessions_[server_id] = session; 568 session_aliases_[session].insert(server_id); 569 return true; 570 } 571 } 572 return false; 573 } 574 575 void QuicStreamFactory::OnJobComplete(Job* job, int rv) { 576 if (rv == OK) { 577 require_confirmation_ = false; 578 579 // Create all the streams, but do not notify them yet. 580 for (RequestSet::iterator it = job_requests_map_[job].begin(); 581 it != job_requests_map_[job].end() ; ++it) { 582 DCHECK(HasActiveSession(job->server_id())); 583 (*it)->set_stream(CreateIfSessionExists(job->server_id(), 584 (*it)->net_log())); 585 } 586 } 587 while (!job_requests_map_[job].empty()) { 588 RequestSet::iterator it = job_requests_map_[job].begin(); 589 QuicStreamRequest* request = *it; 590 job_requests_map_[job].erase(it); 591 active_requests_.erase(request); 592 // Even though we're invoking callbacks here, we don't need to worry 593 // about |this| being deleted, because the factory is owned by the 594 // profile which can not be deleted via callbacks. 595 request->OnRequestComplete(rv); 596 } 597 active_jobs_.erase(job->server_id()); 598 job_requests_map_.erase(job); 599 delete job; 600 return; 601 } 602 603 // Returns a newly created QuicHttpStream owned by the caller, if a 604 // matching session already exists. Returns NULL otherwise. 605 scoped_ptr<QuicHttpStream> QuicStreamFactory::CreateIfSessionExists( 606 const QuicServerId& server_id, 607 const BoundNetLog& net_log) { 608 if (!HasActiveSession(server_id)) { 609 DVLOG(1) << "No active session"; 610 return scoped_ptr<QuicHttpStream>(); 611 } 612 613 QuicClientSession* session = active_sessions_[server_id]; 614 DCHECK(session); 615 return scoped_ptr<QuicHttpStream>( 616 new QuicHttpStream(session->GetWeakPtr())); 617 } 618 619 void QuicStreamFactory::OnIdleSession(QuicClientSession* session) { 620 } 621 622 void QuicStreamFactory::OnSessionGoingAway(QuicClientSession* session) { 623 const AliasSet& aliases = session_aliases_[session]; 624 for (AliasSet::const_iterator it = aliases.begin(); it != aliases.end(); 625 ++it) { 626 DCHECK(active_sessions_.count(*it)); 627 DCHECK_EQ(session, active_sessions_[*it]); 628 // Track sessions which have recently gone away so that we can disable 629 // port suggestions. 630 if (session->goaway_received()) { 631 gone_away_aliases_.insert(*it); 632 } 633 634 active_sessions_.erase(*it); 635 ProcessGoingAwaySession(session, *it, true); 636 } 637 ProcessGoingAwaySession(session, all_sessions_[session], false); 638 if (!aliases.empty()) { 639 const IpAliasKey ip_alias_key(session->connection()->peer_address(), 640 aliases.begin()->is_https()); 641 ip_aliases_[ip_alias_key].erase(session); 642 if (ip_aliases_[ip_alias_key].empty()) { 643 ip_aliases_.erase(ip_alias_key); 644 } 645 } 646 session_aliases_.erase(session); 647 } 648 649 void QuicStreamFactory::OnSessionClosed(QuicClientSession* session) { 650 DCHECK_EQ(0u, session->GetNumOpenStreams()); 651 OnSessionGoingAway(session); 652 delete session; 653 all_sessions_.erase(session); 654 } 655 656 void QuicStreamFactory::OnSessionConnectTimeout( 657 QuicClientSession* session) { 658 const AliasSet& aliases = session_aliases_[session]; 659 for (AliasSet::const_iterator it = aliases.begin(); it != aliases.end(); 660 ++it) { 661 DCHECK(active_sessions_.count(*it)); 662 DCHECK_EQ(session, active_sessions_[*it]); 663 active_sessions_.erase(*it); 664 } 665 666 if (aliases.empty()) { 667 return; 668 } 669 670 const IpAliasKey ip_alias_key(session->connection()->peer_address(), 671 aliases.begin()->is_https()); 672 ip_aliases_[ip_alias_key].erase(session); 673 if (ip_aliases_[ip_alias_key].empty()) { 674 ip_aliases_.erase(ip_alias_key); 675 } 676 QuicServerId server_id = *aliases.begin(); 677 session_aliases_.erase(session); 678 Job* job = new Job(this, host_resolver_, session, server_id); 679 active_jobs_[server_id] = job; 680 int rv = job->Run(base::Bind(&QuicStreamFactory::OnJobComplete, 681 base::Unretained(this), job)); 682 DCHECK_EQ(ERR_IO_PENDING, rv); 683 } 684 685 void QuicStreamFactory::CancelRequest(QuicStreamRequest* request) { 686 DCHECK(ContainsKey(active_requests_, request)); 687 Job* job = active_requests_[request]; 688 job_requests_map_[job].erase(request); 689 active_requests_.erase(request); 690 } 691 692 void QuicStreamFactory::CloseAllSessions(int error) { 693 while (!active_sessions_.empty()) { 694 size_t initial_size = active_sessions_.size(); 695 active_sessions_.begin()->second->CloseSessionOnError(error); 696 DCHECK_NE(initial_size, active_sessions_.size()); 697 } 698 while (!all_sessions_.empty()) { 699 size_t initial_size = all_sessions_.size(); 700 all_sessions_.begin()->first->CloseSessionOnError(error); 701 DCHECK_NE(initial_size, all_sessions_.size()); 702 } 703 DCHECK(all_sessions_.empty()); 704 } 705 706 base::Value* QuicStreamFactory::QuicStreamFactoryInfoToValue() const { 707 base::ListValue* list = new base::ListValue(); 708 709 for (SessionMap::const_iterator it = active_sessions_.begin(); 710 it != active_sessions_.end(); ++it) { 711 const QuicServerId& server_id = it->first; 712 QuicClientSession* session = it->second; 713 const AliasSet& aliases = session_aliases_.find(session)->second; 714 // Only add a session to the list once. 715 if (server_id == *aliases.begin()) { 716 std::set<HostPortPair> hosts; 717 for (AliasSet::const_iterator alias_it = aliases.begin(); 718 alias_it != aliases.end(); ++alias_it) { 719 hosts.insert(alias_it->host_port_pair()); 720 } 721 list->Append(session->GetInfoAsValue(hosts)); 722 } 723 } 724 return list; 725 } 726 727 void QuicStreamFactory::ClearCachedStatesInCryptoConfig() { 728 crypto_config_.ClearCachedStates(); 729 } 730 731 void QuicStreamFactory::OnIPAddressChanged() { 732 CloseAllSessions(ERR_NETWORK_CHANGED); 733 require_confirmation_ = true; 734 } 735 736 void QuicStreamFactory::OnCertAdded(const X509Certificate* cert) { 737 CloseAllSessions(ERR_CERT_DATABASE_CHANGED); 738 } 739 740 void QuicStreamFactory::OnCACertChanged(const X509Certificate* cert) { 741 // We should flush the sessions if we removed trust from a 742 // cert, because a previously trusted server may have become 743 // untrusted. 744 // 745 // We should not flush the sessions if we added trust to a cert. 746 // 747 // Since the OnCACertChanged method doesn't tell us what 748 // kind of change it is, we have to flush the socket 749 // pools to be safe. 750 CloseAllSessions(ERR_CERT_DATABASE_CHANGED); 751 } 752 753 bool QuicStreamFactory::HasActiveSession( 754 const QuicServerId& server_id) const { 755 return ContainsKey(active_sessions_, server_id); 756 } 757 758 int QuicStreamFactory::CreateSession( 759 const QuicServerId& server_id, 760 scoped_ptr<QuicServerInfo> server_info, 761 const AddressList& address_list, 762 const BoundNetLog& net_log, 763 QuicClientSession** session) { 764 bool enable_port_selection = enable_port_selection_; 765 if (enable_port_selection && 766 ContainsKey(gone_away_aliases_, server_id)) { 767 // Disable port selection when the server is going away. 768 // There is no point in trying to return to the same server, if 769 // that server is no longer handling requests. 770 enable_port_selection = false; 771 gone_away_aliases_.erase(server_id); 772 } 773 774 QuicConnectionId connection_id = random_generator_->RandUint64(); 775 IPEndPoint addr = *address_list.begin(); 776 scoped_refptr<PortSuggester> port_suggester = 777 new PortSuggester(server_id.host_port_pair(), port_seed_); 778 DatagramSocket::BindType bind_type = enable_port_selection ? 779 DatagramSocket::RANDOM_BIND : // Use our callback. 780 DatagramSocket::DEFAULT_BIND; // Use OS to randomize. 781 scoped_ptr<DatagramClientSocket> socket( 782 client_socket_factory_->CreateDatagramClientSocket( 783 bind_type, 784 base::Bind(&PortSuggester::SuggestPort, port_suggester), 785 net_log.net_log(), net_log.source())); 786 int rv = socket->Connect(addr); 787 if (rv != OK) { 788 HistogramCreateSessionFailure(CREATION_ERROR_CONNECTING_SOCKET); 789 return rv; 790 } 791 UMA_HISTOGRAM_COUNTS("Net.QuicEphemeralPortsSuggested", 792 port_suggester->call_count()); 793 if (enable_port_selection) { 794 DCHECK_LE(1u, port_suggester->call_count()); 795 } else { 796 DCHECK_EQ(0u, port_suggester->call_count()); 797 } 798 799 // We should adaptively set this buffer size, but for now, we'll use a size 800 // that is more than large enough for a full receive window, and yet 801 // does not consume "too much" memory. If we see bursty packet loss, we may 802 // revisit this setting and test for its impact. 803 const int32 kSocketBufferSize(TcpReceiver::kReceiveWindowTCP); 804 rv = socket->SetReceiveBufferSize(kSocketBufferSize); 805 if (rv != OK) { 806 HistogramCreateSessionFailure(CREATION_ERROR_SETTING_RECEIVE_BUFFER); 807 return rv; 808 } 809 // Set a buffer large enough to contain the initial CWND's worth of packet 810 // to work around the problem with CHLO packets being sent out with the 811 // wrong encryption level, when the send buffer is full. 812 rv = socket->SetSendBufferSize(kMaxPacketSize * 20); 813 if (rv != OK) { 814 HistogramCreateSessionFailure(CREATION_ERROR_SETTING_SEND_BUFFER); 815 return rv; 816 } 817 818 scoped_ptr<QuicDefaultPacketWriter> writer( 819 new QuicDefaultPacketWriter(socket.get())); 820 821 if (!helper_.get()) { 822 helper_.reset(new QuicConnectionHelper( 823 base::MessageLoop::current()->message_loop_proxy().get(), 824 clock_.get(), random_generator_)); 825 } 826 827 QuicConnection* connection = 828 new QuicConnection(connection_id, addr, helper_.get(), writer.get(), 829 false, supported_versions_); 830 writer->SetConnection(connection); 831 connection->set_max_packet_length(max_packet_length_); 832 833 InitializeCachedStateInCryptoConfig(server_id, server_info); 834 835 QuicConfig config = config_; 836 config.SetInitialCongestionWindowToSend( 837 server_id.is_https() ? kServerSecureInitialCongestionWindow 838 : kServerInecureInitialCongestionWindow); 839 config.SetInitialFlowControlWindowToSend(kInitialReceiveWindowSize); 840 config.SetInitialStreamFlowControlWindowToSend(kInitialReceiveWindowSize); 841 config.SetInitialSessionFlowControlWindowToSend(kInitialReceiveWindowSize); 842 if (http_server_properties_) { 843 const HttpServerProperties::NetworkStats* stats = 844 http_server_properties_->GetServerNetworkStats( 845 server_id.host_port_pair()); 846 if (stats != NULL) { 847 config.SetInitialRoundTripTimeUsToSend(stats->srtt.InMicroseconds()); 848 } 849 } 850 851 *session = new QuicClientSession( 852 connection, socket.Pass(), writer.Pass(), this, 853 quic_crypto_client_stream_factory_, server_info.Pass(), server_id, 854 config, &crypto_config_, 855 base::MessageLoop::current()->message_loop_proxy().get(), 856 net_log.net_log()); 857 all_sessions_[*session] = server_id; // owning pointer 858 return OK; 859 } 860 861 bool QuicStreamFactory::HasActiveJob(const QuicServerId& key) const { 862 return ContainsKey(active_jobs_, key); 863 } 864 865 void QuicStreamFactory::ActivateSession( 866 const QuicServerId& server_id, 867 QuicClientSession* session) { 868 DCHECK(!HasActiveSession(server_id)); 869 UMA_HISTOGRAM_COUNTS("Net.QuicActiveSessions", active_sessions_.size()); 870 active_sessions_[server_id] = session; 871 session_aliases_[session].insert(server_id); 872 const IpAliasKey ip_alias_key(session->connection()->peer_address(), 873 server_id.is_https()); 874 DCHECK(!ContainsKey(ip_aliases_[ip_alias_key], session)); 875 ip_aliases_[ip_alias_key].insert(session); 876 } 877 878 void QuicStreamFactory::InitializeCachedStateInCryptoConfig( 879 const QuicServerId& server_id, 880 const scoped_ptr<QuicServerInfo>& server_info) { 881 if (!server_info) 882 return; 883 884 QuicCryptoClientConfig::CachedState* cached = 885 crypto_config_.LookupOrCreate(server_id); 886 if (!cached->IsEmpty()) 887 return; 888 889 if (!cached->Initialize(server_info->state().server_config, 890 server_info->state().source_address_token, 891 server_info->state().certs, 892 server_info->state().server_config_sig, 893 clock_->WallNow())) 894 return; 895 896 if (!server_id.is_https()) { 897 // Don't check the certificates for insecure QUIC. 898 cached->SetProofValid(); 899 } 900 } 901 902 void QuicStreamFactory::ProcessGoingAwaySession( 903 QuicClientSession* session, 904 const QuicServerId& server_id, 905 bool session_was_active) { 906 if (!http_server_properties_) 907 return; 908 909 const QuicConnectionStats& stats = session->connection()->GetStats(); 910 if (session->IsCryptoHandshakeConfirmed()) { 911 HttpServerProperties::NetworkStats network_stats; 912 network_stats.srtt = base::TimeDelta::FromMicroseconds(stats.srtt_us); 913 network_stats.bandwidth_estimate = stats.estimated_bandwidth; 914 http_server_properties_->SetServerNetworkStats(server_id.host_port_pair(), 915 network_stats); 916 return; 917 } 918 919 UMA_HISTOGRAM_COUNTS("Net.QuicHandshakeNotConfirmedNumPacketsReceived", 920 stats.packets_received); 921 922 if (!session_was_active) 923 return; 924 925 const HostPortPair& server = server_id.host_port_pair(); 926 // Don't try to change the alternate-protocol state, if the 927 // alternate-protocol state is unknown. 928 if (!http_server_properties_->HasAlternateProtocol(server)) 929 return; 930 931 // TODO(rch): In the special case where the session has received no 932 // packets from the peer, we should consider blacklisting this 933 // differently so that we still race TCP but we don't consider the 934 // session connected until the handshake has been confirmed. 935 HistogramBrokenAlternateProtocolLocation( 936 BROKEN_ALTERNATE_PROTOCOL_LOCATION_QUIC_STREAM_FACTORY); 937 PortAlternateProtocolPair alternate = 938 http_server_properties_->GetAlternateProtocol(server); 939 DCHECK_EQ(QUIC, alternate.protocol); 940 941 // Since the session was active, there's no longer an 942 // HttpStreamFactoryImpl::Job running which can mark it broken, unless the 943 // TCP job also fails. So to avoid not using QUIC when we otherwise could, 944 // we mark it as broken, and then immediately re-enable it. This leaves 945 // QUIC as "recently broken" which means that 0-RTT will be disabled but 946 // we'll still race. 947 http_server_properties_->SetBrokenAlternateProtocol(server); 948 http_server_properties_->ClearAlternateProtocol(server); 949 http_server_properties_->SetAlternateProtocol( 950 server, alternate.port, alternate.protocol); 951 DCHECK_EQ(QUIC, 952 http_server_properties_->GetAlternateProtocol(server).protocol); 953 DCHECK(http_server_properties_->WasAlternateProtocolRecentlyBroken( 954 server)); 955 } 956 957 } // namespace net 958