Revert r59012 which started using Chrome sockets for sync.

jingle/notifier/communicator/single_login_attempt.cc

 // Copyright (c) 2009 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 <algorithm>
 #include <cstddef>
 #include <string>
 #include <vector>
 
 #include "jingle/notifier/communicator/single_login_attempt.h"
 
 #include "base/logging.h"
 #include "jingle/notifier/base/chrome_async_socket.h"
 #include "jingle/notifier/base/xmpp_client_socket_factory.h"
 #include "jingle/notifier/communicator/connection_options.h"
 #include "jingle/notifier/communicator/connection_settings.h"
 #include "jingle/notifier/communicator/const_communicator.h"
 #include "jingle/notifier/communicator/gaia_token_pre_xmpp_auth.h"
 #include "jingle/notifier/communicator/login_failure.h"
 #include "jingle/notifier/communicator/login_settings.h"
+#include "jingle/notifier/communicator/product_info.h"
 #include "jingle/notifier/communicator/xmpp_connection_generator.h"
+#include "jingle/notifier/communicator/xmpp_socket_adapter.h"
 #include "net/base/ssl_config_service.h"
 #include "net/socket/client_socket_factory.h"
+#include "talk/base/asynchttprequest.h"
+#include "talk/base/firewallsocketserver.h"
+#include "talk/base/signalthread.h"
+#include "talk/base/taskrunner.h"
+#include "talk/base/win32socketinit.h"
 #include "talk/xmllite/xmlelement.h"
 #include "talk/xmpp/xmppclient.h"
 #include "talk/xmpp/xmppclientsettings.h"
 #include "talk/xmpp/constants.h"
 
 namespace net {
 class NetLog;
 }  // namespace net
 
 namespace notifier {
@@ skipping 13 matching lines @@
   *stream_error = NULL;
   if (*error == buzz::XmppEngine::ERROR_STREAM) {
     const buzz::XmlElement* error_element = client->GetStreamError();
     if (error_element) {
       *stream_error = new buzz::XmlElement(*error_element);
     }
   }
 }
 
 SingleLoginAttempt::SingleLoginAttempt(talk_base::TaskParent* parent,
-                                       LoginSettings* login_settings)
+                                       LoginSettings* login_settings,
+                                       bool use_chrome_async_socket,
+                                       bool successful_connection)
     : talk_base::Task(parent),
+      use_chrome_async_socket_(use_chrome_async_socket),
       state_(buzz::XmppEngine::STATE_NONE),
       code_(buzz::XmppEngine::ERROR_NONE),
       subcode_(0),
       need_authentication_(false),
       certificate_expired_(false),
+      cookie_refreshed_(false),
+      successful_connection_(successful_connection),
       login_settings_(login_settings),
       client_(NULL) {
+#if defined(OS_WIN)
+  talk_base::EnsureWinsockInit();
+#endif
   connection_generator_.reset(new XmppConnectionGenerator(
                                   this,
                                   login_settings_->host_resolver(),
                                   &login_settings_->connection_options(),
                                   login_settings_->try_ssltcp_first(),
                                   login_settings_->proxy_only(),
                                   login_settings_->server_list(),
                                   login_settings_->server_count()));
 
   connection_generator_->SignalExhaustedSettings.connect(
@@ skipping 56 matching lines @@
     return;
   }
 
   if (!successfully_resolved_dns) {
     code_ = buzz::XmppEngine::ERROR_SOCKET;
     subcode_ = first_dns_error;
   }
 
   LOG(INFO) << "Connection failed with error " << code_;
 
-  SignalNeedAutoReconnect();
+  // We were connected and we had a problem.
+  if (successful_connection_) {
+    SignalNeedAutoReconnect();
+    // Expect to be deleted at this point.
+    return;
+  }
+
+  DiagnoseConnectionError();
 }
 
 void SingleLoginAttempt::UseNextConnection() {
   DCHECK(connection_generator_.get());
   ClearClient();
   connection_generator_->UseNextConnection();
 }
 
 void SingleLoginAttempt::UseCurrentConnection() {
   DCHECK(connection_generator_.get());
@@ skipping 43 matching lines @@
   need_authentication_ = true;
 }
 
 void SingleLoginAttempt::OnCertificateExpired() {
   // We can check this flag later if all connection options fail.
   certificate_expired_ = true;
 }
 
 buzz::AsyncSocket* SingleLoginAttempt::CreateSocket(
     const buzz::XmppClientSettings& xcs) {
-  bool use_fake_ssl_client_socket =
-      (xcs.protocol() == cricket::PROTO_SSLTCP);
-  net::ClientSocketFactory* const client_socket_factory =
-      new XmppClientSocketFactory(
-          net::ClientSocketFactory::GetDefaultFactory(),
-          use_fake_ssl_client_socket);
-  // The default SSLConfig is good enough for us for now.
-  const net::SSLConfig ssl_config;
-  // A read buffer of 64k ought to be sufficient.
-  const size_t kReadBufSize = 64U * 1024U;
-  // This number was taken from a similar number in
-  // XmppSocketAdapter.
-  const size_t kWriteBufSize = 64U * 1024U;
-  // TODO(akalin): Use a real NetLog.
-  net::NetLog* const net_log = NULL;
-  return new ChromeAsyncSocket(
-      client_socket_factory, ssl_config,
-      kReadBufSize, kWriteBufSize, net_log);
+  if (use_chrome_async_socket_) {
+    bool use_fake_ssl_client_socket =
+        (xcs.protocol() == cricket::PROTO_SSLTCP);
+    net::ClientSocketFactory* const client_socket_factory =
+        new XmppClientSocketFactory(
+            net::ClientSocketFactory::GetDefaultFactory(),
+            use_fake_ssl_client_socket);
+    // The default SSLConfig is good enough for us for now.
+    const net::SSLConfig ssl_config;
+    // A read buffer of 64k ought to be sufficient.
+    const size_t kReadBufSize = 64U * 1024U;
+    // This number was taken from a similar number in
+    // XmppSocketAdapter.
+    const size_t kWriteBufSize = 64U * 1024U;
+    // TODO(akalin): Use a real NetLog.
+    net::NetLog* const net_log = NULL;
+    return new ChromeAsyncSocket(
+        client_socket_factory, ssl_config,
+        kReadBufSize, kWriteBufSize, net_log);
+  }
+  // TODO(akalin): Always use ChromeAsyncSocket and get rid of this
+  // code.
+  bool allow_unverified_certs =
+      login_settings_->connection_options().allow_unverified_certs();
+  XmppSocketAdapter* adapter = new XmppSocketAdapter(xcs,
+                                                     allow_unverified_certs);
+  adapter->SignalAuthenticationError.connect(
+      this,
+      &SingleLoginAttempt::OnAuthenticationError);
+  if (login_settings_->firewall()) {
+    adapter->set_firewall(true);
+  }
+  return adapter;
 }
 
 buzz::PreXmppAuth* SingleLoginAttempt::CreatePreXmppAuth(
     const buzz::XmppClientSettings& xcs) {
   buzz::Jid jid(xcs.user(), xcs.host(), buzz::STR_EMPTY);
   return new GaiaTokenPreXmppAuth(
       jid.Str(), xcs.auth_cookie(), xcs.token_service());
 }
 
+void SingleLoginAttempt::OnFreshAuthCookie(const std::string& auth_cookie) {
+  // Remember this is a fresh cookie.
+  cookie_refreshed_ = true;
+
+  // TODO(sync): do the cookie logic (part of which is in the #if 0 below).
+
+  // The following code is what PhoneWindow does for the equivalent method.
+#if 0
+  // Save cookie
+  AccountInfo current(account_history_.current());
+  current.set_auth_cookie(auth_cookie);
+  account_history_.set_current(current);
+
+  // Calc next time to refresh cookie, between 5 and 10 days. The cookie has
+  // 14 days of life; this gives at least 4 days of retries before the current
+  // cookie expires, maximizing the chance of having a valid cookie next time
+  // the connection servers go down.
+  FTULL now;
+
+  // NOTE: The following line is win32.  Address this when implementing this
+  // code (doing "the cookie logic").
+  GetSystemTimeAsFileTime(&(now.ft));
+  ULONGLONG five_days = (ULONGLONG)10000 * 1000 * 60 * 60 * 24 * 5;  // 5 days
+  ULONGLONG random = (ULONGLONG)10000 *          // get to 100 ns units
+      ((rand() % (5 * 24 * 60)) * (60 * 1000) +  // random min. in 5 day period
+      (rand() % 1000) * 60);                     // random 1/1000th of a minute
+  next_cookie_refresh_ = now.ull + five_days + random;  // 5-10 days
+#endif
+}
+
+void SingleLoginAttempt::DiagnoseConnectionError() {
+  switch (code_) {
+    case buzz::XmppEngine::ERROR_MISSING_USERNAME:
+    case buzz::XmppEngine::ERROR_NETWORK_TIMEOUT:
+    case buzz::XmppEngine::ERROR_DOCUMENT_CLOSED:
+    case buzz::XmppEngine::ERROR_BIND:
+    case buzz::XmppEngine::ERROR_AUTH:
+    case buzz::XmppEngine::ERROR_TLS:
+    case buzz::XmppEngine::ERROR_UNAUTHORIZED:
+    case buzz::XmppEngine::ERROR_VERSION:
+    case buzz::XmppEngine::ERROR_STREAM:
+    case buzz::XmppEngine::ERROR_XML:
+    case buzz::XmppEngine::ERROR_NONE:
+    default: {
+      LoginFailure failure(LoginFailure::XMPP_ERROR, code_, subcode_);
+      SignalLoginFailure(failure);
+      return;
+    }
+
+      // The following errors require diagnosistics:
+      // * spurious close of connection
+      // * socket errors after auth
+    case buzz::XmppEngine::ERROR_CONNECTION_CLOSED:
+    case buzz::XmppEngine::ERROR_SOCKET:
+      break;
+  }
+
+  talk_base::AsyncHttpRequest *http_request =
+    new talk_base::AsyncHttpRequest(GetUserAgentString());
+  http_request->set_host("www.google.com");
+  http_request->set_port(80);
+  http_request->set_secure(false);
+  http_request->request().path = "/";
+  http_request->request().verb = talk_base::HV_GET;
+
+  talk_base::ProxyInfo proxy;
+  DCHECK(connection_generator_.get());
+  if (connection_generator_.get()) {
+    proxy = connection_generator_->proxy();
+  }
+  http_request->set_proxy(proxy);
+  http_request->set_firewall(login_settings_->firewall());
+
+  http_request->SignalWorkDone.connect(this,
+                                       &SingleLoginAttempt::OnHttpTestDone);
+  http_request->Start();
+  http_request->Release();
+}
+
+void SingleLoginAttempt::OnHttpTestDone(talk_base::SignalThread* thread) {
+  DCHECK(thread);
+
+  talk_base::AsyncHttpRequest* request =
+    static_cast<talk_base::AsyncHttpRequest*>(thread);
+
+  if (request->response().scode == 200) {
+    // We were able to do an HTTP GET of www.google.com:80
+
+    //
+    // The original error should be reported
+    //
+    LoginFailure failure(LoginFailure::XMPP_ERROR, code_, subcode_);
+    SignalLoginFailure(failure);
+    return;
+  }
+
+  // Otherwise lets transmute the error into ERROR_SOCKET, and put the subcode
+  // as an indicator of what we think the problem might be.
+
+#if 0
+  // TODO(sync): determine if notifier has an analogous situation.
+
+  //
+  // We weren't able to do an HTTP GET of www.google.com:80
+  //
+  GAutoupdater::Version version_logged_in(g_options.version_logged_in());
+  GAutoupdater::Version version_installed(GetProductVersion().c_str());
+  if (version_logged_in < version_installed) {
+    //
+    // Google Talk has been updated and can no longer connect to the Google
+    // Talk Service. Your firewall is probably not allowing the new version of
+    // Google Talk to connect to the internet. Please adjust your firewall
+    // settings to allow the new version of Google Talk to connect to the
+    // internet.
+    //
+    // We'll use the "error=1" to help figure this out for now.
+    //
+    LoginFailure failure(LoginFailure::XMPP_ERROR,
+                         buzz::XmppEngine::ERROR_SOCKET,
+                         1);
+    SignalLoginFailure(failure);
+    return;
+  }
+#endif
+
+  //
+  // Any other checking we can add here?
+  //
+
+  //
+  // Google Talk is unable to use your internet connection. Either your network
+  // isn't configured or Google Talk is being blocked by a local firewall.
+  //
+  // We'll use the "error=0" to help figure this out for now
+  //
+  LoginFailure failure(LoginFailure::XMPP_ERROR,
+                       buzz::XmppEngine::ERROR_SOCKET,
+                       0);
+  SignalLoginFailure(failure);
+}
+
 void SingleLoginAttempt::OnClientStateChange(buzz::XmppEngine::State state) {
   if (state_ == state)
     return;
 
   buzz::XmppEngine::State previous_state = state_;
   state_ = state;
 
   switch (state) {
     case buzz::XmppEngine::STATE_NONE:
     case buzz::XmppEngine::STATE_START:
     case buzz::XmppEngine::STATE_OPENING:
+      // Do nothing.
+      break;
     case buzz::XmppEngine::STATE_OPEN:
-      // Do nothing.
+      successful_connection_ = true;
       break;
     case buzz::XmppEngine::STATE_CLOSED:
       OnClientStateChangeClosed(previous_state);
       break;
   }
   SignalClientStateChange(state);
   if (state_ == buzz::XmppEngine::STATE_CLOSED) {
     OnClientStateChange(buzz::XmppEngine::STATE_NONE);
   }
 }
@@ skipping 56 matching lines @@
     // There was a problem with credentials (username/password).
     HandleConnectionPasswordError();
     return;
   }
 
   // Unexpected disconnect,
   // Unreachable host,
   // Or internal server binding error -
   // All these are temporary problems, so continue reconnecting.
 
+  // GaiaAuth signals this directly via SignalCertificateExpired, but
+  // SChannelAdapter propagates the error through SocketWindow as a socket
+  // error.
+  if (code_ == buzz::XmppEngine::ERROR_SOCKET &&
+      subcode_ == SEC_E_CERT_EXPIRED) {
+    certificate_expired_ = true;
+  }
+
   login_settings_->modifiable_user_settings()->set_resource("");
 
   // Look for stream::error server redirection stanza "see-other-host".
   if (stream_error) {
     const buzz::XmlElement* other =
         stream_error->FirstNamed(buzz::QN_XSTREAM_SEE_OTHER_HOST);
     if (other) {
       const buzz::XmlElement* text =
           stream_error->FirstNamed(buzz::QN_XSTREAM_TEXT);
       if (text) {
@@ skipping 25 matching lines @@
   DCHECK(connection_generator_.get());
   if (!connection_generator_.get()) {
     return;
   }
 
   // Iterate to the next possible connection (still trying to connect).
   UseNextConnection();
 }
 
 }  // namespace notifier