chromeos/dbus/bluetooth_agent_service_provider.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/dbus/bluetooth_agent_service_provider.h"
   6
   7 #include <string>
   8
   9 #include "base/bind.h"
  10 #include "base/chromeos/chromeos_version.h"
  11 #include "base/logging.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "base/threading/platform_thread.h"
  14 #include "dbus/bus.h"
  15 #include "dbus/exported_object.h"
  16 #include "dbus/message.h"
  17 #include "dbus/object_path.h"
  18 #include "third_party/cros_system_api/dbus/service_constants.h"
  19
  20 namespace {
  21
  22 // Constants used by BlueZ for the ConfirmModeChange method.
  23 const char kModeOff[] = "off";
  24 const char kModeConnectable[] = "connectable";
  25 const char kModeDiscoverable[] = "discoverable";
  26
  27 }  // namespace
  28
  29 namespace chromeos {
  30
  31 // The BluetoothAgentServiceProvider implementation used in production.
  32 class BluetoothAgentServiceProviderImpl : public BluetoothAgentServiceProvider {
  33  public:
  34   BluetoothAgentServiceProviderImpl(dbus::Bus* bus,
  35                                     const dbus::ObjectPath& object_path,
  36                                     Delegate* delegate)
  37       : origin_thread_id_(base::PlatformThread::CurrentId()),
  38         bus_(bus),
  39         delegate_(delegate),
  40         object_path_(object_path),
  41         weak_ptr_factory_(this) {
  42     VLOG(1) << "Creating BluetoothAdapterClientImpl for "
  43             << object_path.value();
  44
  45     exported_object_ = bus_->GetExportedObject(object_path_);
  46
  47     exported_object_->ExportMethod(
  48         bluetooth_agent::kBluetoothAgentInterface,
  49         bluetooth_agent::kRelease,
  50         base::Bind(&BluetoothAgentServiceProviderImpl::Release,
  51                    weak_ptr_factory_.GetWeakPtr()),
  52         base::Bind(&BluetoothAgentServiceProviderImpl::ReleaseExported,
  53                    weak_ptr_factory_.GetWeakPtr()));
  54
  55     exported_object_->ExportMethod(
  56         bluetooth_agent::kBluetoothAgentInterface,
  57         bluetooth_agent::kRequestPinCode,
  58         base::Bind(&BluetoothAgentServiceProviderImpl::RequestPinCode,
  59                    weak_ptr_factory_.GetWeakPtr()),
  60         base::Bind(&BluetoothAgentServiceProviderImpl::RequestPinCodeExported,
  61                    weak_ptr_factory_.GetWeakPtr()));
  62
  63     exported_object_->ExportMethod(
  64         bluetooth_agent::kBluetoothAgentInterface,
  65         bluetooth_agent::kRequestPasskey,
  66         base::Bind(&BluetoothAgentServiceProviderImpl::RequestPasskey,
  67                    weak_ptr_factory_.GetWeakPtr()),
  68         base::Bind(&BluetoothAgentServiceProviderImpl::RequestPasskeyExported,
  69                    weak_ptr_factory_.GetWeakPtr()));
  70
  71     exported_object_->ExportMethod(
  72         bluetooth_agent::kBluetoothAgentInterface,
  73         bluetooth_agent::kDisplayPinCode,
  74         base::Bind(&BluetoothAgentServiceProviderImpl::DisplayPinCode,
  75                    weak_ptr_factory_.GetWeakPtr()),
  76         base::Bind(&BluetoothAgentServiceProviderImpl::DisplayPinCodeExported,
  77                    weak_ptr_factory_.GetWeakPtr()));
  78
  79     exported_object_->ExportMethod(
  80         bluetooth_agent::kBluetoothAgentInterface,
  81         bluetooth_agent::kDisplayPasskey,
  82         base::Bind(&BluetoothAgentServiceProviderImpl::DisplayPasskey,
  83                    weak_ptr_factory_.GetWeakPtr()),
  84         base::Bind(&BluetoothAgentServiceProviderImpl::DisplayPasskeyExported,
  85                    weak_ptr_factory_.GetWeakPtr()));
  86
  87     exported_object_->ExportMethod(
  88         bluetooth_agent::kBluetoothAgentInterface,
  89         bluetooth_agent::kRequestConfirmation,
  90         base::Bind(&BluetoothAgentServiceProviderImpl::RequestConfirmation,
  91                    weak_ptr_factory_.GetWeakPtr()),
  92         base::Bind(
  93             &BluetoothAgentServiceProviderImpl::RequestConfirmationExported,
  94             weak_ptr_factory_.GetWeakPtr()));
  95
  96     exported_object_->ExportMethod(
  97         bluetooth_agent::kBluetoothAgentInterface,
  98         bluetooth_agent::kAuthorize,
  99         base::Bind(&BluetoothAgentServiceProviderImpl::Authorize,
 100                    weak_ptr_factory_.GetWeakPtr()),
 101         base::Bind(&BluetoothAgentServiceProviderImpl::AuthorizeExported,
 102                    weak_ptr_factory_.GetWeakPtr()));
 103
 104     exported_object_->ExportMethod(
 105         bluetooth_agent::kBluetoothAgentInterface,
 106         bluetooth_agent::kConfirmModeChange,
 107         base::Bind(&BluetoothAgentServiceProviderImpl::ConfirmModeChange,
 108                    weak_ptr_factory_.GetWeakPtr()),
 109         base::Bind(
 110             &BluetoothAgentServiceProviderImpl::ConfirmModeChangeExported,
 111             weak_ptr_factory_.GetWeakPtr()));
 112
 113     exported_object_->ExportMethod(
 114         bluetooth_agent::kBluetoothAgentInterface,
 115         bluetooth_agent::kCancel,
 116         base::Bind(&BluetoothAgentServiceProviderImpl::Cancel,
 117                    weak_ptr_factory_.GetWeakPtr()),
 118         base::Bind(&BluetoothAgentServiceProviderImpl::CancelExported,
 119                    weak_ptr_factory_.GetWeakPtr()));
 120   }
 121
 122   virtual ~BluetoothAgentServiceProviderImpl() {
 123     // Unregister the object path so we can reuse with a new agent.
 124     bus_->UnregisterExportedObject(object_path_);
 125   }
 126
 127  private:
 128   // Returns true if the current thread is on the origin thread.
 129   bool OnOriginThread() {
 130     return base::PlatformThread::CurrentId() == origin_thread_id_;
 131   }
 132
 133   // Called by dbus:: when the agent is unregistered from the Bluetooth
 134   // daemon, generally at the end of a pairing request.
 135   void Release(dbus::MethodCall* method_call,
 136                dbus::ExportedObject::ResponseSender response_sender) {
 137     DCHECK(OnOriginThread());
 138     DCHECK(delegate_);
 139
 140     delegate_->Release();
 141
 142     response_sender.Run(dbus::Response::FromMethodCall(method_call));
 143   }
 144
 145   // Called by dbus:: when the Release method is exported.
 146   void ReleaseExported(const std::string& interface_name,
 147                        const std::string& method_name,
 148                        bool success) {
 149     LOG_IF(WARNING, !success) << "Failed to export "
 150                               << interface_name << "." << method_name;
 151   }
 152
 153   // Called by dbus:: when the Bluetooth daemon requires a PIN Code for
 154   // device authentication.
 155   void RequestPinCode(dbus::MethodCall* method_call,
 156                       dbus::ExportedObject::ResponseSender response_sender) {
 157     DCHECK(OnOriginThread());
 158     DCHECK(delegate_);
 159
 160     dbus::MessageReader reader(method_call);
 161     dbus::ObjectPath device_path;
 162     if (!reader.PopObjectPath(&device_path)) {
 163       LOG(WARNING) << "RequestPinCode called with incorrect paramters: "
 164                    << method_call->ToString();
 165       return;
 166     }
 167
 168     Delegate::PinCodeCallback callback = base::Bind(
 169         &BluetoothAgentServiceProviderImpl::OnPinCode,
 170         weak_ptr_factory_.GetWeakPtr(),
 171         method_call,
 172         response_sender);
 173
 174     delegate_->RequestPinCode(device_path, callback);
 175   }
 176
 177   // Called by dbus:: when the RequestPinCode method is exported.
 178   void RequestPinCodeExported(const std::string& interface_name,
 179                               const std::string& method_name,
 180                               bool success) {
 181     LOG_IF(WARNING, !success) << "Failed to export "
 182                               << interface_name << "." << method_name;
 183   }
 184
 185   // Called by dbus:: when the Bluetooth daemon requires a Passkey for
 186   // device authentication.
 187   void RequestPasskey(dbus::MethodCall* method_call,
 188                       dbus::ExportedObject::ResponseSender response_sender) {
 189     DCHECK(OnOriginThread());
 190     DCHECK(delegate_);
 191
 192     dbus::MessageReader reader(method_call);
 193     dbus::ObjectPath device_path;
 194     if (!reader.PopObjectPath(&device_path)) {
 195       LOG(WARNING) << "RequestPasskey called with incorrect paramters: "
 196                    << method_call->ToString();
 197       return;
 198     }
 199
 200     Delegate::PasskeyCallback callback = base::Bind(
 201         &BluetoothAgentServiceProviderImpl::OnPasskey,
 202         weak_ptr_factory_.GetWeakPtr(),
 203         method_call,
 204         response_sender);
 205
 206     delegate_->RequestPasskey(device_path, callback);
 207   }
 208
 209   // Called by dbus:: when the RequestPasskey method is exported.
 210   void RequestPasskeyExported(const std::string& interface_name,
 211                               const std::string& method_name,
 212                               bool success) {
 213     LOG_IF(WARNING, !success) << "Failed to export "
 214                               << interface_name << "." << method_name;
 215   }
 216
 217   // Called by dbus:: when the Bluetooth daemon requires that the user
 218   // enter a PIN Code into the remote device so that it may be
 219   // authenticated.
 220   void DisplayPinCode(dbus::MethodCall* method_call,
 221                       dbus::ExportedObject::ResponseSender response_sender) {
 222     DCHECK(OnOriginThread());
 223     DCHECK(delegate_);
 224
 225     dbus::MessageReader reader(method_call);
 226     dbus::ObjectPath device_path;
 227     std::string pincode;
 228     if (!reader.PopObjectPath(&device_path) ||
 229         !reader.PopString(&pincode)) {
 230       LOG(WARNING) << "DisplayPinCode called with incorrect paramters: "
 231                    << method_call->ToString();
 232       return;
 233     }
 234
 235     delegate_->DisplayPinCode(device_path, pincode);
 236
 237     response_sender.Run(dbus::Response::FromMethodCall(method_call));
 238   }
 239
 240   // Called by dbus:: when the DisplayPinCode method is exported.
 241   void DisplayPinCodeExported(const std::string& interface_name,
 242                               const std::string& method_name,
 243                               bool success) {
 244     LOG_IF(WARNING, !success) << "Failed to export "
 245                               << interface_name << "." << method_name;
 246   }
 247
 248   // Called by dbus:: when the Bluetooth daemon requires that the user
 249   // enter a Passkey into the remote device so that it may be
 250   // authenticated.
 251   void DisplayPasskey(dbus::MethodCall* method_call,
 252                       dbus::ExportedObject::ResponseSender response_sender) {
 253     DCHECK(OnOriginThread());
 254     DCHECK(delegate_);
 255
 256     dbus::MessageReader reader(method_call);
 257     dbus::ObjectPath device_path;
 258     uint32 passkey;
 259     if (!reader.PopObjectPath(&device_path) ||
 260         !reader.PopUint32(&passkey)) {
 261       LOG(WARNING) << "DisplayPasskey called with incorrect paramters: "
 262                    << method_call->ToString();
 263       return;
 264     }
 265
 266     delegate_->DisplayPasskey(device_path, passkey);
 267
 268     response_sender.Run(dbus::Response::FromMethodCall(method_call));
 269   }
 270
 271   // Called by dbus:: when the DisplayPasskey method is exported.
 272   void DisplayPasskeyExported(const std::string& interface_name,
 273                               const std::string& method_name,
 274                               bool success) {
 275     LOG_IF(WARNING, !success) << "Failed to export "
 276                               << interface_name << "." << method_name;
 277   }
 278
 279   // Called by dbus:: when the Bluetooth daemon requires that the user
 280   // confirm that a Passkey is displayed on the screen of the remote
 281   // device so that it may be authenticated.
 282   void RequestConfirmation(
 283       dbus::MethodCall* method_call,
 284       dbus::ExportedObject::ResponseSender response_sender) {
 285     DCHECK(OnOriginThread());
 286     DCHECK(delegate_);
 287
 288     dbus::MessageReader reader(method_call);
 289     dbus::ObjectPath device_path;
 290     uint32 passkey;
 291     if (!reader.PopObjectPath(&device_path) ||
 292         !reader.PopUint32(&passkey)) {
 293       LOG(WARNING) << "RequestConfirmation called with incorrect paramters: "
 294                    << method_call->ToString();
 295       return;
 296     }
 297
 298     Delegate::ConfirmationCallback callback = base::Bind(
 299         &BluetoothAgentServiceProviderImpl::OnConfirmation,
 300         weak_ptr_factory_.GetWeakPtr(),
 301         method_call,
 302         response_sender);
 303
 304     delegate_->RequestConfirmation(device_path, passkey, callback);
 305   }
 306
 307   // Called by dbus:: when the RequestConfirmation method is exported.
 308   void RequestConfirmationExported(const std::string& interface_name,
 309                                    const std::string& method_name,
 310                                    bool success) {
 311     LOG_IF(WARNING, !success) << "Failed to export "
 312                               << interface_name << "." << method_name;
 313   }
 314
 315   // Called by dbus:: when the Bluetooth daemon requires that the user
 316   // confirm that that a remote device is authorized to connect to a service
 317   // UUID.
 318   void Authorize(dbus::MethodCall* method_call,
 319                  dbus::ExportedObject::ResponseSender response_sender) {
 320     DCHECK(OnOriginThread());
 321     DCHECK(delegate_);
 322
 323     dbus::MessageReader reader(method_call);
 324     dbus::ObjectPath device_path;
 325     std::string uuid;
 326     if (!reader.PopObjectPath(&device_path) ||
 327         !reader.PopString(&uuid)) {
 328       LOG(WARNING) << "Authorize called with incorrect paramters: "
 329                    << method_call->ToString();
 330       return;
 331     }
 332
 333     Delegate::ConfirmationCallback callback = base::Bind(
 334         &BluetoothAgentServiceProviderImpl::OnConfirmation,
 335         weak_ptr_factory_.GetWeakPtr(),
 336         method_call,
 337         response_sender);
 338
 339     delegate_->Authorize(device_path, uuid, callback);
 340   }
 341
 342   // Called by dbus:: when the Authorize method is exported.
 343   void AuthorizeExported(const std::string& interface_name,
 344                          const std::string& method_name,
 345                          bool success) {
 346     LOG_IF(WARNING, !success) << "Failed to export "
 347                               << interface_name << "." << method_name;
 348   }
 349
 350   // Called by dbus:: when the Bluetooth daemon requires that the user
 351   // confirm that the adapter may change mode.
 352   void ConfirmModeChange(dbus::MethodCall* method_call,
 353                          dbus::ExportedObject::ResponseSender response_sender) {
 354     DCHECK(OnOriginThread());
 355     DCHECK(delegate_);
 356
 357     dbus::MessageReader reader(method_call);
 358     std::string mode_str;
 359     if (!reader.PopString(&mode_str)) {
 360       LOG(WARNING) << "ConfirmModeChange called with incorrect paramters: "
 361                    << method_call->ToString();
 362       return;
 363     }
 364
 365     Delegate::Mode mode;
 366     if (mode_str == kModeOff) {
 367       mode = Delegate::OFF;
 368     } else if (mode_str == kModeConnectable) {
 369       mode = Delegate::CONNECTABLE;
 370     } else if (mode_str == kModeDiscoverable) {
 371       mode = Delegate::DISCOVERABLE;
 372     } else {
 373       LOG(WARNING) << "ConfirmModeChange called with unknown mode: "
 374                    << mode_str;
 375       return;
 376     }
 377
 378     Delegate::ConfirmationCallback callback = base::Bind(
 379         &BluetoothAgentServiceProviderImpl::OnConfirmation,
 380         weak_ptr_factory_.GetWeakPtr(),
 381         method_call,
 382         response_sender);
 383
 384     delegate_->ConfirmModeChange(mode, callback);
 385   }
 386
 387   // Called by dbus:: when the ConfirmModeChange method is exported.
 388   void ConfirmModeChangeExported(const std::string& interface_name,
 389                                  const std::string& method_name,
 390                                  bool success) {
 391     LOG_IF(WARNING, !success) << "Failed to export "
 392                               << interface_name << "." << method_name;
 393   }
 394
 395   // Called by dbus:: when the request failed before a reply was returned
 396   // from the device.
 397   void Cancel(dbus::MethodCall* method_call,
 398               dbus::ExportedObject::ResponseSender response_sender) {
 399     DCHECK(OnOriginThread());
 400     DCHECK(delegate_);
 401
 402     delegate_->Cancel();
 403
 404     response_sender.Run(dbus::Response::FromMethodCall(method_call));
 405   }
 406
 407   // Called by dbus:: when the Cancel method is exported.
 408   void CancelExported(const std::string& interface_name,
 409                       const std::string& method_name,
 410                       bool success) {
 411     LOG_IF(WARNING, !success) << "Failed to export "
 412                               << interface_name << "." << method_name;
 413   }
 414
 415   // Called by the Delegate to response to a method requesting a PIN code.
 416   void OnPinCode(dbus::MethodCall* method_call,
 417                  dbus::ExportedObject::ResponseSender response_sender,
 418                  Delegate::Status status,
 419                  const std::string& pincode) {
 420     DCHECK(OnOriginThread());
 421
 422     switch (status) {
 423       case Delegate::SUCCESS: {
 424         scoped_ptr<dbus::Response> response(
 425             dbus::Response::FromMethodCall(method_call));
 426         dbus::MessageWriter writer(response.get());
 427         writer.AppendString(pincode);
 428         response_sender.Run(response.Pass());
 429         break;
 430       }
 431       case Delegate::REJECTED: {
 432         response_sender.Run(
 433             dbus::ErrorResponse::FromMethodCall(
 434                 method_call, bluetooth_agent::kErrorRejected, "rejected")
 435             .PassAs<dbus::Response>());
 436         break;
 437       }
 438       case Delegate::CANCELLED: {
 439         response_sender.Run(
 440             dbus::ErrorResponse::FromMethodCall(
 441                 method_call, bluetooth_agent::kErrorCanceled, "canceled")
 442             .PassAs<dbus::Response>());
 443         break;
 444       }
 445       default:
 446         NOTREACHED() << "Unexpected status code from delegate: " << status;
 447     }
 448   }
 449
 450   // Called by the Delegate to response to a method requesting a Passkey.
 451   void OnPasskey(dbus::MethodCall* method_call,
 452                  dbus::ExportedObject::ResponseSender response_sender,
 453                  Delegate::Status status,
 454                  uint32 passkey) {
 455     DCHECK(OnOriginThread());
 456
 457     switch (status) {
 458       case Delegate::SUCCESS: {
 459         scoped_ptr<dbus::Response> response(
 460             dbus::Response::FromMethodCall(method_call));
 461         dbus::MessageWriter writer(response.get());
 462         writer.AppendUint32(passkey);
 463         response_sender.Run(response.Pass());
 464         break;
 465       }
 466       case Delegate::REJECTED: {
 467         response_sender.Run(
 468             dbus::ErrorResponse::FromMethodCall(
 469                 method_call, bluetooth_agent::kErrorRejected, "rejected")
 470             .PassAs<dbus::Response>());
 471         break;
 472       }
 473       case Delegate::CANCELLED: {
 474         response_sender.Run(
 475             dbus::ErrorResponse::FromMethodCall(
 476                 method_call, bluetooth_agent::kErrorCanceled, "canceled")
 477             .PassAs<dbus::Response>());
 478         break;
 479       }
 480       default:
 481         NOTREACHED() << "Unexpected status code from delegate: " << status;
 482     }
 483   }
 484
 485   // Called by the Delegate in response to a method requiring confirmation.
 486   void OnConfirmation(dbus::MethodCall* method_call,
 487                       dbus::ExportedObject::ResponseSender response_sender,
 488                       Delegate::Status status) {
 489     DCHECK(OnOriginThread());
 490
 491     switch (status) {
 492       case Delegate::SUCCESS: {
 493         response_sender.Run(dbus::Response::FromMethodCall(method_call));
 494         break;
 495       }
 496       case Delegate::REJECTED: {
 497         response_sender.Run(
 498             dbus::ErrorResponse::FromMethodCall(
 499                 method_call, bluetooth_agent::kErrorRejected, "rejected")
 500             .PassAs<dbus::Response>());
 501         break;
 502       }
 503       case Delegate::CANCELLED: {
 504         response_sender.Run(
 505             dbus::ErrorResponse::FromMethodCall(
 506                 method_call, bluetooth_agent::kErrorCanceled, "canceled")
 507             .PassAs<dbus::Response>());
 508         break;
 509       }
 510       default:
 511         NOTREACHED() << "Unexpected status code from delegate: " << status;
 512     }
 513   }
 514
 515   // Origin thread (i.e. the UI thread in production).
 516   base::PlatformThreadId origin_thread_id_;
 517
 518   // D-Bus bus object is exported on, not owned by this object and must
 519   // outlive it.
 520   dbus::Bus* bus_;
 521
 522   // All incoming method calls are passed on to the Delegate and a callback
 523   // passed to generate the reply. |delegate_| is generally the object that
 524   // owns this one, and must outlive it.
 525   Delegate* delegate_;
 526
 527   // D-Bus object path of object we are exporting, kept so we can unregister
 528   // again in our destructor.
 529   dbus::ObjectPath object_path_;
 530
 531   // D-Bus object we are exporting, owned by this object.
 532   scoped_refptr<dbus::ExportedObject> exported_object_;
 533
 534   // Weak pointer factory for generating 'this' pointers that might live longer
 535   // than we do.
 536   // Note: This should remain the last member so it'll be destroyed and
 537   // invalidate its weak pointers before any other members are destroyed.
 538   base::WeakPtrFactory<BluetoothAgentServiceProviderImpl> weak_ptr_factory_;
 539
 540   DISALLOW_COPY_AND_ASSIGN(BluetoothAgentServiceProviderImpl);
 541 };
 542
 543 // The BluetoothAgentServiceProvider implementation used on Linux desktop,
 544 // which does nothing.
 545 class BluetoothAgentServiceProviderStubImpl
 546     : public BluetoothAgentServiceProvider {
 547  public:
 548   explicit BluetoothAgentServiceProviderStubImpl(Delegate* delegate_) {
 549   }
 550
 551   virtual ~BluetoothAgentServiceProviderStubImpl() {
 552   }
 553 };
 554
 555 BluetoothAgentServiceProvider::BluetoothAgentServiceProvider() {
 556 }
 557
 558 BluetoothAgentServiceProvider::~BluetoothAgentServiceProvider() {
 559 }
 560
 561 // static
 562 BluetoothAgentServiceProvider* BluetoothAgentServiceProvider::Create(
 563     dbus::Bus* bus,
 564     const dbus::ObjectPath& object_path,
 565     Delegate* delegate) {
 566   if (base::chromeos::IsRunningOnChromeOS()) {
 567     return new BluetoothAgentServiceProviderImpl(bus, object_path, delegate);
 568   } else {
 569     return new BluetoothAgentServiceProviderStubImpl(delegate);
 570   }
 571 }
 572
 573 }  // namespace chromeos