device/bluetooth/bluetooth_socket_chromeos.cc

   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 "device/bluetooth/bluetooth_socket_chromeos.h"
   6
   7 #include <queue>
   8 #include <string>
   9
  10 #include "base/basictypes.h"
  11 #include "base/bind.h"
  12 #include "base/callback.h"
  13 #include "base/logging.h"
  14 #include "base/memory/linked_ptr.h"
  15 #include "base/memory/ref_counted.h"
  16 #include "base/memory/scoped_ptr.h"
  17 #include "base/sequenced_task_runner.h"
  18 #include "base/strings/string_util.h"
  19 #include "base/task_runner_util.h"
  20 #include "base/threading/thread_restrictions.h"
  21 #include "base/threading/worker_pool.h"
  22 #include "chromeos/dbus/bluetooth_device_client.h"
  23 #include "chromeos/dbus/bluetooth_profile_manager_client.h"
  24 #include "chromeos/dbus/bluetooth_profile_service_provider.h"
  25 #include "chromeos/dbus/dbus_thread_manager.h"
  26 #include "dbus/bus.h"
  27 #include "dbus/file_descriptor.h"
  28 #include "dbus/object_path.h"
  29 #include "device/bluetooth/bluetooth_adapter.h"
  30 #include "device/bluetooth/bluetooth_adapter_chromeos.h"
  31 #include "device/bluetooth/bluetooth_device.h"
  32 #include "device/bluetooth/bluetooth_device_chromeos.h"
  33 #include "device/bluetooth/bluetooth_socket.h"
  34 #include "device/bluetooth/bluetooth_socket_net.h"
  35 #include "device/bluetooth/bluetooth_socket_thread.h"
  36 #include "net/base/ip_endpoint.h"
  37 #include "net/base/net_errors.h"
  38 #include "third_party/cros_system_api/dbus/service_constants.h"
  39
  40 using device::BluetoothAdapter;
  41 using device::BluetoothDevice;
  42 using device::BluetoothSocketThread;
  43 using device::BluetoothUUID;
  44
  45 namespace {
  46
  47 const char kAcceptFailed[] = "Failed to accept connection.";
  48 const char kInvalidUUID[] = "Invalid UUID";
  49 const char kSocketNotListening[] = "Socket is not listening.";
  50
  51 }  // namespace
  52
  53 namespace chromeos {
  54
  55 // static
  56 scoped_refptr<BluetoothSocketChromeOS>
  57 BluetoothSocketChromeOS::CreateBluetoothSocket(
  58     scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
  59     scoped_refptr<BluetoothSocketThread> socket_thread) {
  60   DCHECK(ui_task_runner->RunsTasksOnCurrentThread());
  61
  62   return make_scoped_refptr(
  63       new BluetoothSocketChromeOS(ui_task_runner, socket_thread));
  64 }
  65
  66 BluetoothSocketChromeOS::AcceptRequest::AcceptRequest() {}
  67
  68 BluetoothSocketChromeOS::AcceptRequest::~AcceptRequest() {}
  69
  70 BluetoothSocketChromeOS::ConnectionRequest::ConnectionRequest()
  71     : accepting(false),
  72       cancelled(false) {}
  73
  74 BluetoothSocketChromeOS::ConnectionRequest::~ConnectionRequest() {}
  75
  76 BluetoothSocketChromeOS::BluetoothSocketChromeOS(
  77     scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
  78     scoped_refptr<BluetoothSocketThread> socket_thread)
  79     : BluetoothSocketNet(ui_task_runner, socket_thread) {
  80 }
  81
  82 BluetoothSocketChromeOS::~BluetoothSocketChromeOS() {
  83   DCHECK(object_path_.value().empty());
  84   DCHECK(profile_.get() == NULL);
  85
  86   if (adapter_.get()) {
  87     adapter_->RemoveObserver(this);
  88     adapter_ = NULL;
  89   }
  90 }
  91
  92 void BluetoothSocketChromeOS::Connect(
  93     const BluetoothDeviceChromeOS* device,
  94     const BluetoothUUID& uuid,
  95     SecurityLevel security_level,
  96     const base::Closure& success_callback,
  97     const ErrorCompletionCallback& error_callback) {
  98   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
  99   DCHECK(object_path_.value().empty());
 100   DCHECK(!profile_.get());
 101
 102   if (!uuid.IsValid()) {
 103     error_callback.Run(kInvalidUUID);
 104     return;
 105   }
 106
 107   device_address_ = device->GetAddress();
 108   device_path_ = device->object_path();
 109   uuid_ = uuid;
 110   options_.reset(new BluetoothProfileManagerClient::Options());
 111   if (security_level == SECURITY_LEVEL_LOW)
 112     options_->require_authentication.reset(new bool(false));
 113
 114   RegisterProfile(success_callback, error_callback);
 115 }
 116
 117 void BluetoothSocketChromeOS::Listen(
 118     scoped_refptr<BluetoothAdapter> adapter,
 119     SocketType socket_type,
 120     const BluetoothUUID& uuid,
 121     const BluetoothAdapter::ServiceOptions& service_options,
 122     const base::Closure& success_callback,
 123     const ErrorCompletionCallback& error_callback) {
 124   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
 125   DCHECK(object_path_.value().empty());
 126   DCHECK(!profile_.get());
 127
 128   if (!uuid.IsValid()) {
 129     error_callback.Run(kInvalidUUID);
 130     return;
 131   }
 132
 133   adapter_ = adapter;
 134   adapter_->AddObserver(this);
 135
 136   uuid_ = uuid;
 137   options_.reset(new BluetoothProfileManagerClient::Options());
 138   if (service_options.name)
 139     options_->name.reset(new std::string(*service_options.name));
 140
 141   switch (socket_type) {
 142     case kRfcomm:
 143       options_->channel.reset(
 144           new uint16(service_options.channel ? *service_options.channel : 0));
 145       break;
 146     case kL2cap:
 147       options_->psm.reset(
 148           new uint16(service_options.psm ? *service_options.psm : 0));
 149       break;
 150     default:
 151       NOTREACHED();
 152   }
 153
 154   RegisterProfile(success_callback, error_callback);
 155 }
 156
 157 void BluetoothSocketChromeOS::Close() {
 158   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
 159
 160   if (profile_)
 161     UnregisterProfile();
 162
 163   // In the case below, where an asynchronous task gets posted on the socket
 164   // thread in BluetoothSocketNet::Close, a reference will be held to this
 165   // socket by the callback. This may cause the BluetoothAdapter to outlive
 166   // DBusThreadManager during shutdown if that callback executes too late.
 167   if (adapter_.get()) {
 168     adapter_->RemoveObserver(this);
 169     adapter_ = NULL;
 170   }
 171
 172   if (!device_path_.value().empty()) {
 173     BluetoothSocketNet::Close();
 174   } else {
 175     DoCloseListening();
 176   }
 177 }
 178
 179 void BluetoothSocketChromeOS::Disconnect(const base::Closure& callback) {
 180   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
 181
 182   if (profile_)
 183    UnregisterProfile();
 184
 185   if (!device_path_.value().empty()) {
 186     BluetoothSocketNet::Disconnect(callback);
 187   } else {
 188     DoCloseListening();
 189     callback.Run();
 190   }
 191 }
 192
 193 void BluetoothSocketChromeOS::Accept(
 194     const AcceptCompletionCallback& success_callback,
 195     const ErrorCompletionCallback& error_callback) {
 196   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
 197
 198   if (!device_path_.value().empty()) {
 199     error_callback.Run(kSocketNotListening);
 200     return;
 201   }
 202
 203   // Only one pending accept at a time
 204   if (accept_request_.get()) {
 205     error_callback.Run(net::ErrorToString(net::ERR_IO_PENDING));
 206     return;
 207   }
 208
 209   accept_request_.reset(new AcceptRequest);
 210   accept_request_->success_callback = success_callback;
 211   accept_request_->error_callback = error_callback;
 212
 213   if (connection_request_queue_.size() >= 1) {
 214     AcceptConnectionRequest();
 215   }
 216 }
 217
 218 void BluetoothSocketChromeOS::RegisterProfile(
 219     const base::Closure& success_callback,
 220     const ErrorCompletionCallback& error_callback) {
 221   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
 222   DCHECK(object_path_.value().empty());
 223   DCHECK(!profile_.get());
 224
 225   // The object path is relatively meaningless, but has to be unique, so for
 226   // connecting profiles use a combination of the device address and profile
 227   // UUID.
 228   std::string device_address_path, uuid_path;
 229   base::ReplaceChars(device_address_, ":-", "_", &device_address_path);
 230   base::ReplaceChars(uuid_.canonical_value(), ":-", "_", &uuid_path);
 231   if (!device_address_path.empty()) {
 232     object_path_ = dbus::ObjectPath("/org/chromium/bluetooth_profile/" +
 233                                     device_address_path + "/" + uuid_path);
 234   } else {
 235     object_path_ = dbus::ObjectPath("/org/chromium/bluetooth_profile/" +
 236                                     uuid_path);
 237   }
 238
 239   // Create the service provider for the profile object.
 240   dbus::Bus* system_bus = DBusThreadManager::Get()->GetSystemBus();
 241   profile_.reset(BluetoothProfileServiceProvider::Create(
 242       system_bus, object_path_, this));
 243   DCHECK(profile_.get());
 244
 245   // Before reaching out to the Bluetooth Daemon to register a listening socket,
 246   // make sure it's actually running. If not, report success and carry on;
 247   // the profile will be registered when the daemon becomes available.
 248   if (adapter_ && !adapter_->IsPresent()) {
 249     VLOG(1) << object_path_.value() << ": Delaying profile registration.";
 250     success_callback.Run();
 251     return;
 252   }
 253
 254   VLOG(1) << object_path_.value() << ": Registering profile.";
 255   DBusThreadManager::Get()->GetBluetoothProfileManagerClient()->
 256       RegisterProfile(
 257           object_path_,
 258           uuid_.canonical_value(),
 259           *options_,
 260           base::Bind(&BluetoothSocketChromeOS::OnRegisterProfile,
 261                      this,
 262                      success_callback,
 263                      error_callback),
 264           base::Bind(&BluetoothSocketChromeOS::OnRegisterProfileError,
 265                      this,
 266                      error_callback));
 267 }
 268
 269 void BluetoothSocketChromeOS::OnRegisterProfile(
 270     const base::Closure& success_callback,
 271     const ErrorCompletionCallback& error_callback) {
 272   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
 273   if (!device_path_.value().empty()) {
 274     VLOG(1) << object_path_.value() << ": Profile registered, connecting to "
 275             << device_path_.value();
 276
 277     DBusThreadManager::Get()->GetBluetoothDeviceClient()->
 278         ConnectProfile(
 279             device_path_,
 280             uuid_.canonical_value(),
 281             base::Bind(
 282                 &BluetoothSocketChromeOS::OnConnectProfile,
 283                 this,
 284                 success_callback),
 285             base::Bind(
 286                 &BluetoothSocketChromeOS::OnConnectProfileError,
 287                 this,
 288                 error_callback));
 289   } else {
 290     VLOG(1) << object_path_.value() << ": Profile registered.";
 291     success_callback.Run();
 292   }
 293 }
 294
 295 void BluetoothSocketChromeOS::OnRegisterProfileError(
 296     const ErrorCompletionCallback& error_callback,
 297     const std::string& error_name,
 298     const std::string& error_message) {
 299   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
 300   LOG(WARNING) << object_path_.value() << ": Failed to register profile: "
 301                << error_name << ": " << error_message;
 302   error_callback.Run(error_message);
 303 }
 304
 305 void BluetoothSocketChromeOS::OnConnectProfile(
 306     const base::Closure& success_callback) {
 307   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
 308   VLOG(1) << object_path_.value() << ": Profile connected.";
 309   UnregisterProfile();
 310   success_callback.Run();
 311 }
 312
 313 void BluetoothSocketChromeOS::OnConnectProfileError(
 314     const ErrorCompletionCallback& error_callback,
 315     const std::string& error_name,
 316     const std::string& error_message) {
 317   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
 318   LOG(WARNING) << object_path_.value() << ": Failed to connect profile: "
 319                << error_name << ": " << error_message;
 320   UnregisterProfile();
 321   error_callback.Run(error_message);
 322 }
 323
 324 void BluetoothSocketChromeOS::AdapterPresentChanged(BluetoothAdapter* adapter,
 325                                                     bool present) {
 326   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
 327   DCHECK(!object_path_.value().empty());
 328   DCHECK(profile_.get());
 329
 330   if (!present)
 331     return;
 332
 333   VLOG(1) << object_path_.value() << ": Re-register profile.";
 334   DBusThreadManager::Get()->GetBluetoothProfileManagerClient()->
 335       RegisterProfile(
 336           object_path_,
 337           uuid_.canonical_value(),
 338           *options_,
 339           base::Bind(&BluetoothSocketChromeOS::OnInternalRegisterProfile,
 340                      this),
 341           base::Bind(&BluetoothSocketChromeOS::OnInternalRegisterProfileError,
 342                      this));
 343 }
 344
 345 void BluetoothSocketChromeOS::OnInternalRegisterProfile() {
 346   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
 347
 348   VLOG(1) << object_path_.value() << ": Profile re-registered";
 349 }
 350
 351 void BluetoothSocketChromeOS::OnInternalRegisterProfileError(
 352     const std::string& error_name,
 353     const std::string& error_message) {
 354   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
 355
 356   // It's okay if the profile already exists, it means we registered it on
 357   // initialization.
 358   if (error_name == bluetooth_profile_manager::kErrorAlreadyExists)
 359     return;
 360
 361   LOG(WARNING) << object_path_.value() << ": Failed to re-register profile: "
 362                << error_name << ": " << error_message;
 363 }
 364
 365 void BluetoothSocketChromeOS::Released() {
 366   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
 367   VLOG(1) << object_path_.value() << ": Release";
 368 }
 369
 370 void BluetoothSocketChromeOS::NewConnection(
 371     const dbus::ObjectPath& device_path,
 372     scoped_ptr<dbus::FileDescriptor> fd,
 373     const BluetoothProfileServiceProvider::Delegate::Options& options,
 374     const ConfirmationCallback& callback) {
 375   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
 376   VLOG(1) << object_path_.value() << ": New connection from device: "
 377           << device_path.value();
 378
 379   if (!device_path_.value().empty()) {
 380     DCHECK(device_path_ == device_path);
 381
 382     socket_thread()->task_runner()->PostTask(
 383         FROM_HERE,
 384         base::Bind(
 385             &BluetoothSocketChromeOS::DoNewConnection,
 386             this,
 387             device_path_,
 388             base::Passed(&fd),
 389             options,
 390             callback));
 391   } else {
 392     linked_ptr<ConnectionRequest> request(new ConnectionRequest());
 393     request->device_path = device_path;
 394     request->fd = fd.Pass();
 395     request->options = options;
 396     request->callback = callback;
 397
 398     connection_request_queue_.push(request);
 399     VLOG(1) << object_path_.value() << ": Connection is now pending.";
 400     if (accept_request_) {
 401       AcceptConnectionRequest();
 402     }
 403   }
 404 }
 405
 406 void BluetoothSocketChromeOS::RequestDisconnection(
 407     const dbus::ObjectPath& device_path,
 408     const ConfirmationCallback& callback) {
 409   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
 410   VLOG(1) << object_path_.value() << ": Request disconnection";
 411   callback.Run(SUCCESS);
 412 }
 413
 414 void BluetoothSocketChromeOS::Cancel() {
 415   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
 416   VLOG(1) << object_path_.value() << ": Cancel";
 417
 418   if (!connection_request_queue_.size())
 419     return;
 420
 421   // If the front request is being accepted mark it as cancelled, otherwise
 422   // just pop it from the queue.
 423   linked_ptr<ConnectionRequest> request = connection_request_queue_.front();
 424   if (!request->accepting) {
 425     request->cancelled = true;
 426   } else {
 427     connection_request_queue_.pop();
 428   }
 429 }
 430
 431 void BluetoothSocketChromeOS::AcceptConnectionRequest() {
 432   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
 433   DCHECK(accept_request_.get());
 434   DCHECK(connection_request_queue_.size() >= 1);
 435
 436   VLOG(1) << object_path_.value() << ": Accepting pending connection.";
 437
 438   linked_ptr<ConnectionRequest> request = connection_request_queue_.front();
 439   request->accepting = true;
 440
 441   BluetoothDeviceChromeOS* device =
 442       static_cast<BluetoothAdapterChromeOS*>(adapter_.get())->
 443           GetDeviceWithPath(request->device_path);
 444   DCHECK(device);
 445
 446   scoped_refptr<BluetoothSocketChromeOS> client_socket =
 447       BluetoothSocketChromeOS::CreateBluetoothSocket(
 448           ui_task_runner(), socket_thread());
 449
 450   client_socket->device_address_ = device->GetAddress();
 451   client_socket->device_path_ = request->device_path;
 452   client_socket->uuid_ = uuid_;
 453
 454   socket_thread()->task_runner()->PostTask(
 455       FROM_HERE,
 456       base::Bind(
 457           &BluetoothSocketChromeOS::DoNewConnection,
 458           client_socket,
 459           request->device_path,
 460           base::Passed(&request->fd),
 461           request->options,
 462           base::Bind(&BluetoothSocketChromeOS::OnNewConnection,
 463                      this,
 464                      client_socket,
 465                      request->callback)));
 466 }
 467
 468 void BluetoothSocketChromeOS::DoNewConnection(
 469     const dbus::ObjectPath& device_path,
 470     scoped_ptr<dbus::FileDescriptor> fd,
 471     const BluetoothProfileServiceProvider::Delegate::Options& options,
 472     const ConfirmationCallback& callback) {
 473   DCHECK(socket_thread()->task_runner()->RunsTasksOnCurrentThread());
 474   base::ThreadRestrictions::AssertIOAllowed();
 475   fd->CheckValidity();
 476
 477   VLOG(1) << object_path_.value() << ": Validity check complete.";
 478   if (!fd->is_valid()) {
 479     LOG(WARNING) << object_path_.value() << " :" << fd->value()
 480                  << ": Invalid file descriptor received from Bluetooth Daemon.";
 481     ui_task_runner()->PostTask(FROM_HERE,
 482                                base::Bind(callback, REJECTED));;
 483     return;
 484   }
 485
 486   if (tcp_socket()) {
 487     LOG(WARNING) << object_path_.value() << ": Already connected";
 488     ui_task_runner()->PostTask(FROM_HERE,
 489                                base::Bind(callback, REJECTED));;
 490     return;
 491   }
 492
 493   ResetTCPSocket();
 494
 495   // Note: We don't have a meaningful |IPEndPoint|, but that is ok since the
 496   // TCPSocket implementation does not actually require one.
 497   int net_result = tcp_socket()->AdoptConnectedSocket(fd->value(),
 498                                                       net::IPEndPoint());
 499   if (net_result != net::OK) {
 500     LOG(WARNING) << object_path_.value() << ": Error adopting socket: "
 501                  << std::string(net::ErrorToString(net_result));
 502     ui_task_runner()->PostTask(FROM_HERE,
 503                                base::Bind(callback, REJECTED));;
 504     return;
 505   }
 506
 507   VLOG(2) << object_path_.value() << ": Taking descriptor, confirming success.";
 508   fd->TakeValue();
 509   ui_task_runner()->PostTask(FROM_HERE,
 510                              base::Bind(callback, SUCCESS));;
 511 }
 512
 513 void BluetoothSocketChromeOS::OnNewConnection(
 514     scoped_refptr<BluetoothSocket> socket,
 515     const ConfirmationCallback& callback,
 516     Status status) {
 517   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
 518   DCHECK(accept_request_.get());
 519   DCHECK(connection_request_queue_.size() >= 1);
 520
 521   linked_ptr<ConnectionRequest> request = connection_request_queue_.front();
 522   if (status == SUCCESS && !request->cancelled) {
 523     BluetoothDeviceChromeOS* device =
 524         static_cast<BluetoothAdapterChromeOS*>(adapter_.get())->
 525             GetDeviceWithPath(request->device_path);
 526     DCHECK(device);
 527
 528     accept_request_->success_callback.Run(device, socket);
 529   } else {
 530     accept_request_->error_callback.Run(kAcceptFailed);
 531   }
 532
 533   accept_request_.reset(NULL);
 534   connection_request_queue_.pop();
 535
 536   callback.Run(status);
 537 }
 538
 539 void BluetoothSocketChromeOS::DoCloseListening() {
 540   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
 541
 542   if (accept_request_) {
 543     accept_request_->error_callback.Run(
 544         net::ErrorToString(net::ERR_CONNECTION_CLOSED));
 545     accept_request_.reset(NULL);
 546   }
 547
 548   while (connection_request_queue_.size() > 0) {
 549     linked_ptr<ConnectionRequest> request = connection_request_queue_.front();
 550     request->callback.Run(REJECTED);
 551     connection_request_queue_.pop();
 552   }
 553 }
 554
 555 void BluetoothSocketChromeOS::UnregisterProfile() {
 556   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
 557   DCHECK(!object_path_.value().empty());
 558   DCHECK(profile_.get());
 559
 560   VLOG(1) << object_path_.value() << ": Unregister profile";
 561   DBusThreadManager::Get()->GetBluetoothProfileManagerClient()->
 562       UnregisterProfile(
 563           object_path_,
 564           base::Bind(&BluetoothSocketChromeOS::OnUnregisterProfile,
 565                      this,
 566                      object_path_),
 567           base::Bind(&BluetoothSocketChromeOS::OnUnregisterProfileError,
 568                      this,
 569                      object_path_));
 570
 571   profile_.reset();
 572   object_path_ = dbus::ObjectPath("");
 573 }
 574
 575 void BluetoothSocketChromeOS::OnUnregisterProfile(
 576     const dbus::ObjectPath& object_path) {
 577   VLOG(1) << object_path.value() << ": Profile unregistered";
 578 }
 579
 580 void BluetoothSocketChromeOS::OnUnregisterProfileError(
 581     const dbus::ObjectPath& object_path,
 582     const std::string& error_name,
 583     const std::string& error_message) {
 584   // It's okay if the profile doesn't exist, it means we haven't registered it
 585   // yet.
 586   if (error_name == bluetooth_profile_manager::kErrorDoesNotExist)
 587     return;
 588
 589   LOG(WARNING) << object_path_.value() << ": Failed to unregister profile: "
 590                << error_name << ": " << error_message;
 591 }
 592
 593 }  // namespace chromeos