remoting/host/setup/host_starter.cc

   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/host/setup/host_starter.h"
   6
   7 #include "base/guid.h"
   8 #include "base/thread_task_runner_handle.h"
   9 #include "base/values.h"
  10 #include "google_apis/google_api_keys.h"
  11 #include "remoting/host/pin_hash.h"
  12 #include "remoting/host/setup/oauth_helper.h"
  13
  14 namespace {
  15 const int kMaxGetTokensRetries = 3;
  16 }  // namespace
  17
  18 namespace remoting {
  19
  20 HostStarter::HostStarter(
  21     scoped_ptr<gaia::GaiaOAuthClient> oauth_client,
  22     scoped_ptr<remoting::ServiceClient> service_client,
  23     scoped_refptr<remoting::DaemonController> daemon_controller)
  24     : oauth_client_(oauth_client.Pass()),
  25       service_client_(service_client.Pass()),
  26       daemon_controller_(daemon_controller),
  27       consent_to_data_collection_(false),
  28       unregistering_host_(false),
  29       weak_ptr_factory_(this) {
  30   weak_ptr_ = weak_ptr_factory_.GetWeakPtr();
  31   main_task_runner_ = base::ThreadTaskRunnerHandle::Get();
  32 }
  33
  34 HostStarter::~HostStarter() {
  35 }
  36
  37 scoped_ptr<HostStarter> HostStarter::Create(
  38     const std::string& chromoting_hosts_url,
  39     net::URLRequestContextGetter* url_request_context_getter) {
  40   scoped_ptr<gaia::GaiaOAuthClient> oauth_client(
  41       new gaia::GaiaOAuthClient(url_request_context_getter));
  42   scoped_ptr<remoting::ServiceClient> service_client(
  43       new remoting::ServiceClient(
  44           chromoting_hosts_url, url_request_context_getter));
  45   scoped_refptr<remoting::DaemonController> daemon_controller(
  46       remoting::DaemonController::Create());
  47   return scoped_ptr<HostStarter>(
  48       new HostStarter(oauth_client.Pass(), service_client.Pass(),
  49                       daemon_controller));
  50 }
  51
  52 void HostStarter::StartHost(
  53     const std::string& host_name,
  54     const std::string& host_pin,
  55     bool consent_to_data_collection,
  56     const std::string& auth_code,
  57     const std::string& redirect_url,
  58     CompletionCallback on_done) {
  59   DCHECK(main_task_runner_->BelongsToCurrentThread());
  60   DCHECK(on_done_.is_null());
  61
  62   host_name_ = host_name;
  63   host_pin_ = host_pin;
  64   consent_to_data_collection_ = consent_to_data_collection;
  65   on_done_ = on_done;
  66   oauth_client_info_.client_id =
  67       google_apis::GetOAuth2ClientID(google_apis::CLIENT_REMOTING);
  68   oauth_client_info_.client_secret =
  69       google_apis::GetOAuth2ClientSecret(google_apis::CLIENT_REMOTING);
  70   oauth_client_info_.redirect_uri = redirect_url;
  71   // Map the authorization code to refresh and access tokens.
  72   oauth_client_->GetTokensFromAuthCode(oauth_client_info_, auth_code,
  73                                        kMaxGetTokensRetries, this);
  74 }
  75
  76 void HostStarter::OnGetTokensResponse(
  77     const std::string& refresh_token,
  78     const std::string& access_token,
  79     int expires_in_seconds) {
  80   if (!main_task_runner_->BelongsToCurrentThread()) {
  81     main_task_runner_->PostTask(FROM_HERE, base::Bind(
  82         &HostStarter::OnGetTokensResponse, weak_ptr_,
  83         refresh_token, access_token, expires_in_seconds));
  84     return;
  85   }
  86   refresh_token_ = refresh_token;
  87   access_token_ = access_token;
  88   // Get the email corresponding to the access token.
  89   oauth_client_->GetUserEmail(access_token_, 1, this);
  90 }
  91
  92 void HostStarter::OnRefreshTokenResponse(
  93     const std::string& access_token,
  94     int expires_in_seconds) {
  95   // We never request a refresh token, so this call is not expected.
  96   NOTREACHED();
  97 }
  98
  99 // This function is called twice: once with the host owner credentials, and once
 100 // with the service account credentials.
 101 void HostStarter::OnGetUserEmailResponse(const std::string& user_email) {
 102   if (!main_task_runner_->BelongsToCurrentThread()) {
 103     main_task_runner_->PostTask(FROM_HERE, base::Bind(
 104         &HostStarter::OnGetUserEmailResponse, weak_ptr_, user_email));
 105     return;
 106   }
 107
 108   if (host_owner_.empty()) {
 109     // This is the first callback, with the host owner credentials. Store the
 110     // owner's email, and register the host.
 111     host_owner_ = user_email;
 112     host_id_ = base::GenerateGUID();
 113     key_pair_ = RsaKeyPair::Generate();
 114
 115     std::string host_client_id;
 116     host_client_id = google_apis::GetOAuth2ClientID(
 117         google_apis::CLIENT_REMOTING_HOST);
 118
 119     service_client_->RegisterHost(
 120         host_id_, host_name_, key_pair_->GetPublicKey(), host_client_id,
 121         access_token_, this);
 122   } else {
 123     // This is the second callback, with the service account credentials.
 124     // This email is the service account's email, used to login to XMPP.
 125     xmpp_login_ = user_email;
 126     StartHostProcess();
 127   }
 128 }
 129
 130 void HostStarter::OnHostRegistered(const std::string& authorization_code) {
 131   if (!main_task_runner_->BelongsToCurrentThread()) {
 132     main_task_runner_->PostTask(FROM_HERE, base::Bind(
 133         &HostStarter::OnHostRegistered, weak_ptr_, authorization_code));
 134     return;
 135   }
 136
 137   if (authorization_code.empty()) {
 138     // No service account code, start the host with the owner's credentials.
 139     xmpp_login_ = host_owner_;
 140     StartHostProcess();
 141     return;
 142   }
 143
 144   // Received a service account authorization code, update oauth_client_info_
 145   // to use the service account client keys, and get service account tokens.
 146   oauth_client_info_.client_id =
 147       google_apis::GetOAuth2ClientID(
 148           google_apis::CLIENT_REMOTING_HOST);
 149   oauth_client_info_.client_secret =
 150       google_apis::GetOAuth2ClientSecret(
 151           google_apis::CLIENT_REMOTING_HOST);
 152   oauth_client_info_.redirect_uri = "oob";
 153   oauth_client_->GetTokensFromAuthCode(
 154       oauth_client_info_, authorization_code, kMaxGetTokensRetries, this);
 155 }
 156
 157 void HostStarter::StartHostProcess() {
 158   // Start the host.
 159   std::string host_secret_hash = remoting::MakeHostPinHash(host_id_, host_pin_);
 160   scoped_ptr<base::DictionaryValue> config(new base::DictionaryValue());
 161   if (host_owner_ != xmpp_login_) {
 162     config->SetString("host_owner", host_owner_);
 163   }
 164   config->SetString("xmpp_login", xmpp_login_);
 165   config->SetString("oauth_refresh_token", refresh_token_);
 166   config->SetString("host_id", host_id_);
 167   config->SetString("host_name", host_name_);
 168   config->SetString("private_key", key_pair_->ToString());
 169   config->SetString("host_secret_hash", host_secret_hash);
 170   daemon_controller_->SetConfigAndStart(
 171       config.Pass(), consent_to_data_collection_,
 172       base::Bind(&HostStarter::OnHostStarted, base::Unretained(this)));
 173 }
 174
 175 void HostStarter::OnHostStarted(DaemonController::AsyncResult result) {
 176   if (!main_task_runner_->BelongsToCurrentThread()) {
 177     main_task_runner_->PostTask(FROM_HERE, base::Bind(
 178         &HostStarter::OnHostStarted, weak_ptr_, result));
 179     return;
 180   }
 181   if (result != DaemonController::RESULT_OK) {
 182     unregistering_host_ = true;
 183     service_client_->UnregisterHost(host_id_, access_token_, this);
 184     return;
 185   }
 186   CompletionCallback cb = on_done_;
 187   on_done_.Reset();
 188   cb.Run(START_COMPLETE);
 189 }
 190
 191 void HostStarter::OnOAuthError() {
 192   if (!main_task_runner_->BelongsToCurrentThread()) {
 193     main_task_runner_->PostTask(FROM_HERE, base::Bind(
 194         &HostStarter::OnOAuthError, weak_ptr_));
 195     return;
 196   }
 197   CompletionCallback cb = on_done_;
 198   on_done_.Reset();
 199   if (unregistering_host_) {
 200     LOG(ERROR) << "OAuth error occurred when unregistering host.";
 201     cb.Run(START_ERROR);
 202   } else {
 203     cb.Run(OAUTH_ERROR);
 204   }
 205 }
 206
 207 void HostStarter::OnNetworkError(int response_code) {
 208   if (!main_task_runner_->BelongsToCurrentThread()) {
 209     main_task_runner_->PostTask(FROM_HERE, base::Bind(
 210         &HostStarter::OnNetworkError, weak_ptr_, response_code));
 211     return;
 212   }
 213   CompletionCallback cb = on_done_;
 214   on_done_.Reset();
 215   if (unregistering_host_) {
 216     LOG(ERROR) << "Network error occurred when unregistering host.";
 217     cb.Run(START_ERROR);
 218   } else {
 219     cb.Run(NETWORK_ERROR);
 220   }
 221 }
 222
 223 void HostStarter::OnHostUnregistered() {
 224   if (!main_task_runner_->BelongsToCurrentThread()) {
 225     main_task_runner_->PostTask(FROM_HERE, base::Bind(
 226         &HostStarter::OnHostUnregistered, weak_ptr_));
 227     return;
 228   }
 229   CompletionCallback cb = on_done_;
 230   on_done_.Reset();
 231   cb.Run(START_ERROR);
 232 }
 233
 234 }  // namespace remoting