Fix late binding induced mismatch of Socket and AuthController

net/http/http_network_transaction.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/http/http_network_transaction.h"
 
 #include <set>
 #include <vector>
 
 #include "base/compiler_specific.h"
@@ skipping 314 matching lines @@
   if (target == HttpAuth::AUTH_NONE) {
     NOTREACHED();
     return ERR_UNEXPECTED;
   }
   pending_auth_target_ = HttpAuth::AUTH_NONE;
 
   auth_controllers_[target]->ResetAuth(username, password);
 
   if (target == HttpAuth::AUTH_PROXY && using_ssl_ && proxy_info_.is_http()) {
     DCHECK(establishing_tunnel_);
-    next_state_ = STATE_INIT_CONNECTION;
+    next_state_ = STATE_RESTART_TUNNEL_AUTH;
+    auth_controllers_[target] = NULL;
     ResetStateForRestart();
   } else {
     PrepareForAuthRestart(target);
   }
 
   DCHECK(user_callback_ == NULL);
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     user_callback_ = callback;
 
@@ skipping 180 matching lines @@
       case STATE_RESOLVE_PROXY_COMPLETE:
         rv = DoResolveProxyComplete(rv);
         break;
       case STATE_INIT_CONNECTION:
         DCHECK_EQ(OK, rv);
         rv = DoInitConnection();
         break;
       case STATE_INIT_CONNECTION_COMPLETE:
         rv = DoInitConnectionComplete(rv);
         break;
+      case STATE_RESTART_TUNNEL_AUTH:
+        DCHECK_EQ(OK, rv);
+        rv = DoRestartTunnelAuth();
+        break;
+      case STATE_RESTART_TUNNEL_AUTH_COMPLETE:
+        rv = DoRestartTunnelAuthComplete(rv);
+        break;
       case STATE_GENERATE_PROXY_AUTH_TOKEN:
         DCHECK_EQ(OK, rv);
         rv = DoGenerateProxyAuthToken();
         break;
       case STATE_GENERATE_PROXY_AUTH_TOKEN_COMPLETE:
         rv = DoGenerateProxyAuthTokenComplete(rv);
         break;
       case STATE_GENERATE_SERVER_AUTH_TOKEN:
         DCHECK_EQ(OK, rv);
         rv = DoGenerateServerAuthToken();
@@ skipping 163 matching lines @@
 
   next_state_ = STATE_INIT_CONNECTION;
   return OK;
 }
 
 int HttpNetworkTransaction::DoInitConnection() {
   DCHECK(!connection_->is_initialized());
   DCHECK(proxy_info_.proxy_server().is_valid());
   next_state_ = STATE_INIT_CONNECTION_COMPLETE;
 
-  // Now that the proxy server has been resolved, create the auth_controllers_.
-  for (int i = 0; i < HttpAuth::AUTH_NUM_TARGETS; i++) {
-    HttpAuth::Target target = static_cast<HttpAuth::Target>(i);
-    if (!auth_controllers_[target].get())
-      auth_controllers_[target] = new HttpAuthController(target,
-                                                         AuthURL(target),
-                                                         session_);
-  }
-
   bool want_spdy_over_npn = alternate_protocol_mode_ == kUsingAlternateProtocol
       && alternate_protocol_ == HttpAlternateProtocols::NPN_SPDY_1;
   using_ssl_ = request_->url.SchemeIs("https") ||
       (want_spdy_without_npn_ && want_ssl_over_spdy_without_npn_) ||
       want_spdy_over_npn;
   using_spdy_ = false;
   response_.was_fetched_via_proxy = !proxy_info_.is_direct();
 
   // Check first if we have a spdy session for this group.  If so, then go
   // straight to using that.
@@ skipping 28 matching lines @@
                                      request_->referrer,
                                      disable_resolver_cache);
   } else {
     ProxyServer proxy_server = proxy_info_.proxy_server();
     proxy_host_port.reset(new HostPortPair(proxy_server.host_port_pair()));
     scoped_refptr<TCPSocketParams> proxy_tcp_params =
         new TCPSocketParams(*proxy_host_port, request_->priority,
                             request_->referrer, disable_resolver_cache);
 
     if (proxy_info_.is_http()) {
-      scoped_refptr<HttpAuthController> http_proxy_auth;
-      if (using_ssl_) {
-        http_proxy_auth = auth_controllers_[HttpAuth::AUTH_PROXY];
-        establishing_tunnel_ = true;
-      }
+      establishing_tunnel_ = using_ssl_;
       http_proxy_params = new HttpProxySocketParams(proxy_tcp_params,
                                                     request_->url, endpoint_,
-                                                    http_proxy_auth,
-                                                    using_ssl_);
+                                                    session_, using_ssl_);
     } else {
       DCHECK(proxy_info_.is_socks());
       char socks_version;
       if (proxy_server.scheme() == ProxyServer::SCHEME_SOCKS5)
         socks_version = '5';
       else
         socks_version = '4';
       connection_group =
           StringPrintf("socks%c/%s", socks_version, connection_group.c_str());
 
@@ skipping 87 matching lines @@
     if(want_ssl_over_spdy_without_npn_ && want_spdy_without_npn_)
       using_spdy_ = true;
   }
 
   // We may be using spdy without SSL
   if(!want_ssl_over_spdy_without_npn_ && want_spdy_without_npn_)
     using_spdy_ = true;
 
   if (result == ERR_PROXY_AUTH_REQUESTED) {
     DCHECK(!ssl_started);
-    const HttpResponseInfo& tunnel_auth_response =
-        connection_->ssl_error_response_info();
-
-    response_.headers = tunnel_auth_response.headers;
-    response_.auth_challenge = tunnel_auth_response.auth_challenge;
-    headers_valid_ = true;
-    pending_auth_target_ = HttpAuth::AUTH_PROXY;
-    return OK;
+    // Other state (i.e. |using_ssl_| suggests that |connection_| will have an

[eroman, 2010/07/30 22:11:11]

This seems like an unmatched parenthesis.

+    // SSL socket, but there was an error before that could happened.  This
+    // puts the in progress HttpProxy socket into |connection_| in order to
+    // complete the auth.  The tunnel restart code is carefully to remove it
+    // before returning control to the rest of this class.
+    connection_.reset(connection_->release_pending_http_proxy_connection());
+    return HandleTunnelAuthFailure(result);
   }
 
   if ((!ssl_started && result < 0 &&
        alternate_protocol_mode_ == kUsingAlternateProtocol) ||
       result == ERR_NPN_NEGOTIATION_FAILED) {
     // Mark the alternate protocol as broken and fallback.
     MarkBrokenAlternateProtocolAndFallback();
     return OK;
   }
 
@@ skipping 59 matching lines @@
   if (using_spdy_) {
     UpdateConnectionTypeHistograms(CONNECTION_SPDY);
     // TODO(cbentzel): Add auth support to spdy. See http://crbug.com/46620
     next_state_ = STATE_SPDY_GET_STREAM;
   } else {
     next_state_ = STATE_GENERATE_PROXY_AUTH_TOKEN;
   }
   return OK;
 }
 
+int HttpNetworkTransaction::DoRestartTunnelAuth() {
+  next_state_ = STATE_RESTART_TUNNEL_AUTH_COMPLETE;
+  HttpProxyClientSocket* http_proxy_socket =
+      static_cast<HttpProxyClientSocket*>(connection_->socket());
+  return http_proxy_socket->RestartWithAuth(&io_callback_);
+}
+
+int HttpNetworkTransaction::DoRestartTunnelAuthComplete(int result) {
+  if (result == ERR_PROXY_AUTH_REQUESTED)
+    return HandleTunnelAuthFailure(result);
+
+  if (result == OK) {
+    // Now that we've got the HttpProxyClientSocket connected.  We have
+    // to release it as an idle socket into the pool and start the connection
+    // process from the beginning.  Trying to pass it in with the
+    // SSLSocketParams might cause a deadlock since params are dispatched
+    // interchangeably.  This request won't necessarily get this http proxy
+    // socket, but there will be forward progress.
+    connection_->Reset();
+    establishing_tunnel_ = false;
+    next_state_ = STATE_INIT_CONNECTION;
+    return OK;
+  }
+
+  return ReconsiderProxyAfterError(result);
+}
+
 int HttpNetworkTransaction::DoGenerateProxyAuthToken() {
   next_state_ = STATE_GENERATE_PROXY_AUTH_TOKEN_COMPLETE;
   if (!ShouldApplyProxyAuth())
     return OK;
-  return auth_controllers_[HttpAuth::AUTH_PROXY]->MaybeGenerateAuthToken(
-      request_, &io_callback_, net_log_);
+  HttpAuth::Target target = HttpAuth::AUTH_PROXY;
+  if (!auth_controllers_[target].get())
+    auth_controllers_[target] = new HttpAuthController(target, AuthURL(target),
+                                                       session_);
+  return auth_controllers_[target]->MaybeGenerateAuthToken(request_,
+                                                           &io_callback_,
+                                                           net_log_);
 }
 
 int HttpNetworkTransaction::DoGenerateProxyAuthTokenComplete(int rv) {
   DCHECK_NE(ERR_IO_PENDING, rv);
   if (rv == OK)
     next_state_ = STATE_GENERATE_SERVER_AUTH_TOKEN;
   return rv;
 }
 
 int HttpNetworkTransaction::DoGenerateServerAuthToken() {
   next_state_ = STATE_GENERATE_SERVER_AUTH_TOKEN_COMPLETE;
+  HttpAuth::Target target = HttpAuth::AUTH_SERVER;
+  if (!auth_controllers_[target].get())
+    auth_controllers_[target] = new HttpAuthController(target, AuthURL(target),
+                                                       session_);
   if (!ShouldApplyServerAuth())
     return OK;
-  return auth_controllers_[HttpAuth::AUTH_SERVER]->MaybeGenerateAuthToken(
-      request_, &io_callback_, net_log_);
+  return auth_controllers_[target]->MaybeGenerateAuthToken(request_,
+                                                           &io_callback_,
+                                                           net_log_);
 }
 
 int HttpNetworkTransaction::DoGenerateServerAuthTokenComplete(int rv) {
   DCHECK_NE(ERR_IO_PENDING, rv);
   if (rv == OK)
     next_state_ = STATE_SEND_REQUEST;
   return rv;
 }
 
 int HttpNetworkTransaction::DoSendRequest() {
@@ skipping 499 matching lines @@
                               base::TimeDelta::FromMilliseconds(1),
                               base::TimeDelta::FromMinutes(10), 100);
   if (!reused_socket_) {
     UMA_HISTOGRAM_CLIPPED_TIMES(
         "Net.Transaction_Latency_Total_New_Connection_Under_10",
         total_duration, base::TimeDelta::FromMilliseconds(1),
         base::TimeDelta::FromMinutes(10), 100);
   }
 }
 
+int HttpNetworkTransaction::HandleTunnelAuthFailure(int error) {
+  DCHECK(establishing_tunnel_);
+  DCHECK_EQ(ERR_PROXY_AUTH_REQUESTED, error);
+  HttpProxyClientSocket* http_proxy_socket =
+      static_cast<HttpProxyClientSocket*>(connection_->socket());
+
+  const HttpResponseInfo* tunnel_auth_response =
+      http_proxy_socket->GetResponseInfo();
+  response_.headers = tunnel_auth_response->headers;
+  response_.auth_challenge = tunnel_auth_response->auth_challenge;
+  headers_valid_ = true;
+
+  auth_controllers_[HttpAuth::AUTH_PROXY] =
+      http_proxy_socket->auth_controller();
+  pending_auth_target_ = HttpAuth::AUTH_PROXY;
+  return OK;
+}
+
 int HttpNetworkTransaction::HandleCertificateError(int error) {
   DCHECK(using_ssl_);
   DCHECK(IsCertificateError(error));
 
   SSLClientSocket* ssl_socket =
       static_cast<SSLClientSocket*>(connection_->socket());
   ssl_socket->GetSSLInfo(&response_.ssl_info);
 
   // Add the bad certificate to the set of allowed certificates in the
   // SSL info object. This data structure will be consulted after calling
@@ skipping 294 matching lines @@
     default:
       description = StringPrintf("Unknown state 0x%08X (%u)", state, state);
       break;
   }
   return description;
 }
 
 #undef STATE_CASE
 
 }  // namespace net