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