src/chromeos/cryptohome/async_method_caller.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 "chromeos/cryptohome/async_method_caller.h"
   6
   7 #include "base/bind.h"
   8 #include "base/containers/hash_tables.h"
   9 #include "base/location.h"
  10 #include "base/message_loop/message_loop_proxy.h"
  11 #include "chromeos/dbus/cryptohome_client.h"
  12 #include "chromeos/dbus/dbus_thread_manager.h"
  13
  14 using chromeos::DBusThreadManager;
  15
  16 namespace cryptohome {
  17
  18 namespace {
  19
  20 AsyncMethodCaller* g_async_method_caller = NULL;
  21
  22 // The implementation of AsyncMethodCaller
  23 class AsyncMethodCallerImpl : public AsyncMethodCaller {
  24  public:
  25   AsyncMethodCallerImpl() : weak_ptr_factory_(this) {
  26     DBusThreadManager::Get()->GetCryptohomeClient()->SetAsyncCallStatusHandlers(
  27         base::Bind(&AsyncMethodCallerImpl::HandleAsyncResponse,
  28                    weak_ptr_factory_.GetWeakPtr()),
  29         base::Bind(&AsyncMethodCallerImpl::HandleAsyncDataResponse,
  30                    weak_ptr_factory_.GetWeakPtr()));
  31   }
  32
  33   virtual ~AsyncMethodCallerImpl() {
  34     DBusThreadManager::Get()->GetCryptohomeClient()->
  35         ResetAsyncCallStatusHandlers();
  36   }
  37
  38   virtual void AsyncCheckKey(const std::string& user_email,
  39                              const std::string& passhash,
  40                              Callback callback) OVERRIDE {
  41     DBusThreadManager::Get()->GetCryptohomeClient()->
  42         AsyncCheckKey(user_email, passhash, base::Bind(
  43             &AsyncMethodCallerImpl::RegisterAsyncCallback,
  44             weak_ptr_factory_.GetWeakPtr(),
  45             callback,
  46             "Couldn't initiate async check of user's key."));
  47   }
  48
  49   virtual void AsyncMigrateKey(const std::string& user_email,
  50                                const std::string& old_hash,
  51                                const std::string& new_hash,
  52                                Callback callback) OVERRIDE {
  53     DBusThreadManager::Get()->GetCryptohomeClient()->
  54         AsyncMigrateKey(user_email, old_hash, new_hash, base::Bind(
  55             &AsyncMethodCallerImpl::RegisterAsyncCallback,
  56             weak_ptr_factory_.GetWeakPtr(),
  57             callback,
  58             "Couldn't initiate aync migration of user's key"));
  59   }
  60
  61   virtual void AsyncMount(const std::string& user_email,
  62                           const std::string& passhash,
  63                           int flags,
  64                           Callback callback) OVERRIDE {
  65     DBusThreadManager::Get()->GetCryptohomeClient()->
  66         AsyncMount(user_email, passhash, flags, base::Bind(
  67             &AsyncMethodCallerImpl::RegisterAsyncCallback,
  68             weak_ptr_factory_.GetWeakPtr(),
  69             callback,
  70             "Couldn't initiate async mount of cryptohome."));
  71   }
  72
  73   virtual void AsyncAddKey(const std::string& user_email,
  74                            const std::string& passhash,
  75                            const std::string& new_passhash,
  76                            Callback callback) OVERRIDE {
  77     DBusThreadManager::Get()->GetCryptohomeClient()->
  78         AsyncAddKey(user_email, passhash, new_passhash, base::Bind(
  79             &AsyncMethodCallerImpl::RegisterAsyncCallback,
  80             weak_ptr_factory_.GetWeakPtr(),
  81             callback,
  82             "Couldn't initiate async key addition."));
  83   }
  84
  85   virtual void AsyncMountGuest(Callback callback) OVERRIDE {
  86     DBusThreadManager::Get()->GetCryptohomeClient()->
  87         AsyncMountGuest(base::Bind(
  88             &AsyncMethodCallerImpl::RegisterAsyncCallback,
  89             weak_ptr_factory_.GetWeakPtr(),
  90             callback,
  91             "Couldn't initiate async mount of cryptohome."));
  92   }
  93
  94   virtual void AsyncMountPublic(const std::string& public_mount_id,
  95                                 int flags,
  96                                 Callback callback) OVERRIDE {
  97     DBusThreadManager::Get()->GetCryptohomeClient()->
  98         AsyncMountPublic(public_mount_id, flags, base::Bind(
  99             &AsyncMethodCallerImpl::RegisterAsyncCallback,
 100             weak_ptr_factory_.GetWeakPtr(),
 101             callback,
 102             "Couldn't initiate async mount public of cryptohome."));
 103   }
 104
 105   virtual void AsyncRemove(const std::string& user_email,
 106                            Callback callback) OVERRIDE {
 107     DBusThreadManager::Get()->GetCryptohomeClient()->
 108         AsyncRemove(user_email, base::Bind(
 109             &AsyncMethodCallerImpl::RegisterAsyncCallback,
 110             weak_ptr_factory_.GetWeakPtr(),
 111             callback,
 112             "Couldn't initiate async removal of cryptohome."));
 113   }
 114
 115   virtual void AsyncTpmAttestationCreateEnrollRequest(
 116       const DataCallback& callback) OVERRIDE {
 117     DBusThreadManager::Get()->GetCryptohomeClient()->
 118         AsyncTpmAttestationCreateEnrollRequest(base::Bind(
 119             &AsyncMethodCallerImpl::RegisterAsyncDataCallback,
 120             weak_ptr_factory_.GetWeakPtr(),
 121             callback,
 122             "Couldn't initiate async attestation enroll request."));
 123   }
 124
 125   virtual void AsyncTpmAttestationEnroll(const std::string& pca_response,
 126                                          const Callback& callback) OVERRIDE {
 127     DBusThreadManager::Get()->GetCryptohomeClient()->
 128         AsyncTpmAttestationEnroll(pca_response, base::Bind(
 129             &AsyncMethodCallerImpl::RegisterAsyncCallback,
 130             weak_ptr_factory_.GetWeakPtr(),
 131             callback,
 132             "Couldn't initiate async attestation enroll."));
 133   }
 134
 135   virtual void AsyncTpmAttestationCreateCertRequest(
 136       chromeos::attestation::AttestationCertificateProfile certificate_profile,
 137       const std::string& user_id,
 138       const std::string& request_origin,
 139       const DataCallback& callback) OVERRIDE {
 140     DBusThreadManager::Get()->GetCryptohomeClient()->
 141         AsyncTpmAttestationCreateCertRequest(
 142             certificate_profile,
 143             user_id,
 144             request_origin,
 145             base::Bind(&AsyncMethodCallerImpl::RegisterAsyncDataCallback,
 146                        weak_ptr_factory_.GetWeakPtr(),
 147                        callback,
 148                        "Couldn't initiate async attestation cert request."));
 149   }
 150
 151   virtual void AsyncTpmAttestationFinishCertRequest(
 152       const std::string& pca_response,
 153       chromeos::attestation::AttestationKeyType key_type,
 154       const std::string& user_id,
 155       const std::string& key_name,
 156       const DataCallback& callback) OVERRIDE {
 157     DBusThreadManager::Get()->GetCryptohomeClient()->
 158         AsyncTpmAttestationFinishCertRequest(
 159             pca_response,
 160             key_type,
 161             user_id,
 162             key_name,
 163             base::Bind(
 164                 &AsyncMethodCallerImpl::RegisterAsyncDataCallback,
 165                 weak_ptr_factory_.GetWeakPtr(),
 166                 callback,
 167                 "Couldn't initiate async attestation finish cert request."));
 168   }
 169
 170   virtual void TpmAttestationRegisterKey(
 171       chromeos::attestation::AttestationKeyType key_type,
 172       const std::string& user_id,
 173       const std::string& key_name,
 174       const Callback& callback) OVERRIDE {
 175     DBusThreadManager::Get()->GetCryptohomeClient()->
 176         TpmAttestationRegisterKey(
 177             key_type,
 178             user_id,
 179             key_name,
 180             base::Bind(
 181                 &AsyncMethodCallerImpl::RegisterAsyncCallback,
 182                 weak_ptr_factory_.GetWeakPtr(),
 183                 callback,
 184                 "Couldn't initiate async attestation register key."));
 185   }
 186
 187   virtual void TpmAttestationSignEnterpriseChallenge(
 188       chromeos::attestation::AttestationKeyType key_type,
 189       const std::string& user_id,
 190       const std::string& key_name,
 191       const std::string& domain,
 192       const std::string& device_id,
 193       chromeos::attestation::AttestationChallengeOptions options,
 194       const std::string& challenge,
 195       const DataCallback& callback) OVERRIDE {
 196     DBusThreadManager::Get()->GetCryptohomeClient()->
 197         TpmAttestationSignEnterpriseChallenge(
 198             key_type,
 199             user_id,
 200             key_name,
 201             domain,
 202             device_id,
 203             options,
 204             challenge,
 205             base::Bind(
 206                 &AsyncMethodCallerImpl::RegisterAsyncDataCallback,
 207                 weak_ptr_factory_.GetWeakPtr(),
 208                 callback,
 209                 "Couldn't initiate async attestation enterprise challenge."));
 210   }
 211
 212   virtual void TpmAttestationSignSimpleChallenge(
 213       chromeos::attestation::AttestationKeyType key_type,
 214       const std::string& user_id,
 215       const std::string& key_name,
 216       const std::string& challenge,
 217       const DataCallback& callback) OVERRIDE {
 218     DBusThreadManager::Get()->GetCryptohomeClient()->
 219         TpmAttestationSignSimpleChallenge(
 220             key_type,
 221             user_id,
 222             key_name,
 223             challenge,
 224             base::Bind(
 225                 &AsyncMethodCallerImpl::RegisterAsyncDataCallback,
 226                 weak_ptr_factory_.GetWeakPtr(),
 227                 callback,
 228                 "Couldn't initiate async attestation simple challenge."));
 229   }
 230
 231   virtual void AsyncGetSanitizedUsername(
 232       const std::string& user,
 233       const DataCallback& callback) OVERRIDE {
 234     DBusThreadManager::Get()->GetCryptohomeClient()->
 235         GetSanitizedUsername(user,
 236         base::Bind(
 237             &AsyncMethodCallerImpl::GetSanitizedUsernameCallback,
 238             weak_ptr_factory_.GetWeakPtr(),
 239             callback));
 240   }
 241
 242   virtual void GetSanitizedUsernameCallback(
 243       const DataCallback& callback,
 244       const chromeos::DBusMethodCallStatus call_status,
 245       const std::string& result) {
 246     callback.Run(true, result);
 247   }
 248
 249  private:
 250   struct CallbackElement {
 251     CallbackElement() {}
 252     explicit CallbackElement(const AsyncMethodCaller::Callback& callback)
 253         : callback(callback),
 254           proxy(base::MessageLoopProxy::current()) {
 255     }
 256     AsyncMethodCaller::Callback callback;
 257     scoped_refptr<base::MessageLoopProxy> proxy;
 258   };
 259
 260   struct DataCallbackElement {
 261     DataCallbackElement() {}
 262     explicit DataCallbackElement(
 263         const AsyncMethodCaller::DataCallback& callback)
 264         : data_callback(callback),
 265           proxy(base::MessageLoopProxy::current()) {
 266     }
 267     AsyncMethodCaller::DataCallback data_callback;
 268     scoped_refptr<base::MessageLoopProxy> proxy;
 269   };
 270
 271   typedef base::hash_map<int, CallbackElement> CallbackMap;
 272   typedef base::hash_map<int, DataCallbackElement> DataCallbackMap;
 273
 274   // Handles the response for async calls.
 275   // Below is described how async calls work.
 276   // 1. CryptohomeClient::AsyncXXX returns "async ID".
 277   // 2. RegisterAsyncCallback registers the "async ID" with the user-provided
 278   //    callback.
 279   // 3. Cryptohome will return the result asynchronously as a signal with
 280   //    "async ID"
 281   // 4. "HandleAsyncResponse" handles the result signal and call the registered
 282   //    callback associated with the "async ID".
 283   void HandleAsyncResponse(int async_id, bool return_status, int return_code) {
 284     const CallbackMap::iterator it = callback_map_.find(async_id);
 285     if (it == callback_map_.end()) {
 286       LOG(ERROR) << "Received signal for unknown async_id " << async_id;
 287       return;
 288     }
 289     it->second.proxy->PostTask(FROM_HERE,
 290         base::Bind(it->second.callback,
 291                    return_status,
 292                    static_cast<MountError>(return_code)));
 293     callback_map_.erase(it);
 294   }
 295
 296   // Similar to HandleAsyncResponse but for signals with a raw data payload.
 297   void HandleAsyncDataResponse(int async_id,
 298                                bool return_status,
 299                                const std::string& return_data) {
 300     const DataCallbackMap::iterator it = data_callback_map_.find(async_id);
 301     if (it == data_callback_map_.end()) {
 302       LOG(ERROR) << "Received signal for unknown async_id " << async_id;
 303       return;
 304     }
 305     it->second.proxy->PostTask(FROM_HERE,
 306         base::Bind(it->second.data_callback, return_status, return_data));
 307     data_callback_map_.erase(it);
 308   }
 309
 310   // Registers a callback which is called when the result for AsyncXXX is ready.
 311   void RegisterAsyncCallback(
 312       Callback callback, const char* error, int async_id) {
 313     if (async_id == 0) {
 314       LOG(ERROR) << error;
 315       return;
 316     }
 317     VLOG(1) << "Adding handler for " << async_id;
 318     DCHECK_EQ(callback_map_.count(async_id), 0U);
 319     DCHECK_EQ(data_callback_map_.count(async_id), 0U);
 320     callback_map_[async_id] = CallbackElement(callback);
 321   }
 322
 323   // Registers a callback which is called when the result for AsyncXXX is ready.
 324   void RegisterAsyncDataCallback(
 325       DataCallback callback, const char* error, int async_id) {
 326     if (async_id == 0) {
 327       LOG(ERROR) << error;
 328       return;
 329     }
 330     VLOG(1) << "Adding handler for " << async_id;
 331     DCHECK_EQ(callback_map_.count(async_id), 0U);
 332     DCHECK_EQ(data_callback_map_.count(async_id), 0U);
 333     data_callback_map_[async_id] = DataCallbackElement(callback);
 334   }
 335
 336   base::WeakPtrFactory<AsyncMethodCallerImpl> weak_ptr_factory_;
 337   CallbackMap callback_map_;
 338   DataCallbackMap data_callback_map_;
 339
 340   DISALLOW_COPY_AND_ASSIGN(AsyncMethodCallerImpl);
 341 };
 342
 343 }  // namespace
 344
 345 // static
 346 void AsyncMethodCaller::Initialize() {
 347   if (g_async_method_caller) {
 348     LOG(WARNING) << "AsyncMethodCaller was already initialized";
 349     return;
 350   }
 351   g_async_method_caller = new AsyncMethodCallerImpl();
 352   VLOG(1) << "AsyncMethodCaller initialized";
 353 }
 354
 355 // static
 356 void AsyncMethodCaller::InitializeForTesting(
 357     AsyncMethodCaller* async_method_caller) {
 358   if (g_async_method_caller) {
 359     LOG(WARNING) << "AsyncMethodCaller was already initialized";
 360     return;
 361   }
 362   g_async_method_caller = async_method_caller;
 363   VLOG(1) << "AsyncMethodCaller initialized";
 364 }
 365
 366 // static
 367 void AsyncMethodCaller::Shutdown() {
 368   if (!g_async_method_caller) {
 369     LOG(WARNING) << "AsyncMethodCaller::Shutdown() called with NULL manager";
 370     return;
 371   }
 372   delete g_async_method_caller;
 373   g_async_method_caller = NULL;
 374   VLOG(1) << "AsyncMethodCaller Shutdown completed";
 375 }
 376
 377 // static
 378 AsyncMethodCaller* AsyncMethodCaller::GetInstance() {
 379   return g_async_method_caller;
 380 }
 381
 382 }  // namespace cryptohome