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