OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/http/http_proxy_client_socket_pool.h" | 5 #include "net/http/http_proxy_client_socket_pool.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 | 8 |
9 #include "base/time.h" | 9 #include "base/time.h" |
10 #include "base/values.h" | 10 #include "base/values.h" |
(...skipping 10 matching lines...) Expand all Loading... |
21 #include "net/socket/ssl_client_socket_pool.h" | 21 #include "net/socket/ssl_client_socket_pool.h" |
22 #include "net/socket/transport_client_socket_pool.h" | 22 #include "net/socket/transport_client_socket_pool.h" |
23 #include "net/spdy/spdy_proxy_client_socket.h" | 23 #include "net/spdy/spdy_proxy_client_socket.h" |
24 #include "net/spdy/spdy_session.h" | 24 #include "net/spdy/spdy_session.h" |
25 #include "net/spdy/spdy_session_pool.h" | 25 #include "net/spdy/spdy_session_pool.h" |
26 #include "net/spdy/spdy_settings_storage.h" | 26 #include "net/spdy/spdy_settings_storage.h" |
27 #include "net/spdy/spdy_stream.h" | 27 #include "net/spdy/spdy_stream.h" |
28 | 28 |
29 namespace net { | 29 namespace net { |
30 | 30 |
31 namespace { | |
32 | |
33 std::string GetProxyUrl(const scoped_refptr<HttpProxySocketParams>& params) { | |
34 return (params->ssl_params() != NULL ? "https://" : "http://") | |
35 + params->destination().host_port_pair().ToString(); | |
36 } | |
37 | |
38 } // namespace | |
39 | |
40 HttpProxySocketParams::HttpProxySocketParams( | 31 HttpProxySocketParams::HttpProxySocketParams( |
41 const scoped_refptr<TransportSocketParams>& transport_params, | 32 const scoped_refptr<TransportSocketParams>& transport_params, |
42 const scoped_refptr<SSLSocketParams>& ssl_params, | 33 const scoped_refptr<SSLSocketParams>& ssl_params, |
43 const GURL& request_url, | 34 const GURL& request_url, |
44 const std::string& user_agent, | 35 const std::string& user_agent, |
45 const HostPortPair& endpoint, | 36 const HostPortPair& endpoint, |
46 HttpAuthCache* http_auth_cache, | 37 HttpAuthCache* http_auth_cache, |
47 HttpAuthHandlerFactory* http_auth_handler_factory, | 38 HttpAuthHandlerFactory* http_auth_handler_factory, |
48 SpdySessionPool* spdy_session_pool, | 39 SpdySessionPool* spdy_session_pool, |
49 bool tunnel, | 40 bool tunnel) |
50 TunnelAuthCallback auth_needed_callback) | |
51 : transport_params_(transport_params), | 41 : transport_params_(transport_params), |
52 ssl_params_(ssl_params), | 42 ssl_params_(ssl_params), |
53 spdy_session_pool_(spdy_session_pool), | 43 spdy_session_pool_(spdy_session_pool), |
54 request_url_(request_url), | 44 request_url_(request_url), |
55 user_agent_(user_agent), | 45 user_agent_(user_agent), |
56 endpoint_(endpoint), | 46 endpoint_(endpoint), |
57 http_auth_cache_(tunnel ? http_auth_cache : NULL), | 47 http_auth_cache_(tunnel ? http_auth_cache : NULL), |
58 http_auth_handler_factory_(tunnel ? http_auth_handler_factory : NULL), | 48 http_auth_handler_factory_(tunnel ? http_auth_handler_factory : NULL), |
59 tunnel_(tunnel), | 49 tunnel_(tunnel) { |
60 auth_needed_callback_(auth_needed_callback) { | |
61 DCHECK((transport_params == NULL && ssl_params != NULL) || | 50 DCHECK((transport_params == NULL && ssl_params != NULL) || |
62 (transport_params != NULL && ssl_params == NULL)); | 51 (transport_params != NULL && ssl_params == NULL)); |
63 if (transport_params_) | 52 if (transport_params_) |
64 ignore_limits_ = transport_params->ignore_limits(); | 53 ignore_limits_ = transport_params->ignore_limits(); |
65 else | 54 else |
66 ignore_limits_ = ssl_params->ignore_limits(); | 55 ignore_limits_ = ssl_params->ignore_limits(); |
67 } | 56 } |
68 | 57 |
69 const HostResolver::RequestInfo& HttpProxySocketParams::destination() const { | 58 const HostResolver::RequestInfo& HttpProxySocketParams::destination() const { |
70 if (transport_params_ == NULL) | 59 if (transport_params_ == NULL) |
(...skipping 20 matching lines...) Expand all Loading... |
91 : ConnectJob(group_name, timeout_duration, delegate, | 80 : ConnectJob(group_name, timeout_duration, delegate, |
92 BoundNetLog::Make(net_log, NetLog::SOURCE_CONNECT_JOB)), | 81 BoundNetLog::Make(net_log, NetLog::SOURCE_CONNECT_JOB)), |
93 params_(params), | 82 params_(params), |
94 transport_pool_(transport_pool), | 83 transport_pool_(transport_pool), |
95 ssl_pool_(ssl_pool), | 84 ssl_pool_(ssl_pool), |
96 resolver_(host_resolver), | 85 resolver_(host_resolver), |
97 ALLOW_THIS_IN_INITIALIZER_LIST( | 86 ALLOW_THIS_IN_INITIALIZER_LIST( |
98 callback_(base::Bind(&HttpProxyConnectJob::OnIOComplete, | 87 callback_(base::Bind(&HttpProxyConnectJob::OnIOComplete, |
99 base::Unretained(this)))), | 88 base::Unretained(this)))), |
100 using_spdy_(false), | 89 using_spdy_(false), |
101 protocol_negotiated_(SSLClientSocket::kProtoUnknown), | 90 protocol_negotiated_(SSLClientSocket::kProtoUnknown) { |
102 auth_(params->tunnel() ? | |
103 new HttpAuthController(HttpAuth::AUTH_PROXY, | |
104 GURL(GetProxyUrl(params_)), | |
105 params->http_auth_cache(), | |
106 params->http_auth_handler_factory()) | |
107 : NULL), | |
108 ALLOW_THIS_IN_INITIALIZER_LIST(ptr_factory_(this)) { | |
109 } | 91 } |
110 | 92 |
111 HttpProxyConnectJob::~HttpProxyConnectJob() {} | 93 HttpProxyConnectJob::~HttpProxyConnectJob() {} |
112 | 94 |
113 LoadState HttpProxyConnectJob::GetLoadState() const { | 95 LoadState HttpProxyConnectJob::GetLoadState() const { |
114 switch (next_state_) { | 96 switch (next_state_) { |
115 case STATE_TCP_CONNECT: | 97 case STATE_TCP_CONNECT: |
116 case STATE_TCP_CONNECT_COMPLETE: | 98 case STATE_TCP_CONNECT_COMPLETE: |
117 case STATE_SSL_CONNECT: | 99 case STATE_SSL_CONNECT: |
118 case STATE_SSL_CONNECT_COMPLETE: | 100 case STATE_SSL_CONNECT_COMPLETE: |
119 return transport_socket_handle_->GetLoadState(); | 101 return transport_socket_handle_->GetLoadState(); |
120 case STATE_HTTP_PROXY_CONNECT: | 102 case STATE_HTTP_PROXY_CONNECT: |
121 case STATE_HTTP_PROXY_CONNECT_COMPLETE: | 103 case STATE_HTTP_PROXY_CONNECT_COMPLETE: |
122 case STATE_SPDY_PROXY_CREATE_STREAM: | 104 case STATE_SPDY_PROXY_CREATE_STREAM: |
123 case STATE_SPDY_PROXY_CREATE_STREAM_COMPLETE: | 105 case STATE_SPDY_PROXY_CREATE_STREAM_COMPLETE: |
124 case STATE_RESTART_WITH_AUTH: | |
125 case STATE_RESTART_WITH_AUTH_COMPLETE: | |
126 return LOAD_STATE_ESTABLISHING_PROXY_TUNNEL; | 106 return LOAD_STATE_ESTABLISHING_PROXY_TUNNEL; |
127 default: | 107 default: |
128 NOTREACHED(); | 108 NOTREACHED(); |
129 return LOAD_STATE_IDLE; | 109 return LOAD_STATE_IDLE; |
130 } | 110 } |
131 } | 111 } |
132 | 112 |
133 void HttpProxyConnectJob::GetAdditionalErrorState(ClientSocketHandle * handle) { | 113 void HttpProxyConnectJob::GetAdditionalErrorState(ClientSocketHandle * handle) { |
134 if (error_response_info_.cert_request_info) { | 114 if (error_response_info_.cert_request_info) { |
135 handle->set_ssl_error_response_info(error_response_info_); | 115 handle->set_ssl_error_response_info(error_response_info_); |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
172 case STATE_HTTP_PROXY_CONNECT_COMPLETE: | 152 case STATE_HTTP_PROXY_CONNECT_COMPLETE: |
173 rv = DoHttpProxyConnectComplete(rv); | 153 rv = DoHttpProxyConnectComplete(rv); |
174 break; | 154 break; |
175 case STATE_SPDY_PROXY_CREATE_STREAM: | 155 case STATE_SPDY_PROXY_CREATE_STREAM: |
176 DCHECK_EQ(OK, rv); | 156 DCHECK_EQ(OK, rv); |
177 rv = DoSpdyProxyCreateStream(); | 157 rv = DoSpdyProxyCreateStream(); |
178 break; | 158 break; |
179 case STATE_SPDY_PROXY_CREATE_STREAM_COMPLETE: | 159 case STATE_SPDY_PROXY_CREATE_STREAM_COMPLETE: |
180 rv = DoSpdyProxyCreateStreamComplete(rv); | 160 rv = DoSpdyProxyCreateStreamComplete(rv); |
181 break; | 161 break; |
182 case STATE_RESTART_WITH_AUTH: | |
183 DCHECK_EQ(OK, rv); | |
184 rv = DoRestartWithAuth(); | |
185 break; | |
186 case STATE_RESTART_WITH_AUTH_COMPLETE: | |
187 rv = DoRestartWithAuthComplete(rv); | |
188 break; | |
189 default: | 162 default: |
190 NOTREACHED() << "bad state"; | 163 NOTREACHED() << "bad state"; |
191 rv = ERR_FAILED; | 164 rv = ERR_FAILED; |
192 break; | 165 break; |
193 } | 166 } |
194 } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE); | 167 } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE); |
195 | 168 |
196 return rv; | 169 return rv; |
197 } | 170 } |
198 | 171 |
(...skipping 87 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
286 const HostResolver::RequestInfo& tcp_destination = params_->destination(); | 259 const HostResolver::RequestInfo& tcp_destination = params_->destination(); |
287 const HostPortPair& proxy_server = tcp_destination.host_port_pair(); | 260 const HostPortPair& proxy_server = tcp_destination.host_port_pair(); |
288 | 261 |
289 // Add a HttpProxy connection on top of the tcp socket. | 262 // Add a HttpProxy connection on top of the tcp socket. |
290 transport_socket_.reset( | 263 transport_socket_.reset( |
291 new HttpProxyClientSocket(transport_socket_handle_.release(), | 264 new HttpProxyClientSocket(transport_socket_handle_.release(), |
292 params_->request_url(), | 265 params_->request_url(), |
293 params_->user_agent(), | 266 params_->user_agent(), |
294 params_->endpoint(), | 267 params_->endpoint(), |
295 proxy_server, | 268 proxy_server, |
296 auth_, | 269 params_->http_auth_cache(), |
| 270 params_->http_auth_handler_factory(), |
297 params_->tunnel(), | 271 params_->tunnel(), |
298 using_spdy_, | 272 using_spdy_, |
299 protocol_negotiated_, | 273 protocol_negotiated_, |
300 params_->ssl_params() != NULL)); | 274 params_->ssl_params() != NULL)); |
301 return transport_socket_->Connect(callback_); | 275 return transport_socket_->Connect(callback_); |
302 } | 276 } |
303 | 277 |
304 void HttpProxyConnectJob::HandleProxyAuthChallenge() { | |
305 next_state_ = STATE_RESTART_WITH_AUTH; | |
306 params_->auth_needed_callback().Run( | |
307 *transport_socket_->GetConnectResponseInfo(), | |
308 transport_socket_->GetAuthController(), | |
309 callback_); | |
310 } | |
311 | |
312 int HttpProxyConnectJob::DoRestartWithAuth() { | |
313 // If no auth was added to the controller, then we should abort. | |
314 next_state_ = STATE_RESTART_WITH_AUTH_COMPLETE; | |
315 if (!transport_socket_->GetAuthController()->HaveAuth()) { | |
316 return ERR_PROXY_AUTH_REQUESTED; | |
317 } | |
318 | |
319 return transport_socket_->RestartWithAuth(callback_); | |
320 } | |
321 | |
322 int HttpProxyConnectJob::DoRestartWithAuthComplete(int result) { | |
323 if (result != OK) { | |
324 if (result == ERR_NO_KEEP_ALIVE_ON_AUTH_RESTART) { | |
325 next_state_ = params_->transport_params() ? | |
326 STATE_TCP_CONNECT : STATE_SSL_CONNECT; | |
327 return OK; | |
328 } | |
329 if (result == ERR_PROXY_AUTH_REQUESTED || | |
330 result == ERR_HTTPS_PROXY_TUNNEL_RESPONSE) { | |
331 set_socket(transport_socket_.release()); | |
332 } | |
333 return result; | |
334 } | |
335 | |
336 next_state_ = STATE_HTTP_PROXY_CONNECT_COMPLETE; | |
337 return OK; | |
338 } | |
339 | |
340 int HttpProxyConnectJob::DoHttpProxyConnectComplete(int result) { | 278 int HttpProxyConnectJob::DoHttpProxyConnectComplete(int result) { |
341 // Handle a proxy auth challenge by asynchronously invoking the callback. | 279 if (result == OK || result == ERR_PROXY_AUTH_REQUESTED || |
342 // We do this asynchronously so that the caller is notified of job | |
343 // completion only via NotifyDelegateOfCompletion. | |
344 if (result == ERR_PROXY_AUTH_REQUESTED) { | |
345 MessageLoop::current()->PostTask( | |
346 FROM_HERE, | |
347 base::Bind(&HttpProxyConnectJob::HandleProxyAuthChallenge, | |
348 ptr_factory_.GetWeakPtr())); | |
349 return ERR_IO_PENDING; | |
350 } | |
351 if (result == OK || | |
352 result == ERR_HTTPS_PROXY_TUNNEL_RESPONSE) { | 280 result == ERR_HTTPS_PROXY_TUNNEL_RESPONSE) { |
353 set_socket(transport_socket_.release()); | 281 set_socket(transport_socket_.release()); |
354 } | 282 } |
355 | 283 |
356 return result; | 284 return result; |
357 } | 285 } |
358 | 286 |
359 int HttpProxyConnectJob::DoSpdyProxyCreateStream() { | 287 int HttpProxyConnectJob::DoSpdyProxyCreateStream() { |
360 DCHECK(using_spdy_); | 288 DCHECK(using_spdy_); |
361 DCHECK(params_->tunnel()); | 289 DCHECK(params_->tunnel()); |
(...skipping 29 matching lines...) Expand all Loading... |
391 if (result < 0) | 319 if (result < 0) |
392 return result; | 320 return result; |
393 | 321 |
394 next_state_ = STATE_HTTP_PROXY_CONNECT_COMPLETE; | 322 next_state_ = STATE_HTTP_PROXY_CONNECT_COMPLETE; |
395 transport_socket_.reset( | 323 transport_socket_.reset( |
396 new SpdyProxyClientSocket(spdy_stream_, | 324 new SpdyProxyClientSocket(spdy_stream_, |
397 params_->user_agent(), | 325 params_->user_agent(), |
398 params_->endpoint(), | 326 params_->endpoint(), |
399 params_->request_url(), | 327 params_->request_url(), |
400 params_->destination().host_port_pair(), | 328 params_->destination().host_port_pair(), |
401 auth_)); | 329 params_->http_auth_cache(), |
| 330 params_->http_auth_handler_factory())); |
402 return transport_socket_->Connect(callback_); | 331 return transport_socket_->Connect(callback_); |
403 } | 332 } |
404 | 333 |
405 int HttpProxyConnectJob::ConnectInternal() { | 334 int HttpProxyConnectJob::ConnectInternal() { |
406 if (params_->transport_params()) | 335 if (params_->transport_params()) |
407 next_state_ = STATE_TCP_CONNECT; | 336 next_state_ = STATE_TCP_CONNECT; |
408 else | 337 else |
409 next_state_ = STATE_SSL_CONNECT; | 338 next_state_ = STATE_SSL_CONNECT; |
410 return DoLoop(OK); | 339 return DoLoop(OK); |
411 } | 340 } |
(...skipping 133 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
545 | 474 |
546 base::TimeDelta HttpProxyClientSocketPool::ConnectionTimeout() const { | 475 base::TimeDelta HttpProxyClientSocketPool::ConnectionTimeout() const { |
547 return base_.ConnectionTimeout(); | 476 return base_.ConnectionTimeout(); |
548 } | 477 } |
549 | 478 |
550 ClientSocketPoolHistograms* HttpProxyClientSocketPool::histograms() const { | 479 ClientSocketPoolHistograms* HttpProxyClientSocketPool::histograms() const { |
551 return base_.histograms(); | 480 return base_.histograms(); |
552 } | 481 } |
553 | 482 |
554 } // namespace net | 483 } // namespace net |
OLD | NEW |