Ensure canonical Bluetooth UUIDs are used.

chrome/browser/extensions/api/bluetooth/bluetooth_api.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/extensions/api/bluetooth/bluetooth_api.h"
 
 #if defined(OS_CHROMEOS)
 #include <errno.h>
 #endif
 
 #include <string>
 
 #include "chrome/browser/extensions/api/bluetooth/bluetooth_api_utils.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/experimental_bluetooth.h"
 #include "content/public/browser/browser_thread.h"
 
 #if defined(OS_CHROMEOS)
 #include "base/memory/ref_counted.h"
 #include "base/safe_strerror_posix.h"
 #include "chrome/browser/chromeos/bluetooth/bluetooth_adapter.h"
 #include "chrome/browser/chromeos/bluetooth/bluetooth_device.h"
 #include "chrome/browser/chromeos/bluetooth/bluetooth_socket.h"
+#include "chrome/browser/chromeos/bluetooth/bluetooth_utils.h"
 #include "chrome/browser/chromeos/extensions/bluetooth_event_router.h"
 #include "chromeos/dbus/bluetooth_out_of_band_client.h"
 
 namespace {
 
 chromeos::ExtensionBluetoothEventRouter* GetEventRouter(Profile* profile) {
   return profile->GetExtensionService()->bluetooth_event_router();
 }
 
 const chromeos::BluetoothAdapter* GetAdapter(Profile* profile) {
   return GetEventRouter(profile)->adapter();
 }
 
 chromeos::BluetoothAdapter* GetMutableAdapter(Profile* profile) {
   return GetEventRouter(profile)->GetMutableAdapter();
 }
 
 }  // namespace
 #endif
 
 namespace {
 
 const char kCouldNotGetLocalOutOfBandPairingData[] =
     "Could not get local Out Of Band Pairing Data";
 const char kCouldNotSetOutOfBandPairingData[] =
     "Could not set Out Of Band Pairing Data";
 const char kFailedToConnect[] = "Connection failed";
 const char kInvalidDevice[] = "Invalid device";
+const char kInvalidUuid[] = "Invalid UUID";
 const char kServiceDiscoveryFailed[] = "Service discovery failed";
 const char kSocketNotFoundError[] = "Socket not found: invalid socket id";
 const char kStartDiscoveryFailed[] =
     "Starting discovery failed, or already discovering";
 const char kStopDiscoveryFailed[] = "Failed to stop discovery";
 
 }  // namespace
 
 namespace Connect = extensions::api::experimental_bluetooth::Connect;
 namespace Disconnect = extensions::api::experimental_bluetooth::Disconnect;
@@ skipping 41 matching lines @@
     SendResponse(true);
 }
 
 bool BluetoothGetDevicesFunction::RunImpl() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   scoped_ptr<GetDevices::Params> params(GetDevices::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
   const experimental_bluetooth::GetDevicesOptions& options = params->options;
 
+  std::string uuid;
+  if (options.uuid.get() != NULL) {
+    uuid = chromeos::bluetooth_utils::CanonicalUuid(*options.uuid.get());
+    if (uuid.empty()) {
+      SetError(kInvalidUuid);
+      return false;
+    }
+  }
+
   ListValue* matches = new ListValue;
   SetResult(matches);
 
   CHECK_EQ(0, callbacks_pending_);
 
   chromeos::BluetoothAdapter::DeviceList devices =
       GetMutableAdapter(profile())->GetDevices();
   for (chromeos::BluetoothAdapter::DeviceList::iterator i = devices.begin();
       i != devices.end(); ++i) {
     chromeos::BluetoothDevice* device = *i;
 
-    if (options.uuid.get() != NULL &&
-        !(device->ProvidesServiceWithUUID(*(options.uuid))))
+    if (!uuid.empty() && !(device->ProvidesServiceWithUUID(uuid)))
       continue;
 
     if (options.name.get() == NULL) {
       matches->Append(experimental_bluetooth::BluetoothDeviceToValue(*device));
       continue;
     }
 
     callbacks_pending_++;
     device->ProvidesServiceWithName(
         *(options.name),
@@ skipping 35 matching lines @@
 }
 
 bool BluetoothGetServicesFunction::RunImpl() {
   scoped_ptr<GetServices::Params> params(GetServices::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
   const experimental_bluetooth::GetServicesOptions& options = params->options;
 
   chromeos::BluetoothDevice* device =
       GetMutableAdapter(profile())->GetDevice(options.device_address);
   if (!device) {
-    SendResponse(false);
     SetError(kInvalidDevice);
     return false;
   }
 
   ListValue* services = new ListValue;
   SetResult(services);
 
   device->GetServiceRecords(
       base::Bind(&BluetoothGetServicesFunction::GetServiceRecordsCallback,
                  this,
@@ skipping 22 matching lines @@
     SetError(kFailedToConnect);
     SendResponse(false);
   }
 }
 
 bool BluetoothConnectFunction::RunImpl() {
   scoped_ptr<Connect::Params> params(Connect::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
   const experimental_bluetooth::ConnectOptions& options = params->options;
 
+  std::string uuid = chromeos::bluetooth_utils::CanonicalUuid(
+      options.service_uuid);
+  if (uuid.empty()) {
+    SetError(kInvalidUuid);
+    return false;
+  }
+
   chromeos::BluetoothDevice* device =
       GetMutableAdapter(profile())->GetDevice(options.device_address);
   if (!device) {
-    SendResponse(false);
     SetError(kInvalidDevice);
     return false;
   }
 
-  device->ConnectToService(options.service_uuid,
+  device->ConnectToService(uuid,
       base::Bind(&BluetoothConnectFunction::ConnectToServiceCallback,
                  this,
                  device,
-                 options.service_uuid));
+                 uuid));
   return true;
 }
 
 bool BluetoothDisconnectFunction::RunImpl() {
   scoped_ptr<Disconnect::Params> params(Disconnect::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
   const experimental_bluetooth::DisconnectOptions& options = params->options;
   return GetEventRouter(profile())->ReleaseSocket(options.socket_id);
 }
 
@@ skipping 112 matching lines @@
   // TODO(bryeung): update to new-style parameter passing when ArrayBuffer
   // support is added
   DictionaryValue* options;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &options));
   std::string address;
   EXTENSION_FUNCTION_VALIDATE(options->GetString("deviceAddress", &address));
 
   chromeos::BluetoothDevice* device =
       GetMutableAdapter(profile())->GetDevice(address);
   if (!device) {
-    SendResponse(false);
     SetError(kInvalidDevice);
     return false;
   }
 
   if (options->HasKey("data")) {
     DictionaryValue* data_in;
     EXTENSION_FUNCTION_VALIDATE(options->GetDictionary("data", &data_in));
 
     chromeos::BluetoothOutOfBandPairingData data_out;
 
@@ skipping 192 matching lines @@
 #endif
 
 BluetoothReadFunction::BluetoothReadFunction() {}
 BluetoothReadFunction::~BluetoothReadFunction() {}
 
 BluetoothWriteFunction::BluetoothWriteFunction() {}
 BluetoothWriteFunction::~BluetoothWriteFunction() {}
 
 }  // namespace api
 }  // namespace extensions