| // Copyright 2018 The Chromium OS 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 "bluetooth/newblued/device_interface_handler.h" |
| |
| #include <memory> |
| #include <set> |
| #include <string> |
| #include <utility> |
| #include <vector> |
| |
| #include <base/compiler_specific.h> |
| #include <base/stl_util.h> |
| #include <base/strings/stringprintf.h> |
| #include <chromeos/dbus/service_constants.h> |
| |
| #include "bluetooth/newblued/adapter_interface_handler.h" |
| #include "bluetooth/newblued/util.h" |
| |
| namespace bluetooth { |
| |
| namespace { |
| |
| // The default values of Flags, TX Power, EIR Class, Appearance and |
| // Manufacturer ID come from the assigned numbers and Supplement to the |
| // Bluetooth Core Specification defined by Bluetooth SIG. These default values |
| // are used to determine whether the fields are ever received in EIR and set |
| // for a device. |
| constexpr int8_t kDefaultRssi = -128; |
| constexpr int8_t kDefaultTxPower = -128; |
| constexpr uint32_t kDefaultEirClass = 0x1F00; |
| constexpr uint16_t kDefaultAppearance = 0; |
| constexpr uint16_t kDefaultManufacturerId = 0xFFFF; |
| const std::vector<uint8_t> kDefaultFlags({0}); |
| |
| constexpr char kDeviceTypeLe[] = "LE"; |
| |
| // Updates device alias based on its name or address. |
| void UpdateDeviceAlias(Device* device) { |
| // In BlueZ, if alias is never provided or is set to empty for a device, the |
| // value of Alias property is set to the value of Name property if |
| // |device.name| is not empty. If |device.name| is also empty, then Alias |
| // is set to |device.address| in the following string format. |
| // xx-xx-xx-xx-xx-xx |
| std::string alias; |
| if (!device->internal_alias.empty()) { |
| alias = device->internal_alias; |
| } else if (!device->name.value().empty()) { |
| alias = device->name.value(); |
| } else { |
| alias = device->address; |
| std::replace(alias.begin(), alias.end(), ':', '-'); |
| } |
| device->alias.SetValue(std::move(alias)); |
| } |
| |
| // Canonicalizes UUIDs and wraps them as a vector for exposing or updating |
| // service UUIDs. |
| std::vector<std::string> CanonicalizeUuids(const std::set<Uuid>& uuids) { |
| std::vector<std::string> result; |
| result.reserve(uuids.size()); |
| for (const auto& uuid : uuids) |
| result.push_back(uuid.canonical_value()); |
| |
| return result; |
| } |
| |
| // Canonicalizes UUIDs associated with service data for exposing or updating |
| // service data. |
| std::map<std::string, std::vector<uint8_t>> CanonicalizeServiceData( |
| const std::map<Uuid, std::vector<uint8_t>>& service_data) { |
| std::map<std::string, std::vector<uint8_t>> result; |
| for (const auto& data : service_data) |
| result.emplace(data.first.canonical_value(), data.second); |
| |
| return result; |
| } |
| |
| // Converts pair state to string. |
| std::string ConvertPairStateToString(PairState state) { |
| switch (state) { |
| case PairState::CANCELED: |
| return "canceled"; |
| case PairState::NOT_PAIRED: |
| return "not paired"; |
| case PairState::FAILED: |
| return "failed"; |
| case PairState::PAIRED: |
| return "paired"; |
| case PairState::STARTED: |
| return "started"; |
| default: |
| return "unknown"; |
| } |
| } |
| |
| std::string ConvertConnectStateToString(ConnectState state) { |
| switch (state) { |
| case ConnectState::CONNECTED: |
| return "Connected"; |
| case ConnectState::DISCONNECTED: |
| return "Disconnected"; |
| case ConnectState::ERROR: |
| return "Disconnected with error"; |
| case ConnectState::DISCONNECTED_BY_US: |
| return "Disconnected by us"; |
| default: |
| return "Unknown"; |
| } |
| } |
| |
| // Converts the security manager pairing errors to BlueZ's D-Bus errors. |
| std::string ConvertSmPairErrorToDbusError(PairError error_code) { |
| switch (error_code) { |
| case PairError::NONE: |
| // This comes along with the pairing states other than |
| // SM_PAIR_STATE_FAILED. |
| return std::string(); |
| case PairError::ALREADY_PAIRED: |
| return bluetooth_device::kErrorAlreadyExists; |
| case PairError::IN_PROGRESS: |
| return bluetooth_device::kErrorInProgress; |
| case PairError::INVALID_PAIR_REQ: |
| return bluetooth_device::kErrorInvalidArguments; |
| case PairError::L2C_CONN: |
| return bluetooth_device::kErrorConnectionAttemptFailed; |
| case PairError::NO_SUCH_DEVICE: |
| return bluetooth_device::kErrorDoesNotExist; |
| case PairError::PASSKEY_FAILED: |
| case PairError::OOB_NOT_AVAILABLE: |
| case PairError::AUTH_REQ_INFEASIBLE: |
| case PairError::CONF_VALUE_MISMATCHED: |
| case PairError::PAIRING_NOT_SUPPORTED: |
| case PairError::ENCR_KEY_SIZE: |
| case PairError::REPEATED_ATTEMPT: |
| case PairError::INVALID_PARAM: |
| case PairError::UNEXPECTED_SM_CMD: |
| case PairError::SEND_SM_CMD: |
| case PairError::ENCR_CONN: |
| case PairError::UNEXPECTED_L2C_EVT: |
| return bluetooth_device::kErrorAuthenticationFailed; |
| case PairError::STALLED: |
| return bluetooth_device::kErrorAuthenticationTimeout; |
| case PairError::MEMORY: |
| case PairError::UNKNOWN: |
| default: |
| return bluetooth_device::kErrorFailed; |
| } |
| } |
| |
| bool IsHid(uint16_t appearance) { |
| return true; |
| // TODO(mcchou): Check appearance after we memorize the value of properties. |
| // This check is preventing the reconnection of HID devices. |
| // return ((appearance & kAppearanceMask) >> 6) == 0x0f; |
| } |
| |
| } // namespace |
| |
| Device::Device() : Device("") {} |
| |
| Device::Device(const std::string& address) |
| : address(address), |
| is_random_address(false), |
| paired(false), |
| connected(false), |
| trusted(false), |
| blocked(false), |
| services_resolved(false), |
| tx_power(kDefaultTxPower), |
| rssi(kDefaultRssi), |
| eir_class(kDefaultEirClass), |
| appearance(kDefaultAppearance), |
| icon(ConvertAppearanceToIcon(kDefaultAppearance)), |
| flags(kDefaultFlags), |
| manufacturer(ParseDataIntoManufacturer(kDefaultManufacturerId, |
| std::vector<uint8_t>())), |
| identity_address("") {} |
| |
| DeviceInfo::DeviceInfo(bool has_active_discovery_client, |
| const std::string& adv_address, |
| uint8_t address_type, |
| const std::string& resolved_address, |
| int8_t rssi, |
| uint8_t reply_type) |
| : has_active_discovery_client(has_active_discovery_client), |
| advertised_address(adv_address), |
| address_type(address_type), |
| resolved_address(resolved_address), |
| rssi(rssi), |
| reply_type(reply_type), |
| flags(kDefaultFlags), |
| service_uuids(std::set<Uuid>()), |
| name(""), |
| tx_power(kDefaultTxPower), |
| eir_class(kDefaultEirClass), |
| service_data(std::map<Uuid, std::vector<uint8_t>>()), |
| appearance(kDefaultAppearance), |
| icon(ConvertAppearanceToIcon(kDefaultAppearance)), |
| manufacturer(ParseDataIntoManufacturer(kDefaultManufacturerId, |
| std::vector<uint8_t>())) {} |
| |
| DeviceInterfaceHandler::DeviceInterfaceHandler( |
| scoped_refptr<dbus::Bus> bus, |
| Newblue* newblue, |
| ExportedObjectManagerWrapper* exported_object_manager_wrapper) |
| : bus_(bus), |
| newblue_(newblue), |
| exported_object_manager_wrapper_(exported_object_manager_wrapper), |
| weak_ptr_factory_(this) {} |
| |
| bool DeviceInterfaceHandler::Init() { |
| // Retrieve the previously saved scan results, and export only the paired |
| // devices. |
| std::vector<KnownDevice> known_devices = newblue_->GetKnownDevices(); |
| for (const auto& known_device : known_devices) { |
| if (!known_device.is_paired) |
| continue; |
| |
| Device* device = AddOrGetDiscoveredDevice( |
| known_device.address, known_device.address, known_device.address_type); |
| SetDevicePaired(device, true); |
| device->name.SetValue(known_device.name + kNewblueNameSuffix); |
| if (!known_device.identity_address.empty()) |
| device->identity_address.SetValue(known_device.identity_address); |
| |
| UpdateDeviceAlias(device); |
| ExportOrUpdateDevice(device); |
| } |
| |
| // Register for pairing state changed events. |
| pair_observer_id_ = newblue_->RegisterAsPairObserver( |
| base::Bind(&DeviceInterfaceHandler::OnPairStateChanged, |
| weak_ptr_factory_.GetWeakPtr())); |
| if (pair_observer_id_ == kInvalidUniqueId) |
| return false; |
| |
| if (!newblue_->RegisterGattClientConnectCallback( |
| base::Bind(&DeviceInterfaceHandler::OnGattClientConnectCallback, |
| weak_ptr_factory_.GetWeakPtr()))) { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| base::WeakPtr<DeviceInterfaceHandler> DeviceInterfaceHandler::GetWeakPtr() { |
| return weak_ptr_factory_.GetWeakPtr(); |
| } |
| |
| void DeviceInterfaceHandler::OnDeviceDiscovered(const DeviceInfo& device_info) { |
| const std::string& key_address = device_info.resolved_address.empty() |
| ? device_info.advertised_address |
| : device_info.resolved_address; |
| Device* device = FindDevice(key_address); |
| if (device && device->paired.value()) { |
| device->advertised_address.SetValue(device_info.advertised_address); |
| ConnectInternal(key_address, /* connect_response */ nullptr, |
| /* connect_by_us */ true); |
| } |
| |
| if (!device_info.has_active_discovery_client) |
| return; |
| |
| device = AddOrGetDiscoveredDevice(key_address, device_info.advertised_address, |
| device_info.address_type); |
| |
| device->rssi.SetValue(device_info.rssi); |
| |
| UpdateDevice(device, device_info); |
| ExportOrUpdateDevice(device); |
| } |
| |
| bool DeviceInterfaceHandler::RemoveDevice(const std::string& address, |
| std::string* dbus_error) { |
| Device* device = FindDevice(address); |
| // If the device does not exist, assume the operation has succeeded. This is |
| // because the dispatcher may forward RemoveDevice to both BlueZ and NewBlue |
| // without knowing who owns the device. |
| if (!device) |
| return true; |
| |
| // For ongoing pairing, reply to D-Bus calls to prevent timeout. |
| if (ongoing_pairing_.address == address) { |
| ongoing_pairing_.pair_response->ReplyWithError( |
| FROM_HERE, brillo::errors::dbus::kDomain, |
| bluetooth_device::kErrorAuthenticationCanceled, "Pairing canceled"); |
| |
| if (ongoing_pairing_.cancel_pair_response) { |
| ongoing_pairing_.cancel_pair_response->SendRawResponse( |
| ongoing_pairing_.cancel_pair_response->CreateCustomResponse()); |
| } |
| ongoing_pairing_.address.clear(); |
| ongoing_pairing_.pair_response.reset(); |
| ongoing_pairing_.cancel_pair_response.reset(); |
| } |
| // Clear internal pairing state. |
| newblue_->CancelPair(address, device->is_random_address); |
| for (auto& observer : observers_) |
| observer.OnDeviceUnpaired(address); |
| |
| // For ongoing connection, reply to D-Bus calls to prevent timeout. |
| auto connection_session = connection_sessions_.find(address); |
| if (connection_session != connection_sessions_.end()) { |
| // The ongoing connection would be canceled and the disconnection would be |
| // honored. |
| if (connection_session->second.disconnect_response || |
| connection_session->second.disconnect_by_us) { |
| ConnectReply(address, true, ""); |
| } else if (connection_session->second.connect_response || |
| connection_session->second.connect_by_us) { |
| ConnectReply(address, false, bluetooth_device::kErrorFailed); |
| } |
| } |
| |
| // For device which is either connected or to-be-connected, disconnect it. |
| if (base::ContainsKey(connections_, address) || |
| base::ContainsKey(connection_attempts_, address)) { |
| DisconnectInternal(address, /* disconnect_response */ nullptr, |
| /* disconnect_by_us */ true); |
| } |
| |
| dbus::ObjectPath device_path(ConvertDeviceAddressToObjectPath(address)); |
| exported_object_manager_wrapper_->RemoveExportedInterface( |
| device_path, bluetooth_device::kBluetoothDeviceInterface); |
| discovered_devices_.erase(address); |
| return true; |
| } |
| |
| void DeviceInterfaceHandler::AddDeviceObserver( |
| DeviceInterfaceHandler::DeviceObserver* observer) { |
| CHECK(observer); |
| observers_.AddObserver(observer); |
| } |
| |
| void DeviceInterfaceHandler::RemoveDeviceObserver( |
| DeviceInterfaceHandler::DeviceObserver* observer) { |
| CHECK(observer); |
| observers_.RemoveObserver(observer); |
| } |
| |
| std::string DeviceInterfaceHandler::GetAddressByConnectionId( |
| gatt_client_conn_t conn_id) { |
| if (conn_id == kInvalidGattConnectionId) |
| return ""; |
| |
| for (auto& connection : connections_) { |
| if (connection.second.conn_id == conn_id) |
| return connection.first; |
| } |
| |
| return ""; |
| } |
| |
| gatt_client_conn_t DeviceInterfaceHandler::GetConnectionIdByAddress( |
| const std::string& address) { |
| const auto connection = connections_.find(address); |
| return (connection != connections_.end() ? connection->second.conn_id |
| : kInvalidGattConnectionId); |
| } |
| |
| void DeviceInterfaceHandler::SetGattServicesResolved( |
| const std::string& device_address, bool resolved) { |
| Device* device = FindDevice(device_address); |
| CHECK(device != nullptr); |
| |
| if (device->services_resolved.value() == resolved) |
| return; |
| |
| device->services_resolved.SetValue(resolved); |
| ExportOrUpdateDevice(device); |
| } |
| |
| Device* DeviceInterfaceHandler::AddOrGetDiscoveredDevice( |
| const std::string& key_address, |
| const std::string& adv_address, |
| uint8_t address_type) { |
| Device* device = FindDevice(key_address); |
| if (!device) { |
| discovered_devices_[key_address] = std::make_unique<Device>(key_address); |
| device = discovered_devices_[key_address].get(); |
| } |
| device->is_random_address = (address_type == BT_ADDR_TYPE_LE_RANDOM); |
| device->advertised_address.SetValue(adv_address); |
| |
| return device; |
| } |
| |
| void DeviceInterfaceHandler::ExportOrUpdateDevice(Device* device) { |
| bool is_new_device = false; |
| dbus::ObjectPath device_path( |
| ConvertDeviceAddressToObjectPath(device->address.c_str())); |
| |
| ExportedInterface* device_interface = |
| exported_object_manager_wrapper_->GetExportedInterface( |
| device_path, bluetooth_device::kBluetoothDeviceInterface); |
| // The first time a device of this address is discovered, create the D-Bus |
| // object representing that device. |
| if (device_interface == nullptr) { |
| VLOG(1) << base::StringPrintf( |
| "Discovered a new device with %s address %s, rssi %d", |
| device->is_random_address ? "random" : "public", |
| device->address.c_str(), device->rssi.value()); |
| is_new_device = true; |
| |
| exported_object_manager_wrapper_->AddExportedInterface( |
| device_path, bluetooth_device::kBluetoothDeviceInterface, |
| base::Bind( |
| &ExportedObjectManagerWrapper::SetupStandardPropertyHandlers)); |
| |
| device_interface = exported_object_manager_wrapper_->GetExportedInterface( |
| device_path, bluetooth_device::kBluetoothDeviceInterface); |
| |
| AddDeviceMethodHandlers(device_interface); |
| |
| device_interface |
| ->EnsureExportedPropertyRegistered<dbus::ObjectPath>( |
| bluetooth_device::kAdapterProperty) |
| ->SetValue(dbus::ObjectPath(kAdapterObjectPath)); |
| } else { |
| VLOG(2) << base::StringPrintf( |
| "Discovered device with %s address %s, rssi %d", |
| device->is_random_address ? "random" : "public", |
| device->address.c_str(), device->rssi.value()); |
| } |
| |
| UpdateDeviceProperties(device_interface, *device, is_new_device); |
| |
| // The property updates above have to be done before ExportAndBlock() to make |
| // sure that client receives the newly added object complete with its |
| // populated properties. |
| if (is_new_device) |
| device_interface->ExportAndBlock(); |
| |
| ClearPropertiesUpdated(device); |
| } |
| |
| void DeviceInterfaceHandler::AddDeviceMethodHandlers( |
| ExportedInterface* device_interface) { |
| CHECK(device_interface); |
| |
| device_interface->AddMethodHandlerWithMessage( |
| bluetooth_device::kPair, |
| base::Bind(&DeviceInterfaceHandler::HandlePair, base::Unretained(this))); |
| device_interface->AddMethodHandlerWithMessage( |
| bluetooth_device::kCancelPairing, |
| base::Bind(&DeviceInterfaceHandler::HandleCancelPairing, |
| base::Unretained(this))); |
| device_interface->AddMethodHandlerWithMessage( |
| bluetooth_device::kConnect, |
| base::Bind(&DeviceInterfaceHandler::HandleConnect, |
| base::Unretained(this))); |
| device_interface->AddMethodHandlerWithMessage( |
| bluetooth_device::kDisconnect, |
| base::Bind(&DeviceInterfaceHandler::HandleDisconnect, |
| base::Unretained(this))); |
| device_interface->AddMethodHandlerWithMessage( |
| bluetooth_device::kExecuteWrite, |
| base::Bind(&DeviceInterfaceHandler::HandleExecuteWrite, |
| base::Unretained(this))); |
| } |
| |
| void DeviceInterfaceHandler::HandlePair( |
| std::unique_ptr<brillo::dbus_utils::DBusMethodResponse<>> response, |
| dbus::Message* message) { |
| CHECK(message); |
| |
| std::string device_address = |
| ConvertDeviceObjectPathToAddress(message->GetPath().value()); |
| |
| VLOG(1) << "Handling Pair for device " << device_address; |
| |
| if (!ongoing_pairing_.address.empty()) { |
| LOG(WARNING) << "Pairing in progress with " << device_address; |
| response->ReplyWithError(FROM_HERE, brillo::errors::dbus::kDomain, |
| bluetooth_device::kErrorInProgress, |
| "Pairing in progress"); |
| return; |
| } |
| |
| ongoing_pairing_.address = device_address; |
| ongoing_pairing_.pair_response = std::move(response); |
| ongoing_pairing_.cancel_pair_response.reset(); |
| |
| Device* device = FindDevice(device_address); |
| if (!device || !newblue_->Pair(device->address, device->is_random_address, |
| DetermineSecurityRequirements(*device))) { |
| ongoing_pairing_.pair_response->ReplyWithError( |
| FROM_HERE, brillo::errors::dbus::kDomain, |
| bluetooth_device::kErrorFailed, "Unknown device"); |
| |
| // Clear the existing pairing to allow the new pairing request. |
| ongoing_pairing_.address.clear(); |
| ongoing_pairing_.pair_response.reset(); |
| } |
| } |
| |
| void DeviceInterfaceHandler::HandleCancelPairing( |
| std::unique_ptr<brillo::dbus_utils::DBusMethodResponse<>> response, |
| dbus::Message* message) { |
| CHECK(message); |
| |
| std::string device_address = |
| ConvertDeviceObjectPathToAddress(message->GetPath().value()); |
| |
| VLOG(1) << "Handling CancelPairing for device " << device_address; |
| |
| if (device_address.empty() || !ongoing_pairing_.pair_response) { |
| response->ReplyWithError(FROM_HERE, brillo::errors::dbus::kDomain, |
| bluetooth_device::kErrorDoesNotExist, |
| "No ongoing pairing"); |
| return; |
| } |
| |
| ongoing_pairing_.cancel_pair_response = std::move(response); |
| |
| Device* device = FindDevice(device_address); |
| if (!device || |
| !newblue_->CancelPair(device->address, device->is_random_address)) { |
| response->ReplyWithError(FROM_HERE, brillo::errors::dbus::kDomain, |
| bluetooth_device::kErrorFailed, "Unknown device"); |
| ongoing_pairing_.cancel_pair_response.reset(); |
| } |
| } |
| |
| void DeviceInterfaceHandler::HandleConnect( |
| std::unique_ptr<brillo::dbus_utils::DBusMethodResponse<>> response, |
| dbus::Message* message) { |
| CHECK(message); |
| |
| std::string device_address = |
| ConvertDeviceObjectPathToAddress(message->GetPath().value()); |
| |
| VLOG(1) << "Handling Connect for device " << device_address; |
| |
| if (base::ContainsKey(connection_sessions_, device_address)) { |
| response->ReplyWithError(FROM_HERE, brillo::errors::dbus::kDomain, |
| bluetooth_device::kErrorInProgress, |
| "Connection/disconnection in progress"); |
| return; |
| } |
| |
| ConnectInternal(device_address, std::move(response), |
| /* connect_by_us */ false); |
| } |
| |
| void DeviceInterfaceHandler::HandleDisconnect( |
| std::unique_ptr<brillo::dbus_utils::DBusMethodResponse<>> response, |
| dbus::Message* message) { |
| CHECK(message); |
| |
| std::string device_address = |
| ConvertDeviceObjectPathToAddress(message->GetPath().value()); |
| |
| VLOG(1) << "Handling Disconnect for device " << device_address; |
| |
| if (base::ContainsKey(connection_sessions_, device_address)) { |
| response->ReplyWithError(FROM_HERE, brillo::errors::dbus::kDomain, |
| bluetooth_device::kErrorInProgress, |
| "Connection/disconnection in progress"); |
| return; |
| } |
| |
| VLOG(1) << "Disconnect from device " << device_address << " with conn ID " |
| << connections_[device_address].conn_id; |
| |
| DisconnectInternal(device_address, std::move(response), |
| /* disconnect_by_us */ false); |
| } |
| |
| void DeviceInterfaceHandler::HandleExecuteWrite( |
| std::unique_ptr<brillo::dbus_utils::DBusMethodResponse<>> response, |
| dbus::Message* message) { |
| CHECK(message); |
| |
| response->ReplyWithError(FROM_HERE, brillo::errors::dbus::kDomain, |
| bluetooth_device::kErrorFailed, "Not implemented"); |
| } |
| |
| void DeviceInterfaceHandler::ConnectInternal( |
| const std::string& device_address, |
| std::unique_ptr<brillo::dbus_utils::DBusMethodResponse<>> connect_response, |
| bool connect_by_us) { |
| CHECK((!connect_by_us && connect_response != nullptr) || |
| (connect_by_us && connect_response == nullptr)); |
| |
| struct ConnectSession session; |
| session.connect_by_us = connect_by_us; |
| session.connect_response = std::move(connect_response); |
| connection_sessions_.emplace(device_address, std::move(session)); |
| |
| const Device* device = FindDevice(device_address); |
| if (!device) { |
| LOG(WARNING) << "device " << device_address << " not found"; |
| ConnectReply(device_address, false, bluetooth_device::kErrorDoesNotExist); |
| return; |
| } |
| |
| struct bt_addr address; |
| CHECK(ConvertToBtAddr(device->is_random_address, device_address, &address)); |
| |
| if (base::ContainsKey(connection_attempts_, device_address)) { |
| LOG(WARNING) << "Connection with device " << device_address |
| << " in progress"; |
| ConnectReply(device_address, false, bluetooth_device::kErrorInProgress); |
| return; |
| } |
| |
| if (connections_.find(device_address) != connections_.end()) { |
| LOG(WARNING) << "Connection with device " << device_address |
| << " already exists"; |
| ConnectReply(device_address, false, bluetooth_device::kErrorAlreadyExists); |
| return; |
| } |
| |
| gatt_client_conn_t conn_id = newblue_->GattClientConnect( |
| device->advertised_address.value(), device->is_random_address); |
| if (conn_id == kInvalidGattConnectionId) { |
| LOG(WARNING) << "Failed GATT client connect"; |
| ConnectReply(device_address, false, bluetooth_device::kErrorFailed); |
| return; |
| } |
| |
| connection_attempts_.emplace(device_address, conn_id); |
| } |
| |
| void DeviceInterfaceHandler::DisconnectInternal( |
| const std::string& device_address, |
| std::unique_ptr<brillo::dbus_utils::DBusMethodResponse<>> |
| disconnect_response, |
| bool disconnect_by_us) { |
| CHECK((!disconnect_by_us && disconnect_response != nullptr) || |
| (disconnect_by_us && disconnect_response == nullptr)); |
| |
| struct ConnectSession session; |
| session.disconnect_by_us = disconnect_by_us; |
| session.disconnect_response = std::move(disconnect_response); |
| connection_sessions_.emplace(device_address, std::move(session)); |
| |
| if (!FindDevice(device_address)) { |
| LOG(WARNING) << "device " << device_address << " not found"; |
| ConnectReply(device_address, false, bluetooth_device::kErrorDoesNotExist); |
| return; |
| } |
| |
| gatt_client_conn_t id = kInvalidGattConnectionId; |
| |
| auto attempt = connection_attempts_.find(device_address); |
| auto connection = connections_.find(device_address); |
| bool is_attempt = (attempt != connection_attempts_.end()); |
| bool is_connected = (connection != connections_.end()); |
| |
| if (!is_attempt && !is_connected) { |
| VLOG(1) << "device " << device_address |
| << " doesn't have an active connection nor an ongoing connection"; |
| ConnectReply(device_address, false, bluetooth_device::kErrorNotConnected); |
| return; |
| } |
| |
| // There can be either connection attempt or existing connection but not both. |
| CHECK(!(is_attempt && is_connected)); |
| |
| id = is_attempt ? attempt->second : connection->second.conn_id; |
| if (id == kInvalidGattConnectionId) { |
| LOG(WARNING) << "Invalid conn ID to disconnect from device " |
| << device_address; |
| ConnectReply(device_address, false, bluetooth_device::kErrorFailed); |
| return; |
| } |
| |
| if (connection->second.hid_id) |
| newblue_->libnewblue()->BtleHidDetach(connection->second.hid_id); |
| |
| if (newblue_->GattClientDisconnect(id) != GattClientOperationStatus::OK) { |
| LOG(ERROR) << "Failed to disconnect from device " << device_address; |
| ConnectReply(device_address, false, bluetooth_device::kErrorFailed); |
| } |
| } |
| |
| void DeviceInterfaceHandler::ConnectReply(const std::string& device_address, |
| bool success, |
| const std::string& dbus_error) { |
| // In cases where connection/disconnection events were issued by the remote |
| // device OR RemoveDevice() was called, there wouldn't be connection session. |
| auto iter = connection_sessions_.find(device_address); |
| if (iter == connection_sessions_.end()) { |
| VLOG(1) << "No connection session with device " << device_address |
| << ", ignoring"; |
| return; |
| } |
| |
| if (iter->second.connect_by_us || iter->second.disconnect_by_us) { |
| connection_sessions_.erase(iter); |
| return; |
| } |
| |
| if (!(iter->second.connect_response || iter->second.disconnect_response)) { |
| LOG(WARNING) << "Cannot find ongoing connection session or response for " |
| << "device " << device_address; |
| return; |
| } |
| |
| std::unique_ptr<brillo::dbus_utils::DBusMethodResponse<>> response = |
| iter->second.connect_response |
| ? std::move(iter->second.connect_response) |
| : std::move(iter->second.disconnect_response); |
| |
| if (success) { |
| response->SendRawResponse(response->CreateCustomResponse()); |
| } else { |
| response->ReplyWithError(FROM_HERE, brillo::errors::dbus::kDomain, |
| dbus_error, ""); |
| } |
| |
| connection_sessions_.erase(iter); |
| } |
| |
| void DeviceInterfaceHandler::OnGattClientConnectCallback( |
| gatt_client_conn_t conn_id, uint8_t status) { |
| Device* dev_to_notify = nullptr; |
| Device* dev_to_be_connected = nullptr; |
| auto temp_connections = connections_; |
| std::map<std::string, gatt_client_conn_t>::iterator iter = |
| connection_attempts_.end(); |
| bool is_disconnected_by_newblue = true; |
| |
| // See if there is a match in ongoing connection attempts. |
| for (auto it = connection_attempts_.begin(); it != connection_attempts_.end(); |
| ++it) { |
| if (it->second == conn_id) { |
| dev_to_be_connected = FindDevice(it->first); |
| dev_to_notify = dev_to_be_connected; |
| iter = it; |
| break; |
| } |
| } |
| |
| if (iter != connection_attempts_.end()) |
| connection_attempts_.erase(iter); |
| |
| ConnectState state = static_cast<ConnectState>(status); |
| switch (state) { |
| case ConnectState::CONNECTED: |
| // Skip updating connection state if there is no device to associate with, |
| // e.g. the device could be removed if RemoveDevice() was called. |
| if (dev_to_be_connected == nullptr) { |
| VLOG(1) << "Ignoring connected event with conn ID " << conn_id; |
| return; |
| } |
| |
| VLOG(1) << "Connection with ID " << conn_id << " established for device " |
| << dev_to_be_connected->address; |
| |
| struct Connection connection; |
| connection.conn_id = conn_id; |
| connection.hid_id = 0; |
| |
| // TODO(crbug/991880): Wait for the link to be encrypted before starting |
| // any GATT operations for paired devices. |
| |
| // Obtain a HID ID for a HID generic device. |
| if (IsHid(dev_to_be_connected->appearance.value())) |
| connection.hid_id = newblue_->libnewblue()->BtleHidAttach( |
| conn_id, dev_to_be_connected->name.value().c_str()); |
| |
| // Track the new connection and close the attempt. |
| connections_.emplace(dev_to_be_connected->address, connection); |
| ConnectReply(dev_to_be_connected->address, true, ""); |
| |
| for (auto& observer : observers_) |
| observer.OnGattConnected(dev_to_be_connected->address, conn_id); |
| break; |
| case ConnectState::ERROR: |
| VLOG(1) << "Unexpected GATT connection error"; |
| FALLTHROUGH; |
| case ConnectState::DISCONNECTED: |
| is_disconnected_by_newblue = false; |
| FALLTHROUGH; |
| case ConnectState::DISCONNECTED_BY_US: |
| // Close the connection attempt when there is a match. |
| if (dev_to_be_connected) { |
| VLOG(1) << "Connection with ID " << conn_id |
| << " failed to established for device " |
| << dev_to_be_connected->address; |
| |
| ConnectReply(dev_to_be_connected->address, false, |
| bluetooth_device::kErrorFailed); |
| break; |
| } |
| |
| VLOG(1) << "GATT disconnection on conn id " << conn_id << " with status " |
| << static_cast<int>(status); |
| |
| // If there is no match on connection attempt, check if the update is for |
| // the existing connection and update the connection state accordingly. |
| for (auto& connection : temp_connections) { |
| if (connection.second.conn_id != conn_id) |
| continue; |
| |
| connections_.erase(connection.first); |
| ConnectReply(connection.first, true, ""); |
| dev_to_notify = FindDevice(connection.first); |
| |
| for (auto& observer : observers_) |
| observer.OnGattDisconnected(connection.first, conn_id, |
| is_disconnected_by_newblue); |
| break; |
| } |
| break; |
| default: |
| VLOG(1) << "Unexpected GATT connection result, conn " << conn_id |
| << " status = " << status; |
| return; |
| } |
| |
| if (dev_to_notify) { |
| VLOG(1) << "Connection state changed to " |
| << ConvertConnectStateToString(state) << " for device " |
| << dev_to_notify->address; |
| |
| SetDeviceConnected(dev_to_notify, state == ConnectState::CONNECTED); |
| ExportOrUpdateDevice(dev_to_notify); |
| } |
| } |
| |
| void DeviceInterfaceHandler::SetDeviceConnected(Device* device, |
| bool is_connected) { |
| CHECK(device != nullptr); |
| |
| device->connected.SetValue(is_connected); |
| } |
| |
| void DeviceInterfaceHandler::SetDevicePaired(Device* device, bool is_paired) { |
| CHECK(device != nullptr); |
| |
| device->paired.SetValue(is_paired); |
| for (auto& observer : observers_) |
| observer.OnDevicePaired(device->address); |
| } |
| |
| Device* DeviceInterfaceHandler::FindDevice(const std::string& device_address) { |
| auto iter = discovered_devices_.find(device_address); |
| return iter != discovered_devices_.end() ? iter->second.get() : nullptr; |
| } |
| |
| void DeviceInterfaceHandler::UpdateDeviceProperties( |
| ExportedInterface* interface, const Device& device, bool is_new_device) { |
| CHECK(interface); |
| |
| // TODO(mcchou): Properties Modalias and MTU is not yet sorted out. |
| |
| // The following properties are exported when |is_new_device| is true or when |
| // they are updated. |
| if (is_new_device) { |
| // Expose immutable and non-optional properties for the new device. |
| // The address property might be overwritten later by identity address. |
| interface->EnsureExportedPropertyRegistered<std::string>( |
| bluetooth_device::kAddressProperty)->SetValue(device.address); |
| interface->EnsureExportedPropertyRegistered<std::string>( |
| bluetooth_device::kTypeProperty)->SetValue(kDeviceTypeLe); |
| interface->EnsureExportedPropertyRegistered<bool>( |
| bluetooth_device::kLegacyPairingProperty)->SetValue(false); |
| } |
| |
| ExportDBusProperty(interface, bluetooth_device::kPairedProperty, |
| device.paired, is_new_device); |
| ExportDBusProperty(interface, bluetooth_device::kConnectedProperty, |
| device.connected, is_new_device); |
| ExportDBusProperty(interface, bluetooth_device::kTrustedProperty, |
| device.trusted, is_new_device); |
| ExportDBusProperty(interface, bluetooth_device::kBlockedProperty, |
| device.blocked, is_new_device); |
| ExportDBusProperty(interface, bluetooth_device::kAliasProperty, device.alias, |
| is_new_device); |
| ExportDBusProperty(interface, bluetooth_device::kServicesResolvedProperty, |
| device.services_resolved, is_new_device); |
| ExportDBusProperty(interface, bluetooth_device::kAdvertisingDataFlagsProperty, |
| device.flags, is_new_device); |
| // Although RSSI is an optional device property in BlueZ, it is always |
| // provided by libnewblue, thus it is exposed by default. |
| ExportDBusProperty(interface, bluetooth_device::kRSSIProperty, device.rssi, |
| is_new_device); |
| |
| // The following properties are exported only when they are updated. |
| ExportDBusProperty(interface, bluetooth_device::kUUIDsProperty, |
| device.service_uuids, &CanonicalizeUuids, false); |
| ExportDBusProperty(interface, bluetooth_device::kServiceDataProperty, |
| device.service_data, &CanonicalizeServiceData, false); |
| ExportDBusProperty(interface, bluetooth_device::kNameProperty, device.name, |
| false); |
| ExportDBusProperty(interface, bluetooth_device::kTxPowerProperty, |
| device.tx_power, false); |
| ExportDBusProperty(interface, bluetooth_device::kClassProperty, |
| device.eir_class, false); |
| ExportDBusProperty(interface, bluetooth_device::kAppearanceProperty, |
| device.appearance, false); |
| ExportDBusProperty(interface, bluetooth_device::kIconProperty, device.icon, |
| false); |
| ExportDBusProperty(interface, bluetooth_device::kManufacturerDataProperty, |
| device.manufacturer, false); |
| // Overwrite the address property with identity address. |
| ExportDBusProperty(interface, bluetooth_device::kAddressProperty, |
| device.identity_address, false); |
| } |
| |
| void DeviceInterfaceHandler::UpdateDevice(Device* device, |
| const DeviceInfo& device_info) { |
| CHECK(device); |
| |
| // Update device information only if received update from EIR |
| if (device_info.flags != kDefaultFlags) |
| device->flags.SetValue(device_info.flags); |
| if (!device_info.name.empty()) |
| device->name.SetValue(device_info.name); |
| if (device_info.tx_power != kDefaultTxPower) |
| device->tx_power.SetValue(device_info.tx_power); |
| if (device_info.eir_class != kDefaultEirClass) |
| device->eir_class.SetValue(device_info.eir_class); |
| if (device_info.appearance != kDefaultAppearance) { |
| device->appearance.SetValue(device_info.appearance); |
| device->icon.SetValue(device_info.icon); |
| } |
| if (device_info.manufacturer != |
| ParseDataIntoManufacturer(kDefaultManufacturerId, |
| std::vector<uint8_t>())) { |
| device->manufacturer.SetValue(device_info.manufacturer); |
| } |
| if (!device_info.service_uuids.empty()) |
| device->service_uuids.SetValue(device_info.service_uuids); |
| if (!device_info.service_data.empty()) |
| device->service_data.SetValue(device_info.service_data); |
| UpdateDeviceAlias(device); |
| } |
| |
| void DeviceInterfaceHandler::ClearPropertiesUpdated(Device* device) { |
| device->paired.ClearUpdated(); |
| device->connected.ClearUpdated(); |
| device->trusted.ClearUpdated(); |
| device->blocked.ClearUpdated(); |
| device->services_resolved.ClearUpdated(); |
| device->alias.ClearUpdated(); |
| device->name.ClearUpdated(); |
| device->tx_power.ClearUpdated(); |
| device->rssi.ClearUpdated(); |
| device->eir_class.ClearUpdated(); |
| device->appearance.ClearUpdated(); |
| device->icon.ClearUpdated(); |
| device->flags.ClearUpdated(); |
| device->service_uuids.ClearUpdated(); |
| device->service_data.ClearUpdated(); |
| device->manufacturer.ClearUpdated(); |
| device->identity_address.ClearUpdated(); |
| } |
| |
| struct smPairSecurityRequirements |
| DeviceInterfaceHandler::DetermineSecurityRequirements(const Device& device) { |
| struct smPairSecurityRequirements security_requirement = {.bond = false, |
| .mitm = false}; |
| bool security_determined = false; |
| |
| // TODO(mcchou): Determine the security requirement for different type of |
| // devices based on appearance. |
| // These value are defined at https://www.bluetooth.com/specifications/gatt/ |
| // viewer?attributeXmlFile=org.bluetooth.characteristic.gap.appearance.xml. |
| // The translated strings come from BlueZ. |
| switch ((device.appearance.value() & kAppearanceMask) >> 6) { |
| case 0x01: // phone |
| case 0x02: // computer |
| security_requirement.bond = true; |
| security_requirement.mitm = true; |
| security_determined = true; |
| break; |
| case 0x03: // watch |
| security_requirement.bond = true; |
| security_determined = true; |
| break; |
| case 0x0f: // HID Generic |
| switch (device.appearance.value() & 0x3f) { |
| case 0x01: // keyboard |
| case 0x05: // tablet |
| security_requirement.bond = true; |
| security_requirement.mitm = true; |
| security_determined = true; |
| break; |
| case 0x02: // mouse |
| case 0x03: // joystick |
| case 0x04: // gamepad |
| security_requirement.bond = true; |
| security_determined = true; |
| break; |
| case 0x08: // barcode-scanner |
| default: |
| break; |
| } |
| break; |
| case 0x00: // unknown |
| case 0x04: // clock |
| case 0x05: // video-display |
| case 0x06: // remote-control |
| case 0x07: // eye-glasses |
| case 0x08: // tag |
| case 0x09: // key-ring |
| case 0x0a: // multimedia-player |
| case 0x0b: // barcode-scanner |
| case 0x0c: // thermometer |
| case 0x0d: // heart-rate-sensor |
| case 0x0e: // blood-pressure |
| case 0x10: // glucose-meter |
| case 0x11: // running-walking-sensor |
| case 0x12: // cycling |
| case 0x31: // pulse-oximeter |
| case 0x32: // weight-scale |
| case 0x33: // personal-mobility-device |
| case 0x34: // continuous-glucose-monitor |
| case 0x35: // insulin-pump |
| case 0x36: // medication-delivery |
| case 0x51: // outdoor-sports-activity |
| default: |
| break; |
| } |
| |
| if (!security_determined) { |
| security_requirement.bond = true; |
| LOG(WARNING) << base::StringPrintf( |
| "The default security level (bond:%s MITM:%s) will be " |
| "used in pairing with device with appearance 0x%4X", |
| security_requirement.bond ? "true" : "false", |
| security_requirement.mitm ? "true" : "false", |
| device.appearance.value()); |
| } |
| |
| return security_requirement; |
| } |
| |
| void DeviceInterfaceHandler::OnPairStateChanged( |
| const std::string& address, |
| PairState pair_state, |
| PairError pair_error, |
| const std::string& identity_address) { |
| // The device D-Bus object may have already been unexported, e.g. pairing |
| // information is removed during the device removal. |
| Device* device = FindDevice(address); |
| if (!device) |
| return; |
| |
| VLOG(1) << "Pairing state changed to " << ConvertPairStateToString(pair_state) |
| << " for device " << device->address; |
| |
| std::string dbus_error; |
| |
| switch (pair_state) { |
| case PairState::CANCELED: |
| dbus_error = bluetooth_device::kErrorAuthenticationCanceled; |
| FALLTHROUGH; |
| case PairState::NOT_PAIRED: |
| SetDevicePaired(device, false); |
| break; |
| case PairState::FAILED: |
| // If a device is previously paired, security manager will throw a |
| // SM_PAIR_ERR_ALREADY_PAIRED error which should not set the pairing state |
| // to false. |
| SetDevicePaired(device, pair_error == PairError::ALREADY_PAIRED); |
| dbus_error = ConvertSmPairErrorToDbusError(pair_error); |
| break; |
| case PairState::PAIRED: |
| if (!identity_address.empty()) |
| device->identity_address.SetValue(identity_address); |
| SetDevicePaired(device, true); |
| break; |
| case PairState::STARTED: |
| default: |
| // Do not change paired property. |
| break; |
| } |
| |
| if (device->address != ongoing_pairing_.address) { |
| ExportOrUpdateDevice(device); |
| return; |
| } |
| |
| CHECK(!ongoing_pairing_.address.empty()); |
| CHECK(ongoing_pairing_.pair_response); |
| |
| // Reply to the Pair/CancelPairing method calls according to the pairing |
| // state. |
| switch (pair_state) { |
| case PairState::NOT_PAIRED: |
| // Falling back to this state indicate an unknown error, so the cancel |
| // pairing request should fail as well. |
| ongoing_pairing_.pair_response->ReplyWithError( |
| FROM_HERE, brillo::errors::dbus::kDomain, |
| bluetooth_device::kErrorFailed, "Unknown"); |
| |
| if (ongoing_pairing_.cancel_pair_response) { |
| ongoing_pairing_.cancel_pair_response->ReplyWithError( |
| FROM_HERE, brillo::errors::dbus::kDomain, |
| bluetooth_device::kErrorDoesNotExist, "No ongoing pairing"); |
| } |
| break; |
| case PairState::STARTED: |
| // For the start of the pairing, we wait for the result. |
| CHECK(!ongoing_pairing_.cancel_pair_response); |
| break; |
| case PairState::PAIRED: |
| ongoing_pairing_.pair_response->SendRawResponse( |
| ongoing_pairing_.pair_response->CreateCustomResponse()); |
| |
| if (ongoing_pairing_.cancel_pair_response) { |
| ongoing_pairing_.cancel_pair_response->ReplyWithError( |
| FROM_HERE, brillo::errors::dbus::kDomain, |
| bluetooth_device::kErrorFailed, "Unknown - pairing done"); |
| } |
| break; |
| case PairState::CANCELED: |
| ongoing_pairing_.pair_response->ReplyWithError( |
| FROM_HERE, brillo::errors::dbus::kDomain, dbus_error, |
| "Pairing canceled"); |
| |
| if (ongoing_pairing_.cancel_pair_response) { |
| ongoing_pairing_.cancel_pair_response->SendRawResponse( |
| ongoing_pairing_.cancel_pair_response->CreateCustomResponse()); |
| } |
| break; |
| case PairState::FAILED: |
| ongoing_pairing_.pair_response->ReplyWithError( |
| FROM_HERE, brillo::errors::dbus::kDomain, dbus_error, |
| "Pairing failed"); |
| |
| if (ongoing_pairing_.cancel_pair_response) { |
| ongoing_pairing_.cancel_pair_response->ReplyWithError( |
| FROM_HERE, brillo::errors::dbus::kDomain, |
| bluetooth_device::kErrorDoesNotExist, "No ongoing pairing"); |
| } |
| break; |
| default: |
| LOG(WARNING) << "Unexpected pairing state change"; |
| |
| ongoing_pairing_.pair_response->ReplyWithError( |
| FROM_HERE, brillo::errors::dbus::kDomain, |
| bluetooth_device::kErrorFailed, "Unknown"); |
| |
| if (ongoing_pairing_.cancel_pair_response) { |
| ongoing_pairing_.cancel_pair_response->ReplyWithError( |
| FROM_HERE, brillo::errors::dbus::kDomain, |
| bluetooth_device::kErrorFailed, "Unknown"); |
| } |
| break; |
| } |
| |
| if (pair_state != PairState::STARTED) { |
| ongoing_pairing_.address.clear(); |
| ongoing_pairing_.pair_response.reset(); |
| } |
| |
| ongoing_pairing_.cancel_pair_response.reset(); |
| |
| ExportOrUpdateDevice(device); |
| } |
| |
| } // namespace bluetooth |
