src/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/libjingle/source/talk/xmpp/prexmppauth.h"
  21 #include "third_party/libjingle/source/talk/xmpp/saslcookiemechanism.h"
  22 #include "third_party/webrtc/base/thread.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 namespace remoting {
  42
  43 XmppSignalStrategy::XmppServerConfig::XmppServerConfig() {}
  44 XmppSignalStrategy::XmppServerConfig::~XmppServerConfig() {}
  45
  46 XmppSignalStrategy::XmppSignalStrategy(
  47     net::ClientSocketFactory* socket_factory,
  48     scoped_refptr<net::URLRequestContextGetter> request_context_getter,
  49     const XmppSignalStrategy::XmppServerConfig& xmpp_server_config)
  50     : socket_factory_(socket_factory),
  51       request_context_getter_(request_context_getter),
  52       resource_name_(kDefaultResourceName),
  53       xmpp_client_(NULL),
  54       xmpp_server_config_(xmpp_server_config),
  55       state_(DISCONNECTED),
  56       error_(OK) {
  57 #if defined(NDEBUG)
  58   CHECK(xmpp_server_config_.use_tls);
  59 #endif
  60 }
  61
  62 XmppSignalStrategy::~XmppSignalStrategy() {
  63   Disconnect();
  64
  65   // Destroying task runner will destroy XmppClient, but XmppClient may be on
  66   // the stack and it doesn't handle this case properly, so we need to delay
  67   // destruction.
  68   base::ThreadTaskRunnerHandle::Get()->DeleteSoon(
  69       FROM_HERE, task_runner_.release());
  70 }
  71
  72 void XmppSignalStrategy::Connect() {
  73   DCHECK(CalledOnValidThread());
  74
  75   // Disconnect first if we are currently connected.
  76   Disconnect();
  77
  78   buzz::XmppClientSettings settings;
  79   buzz::Jid login_jid(xmpp_server_config_.username);
  80   settings.set_user(login_jid.node());
  81   settings.set_host(login_jid.domain());
  82   settings.set_resource(resource_name_);
  83   settings.set_token_service(xmpp_server_config_.auth_service);
  84   settings.set_auth_token(buzz::AUTH_MECHANISM_GOOGLE_TOKEN,
  85                           xmpp_server_config_.auth_token);
  86   settings.set_server(rtc::SocketAddress(
  87       xmpp_server_config_.host, xmpp_server_config_.port));
  88   settings.set_use_tls(
  89       xmpp_server_config_.use_tls ? buzz::TLS_ENABLED : buzz::TLS_DISABLED);
  90
  91   scoped_ptr<jingle_glue::XmppClientSocketFactory> xmpp_socket_factory(
  92       new jingle_glue::XmppClientSocketFactory(
  93           socket_factory_, net::SSLConfig(), request_context_getter_, false));
  94   buzz::AsyncSocket* socket = new jingle_glue::ChromeAsyncSocket(
  95     xmpp_socket_factory.release(), kReadBufferSize, kWriteBufferSize);
  96
  97   task_runner_.reset(new jingle_glue::TaskPump());
  98   xmpp_client_ = new buzz::XmppClient(task_runner_.get());
  99   xmpp_client_->Connect(
 100       settings, std::string(), socket, CreatePreXmppAuth(settings));
 101   xmpp_client_->SignalStateChange
 102       .connect(this, &XmppSignalStrategy::OnConnectionStateChanged);
 103   xmpp_client_->engine()->AddStanzaHandler(this, buzz::XmppEngine::HL_TYPE);
 104   xmpp_client_->Start();
 105
 106   SetState(CONNECTING);
 107 }
 108
 109 void XmppSignalStrategy::Disconnect() {
 110   DCHECK(CalledOnValidThread());
 111
 112   if (xmpp_client_) {
 113     xmpp_client_->engine()->RemoveStanzaHandler(this);
 114
 115     xmpp_client_->Disconnect();
 116
 117     // |xmpp_client_| should be set to NULL in OnConnectionStateChanged()
 118     // in response to Disconnect() call above.
 119     DCHECK(xmpp_client_ == NULL);
 120   }
 121 }
 122
 123 SignalStrategy::State XmppSignalStrategy::GetState() const {
 124   DCHECK(CalledOnValidThread());
 125   return state_;
 126 }
 127
 128 SignalStrategy::Error XmppSignalStrategy::GetError() const {
 129   DCHECK(CalledOnValidThread());
 130   return error_;
 131 }
 132
 133 std::string XmppSignalStrategy::GetLocalJid() const {
 134   DCHECK(CalledOnValidThread());
 135   return xmpp_client_->jid().Str();
 136 }
 137
 138 void XmppSignalStrategy::AddListener(Listener* listener) {
 139   DCHECK(CalledOnValidThread());
 140   listeners_.AddObserver(listener);
 141 }
 142
 143 void XmppSignalStrategy::RemoveListener(Listener* listener) {
 144   DCHECK(CalledOnValidThread());
 145   listeners_.RemoveObserver(listener);
 146 }
 147
 148 bool XmppSignalStrategy::SendStanza(scoped_ptr<buzz::XmlElement> stanza) {
 149   DCHECK(CalledOnValidThread());
 150   if (!xmpp_client_) {
 151     VLOG(0) << "Dropping signalling message because XMPP "
 152         "connection has been terminated.";
 153     return false;
 154   }
 155
 156   buzz::XmppReturnStatus status = xmpp_client_->SendStanza(stanza.release());
 157   return status == buzz::XMPP_RETURN_OK || status == buzz::XMPP_RETURN_PENDING;
 158 }
 159
 160 std::string XmppSignalStrategy::GetNextId() {
 161   DCHECK(CalledOnValidThread());
 162   if (!xmpp_client_) {
 163     // If the connection has been terminated then it doesn't matter
 164     // what Id we return.
 165     return std::string();
 166   }
 167   return xmpp_client_->NextId();
 168 }
 169
 170 bool XmppSignalStrategy::HandleStanza(const buzz::XmlElement* stanza) {
 171   DCHECK(CalledOnValidThread());
 172   ObserverListBase<Listener>::Iterator it(listeners_);
 173   Listener* listener;
 174   while ((listener = it.GetNext()) != NULL) {
 175     if (listener->OnSignalStrategyIncomingStanza(stanza))
 176       return true;
 177   }
 178   return false;
 179 }
 180
 181 void XmppSignalStrategy::SetAuthInfo(const std::string& username,
 182                                      const std::string& auth_token,
 183                                      const std::string& auth_service) {
 184   DCHECK(CalledOnValidThread());
 185   xmpp_server_config_.username = username;
 186   xmpp_server_config_.auth_token = auth_token;
 187   xmpp_server_config_.auth_service = auth_service;
 188 }
 189
 190 void XmppSignalStrategy::SetResourceName(const std::string &resource_name) {
 191   DCHECK(CalledOnValidThread());
 192   resource_name_ = resource_name;
 193 }
 194
 195 void XmppSignalStrategy::OnConnectionStateChanged(
 196     buzz::XmppEngine::State state) {
 197   DCHECK(CalledOnValidThread());
 198
 199   if (state == buzz::XmppEngine::STATE_OPEN) {
 200     keep_alive_timer_.Start(
 201         FROM_HERE, base::TimeDelta::FromSeconds(kKeepAliveIntervalSeconds),
 202         this, &XmppSignalStrategy::SendKeepAlive);
 203     SetState(CONNECTED);
 204   } else if (state == buzz::XmppEngine::STATE_CLOSED) {
 205     // Make sure we dump errors to the log.
 206     int subcode;
 207     buzz::XmppEngine::Error error = xmpp_client_->GetError(&subcode);
 208     VLOG(0) << "XMPP connection was closed: error=" << error
 209             << ", subcode=" << subcode;
 210
 211     keep_alive_timer_.Stop();
 212
 213     // Client is destroyed by the TaskRunner after the client is
 214     // closed. Reset the pointer so we don't try to use it later.
 215     xmpp_client_ = NULL;
 216
 217     switch (error) {
 218       case buzz::XmppEngine::ERROR_UNAUTHORIZED:
 219       case buzz::XmppEngine::ERROR_AUTH:
 220       case buzz::XmppEngine::ERROR_MISSING_USERNAME:
 221         error_ = AUTHENTICATION_FAILED;
 222         break;
 223
 224       default:
 225         error_ = NETWORK_ERROR;
 226     }
 227
 228     SetState(DISCONNECTED);
 229   }
 230 }
 231
 232 void XmppSignalStrategy::SetState(State new_state) {
 233   if (state_ != new_state) {
 234     state_ = new_state;
 235     FOR_EACH_OBSERVER(Listener, listeners_,
 236                       OnSignalStrategyStateChange(new_state));
 237   }
 238 }
 239
 240 void XmppSignalStrategy::SendKeepAlive() {
 241   xmpp_client_->SendRaw(" ");
 242 }
 243
 244 // static
 245 buzz::PreXmppAuth* XmppSignalStrategy::CreatePreXmppAuth(
 246     const buzz::XmppClientSettings& settings) {
 247   buzz::Jid jid(settings.user(), settings.host(), buzz::STR_EMPTY);
 248   std::string mechanism = notifier::kDefaultGaiaAuthMechanism;
 249   if (settings.token_service() == "oauth2") {
 250     mechanism = "X-OAUTH2";
 251   }
 252
 253   return new notifier::GaiaTokenPreXmppAuth(
 254       jid.Str(), settings.auth_token(), settings.token_service(), mechanism);
 255 }
 256
 257 }  // namespace remoting