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/http/http_stream_factory_impl.h" 6 7 #include <string> 8 9 #include "base/stl_util.h" 10 #include "base/strings/string_number_conversions.h" 11 #include "net/base/net_log.h" 12 #include "net/base/net_util.h" 13 #include "net/http/http_network_session.h" 14 #include "net/http/http_pipelined_connection.h" 15 #include "net/http/http_pipelined_host.h" 16 #include "net/http/http_pipelined_stream.h" 17 #include "net/http/http_server_properties.h" 18 #include "net/http/http_stream_factory_impl_job.h" 19 #include "net/http/http_stream_factory_impl_request.h" 20 #include "net/spdy/spdy_http_stream.h" 21 #include "url/gurl.h" 22 23 namespace net { 24 25 namespace { 26 27 const PortAlternateProtocolPair kNoAlternateProtocol = { 28 0, UNINITIALIZED_ALTERNATE_PROTOCOL 29 }; 30 31 GURL UpgradeUrlToHttps(const GURL& original_url, int port) { 32 GURL::Replacements replacements; 33 // new_sheme and new_port need to be in scope here because GURL::Replacements 34 // references the memory contained by them directly. 35 const std::string new_scheme = "https"; 36 const std::string new_port = base::IntToString(port); 37 replacements.SetSchemeStr(new_scheme); 38 replacements.SetPortStr(new_port); 39 return original_url.ReplaceComponents(replacements); 40 } 41 42 } // namespace 43 44 HttpStreamFactoryImpl::HttpStreamFactoryImpl(HttpNetworkSession* session, 45 bool for_websockets) 46 : session_(session), 47 http_pipelined_host_pool_(this, NULL, 48 session_->http_server_properties(), 49 session_->force_http_pipelining()), 50 for_websockets_(for_websockets) {} 51 52 HttpStreamFactoryImpl::~HttpStreamFactoryImpl() { 53 DCHECK(request_map_.empty()); 54 DCHECK(spdy_session_request_map_.empty()); 55 DCHECK(http_pipelining_request_map_.empty()); 56 57 std::set<const Job*> tmp_job_set; 58 tmp_job_set.swap(orphaned_job_set_); 59 STLDeleteContainerPointers(tmp_job_set.begin(), tmp_job_set.end()); 60 DCHECK(orphaned_job_set_.empty()); 61 62 tmp_job_set.clear(); 63 tmp_job_set.swap(preconnect_job_set_); 64 STLDeleteContainerPointers(tmp_job_set.begin(), tmp_job_set.end()); 65 DCHECK(preconnect_job_set_.empty()); 66 } 67 68 HttpStreamRequest* HttpStreamFactoryImpl::RequestStream( 69 const HttpRequestInfo& request_info, 70 RequestPriority priority, 71 const SSLConfig& server_ssl_config, 72 const SSLConfig& proxy_ssl_config, 73 HttpStreamRequest::Delegate* delegate, 74 const BoundNetLog& net_log) { 75 DCHECK(!for_websockets_); 76 return RequestStreamInternal(request_info, 77 priority, 78 server_ssl_config, 79 proxy_ssl_config, 80 delegate, 81 NULL, 82 net_log); 83 } 84 85 HttpStreamRequest* HttpStreamFactoryImpl::RequestWebSocketStream( 86 const HttpRequestInfo& request_info, 87 RequestPriority priority, 88 const SSLConfig& server_ssl_config, 89 const SSLConfig& proxy_ssl_config, 90 HttpStreamRequest::Delegate* delegate, 91 WebSocketStreamBase::Factory* factory, 92 const BoundNetLog& net_log) { 93 DCHECK(for_websockets_); 94 DCHECK(factory); 95 return RequestStreamInternal(request_info, 96 priority, 97 server_ssl_config, 98 proxy_ssl_config, 99 delegate, 100 factory, 101 net_log); 102 } 103 104 HttpStreamRequest* HttpStreamFactoryImpl::RequestStreamInternal( 105 const HttpRequestInfo& request_info, 106 RequestPriority priority, 107 const SSLConfig& server_ssl_config, 108 const SSLConfig& proxy_ssl_config, 109 HttpStreamRequest::Delegate* delegate, 110 WebSocketStreamBase::Factory* websocket_stream_factory, 111 const BoundNetLog& net_log) { 112 Request* request = new Request(request_info.url, 113 this, 114 delegate, 115 websocket_stream_factory, 116 net_log); 117 118 GURL alternate_url; 119 PortAlternateProtocolPair alternate = 120 GetAlternateProtocolRequestFor(request_info.url, &alternate_url); 121 Job* alternate_job = NULL; 122 if (alternate.protocol != UNINITIALIZED_ALTERNATE_PROTOCOL) { 123 // Never share connection with other jobs for FTP requests. 124 DCHECK(!request_info.url.SchemeIs("ftp")); 125 126 HttpRequestInfo alternate_request_info = request_info; 127 alternate_request_info.url = alternate_url; 128 alternate_job = 129 new Job(this, session_, alternate_request_info, priority, 130 server_ssl_config, proxy_ssl_config, net_log.net_log()); 131 request->AttachJob(alternate_job); 132 alternate_job->MarkAsAlternate(request_info.url, alternate); 133 } 134 135 Job* job = new Job(this, session_, request_info, priority, 136 server_ssl_config, proxy_ssl_config, net_log.net_log()); 137 request->AttachJob(job); 138 if (alternate_job) { 139 // Never share connection with other jobs for FTP requests. 140 DCHECK(!request_info.url.SchemeIs("ftp")); 141 142 job->WaitFor(alternate_job); 143 // Make sure to wait until we call WaitFor(), before starting 144 // |alternate_job|, otherwise |alternate_job| will not notify |job| 145 // appropriately. 146 alternate_job->Start(request); 147 } 148 // Even if |alternate_job| has already finished, it won't have notified the 149 // request yet, since we defer that to the next iteration of the MessageLoop, 150 // so starting |job| is always safe. 151 job->Start(request); 152 return request; 153 } 154 155 void HttpStreamFactoryImpl::PreconnectStreams( 156 int num_streams, 157 const HttpRequestInfo& request_info, 158 RequestPriority priority, 159 const SSLConfig& server_ssl_config, 160 const SSLConfig& proxy_ssl_config) { 161 DCHECK(!for_websockets_); 162 GURL alternate_url; 163 PortAlternateProtocolPair alternate = 164 GetAlternateProtocolRequestFor(request_info.url, &alternate_url); 165 Job* job = NULL; 166 if (alternate.protocol != UNINITIALIZED_ALTERNATE_PROTOCOL) { 167 HttpRequestInfo alternate_request_info = request_info; 168 alternate_request_info.url = alternate_url; 169 job = new Job(this, session_, alternate_request_info, priority, 170 server_ssl_config, proxy_ssl_config, session_->net_log()); 171 job->MarkAsAlternate(request_info.url, alternate); 172 } else { 173 job = new Job(this, session_, request_info, priority, 174 server_ssl_config, proxy_ssl_config, session_->net_log()); 175 } 176 preconnect_job_set_.insert(job); 177 job->Preconnect(num_streams); 178 } 179 180 base::Value* HttpStreamFactoryImpl::PipelineInfoToValue() const { 181 return http_pipelined_host_pool_.PipelineInfoToValue(); 182 } 183 184 const HostMappingRules* HttpStreamFactoryImpl::GetHostMappingRules() const { 185 return session_->params().host_mapping_rules; 186 } 187 188 PortAlternateProtocolPair HttpStreamFactoryImpl::GetAlternateProtocolRequestFor( 189 const GURL& original_url, 190 GURL* alternate_url) const { 191 if (!use_alternate_protocols()) 192 return kNoAlternateProtocol; 193 194 if (original_url.SchemeIs("ftp")) 195 return kNoAlternateProtocol; 196 197 HostPortPair origin = HostPortPair(original_url.HostNoBrackets(), 198 original_url.EffectiveIntPort()); 199 200 const HttpServerProperties& http_server_properties = 201 *session_->http_server_properties(); 202 if (!http_server_properties.HasAlternateProtocol(origin)) 203 return kNoAlternateProtocol; 204 205 PortAlternateProtocolPair alternate = 206 http_server_properties.GetAlternateProtocol(origin); 207 if (alternate.protocol == ALTERNATE_PROTOCOL_BROKEN) 208 return kNoAlternateProtocol; 209 210 DCHECK_LE(NPN_SPDY_1, alternate.protocol); 211 DCHECK_GT(NUM_ALTERNATE_PROTOCOLS, alternate.protocol); 212 213 if (alternate.protocol < NPN_SPDY_2) 214 return kNoAlternateProtocol; 215 216 // Some shared unix systems may have user home directories (like 217 // http://foo.com/~mike) which allow users to emit headers. This is a bad 218 // idea already, but with Alternate-Protocol, it provides the ability for a 219 // single user on a multi-user system to hijack the alternate protocol. 220 // These systems also enforce ports <1024 as restricted ports. So don't 221 // allow protocol upgrades to user-controllable ports. 222 const int kUnrestrictedPort = 1024; 223 if (!session_->params().enable_user_alternate_protocol_ports && 224 (alternate.port >= kUnrestrictedPort && 225 origin.port() < kUnrestrictedPort)) 226 return kNoAlternateProtocol; 227 228 origin.set_port(alternate.port); 229 if (alternate.protocol >= NPN_SPDY_MINIMUM_VERSION && 230 alternate.protocol <= NPN_SPDY_MAXIMUM_VERSION) { 231 if (!spdy_enabled()) 232 return kNoAlternateProtocol; 233 234 if (HttpStreamFactory::HasSpdyExclusion(origin)) 235 return kNoAlternateProtocol; 236 237 *alternate_url = UpgradeUrlToHttps(original_url, alternate.port); 238 } else { 239 DCHECK_EQ(QUIC, alternate.protocol); 240 if (!session_->params().enable_quic || 241 !(original_url.SchemeIs("http") || 242 session_->params().enable_quic_https)) { 243 return kNoAlternateProtocol; 244 } 245 // TODO(rch): Figure out how to make QUIC iteract with PAC 246 // scripts. By not re-writing the URL, we will query the PAC script 247 // for the proxy to use to reach the original URL via TCP. But 248 // the alternate request will be going via UDP to a different port. 249 *alternate_url = original_url; 250 } 251 return alternate; 252 } 253 254 void HttpStreamFactoryImpl::OrphanJob(Job* job, const Request* request) { 255 DCHECK(ContainsKey(request_map_, job)); 256 DCHECK_EQ(request_map_[job], request); 257 DCHECK(!ContainsKey(orphaned_job_set_, job)); 258 259 request_map_.erase(job); 260 261 orphaned_job_set_.insert(job); 262 job->Orphan(request); 263 } 264 265 void HttpStreamFactoryImpl::OnNewSpdySessionReady( 266 const base::WeakPtr<SpdySession>& spdy_session, 267 bool direct, 268 const SSLConfig& used_ssl_config, 269 const ProxyInfo& used_proxy_info, 270 bool was_npn_negotiated, 271 NextProto protocol_negotiated, 272 bool using_spdy, 273 const BoundNetLog& net_log) { 274 while (true) { 275 if (!spdy_session) 276 break; 277 const SpdySessionKey& spdy_session_key = spdy_session->spdy_session_key(); 278 // Each iteration may empty out the RequestSet for |spdy_session_key| in 279 // |spdy_session_request_map_|. So each time, check for RequestSet and use 280 // the first one. 281 // 282 // TODO(willchan): If it's important, switch RequestSet out for a FIFO 283 // queue (Order by priority first, then FIFO within same priority). Unclear 284 // that it matters here. 285 if (!ContainsKey(spdy_session_request_map_, spdy_session_key)) 286 break; 287 Request* request = *spdy_session_request_map_[spdy_session_key].begin(); 288 request->Complete(was_npn_negotiated, 289 protocol_negotiated, 290 using_spdy, 291 net_log); 292 if (for_websockets_) { 293 WebSocketStreamBase::Factory* factory = 294 request->websocket_stream_factory(); 295 DCHECK(factory); 296 bool use_relative_url = direct || request->url().SchemeIs("wss"); 297 request->OnWebSocketStreamReady( 298 NULL, 299 used_ssl_config, 300 used_proxy_info, 301 factory->CreateSpdyStream(spdy_session, use_relative_url)); 302 } else { 303 bool use_relative_url = direct || request->url().SchemeIs("https"); 304 request->OnStreamReady( 305 NULL, 306 used_ssl_config, 307 used_proxy_info, 308 new SpdyHttpStream(spdy_session, use_relative_url)); 309 } 310 } 311 // TODO(mbelshe): Alert other valid requests. 312 } 313 314 void HttpStreamFactoryImpl::OnOrphanedJobComplete(const Job* job) { 315 orphaned_job_set_.erase(job); 316 delete job; 317 } 318 319 void HttpStreamFactoryImpl::OnPreconnectsComplete(const Job* job) { 320 preconnect_job_set_.erase(job); 321 delete job; 322 OnPreconnectsCompleteInternal(); 323 } 324 325 void HttpStreamFactoryImpl::OnHttpPipelinedHostHasAdditionalCapacity( 326 HttpPipelinedHost* host) { 327 while (ContainsKey(http_pipelining_request_map_, host->GetKey())) { 328 HttpPipelinedStream* stream = 329 http_pipelined_host_pool_.CreateStreamOnExistingPipeline( 330 host->GetKey()); 331 if (!stream) { 332 break; 333 } 334 335 Request* request = *http_pipelining_request_map_[host->GetKey()].begin(); 336 request->Complete(stream->was_npn_negotiated(), 337 stream->protocol_negotiated(), 338 false, // not using_spdy 339 stream->net_log()); 340 request->OnStreamReady(NULL, 341 stream->used_ssl_config(), 342 stream->used_proxy_info(), 343 stream); 344 } 345 } 346 347 void HttpStreamFactoryImpl::AbortPipelinedRequestsWithKey( 348 const Job* job, const HttpPipelinedHost::Key& key, int status, 349 const SSLConfig& used_ssl_config) { 350 RequestVector requests_to_fail = http_pipelining_request_map_[key]; 351 for (RequestVector::const_iterator it = requests_to_fail.begin(); 352 it != requests_to_fail.end(); ++it) { 353 Request* request = *it; 354 if (request == request_map_[job]) { 355 continue; 356 } 357 request->OnStreamFailed(NULL, status, used_ssl_config); 358 } 359 } 360 361 } // namespace net 362
