| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| 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. Most | |
| 31 // of XMPP messages are smaller than 4kB. | |
| 32 const size_t kReadBufferSize = 4096; | |
| 33 const size_t kWriteBufferSize = 4096; | |
| 34 | |
| 35 namespace remoting { | |
| 36 | |
| 37 XmppSignalStrategy::XmppServerConfig::XmppServerConfig() {} | |
| 38 XmppSignalStrategy::XmppServerConfig::~XmppServerConfig() {} | |
| 39 | |
| 40 XmppSignalStrategy::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 | |
| 56 XmppSignalStrategy::~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 | |
| 66 void 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 | |
| 103 void 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 | |
| 117 SignalStrategy::State XmppSignalStrategy::GetState() const { | |
| 118 DCHECK(CalledOnValidThread()); | |
| 119 return state_; | |
| 120 } | |
| 121 | |
| 122 SignalStrategy::Error XmppSignalStrategy::GetError() const { | |
| 123 DCHECK(CalledOnValidThread()); | |
| 124 return error_; | |
| 125 } | |
| 126 | |
| 127 std::string XmppSignalStrategy::GetLocalJid() const { | |
| 128 DCHECK(CalledOnValidThread()); | |
| 129 return xmpp_client_->jid().Str(); | |
| 130 } | |
| 131 | |
| 132 void XmppSignalStrategy::AddListener(Listener* listener) { | |
| 133 DCHECK(CalledOnValidThread()); | |
| 134 listeners_.AddObserver(listener); | |
| 135 } | |
| 136 | |
| 137 void XmppSignalStrategy::RemoveListener(Listener* listener) { | |
| 138 DCHECK(CalledOnValidThread()); | |
| 139 listeners_.RemoveObserver(listener); | |
| 140 } | |
| 141 | |
| 142 bool 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 | |
| 154 std::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 | |
| 164 bool 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 | |
| 175 void 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 | |
| 184 void XmppSignalStrategy::SetResourceName(const std::string &resource_name) { | |
| 185 DCHECK(CalledOnValidThread()); | |
| 186 resource_name_ = resource_name; | |
| 187 } | |
| 188 | |
| 189 void 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 | |
| 226 void 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 | |
| 234 void XmppSignalStrategy::SendKeepAlive() { | |
| 235 xmpp_client_->SendRaw(" "); | |
| 236 } | |
| 237 | |
| 238 // static | |
| 239 buzz::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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 390983003:
Remove remoting/jingle_glue (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src