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