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/protocol/pairing_registry.h" 6 7 #include "base/base64.h" 8 #include "base/bind.h" 9 #include "base/guid.h" 10 #include "base/json/json_string_value_serializer.h" 11 #include "base/location.h" 12 #include "base/single_thread_task_runner.h" 13 #include "base/strings/string_number_conversions.h" 14 #include "base/thread_task_runner_handle.h" 15 #include "base/values.h" 16 #include "crypto/random.h" 17 18 namespace remoting { 19 namespace protocol { 20 21 // How many bytes of random data to use for the shared secret. 22 const int kKeySize = 16; 23 24 const char PairingRegistry::kCreatedTimeKey[] = "createdTime"; 25 const char PairingRegistry::kClientIdKey[] = "clientId"; 26 const char PairingRegistry::kClientNameKey[] = "clientName"; 27 const char PairingRegistry::kSharedSecretKey[] = "sharedSecret"; 28 29 PairingRegistry::Pairing::Pairing() { 30 } 31 32 PairingRegistry::Pairing::Pairing(const base::Time& created_time, 33 const std::string& client_name, 34 const std::string& client_id, 35 const std::string& shared_secret) 36 : created_time_(created_time), 37 client_name_(client_name), 38 client_id_(client_id), 39 shared_secret_(shared_secret) { 40 } 41 42 PairingRegistry::Pairing::~Pairing() { 43 } 44 45 PairingRegistry::Pairing PairingRegistry::Pairing::Create( 46 const std::string& client_name) { 47 base::Time created_time = base::Time::Now(); 48 std::string client_id = base::GenerateGUID(); 49 std::string shared_secret; 50 char buffer[kKeySize]; 51 crypto::RandBytes(buffer, arraysize(buffer)); 52 base::Base64Encode(base::StringPiece(buffer, arraysize(buffer)), 53 &shared_secret); 54 return Pairing(created_time, client_name, client_id, shared_secret); 55 } 56 57 PairingRegistry::Pairing PairingRegistry::Pairing::CreateFromValue( 58 const base::DictionaryValue& pairing) { 59 std::string client_name, client_id; 60 double created_time_value; 61 if (pairing.GetDouble(kCreatedTimeKey, &created_time_value) && 62 pairing.GetString(kClientNameKey, &client_name) && 63 pairing.GetString(kClientIdKey, &client_id)) { 64 // The shared secret is optional. 65 std::string shared_secret; 66 pairing.GetString(kSharedSecretKey, &shared_secret); 67 base::Time created_time = base::Time::FromJsTime(created_time_value); 68 return Pairing(created_time, client_name, client_id, shared_secret); 69 } 70 71 LOG(ERROR) << "Failed to load pairing information: unexpected format."; 72 return Pairing(); 73 } 74 75 scoped_ptr<base::DictionaryValue> PairingRegistry::Pairing::ToValue() const { 76 scoped_ptr<base::DictionaryValue> pairing(new base::DictionaryValue()); 77 pairing->SetDouble(kCreatedTimeKey, created_time().ToJsTime()); 78 pairing->SetString(kClientNameKey, client_name()); 79 pairing->SetString(kClientIdKey, client_id()); 80 if (!shared_secret().empty()) 81 pairing->SetString(kSharedSecretKey, shared_secret()); 82 return pairing.Pass(); 83 } 84 85 bool PairingRegistry::Pairing::operator==(const Pairing& other) const { 86 return created_time_ == other.created_time_ && 87 client_id_ == other.client_id_ && 88 client_name_ == other.client_name_ && 89 shared_secret_ == other.shared_secret_; 90 } 91 92 bool PairingRegistry::Pairing::is_valid() const { 93 return !client_id_.empty() && !shared_secret_.empty(); 94 } 95 96 PairingRegistry::PairingRegistry( 97 scoped_refptr<base::SingleThreadTaskRunner> delegate_task_runner, 98 scoped_ptr<Delegate> delegate) 99 : caller_task_runner_(base::ThreadTaskRunnerHandle::Get()), 100 delegate_task_runner_(delegate_task_runner), 101 delegate_(delegate.Pass()) { 102 DCHECK(delegate_); 103 } 104 105 PairingRegistry::Pairing PairingRegistry::CreatePairing( 106 const std::string& client_name) { 107 DCHECK(caller_task_runner_->BelongsToCurrentThread()); 108 109 Pairing result = Pairing::Create(client_name); 110 AddPairing(result); 111 return result; 112 } 113 114 void PairingRegistry::GetPairing(const std::string& client_id, 115 const GetPairingCallback& callback) { 116 DCHECK(caller_task_runner_->BelongsToCurrentThread()); 117 118 GetPairingCallback wrapped_callback = base::Bind( 119 &PairingRegistry::InvokeGetPairingCallbackAndScheduleNext, 120 this, callback); 121 base::Closure request = base::Bind( 122 &PairingRegistry::DoLoad, this, client_id, wrapped_callback); 123 ServiceOrQueueRequest(request); 124 } 125 126 void PairingRegistry::GetAllPairings( 127 const GetAllPairingsCallback& callback) { 128 DCHECK(caller_task_runner_->BelongsToCurrentThread()); 129 130 GetAllPairingsCallback wrapped_callback = base::Bind( 131 &PairingRegistry::InvokeGetAllPairingsCallbackAndScheduleNext, 132 this, callback); 133 GetAllPairingsCallback sanitize_callback = base::Bind( 134 &PairingRegistry::SanitizePairings, 135 this, wrapped_callback); 136 base::Closure request = base::Bind( 137 &PairingRegistry::DoLoadAll, this, sanitize_callback); 138 ServiceOrQueueRequest(request); 139 } 140 141 void PairingRegistry::DeletePairing( 142 const std::string& client_id, const DoneCallback& callback) { 143 DCHECK(caller_task_runner_->BelongsToCurrentThread()); 144 145 DoneCallback wrapped_callback = base::Bind( 146 &PairingRegistry::InvokeDoneCallbackAndScheduleNext, 147 this, callback); 148 base::Closure request = base::Bind( 149 &PairingRegistry::DoDelete, this, client_id, wrapped_callback); 150 ServiceOrQueueRequest(request); 151 } 152 153 void PairingRegistry::ClearAllPairings( 154 const DoneCallback& callback) { 155 DCHECK(caller_task_runner_->BelongsToCurrentThread()); 156 157 DoneCallback wrapped_callback = base::Bind( 158 &PairingRegistry::InvokeDoneCallbackAndScheduleNext, 159 this, callback); 160 base::Closure request = base::Bind( 161 &PairingRegistry::DoDeleteAll, this, wrapped_callback); 162 ServiceOrQueueRequest(request); 163 } 164 165 PairingRegistry::~PairingRegistry() { 166 } 167 168 void PairingRegistry::PostTask( 169 const scoped_refptr<base::SingleThreadTaskRunner>& task_runner, 170 const tracked_objects::Location& from_here, 171 const base::Closure& task) { 172 task_runner->PostTask(from_here, task); 173 } 174 175 void PairingRegistry::AddPairing(const Pairing& pairing) { 176 DoneCallback wrapped_callback = base::Bind( 177 &PairingRegistry::InvokeDoneCallbackAndScheduleNext, 178 this, DoneCallback()); 179 base::Closure request = base::Bind( 180 &PairingRegistry::DoSave, this, pairing, wrapped_callback); 181 ServiceOrQueueRequest(request); 182 } 183 184 void PairingRegistry::DoLoadAll( 185 const protocol::PairingRegistry::GetAllPairingsCallback& callback) { 186 DCHECK(delegate_task_runner_->BelongsToCurrentThread()); 187 188 scoped_ptr<base::ListValue> pairings = delegate_->LoadAll(); 189 PostTask(caller_task_runner_, FROM_HERE, base::Bind(callback, 190 base::Passed(&pairings))); 191 } 192 193 void PairingRegistry::DoDeleteAll( 194 const protocol::PairingRegistry::DoneCallback& callback) { 195 DCHECK(delegate_task_runner_->BelongsToCurrentThread()); 196 197 bool success = delegate_->DeleteAll(); 198 PostTask(caller_task_runner_, FROM_HERE, base::Bind(callback, success)); 199 } 200 201 void PairingRegistry::DoLoad( 202 const std::string& client_id, 203 const protocol::PairingRegistry::GetPairingCallback& callback) { 204 DCHECK(delegate_task_runner_->BelongsToCurrentThread()); 205 206 Pairing pairing = delegate_->Load(client_id); 207 PostTask(caller_task_runner_, FROM_HERE, base::Bind(callback, pairing)); 208 } 209 210 void PairingRegistry::DoSave( 211 const protocol::PairingRegistry::Pairing& pairing, 212 const protocol::PairingRegistry::DoneCallback& callback) { 213 DCHECK(delegate_task_runner_->BelongsToCurrentThread()); 214 215 bool success = delegate_->Save(pairing); 216 PostTask(caller_task_runner_, FROM_HERE, base::Bind(callback, success)); 217 } 218 219 void PairingRegistry::DoDelete( 220 const std::string& client_id, 221 const protocol::PairingRegistry::DoneCallback& callback) { 222 DCHECK(delegate_task_runner_->BelongsToCurrentThread()); 223 224 bool success = delegate_->Delete(client_id); 225 PostTask(caller_task_runner_, FROM_HERE, base::Bind(callback, success)); 226 } 227 228 void PairingRegistry::InvokeDoneCallbackAndScheduleNext( 229 const DoneCallback& callback, bool success) { 230 // CreatePairing doesn't have a callback, so the callback can be null. 231 if (!callback.is_null()) 232 callback.Run(success); 233 234 pending_requests_.pop(); 235 ServiceNextRequest(); 236 } 237 238 void PairingRegistry::InvokeGetPairingCallbackAndScheduleNext( 239 const GetPairingCallback& callback, Pairing pairing) { 240 callback.Run(pairing); 241 pending_requests_.pop(); 242 ServiceNextRequest(); 243 } 244 245 void PairingRegistry::InvokeGetAllPairingsCallbackAndScheduleNext( 246 const GetAllPairingsCallback& callback, 247 scoped_ptr<base::ListValue> pairings) { 248 callback.Run(pairings.Pass()); 249 pending_requests_.pop(); 250 ServiceNextRequest(); 251 } 252 253 void PairingRegistry::SanitizePairings(const GetAllPairingsCallback& callback, 254 scoped_ptr<base::ListValue> pairings) { 255 DCHECK(caller_task_runner_->BelongsToCurrentThread()); 256 257 scoped_ptr<base::ListValue> sanitized_pairings(new base::ListValue()); 258 for (size_t i = 0; i < pairings->GetSize(); ++i) { 259 DictionaryValue* pairing_json; 260 if (!pairings->GetDictionary(i, &pairing_json)) { 261 LOG(WARNING) << "A pairing entry is not a dictionary."; 262 continue; 263 } 264 265 // Parse the pairing data. 266 Pairing pairing = Pairing::CreateFromValue(*pairing_json); 267 if (!pairing.is_valid()) { 268 LOG(WARNING) << "Could not parse a pairing entry."; 269 continue; 270 } 271 272 // Clear the shared secrect and append the pairing data to the list. 273 Pairing sanitized_pairing( 274 pairing.created_time(), 275 pairing.client_name(), 276 pairing.client_id(), 277 ""); 278 sanitized_pairings->Append(sanitized_pairing.ToValue().release()); 279 } 280 281 callback.Run(sanitized_pairings.Pass()); 282 } 283 284 void PairingRegistry::ServiceOrQueueRequest(const base::Closure& request) { 285 bool servicing_request = !pending_requests_.empty(); 286 pending_requests_.push(request); 287 if (!servicing_request) { 288 ServiceNextRequest(); 289 } 290 } 291 292 void PairingRegistry::ServiceNextRequest() { 293 if (pending_requests_.empty()) 294 return; 295 296 PostTask(delegate_task_runner_, FROM_HERE, pending_requests_.front()); 297 } 298 299 } // namespace protocol 300 } // namespace remoting 301
