jingle/glue/proxy_resolving_client_socket.cc

   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 "jingle/glue/proxy_resolving_client_socket.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/bind.h"
   9 #include "base/bind_helpers.h"
  10 #include "base/compiler_specific.h"
  11 #include "base/logging.h"
  12 #include "net/base/io_buffer.h"
  13 #include "net/base/load_flags.h"
  14 #include "net/base/net_errors.h"
  15 #include "net/http/http_network_session.h"
  16 #include "net/socket/client_socket_handle.h"
  17 #include "net/socket/client_socket_pool_manager.h"
  18 #include "net/url_request/url_request_context.h"
  19 #include "net/url_request/url_request_context_getter.h"
  20
  21 namespace jingle_glue {
  22
  23 ProxyResolvingClientSocket::ProxyResolvingClientSocket(
  24     net::ClientSocketFactory* socket_factory,
  25     const scoped_refptr<net::URLRequestContextGetter>& request_context_getter,
  26     const net::SSLConfig& ssl_config,
  27     const net::HostPortPair& dest_host_port_pair)
  28         : proxy_resolve_callback_(
  29               base::Bind(&ProxyResolvingClientSocket::ProcessProxyResolveDone,
  30                          base::Unretained(this))),
  31           connect_callback_(
  32               base::Bind(&ProxyResolvingClientSocket::ProcessConnectDone,
  33                          base::Unretained(this))),
  34           ssl_config_(ssl_config),
  35           pac_request_(NULL),
  36           dest_host_port_pair_(dest_host_port_pair),
  37           // Assume that we intend to do TLS on this socket; all
  38           // current use cases do.
  39           proxy_url_("https://" + dest_host_port_pair_.ToString()),
  40           tried_direct_connect_fallback_(false),
  41           bound_net_log_(
  42               net::BoundNetLog::Make(
  43                   request_context_getter->GetURLRequestContext()->net_log(),
  44                   net::NetLog::SOURCE_SOCKET)),
  45           weak_factory_(this) {
  46   DCHECK(request_context_getter.get());
  47   net::URLRequestContext* request_context =
  48       request_context_getter->GetURLRequestContext();
  49   DCHECK(request_context);
  50   DCHECK(!dest_host_port_pair_.host().empty());
  51   DCHECK_GT(dest_host_port_pair_.port(), 0);
  52   DCHECK(proxy_url_.is_valid());
  53
  54   net::HttpNetworkSession::Params session_params;
  55   session_params.client_socket_factory = socket_factory;
  56   session_params.host_resolver = request_context->host_resolver();
  57   session_params.cert_verifier = request_context->cert_verifier();
  58   session_params.transport_security_state =
  59       request_context->transport_security_state();
  60   // TODO(rkn): This is NULL because ChannelIDService is not thread safe.
  61   session_params.channel_id_service = NULL;
  62   session_params.proxy_service = request_context->proxy_service();
  63   session_params.ssl_config_service = request_context->ssl_config_service();
  64   session_params.http_auth_handler_factory =
  65       request_context->http_auth_handler_factory();
  66   session_params.network_delegate = request_context->network_delegate();
  67   session_params.http_server_properties =
  68       request_context->http_server_properties();
  69   session_params.net_log = request_context->net_log();
  70
  71   const net::HttpNetworkSession::Params* reference_params =
  72       request_context->GetNetworkSessionParams();
  73   if (reference_params) {
  74     // TODO(mmenke):  Just copying specific parameters seems highly regression
  75     // prone.  Should have a better way to do this.
  76     session_params.host_mapping_rules = reference_params->host_mapping_rules;
  77     session_params.ignore_certificate_errors =
  78         reference_params->ignore_certificate_errors;
  79     session_params.testing_fixed_http_port =
  80         reference_params->testing_fixed_http_port;
  81     session_params.testing_fixed_https_port =
  82         reference_params->testing_fixed_https_port;
  83     session_params.next_protos = reference_params->next_protos;
  84     session_params.trusted_spdy_proxy = reference_params->trusted_spdy_proxy;
  85     session_params.force_spdy_over_ssl = reference_params->force_spdy_over_ssl;
  86     session_params.force_spdy_always = reference_params->force_spdy_always;
  87     session_params.forced_spdy_exclusions =
  88         reference_params->forced_spdy_exclusions;
  89     session_params.use_alternate_protocols =
  90         reference_params->use_alternate_protocols;
  91   }
  92
  93   network_session_ = new net::HttpNetworkSession(session_params);
  94 }
  95
  96 ProxyResolvingClientSocket::~ProxyResolvingClientSocket() {
  97   Disconnect();
  98 }
  99
 100 int ProxyResolvingClientSocket::Read(net::IOBuffer* buf, int buf_len,
 101                                      const net::CompletionCallback& callback) {
 102   if (transport_.get() && transport_->socket())
 103     return transport_->socket()->Read(buf, buf_len, callback);
 104   NOTREACHED();
 105   return net::ERR_SOCKET_NOT_CONNECTED;
 106 }
 107
 108 int ProxyResolvingClientSocket::Write(
 109     net::IOBuffer* buf,
 110     int buf_len,
 111     const net::CompletionCallback& callback) {
 112   if (transport_.get() && transport_->socket())
 113     return transport_->socket()->Write(buf, buf_len, callback);
 114   NOTREACHED();
 115   return net::ERR_SOCKET_NOT_CONNECTED;
 116 }
 117
 118 int ProxyResolvingClientSocket::SetReceiveBufferSize(int32 size) {
 119   if (transport_.get() && transport_->socket())
 120     return transport_->socket()->SetReceiveBufferSize(size);
 121   NOTREACHED();
 122   return net::ERR_SOCKET_NOT_CONNECTED;
 123 }
 124
 125 int ProxyResolvingClientSocket::SetSendBufferSize(int32 size) {
 126   if (transport_.get() && transport_->socket())
 127     return transport_->socket()->SetSendBufferSize(size);
 128   NOTREACHED();
 129   return net::ERR_SOCKET_NOT_CONNECTED;
 130 }
 131
 132 int ProxyResolvingClientSocket::Connect(
 133     const net::CompletionCallback& callback) {
 134   DCHECK(user_connect_callback_.is_null());
 135
 136   tried_direct_connect_fallback_ = false;
 137
 138   // First we try and resolve the proxy.
 139   int status = network_session_->proxy_service()->ResolveProxy(
 140       proxy_url_,
 141       net::LOAD_NORMAL,
 142       &proxy_info_,
 143       proxy_resolve_callback_,
 144       &pac_request_,
 145       NULL,
 146       bound_net_log_);
 147   if (status != net::ERR_IO_PENDING) {
 148     // We defer execution of ProcessProxyResolveDone instead of calling it
 149     // directly here for simplicity. From the caller's point of view,
 150     // the connect always happens asynchronously.
 151     base::MessageLoop* message_loop = base::MessageLoop::current();
 152     CHECK(message_loop);
 153     message_loop->PostTask(
 154         FROM_HERE,
 155         base::Bind(&ProxyResolvingClientSocket::ProcessProxyResolveDone,
 156                    weak_factory_.GetWeakPtr(), status));
 157   }
 158   user_connect_callback_ = callback;
 159   return net::ERR_IO_PENDING;
 160 }
 161
 162 void ProxyResolvingClientSocket::RunUserConnectCallback(int status) {
 163   DCHECK_LE(status, net::OK);
 164   net::CompletionCallback user_connect_callback = user_connect_callback_;
 165   user_connect_callback_.Reset();
 166   user_connect_callback.Run(status);
 167 }
 168
 169 // Always runs asynchronously.
 170 void ProxyResolvingClientSocket::ProcessProxyResolveDone(int status) {
 171   pac_request_ = NULL;
 172
 173   DCHECK_NE(status, net::ERR_IO_PENDING);
 174   if (status == net::OK) {
 175     // Remove unsupported proxies from the list.
 176     proxy_info_.RemoveProxiesWithoutScheme(
 177         net::ProxyServer::SCHEME_DIRECT |
 178         net::ProxyServer::SCHEME_HTTP | net::ProxyServer::SCHEME_HTTPS |
 179         net::ProxyServer::SCHEME_SOCKS4 | net::ProxyServer::SCHEME_SOCKS5);
 180
 181     if (proxy_info_.is_empty()) {
 182       // No proxies/direct to choose from. This happens when we don't support
 183       // any of the proxies in the returned list.
 184       status = net::ERR_NO_SUPPORTED_PROXIES;
 185     }
 186   }
 187
 188   // Since we are faking the URL, it is possible that no proxies match our URL.
 189   // Try falling back to a direct connection if we have not tried that before.
 190   if (status != net::OK) {
 191     if (!tried_direct_connect_fallback_) {
 192       tried_direct_connect_fallback_ = true;
 193       proxy_info_.UseDirect();
 194     } else {
 195       CloseTransportSocket();
 196       RunUserConnectCallback(status);
 197       return;
 198     }
 199   }
 200
 201   transport_.reset(new net::ClientSocketHandle);
 202   // Now that we have resolved the proxy, we need to connect.
 203   status = net::InitSocketHandleForRawConnect(
 204       dest_host_port_pair_, network_session_.get(), proxy_info_, ssl_config_,
 205       ssl_config_, net::PRIVACY_MODE_DISABLED, bound_net_log_, transport_.get(),
 206       connect_callback_);
 207   if (status != net::ERR_IO_PENDING) {
 208     // Since this method is always called asynchronously. it is OK to call
 209     // ProcessConnectDone synchronously.
 210     ProcessConnectDone(status);
 211   }
 212 }
 213
 214 void ProxyResolvingClientSocket::ProcessConnectDone(int status) {
 215   if (status != net::OK) {
 216     // If the connection fails, try another proxy.
 217     status = ReconsiderProxyAfterError(status);
 218     // ReconsiderProxyAfterError either returns an error (in which case it is
 219     // not reconsidering a proxy) or returns ERR_IO_PENDING if it is considering
 220     // another proxy.
 221     DCHECK_NE(status, net::OK);
 222     if (status == net::ERR_IO_PENDING)
 223       // Proxy reconsideration pending. Return.
 224       return;
 225     CloseTransportSocket();
 226   } else {
 227     ReportSuccessfulProxyConnection();
 228   }
 229   RunUserConnectCallback(status);
 230 }
 231
 232 // TODO(sanjeevr): This has largely been copied from
 233 // HttpStreamFactoryImpl::Job::ReconsiderProxyAfterError. This should be
 234 // refactored into some common place.
 235 // This method reconsiders the proxy on certain errors. If it does reconsider
 236 // a proxy it always returns ERR_IO_PENDING and posts a call to
 237 // ProcessProxyResolveDone with the result of the reconsideration.
 238 int ProxyResolvingClientSocket::ReconsiderProxyAfterError(int error) {
 239   DCHECK(!pac_request_);
 240   DCHECK_NE(error, net::OK);
 241   DCHECK_NE(error, net::ERR_IO_PENDING);
 242   // A failure to resolve the hostname or any error related to establishing a
 243   // TCP connection could be grounds for trying a new proxy configuration.
 244   //
 245   // Why do this when a hostname cannot be resolved?  Some URLs only make sense
 246   // to proxy servers.  The hostname in those URLs might fail to resolve if we
 247   // are still using a non-proxy config.  We need to check if a proxy config
 248   // now exists that corresponds to a proxy server that could load the URL.
 249   //
 250   switch (error) {
 251     case net::ERR_PROXY_CONNECTION_FAILED:
 252     case net::ERR_NAME_NOT_RESOLVED:
 253     case net::ERR_INTERNET_DISCONNECTED:
 254     case net::ERR_ADDRESS_UNREACHABLE:
 255     case net::ERR_CONNECTION_CLOSED:
 256     case net::ERR_CONNECTION_RESET:
 257     case net::ERR_CONNECTION_REFUSED:
 258     case net::ERR_CONNECTION_ABORTED:
 259     case net::ERR_TIMED_OUT:
 260     case net::ERR_TUNNEL_CONNECTION_FAILED:
 261     case net::ERR_SOCKS_CONNECTION_FAILED:
 262       break;
 263     case net::ERR_SOCKS_CONNECTION_HOST_UNREACHABLE:
 264       // Remap the SOCKS-specific "host unreachable" error to a more
 265       // generic error code (this way consumers like the link doctor
 266       // know to substitute their error page).
 267       //
 268       // Note that if the host resolving was done by the SOCSK5 proxy, we can't
 269       // differentiate between a proxy-side "host not found" versus a proxy-side
 270       // "address unreachable" error, and will report both of these failures as
 271       // ERR_ADDRESS_UNREACHABLE.
 272       return net::ERR_ADDRESS_UNREACHABLE;
 273     default:
 274       return error;
 275   }
 276
 277   if (proxy_info_.is_https() && ssl_config_.send_client_cert) {
 278     network_session_->ssl_client_auth_cache()->Remove(
 279         proxy_info_.proxy_server().host_port_pair());
 280   }
 281
 282   int rv = network_session_->proxy_service()->ReconsiderProxyAfterError(
 283       proxy_url_, net::LOAD_NORMAL, error, &proxy_info_,
 284       proxy_resolve_callback_, &pac_request_, NULL, bound_net_log_);
 285   if (rv == net::OK || rv == net::ERR_IO_PENDING) {
 286     CloseTransportSocket();
 287   } else {
 288     // If ReconsiderProxyAfterError() failed synchronously, it means
 289     // there was nothing left to fall-back to, so fail the transaction
 290     // with the last connection error we got.
 291     rv = error;
 292   }
 293
 294   // We either have new proxy info or there was an error in falling back.
 295   // In both cases we want to post ProcessProxyResolveDone (in the error case
 296   // we might still want to fall back a direct connection).
 297   if (rv != net::ERR_IO_PENDING) {
 298     base::MessageLoop* message_loop = base::MessageLoop::current();
 299     CHECK(message_loop);
 300     message_loop->PostTask(
 301         FROM_HERE,
 302         base::Bind(&ProxyResolvingClientSocket::ProcessProxyResolveDone,
 303                    weak_factory_.GetWeakPtr(), rv));
 304     // Since we potentially have another try to go (trying the direct connect)
 305     // set the return code code to ERR_IO_PENDING.
 306     rv = net::ERR_IO_PENDING;
 307   }
 308   return rv;
 309 }
 310
 311 void ProxyResolvingClientSocket::ReportSuccessfulProxyConnection() {
 312   network_session_->proxy_service()->ReportSuccess(proxy_info_, NULL);
 313 }
 314
 315 void ProxyResolvingClientSocket::Disconnect() {
 316   CloseTransportSocket();
 317   if (pac_request_) {
 318     network_session_->proxy_service()->CancelPacRequest(pac_request_);
 319     pac_request_ = NULL;
 320   }
 321   user_connect_callback_.Reset();
 322 }
 323
 324 bool ProxyResolvingClientSocket::IsConnected() const {
 325   if (!transport_.get() || !transport_->socket())
 326     return false;
 327   return transport_->socket()->IsConnected();
 328 }
 329
 330 bool ProxyResolvingClientSocket::IsConnectedAndIdle() const {
 331   if (!transport_.get() || !transport_->socket())
 332     return false;
 333   return transport_->socket()->IsConnectedAndIdle();
 334 }
 335
 336 int ProxyResolvingClientSocket::GetPeerAddress(
 337     net::IPEndPoint* address) const {
 338   if (transport_.get() && transport_->socket())
 339     return transport_->socket()->GetPeerAddress(address);
 340   NOTREACHED();
 341   return net::ERR_SOCKET_NOT_CONNECTED;
 342 }
 343
 344 int ProxyResolvingClientSocket::GetLocalAddress(
 345     net::IPEndPoint* address) const {
 346   if (transport_.get() && transport_->socket())
 347     return transport_->socket()->GetLocalAddress(address);
 348   NOTREACHED();
 349   return net::ERR_SOCKET_NOT_CONNECTED;
 350 }
 351
 352 const net::BoundNetLog& ProxyResolvingClientSocket::NetLog() const {
 353   if (transport_.get() && transport_->socket())
 354     return transport_->socket()->NetLog();
 355   NOTREACHED();
 356   return bound_net_log_;
 357 }
 358
 359 void ProxyResolvingClientSocket::SetSubresourceSpeculation() {
 360   if (transport_.get() && transport_->socket())
 361     transport_->socket()->SetSubresourceSpeculation();
 362   else
 363     NOTREACHED();
 364 }
 365
 366 void ProxyResolvingClientSocket::SetOmniboxSpeculation() {
 367   if (transport_.get() && transport_->socket())
 368     transport_->socket()->SetOmniboxSpeculation();
 369   else
 370     NOTREACHED();
 371 }
 372
 373 bool ProxyResolvingClientSocket::WasEverUsed() const {
 374   if (transport_.get() && transport_->socket())
 375     return transport_->socket()->WasEverUsed();
 376   NOTREACHED();
 377   return false;
 378 }
 379
 380 bool ProxyResolvingClientSocket::UsingTCPFastOpen() const {
 381   if (transport_.get() && transport_->socket())
 382     return transport_->socket()->UsingTCPFastOpen();
 383   NOTREACHED();
 384   return false;
 385 }
 386
 387 bool ProxyResolvingClientSocket::WasNpnNegotiated() const {
 388   return false;
 389 }
 390
 391 net::NextProto ProxyResolvingClientSocket::GetNegotiatedProtocol() const {
 392   if (transport_.get() && transport_->socket())
 393     return transport_->socket()->GetNegotiatedProtocol();
 394   NOTREACHED();
 395   return net::kProtoUnknown;
 396 }
 397
 398 bool ProxyResolvingClientSocket::GetSSLInfo(net::SSLInfo* ssl_info) {
 399   return false;
 400 }
 401
 402 void ProxyResolvingClientSocket::CloseTransportSocket() {
 403   if (transport_.get() && transport_->socket())
 404     transport_->socket()->Disconnect();
 405   transport_.reset();
 406 }
 407
 408 }  // namespace jingle_glue