remoting/host/it2me/it2me_native_messaging_host.cc

   1 // Copyright 2013 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/host/it2me/it2me_native_messaging_host.h"
   6
   7 #include <string>
   8
   9 #include "base/basictypes.h"
  10 #include "base/bind.h"
  11 #include "base/callback.h"
  12 #include "base/json/json_reader.h"
  13 #include "base/json/json_writer.h"
  14 #include "base/strings/string_number_conversions.h"
  15 #include "base/strings/string_util.h"
  16 #include "base/strings/stringize_macros.h"
  17 #include "base/threading/thread.h"
  18 #include "base/values.h"
  19 #include "media/base/media.h"
  20 #include "net/base/net_util.h"
  21 #include "net/url_request/url_request_context_getter.h"
  22 #include "remoting/base/service_urls.h"
  23 #include "remoting/host/chromoting_host_context.h"
  24 #include "remoting/host/host_exit_codes.h"
  25 #include "remoting/protocol/name_value_map.h"
  26
  27 namespace remoting {
  28
  29 namespace {
  30
  31 const remoting::protocol::NameMapElement<It2MeHostState> kIt2MeHostStates[] = {
  32     {kDisconnected, "DISCONNECTED"},
  33     {kStarting, "STARTING"},
  34     {kRequestedAccessCode, "REQUESTED_ACCESS_CODE"},
  35     {kReceivedAccessCode, "RECEIVED_ACCESS_CODE"},
  36     {kConnected, "CONNECTED"},
  37     {kDisconnecting, "DISCONNECTING"},
  38     {kError, "ERROR"},
  39     {kInvalidDomainError, "INVALID_DOMAIN_ERROR"},
  40 };
  41
  42 }  // namespace
  43
  44 It2MeNativeMessagingHost::It2MeNativeMessagingHost(
  45     scoped_ptr<ChromotingHostContext> context,
  46     scoped_ptr<It2MeHostFactory> factory)
  47     : client_(nullptr),
  48       host_context_(context.Pass()),
  49       factory_(factory.Pass()),
  50       weak_factory_(this) {
  51   weak_ptr_ = weak_factory_.GetWeakPtr();
  52
  53   // Ensures that media library and specific CPU features are initialized.
  54   media::InitializeMediaLibrary();
  55
  56   const ServiceUrls* service_urls = ServiceUrls::GetInstance();
  57   const bool xmpp_server_valid =
  58       net::ParseHostAndPort(service_urls->xmpp_server_address(),
  59                             &xmpp_server_config_.host,
  60                             &xmpp_server_config_.port);
  61   DCHECK(xmpp_server_valid);
  62
  63   xmpp_server_config_.use_tls = service_urls->xmpp_server_use_tls();
  64   directory_bot_jid_ = service_urls->directory_bot_jid();
  65 }
  66
  67 It2MeNativeMessagingHost::~It2MeNativeMessagingHost() {
  68   DCHECK(task_runner()->BelongsToCurrentThread());
  69
  70   if (it2me_host_.get()) {
  71     it2me_host_->Disconnect();
  72     it2me_host_ = nullptr;
  73   }
  74 }
  75
  76 void It2MeNativeMessagingHost::OnMessage(const std::string& message) {
  77   DCHECK(task_runner()->BelongsToCurrentThread());
  78
  79   scoped_ptr<base::DictionaryValue> response(new base::DictionaryValue());
  80   scoped_ptr<base::Value> message_value = base::JSONReader::Read(message);
  81   if (!message_value->IsType(base::Value::TYPE_DICTIONARY)) {
  82     LOG(ERROR) << "Received a message that's not a dictionary.";
  83     client_->CloseChannel(std::string());
  84     return;
  85   }
  86
  87   scoped_ptr<base::DictionaryValue> message_dict(
  88       static_cast<base::DictionaryValue*>(message_value.release()));
  89
  90   // If the client supplies an ID, it will expect it in the response. This
  91   // might be a string or a number, so cope with both.
  92   const base::Value* id;
  93   if (message_dict->Get("id", &id))
  94     response->Set("id", id->DeepCopy());
  95
  96   std::string type;
  97   if (!message_dict->GetString("type", &type)) {
  98     SendErrorAndExit(response.Pass(), "'type' not found in request.");
  99     return;
 100   }
 101
 102   response->SetString("type", type + "Response");
 103
 104   if (type == "hello") {
 105     ProcessHello(*message_dict, response.Pass());
 106   } else if (type == "connect") {
 107     ProcessConnect(*message_dict, response.Pass());
 108   } else if (type == "disconnect") {
 109     ProcessDisconnect(*message_dict, response.Pass());
 110   } else {
 111     SendErrorAndExit(response.Pass(), "Unsupported request type: " + type);
 112   }
 113 }
 114
 115 void It2MeNativeMessagingHost::Start(Client* client) {
 116   DCHECK(task_runner()->BelongsToCurrentThread());
 117   client_ = client;
 118 }
 119
 120 void It2MeNativeMessagingHost::SendMessageToClient(
 121     scoped_ptr<base::DictionaryValue> message) const {
 122   DCHECK(task_runner()->BelongsToCurrentThread());
 123   std::string message_json;
 124   base::JSONWriter::Write(*message, &message_json);
 125   client_->PostMessageFromNativeHost(message_json);
 126 }
 127
 128 void It2MeNativeMessagingHost::ProcessHello(
 129     const base::DictionaryValue& message,
 130     scoped_ptr<base::DictionaryValue> response) const {
 131   DCHECK(task_runner()->BelongsToCurrentThread());
 132
 133   response->SetString("version", STRINGIZE(VERSION));
 134
 135   // This list will be populated when new features are added.
 136   scoped_ptr<base::ListValue> supported_features_list(new base::ListValue());
 137   response->Set("supportedFeatures", supported_features_list.release());
 138
 139   SendMessageToClient(response.Pass());
 140 }
 141
 142 void It2MeNativeMessagingHost::ProcessConnect(
 143     const base::DictionaryValue& message,
 144     scoped_ptr<base::DictionaryValue> response) {
 145   DCHECK(task_runner()->BelongsToCurrentThread());
 146
 147   if (it2me_host_.get()) {
 148     SendErrorAndExit(response.Pass(),
 149                      "Connect can be called only when disconnected.");
 150     return;
 151   }
 152
 153   XmppSignalStrategy::XmppServerConfig xmpp_config = xmpp_server_config_;
 154
 155   if (!message.GetString("userName", &xmpp_config.username)) {
 156     SendErrorAndExit(response.Pass(), "'userName' not found in request.");
 157     return;
 158   }
 159
 160   std::string auth_service_with_token;
 161   if (!message.GetString("authServiceWithToken", &auth_service_with_token)) {
 162     SendErrorAndExit(response.Pass(),
 163                      "'authServiceWithToken' not found in request.");
 164     return;
 165   }
 166
 167   // For backward compatibility the webapp still passes OAuth service as part of
 168   // the authServiceWithToken field. But auth service part is always expected to
 169   // be set to oauth2.
 170   const char kOAuth2ServicePrefix[] = "oauth2:";
 171   if (!base::StartsWithASCII(auth_service_with_token, kOAuth2ServicePrefix,
 172                              true)) {
 173     SendErrorAndExit(response.Pass(), "Invalid 'authServiceWithToken': " +
 174                                           auth_service_with_token);
 175     return;
 176   }
 177
 178   xmpp_config.auth_token =
 179       auth_service_with_token.substr(strlen(kOAuth2ServicePrefix));
 180
 181 #if !defined(NDEBUG)
 182   std::string address;
 183   if (!message.GetString("xmppServerAddress", &address)) {
 184     SendErrorAndExit(response.Pass(),
 185                      "'xmppServerAddress' not found in request.");
 186     return;
 187   }
 188
 189   if (!net::ParseHostAndPort(
 190            address, &xmpp_server_config_.host, &xmpp_server_config_.port)) {
 191     SendErrorAndExit(response.Pass(),
 192                      "Invalid 'xmppServerAddress': " + address);
 193     return;
 194   }
 195
 196   if (!message.GetBoolean("xmppServerUseTls", &xmpp_server_config_.use_tls)) {
 197     SendErrorAndExit(response.Pass(),
 198                      "'xmppServerUseTls' not found in request.");
 199     return;
 200   }
 201
 202   if (!message.GetString("directoryBotJid", &directory_bot_jid_)) {
 203     SendErrorAndExit(response.Pass(),
 204                      "'directoryBotJid' not found in request.");
 205     return;
 206   }
 207 #endif  // !defined(NDEBUG)
 208
 209   // Create the It2Me host and start connecting.
 210   it2me_host_ = factory_->CreateIt2MeHost(host_context_->Copy(),
 211                                           weak_ptr_,
 212                                           xmpp_config,
 213                                           directory_bot_jid_);
 214   it2me_host_->Connect();
 215
 216   SendMessageToClient(response.Pass());
 217 }
 218
 219 void It2MeNativeMessagingHost::ProcessDisconnect(
 220     const base::DictionaryValue& message,
 221     scoped_ptr<base::DictionaryValue> response) {
 222   DCHECK(task_runner()->BelongsToCurrentThread());
 223
 224   if (it2me_host_.get()) {
 225     it2me_host_->Disconnect();
 226     it2me_host_ = nullptr;
 227   }
 228   SendMessageToClient(response.Pass());
 229 }
 230
 231 void It2MeNativeMessagingHost::SendErrorAndExit(
 232     scoped_ptr<base::DictionaryValue> response,
 233     const std::string& description) const {
 234   DCHECK(task_runner()->BelongsToCurrentThread());
 235
 236   LOG(ERROR) << description;
 237
 238   response->SetString("type", "error");
 239   response->SetString("description", description);
 240   SendMessageToClient(response.Pass());
 241
 242   // Trigger a host shutdown by sending an empty message.
 243   client_->CloseChannel(std::string());
 244 }
 245
 246 void It2MeNativeMessagingHost::OnStateChanged(It2MeHostState state) {
 247   DCHECK(task_runner()->BelongsToCurrentThread());
 248
 249   state_ = state;
 250
 251   scoped_ptr<base::DictionaryValue> message(new base::DictionaryValue());
 252
 253   message->SetString("type", "hostStateChanged");
 254   message->SetString("state",
 255                      It2MeNativeMessagingHost::HostStateToString(state));
 256
 257   switch (state_) {
 258     case kReceivedAccessCode:
 259       message->SetString("accessCode", access_code_);
 260       message->SetInteger("accessCodeLifetime",
 261                           access_code_lifetime_.InSeconds());
 262       break;
 263
 264     case kConnected:
 265       message->SetString("client", client_username_);
 266       break;
 267
 268     case kDisconnected:
 269       client_username_.clear();
 270       break;
 271
 272     default:
 273       ;
 274   }
 275
 276   SendMessageToClient(message.Pass());
 277 }
 278
 279 void It2MeNativeMessagingHost::OnNatPolicyChanged(bool nat_traversal_enabled) {
 280   DCHECK(task_runner()->BelongsToCurrentThread());
 281
 282   scoped_ptr<base::DictionaryValue> message(new base::DictionaryValue());
 283
 284   message->SetString("type", "natPolicyChanged");
 285   message->SetBoolean("natTraversalEnabled", nat_traversal_enabled);
 286   SendMessageToClient(message.Pass());
 287 }
 288
 289 // Stores the Access Code for the web-app to query.
 290 void It2MeNativeMessagingHost::OnStoreAccessCode(
 291     const std::string& access_code,
 292     base::TimeDelta access_code_lifetime) {
 293   DCHECK(task_runner()->BelongsToCurrentThread());
 294
 295   access_code_ = access_code;
 296   access_code_lifetime_ = access_code_lifetime;
 297 }
 298
 299 // Stores the client user's name for the web-app to query.
 300 void It2MeNativeMessagingHost::OnClientAuthenticated(
 301     const std::string& client_username) {
 302   DCHECK(task_runner()->BelongsToCurrentThread());
 303
 304   client_username_ = client_username;
 305 }
 306
 307 scoped_refptr<base::SingleThreadTaskRunner>
 308 It2MeNativeMessagingHost::task_runner() const {
 309   return host_context_->ui_task_runner();
 310 }
 311
 312 /* static */
 313 std::string It2MeNativeMessagingHost::HostStateToString(
 314     It2MeHostState host_state) {
 315   return ValueToName(kIt2MeHostStates, host_state);
 316 }
 317
 318 }  // namespace remoting
 319