remoting/signaling/xmpp_signal_strategy.cc

   1 // Copyright 2014 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 "remoting/signaling/xmpp_signal_strategy.h"
   6
   7 #include "base/bind.h"
   8 #include "base/location.h"
   9 #include "base/logging.h"
  10 #include "base/single_thread_task_runner.h"
  11 #include "base/strings/string_util.h"
  12 #include "base/thread_task_runner_handle.h"
  13 #include "jingle/glue/chrome_async_socket.h"
  14 #include "jingle/glue/task_pump.h"
  15 #include "jingle/glue/xmpp_client_socket_factory.h"
  16 #include "jingle/notifier/base/gaia_constants.h"
  17 #include "jingle/notifier/base/gaia_token_pre_xmpp_auth.h"
  18 #include "net/socket/client_socket_factory.h"
  19 #include "net/url_request/url_request_context_getter.h"
  20 #include "third_party/webrtc/base/thread.h"
  21 #include "third_party/webrtc/libjingle/xmpp/prexmppauth.h"
  22 #include "third_party/webrtc/libjingle/xmpp/saslcookiemechanism.h"
  23
  24 const char kDefaultResourceName[] = "chromoting";
  25
  26 // Use 58 seconds keep-alive interval, in case routers terminate
  27 // connections that are idle for more than a minute.
  28 const int kKeepAliveIntervalSeconds = 50;
  29
  30 // Read buffer size used by ChromeAsyncSocket for read and write buffers.
  31 //
  32 // TODO(sergeyu): Currently jingle::ChromeAsyncSocket fails Write() when the
  33 // write buffer is full and talk::XmppClient just ignores the error. As result
  34 // chunks of data sent to the server are dropped (and they may not be full XMPP
  35 // stanzas). The problem needs to be fixed either in XmppClient on
  36 // ChromeAsyncSocket (e.g. ChromeAsyncSocket could close the connection when
  37 // buffer is full).
  38 const size_t kReadBufferSize = 64 * 1024;
  39 const size_t kWriteBufferSize = 64 * 1024;
  40
  41 const int kDefaultXmppPort = 5222;
  42 const int kDefaultHttpsPort = 443;
  43
  44 namespace remoting {
  45
  46 XmppSignalStrategy::XmppServerConfig::XmppServerConfig() {}
  47 XmppSignalStrategy::XmppServerConfig::~XmppServerConfig() {}
  48
  49 XmppSignalStrategy::XmppSignalStrategy(
  50     net::ClientSocketFactory* socket_factory,
  51     const scoped_refptr<net::URLRequestContextGetter>& request_context_getter,
  52     const XmppSignalStrategy::XmppServerConfig& xmpp_server_config)
  53     : socket_factory_(socket_factory),
  54       request_context_getter_(request_context_getter),
  55       resource_name_(kDefaultResourceName),
  56       xmpp_client_(nullptr),
  57       xmpp_server_config_(xmpp_server_config),
  58       state_(DISCONNECTED),
  59       error_(OK) {
  60 #if defined(NDEBUG)
  61   CHECK(xmpp_server_config_.use_tls);
  62 #endif
  63 }
  64
  65 XmppSignalStrategy::~XmppSignalStrategy() {
  66   Disconnect();
  67
  68   // Destroying task runner will destroy XmppClient, but XmppClient may be on
  69   // the stack and it doesn't handle this case properly, so we need to delay
  70   // destruction.
  71   base::ThreadTaskRunnerHandle::Get()->DeleteSoon(
  72       FROM_HERE, task_runner_.release());
  73 }
  74
  75 void XmppSignalStrategy::Connect() {
  76   DCHECK(CalledOnValidThread());
  77
  78   // Disconnect first if we are currently connected.
  79   Disconnect();
  80
  81   buzz::XmppClientSettings settings;
  82   buzz::Jid login_jid(xmpp_server_config_.username);
  83   settings.set_user(login_jid.node());
  84   settings.set_host(login_jid.domain());
  85   settings.set_resource(resource_name_);
  86   settings.set_token_service(xmpp_server_config_.auth_service);
  87   settings.set_auth_token(buzz::AUTH_MECHANISM_GOOGLE_TOKEN,
  88                           xmpp_server_config_.auth_token);
  89
  90   int port = xmpp_server_config_.port;
  91
  92   // Port 5222 may be blocked by firewall. talk.google.com allows connections on
  93   // port 443 which can be used instead of 5222. The webapp still requests to
  94   // use port 5222 for backwards compatibility with older versions of the host
  95   // that do not pass correct |use_fake_ssl_client_socket| value to
  96   // XmppClientSocketFactory (and so cannot connect to port 443). In case we are
  97   // connecting to talk.google.com try to use port 443 anyway.
  98   //
  99   // TODO(sergeyu): Once all hosts support connections on port 443
 100   // the webapp needs to be updated to request port 443 and these 2 lines can be
 101   // removed. crbug.com/443384
 102   if (xmpp_server_config_.host == "talk.google.com" && port == kDefaultXmppPort)
 103     port = kDefaultHttpsPort;
 104
 105   settings.set_server(
 106       rtc::SocketAddress(xmpp_server_config_.host, port));
 107   settings.set_use_tls(
 108       xmpp_server_config_.use_tls ? buzz::TLS_ENABLED : buzz::TLS_DISABLED);
 109
 110   // Enable fake SSL handshake when connecting over HTTPS port.
 111   bool use_fake_ssl_client_socket = (port == kDefaultHttpsPort);
 112
 113   scoped_ptr<jingle_glue::XmppClientSocketFactory> xmpp_socket_factory(
 114       new jingle_glue::XmppClientSocketFactory(socket_factory_,
 115                                                net::SSLConfig(),
 116                                                request_context_getter_,
 117                                                use_fake_ssl_client_socket));
 118   buzz::AsyncSocket* socket = new jingle_glue::ChromeAsyncSocket(
 119       xmpp_socket_factory.release(), kReadBufferSize, kWriteBufferSize);
 120
 121   task_runner_.reset(new jingle_glue::TaskPump());
 122   xmpp_client_ = new buzz::XmppClient(task_runner_.get());
 123   xmpp_client_->Connect(
 124       settings, std::string(), socket, CreatePreXmppAuth(settings));
 125   xmpp_client_->SignalStateChange
 126       .connect(this, &XmppSignalStrategy::OnConnectionStateChanged);
 127   xmpp_client_->engine()->AddStanzaHandler(this, buzz::XmppEngine::HL_TYPE);
 128   xmpp_client_->Start();
 129
 130   SetState(CONNECTING);
 131 }
 132
 133 void XmppSignalStrategy::Disconnect() {
 134   DCHECK(CalledOnValidThread());
 135
 136   if (xmpp_client_) {
 137     xmpp_client_->engine()->RemoveStanzaHandler(this);
 138
 139     xmpp_client_->Disconnect();
 140
 141     // |xmpp_client_| should be set to nullptr in OnConnectionStateChanged()
 142     // in response to Disconnect() call above.
 143     DCHECK(xmpp_client_ == nullptr);
 144   }
 145 }
 146
 147 SignalStrategy::State XmppSignalStrategy::GetState() const {
 148   DCHECK(CalledOnValidThread());
 149   return state_;
 150 }
 151
 152 SignalStrategy::Error XmppSignalStrategy::GetError() const {
 153   DCHECK(CalledOnValidThread());
 154   return error_;
 155 }
 156
 157 std::string XmppSignalStrategy::GetLocalJid() const {
 158   DCHECK(CalledOnValidThread());
 159   return xmpp_client_->jid().Str();
 160 }
 161
 162 void XmppSignalStrategy::AddListener(Listener* listener) {
 163   DCHECK(CalledOnValidThread());
 164   listeners_.AddObserver(listener);
 165 }
 166
 167 void XmppSignalStrategy::RemoveListener(Listener* listener) {
 168   DCHECK(CalledOnValidThread());
 169   listeners_.RemoveObserver(listener);
 170 }
 171
 172 bool XmppSignalStrategy::SendStanza(scoped_ptr<buzz::XmlElement> stanza) {
 173   DCHECK(CalledOnValidThread());
 174   if (!xmpp_client_) {
 175     VLOG(0) << "Dropping signalling message because XMPP "
 176         "connection has been terminated.";
 177     return false;
 178   }
 179
 180   buzz::XmppReturnStatus status = xmpp_client_->SendStanza(stanza.release());
 181   return status == buzz::XMPP_RETURN_OK || status == buzz::XMPP_RETURN_PENDING;
 182 }
 183
 184 std::string XmppSignalStrategy::GetNextId() {
 185   DCHECK(CalledOnValidThread());
 186   if (!xmpp_client_) {
 187     // If the connection has been terminated then it doesn't matter
 188     // what Id we return.
 189     return std::string();
 190   }
 191   return xmpp_client_->NextId();
 192 }
 193
 194 bool XmppSignalStrategy::HandleStanza(const buzz::XmlElement* stanza) {
 195   DCHECK(CalledOnValidThread());
 196   ObserverListBase<Listener>::Iterator it(listeners_);
 197   Listener* listener;
 198   while ((listener = it.GetNext()) != nullptr) {
 199     if (listener->OnSignalStrategyIncomingStanza(stanza))
 200       return true;
 201   }
 202   return false;
 203 }
 204
 205 void XmppSignalStrategy::SetAuthInfo(const std::string& username,
 206                                      const std::string& auth_token,
 207                                      const std::string& auth_service) {
 208   DCHECK(CalledOnValidThread());
 209   xmpp_server_config_.username = username;
 210   xmpp_server_config_.auth_token = auth_token;
 211   xmpp_server_config_.auth_service = auth_service;
 212 }
 213
 214 void XmppSignalStrategy::SetResourceName(const std::string &resource_name) {
 215   DCHECK(CalledOnValidThread());
 216   resource_name_ = resource_name;
 217 }
 218
 219 void XmppSignalStrategy::OnConnectionStateChanged(
 220     buzz::XmppEngine::State state) {
 221   DCHECK(CalledOnValidThread());
 222
 223   if (state == buzz::XmppEngine::STATE_OPEN) {
 224     keep_alive_timer_.Start(
 225         FROM_HERE, base::TimeDelta::FromSeconds(kKeepAliveIntervalSeconds),
 226         this, &XmppSignalStrategy::SendKeepAlive);
 227     SetState(CONNECTED);
 228   } else if (state == buzz::XmppEngine::STATE_CLOSED) {
 229     // Make sure we dump errors to the log.
 230     int subcode;
 231     buzz::XmppEngine::Error error = xmpp_client_->GetError(&subcode);
 232     VLOG(0) << "XMPP connection was closed: error=" << error
 233             << ", subcode=" << subcode;
 234
 235     keep_alive_timer_.Stop();
 236
 237     // Client is destroyed by the TaskRunner after the client is
 238     // closed. Reset the pointer so we don't try to use it later.
 239     xmpp_client_ = nullptr;
 240
 241     switch (error) {
 242       case buzz::XmppEngine::ERROR_UNAUTHORIZED:
 243       case buzz::XmppEngine::ERROR_AUTH:
 244       case buzz::XmppEngine::ERROR_MISSING_USERNAME:
 245         error_ = AUTHENTICATION_FAILED;
 246         break;
 247
 248       default:
 249         error_ = NETWORK_ERROR;
 250     }
 251
 252     SetState(DISCONNECTED);
 253   }
 254 }
 255
 256 void XmppSignalStrategy::SetState(State new_state) {
 257   if (state_ != new_state) {
 258     state_ = new_state;
 259     FOR_EACH_OBSERVER(Listener, listeners_,
 260                       OnSignalStrategyStateChange(new_state));
 261   }
 262 }
 263
 264 void XmppSignalStrategy::SendKeepAlive() {
 265   xmpp_client_->SendRaw(" ");
 266 }
 267
 268 // static
 269 buzz::PreXmppAuth* XmppSignalStrategy::CreatePreXmppAuth(
 270     const buzz::XmppClientSettings& settings) {
 271   buzz::Jid jid(settings.user(), settings.host(), buzz::STR_EMPTY);
 272   std::string mechanism = notifier::kDefaultGaiaAuthMechanism;
 273   if (settings.token_service() == "oauth2") {
 274     mechanism = "X-OAUTH2";
 275   }
 276
 277   return new notifier::GaiaTokenPreXmppAuth(
 278       jid.Str(), settings.auth_token(), settings.token_service(), mechanism);
 279 }
 280
 281 }  // namespace remoting