/****************************************************************************** * * Copyright 2000-2012 Broadcom Corporation * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at: * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * ******************************************************************************/ /***************************************************************************** * * Name: btm_acl.cc * * Description: This file contains functions that handle ACL connections. * This includes operations such as hold and sniff modes, * supported packet types. * * This module contains both internal and external (API) * functions. External (API) functions are distinguishable * by their names beginning with uppercase BTM. * * *****************************************************************************/ #define LOG_TAG "btm_acl" #include #include "bta/include/bta_dm_acl.h" #include "bta/sys/bta_sys.h" #include "btif/include/btif_acl.h" #include "common/metrics.h" #include "device/include/controller.h" #include "device/include/interop.h" #include "include/l2cap_hci_link_interface.h" #include "main/shim/acl_api.h" #include "main/shim/btm_api.h" #include "main/shim/dumpsys.h" #include "main/shim/l2c_api.h" #include "main/shim/shim.h" #include "osi/include/log.h" #include "stack/acl/acl.h" #include "stack/acl/peer_packet_types.h" #include "stack/btm/btm_dev.h" #include "stack/btm/btm_int_types.h" #include "stack/btm/btm_sec.h" #include "stack/btm/security_device_record.h" #include "stack/gatt/connection_manager.h" #include "stack/include/acl_api.h" #include "stack/include/acl_hci_link_interface.h" #include "stack/include/btm_api.h" #include "stack/include/btm_iso_api.h" #include "stack/include/btu.h" #include "stack/include/hci_error_code.h" #include "stack/include/hcimsgs.h" #include "stack/include/l2cap_acl_interface.h" #include "stack/include/sco_hci_link_interface.h" #include "types/hci_role.h" #include "types/raw_address.h" void BTM_update_version_info(const RawAddress& bd_addr, const remote_version_info& remote_version_info); void gatt_find_in_device_record(const RawAddress& bd_addr, tBLE_BD_ADDR* address_with_type); void l2c_link_hci_conn_comp(tHCI_STATUS status, uint16_t handle, const RawAddress& p_bda); void BTM_db_reset(void); extern tBTM_CB btm_cb; struct StackAclBtmAcl { tACL_CONN* acl_allocate_connection(); tACL_CONN* acl_get_connection_from_handle(uint16_t handle); tACL_CONN* btm_bda_to_acl(const RawAddress& bda, tBT_TRANSPORT transport); bool change_connection_packet_types(tACL_CONN& link, const uint16_t new_packet_type_bitmask); void btm_establish_continue(tACL_CONN* p_acl_cb); void btm_read_remote_features(uint16_t handle); void btm_set_default_link_policy(tLINK_POLICY settings); void btm_acl_role_changed(tHCI_STATUS hci_status, const RawAddress& bd_addr, tHCI_ROLE new_role); void hci_start_role_switch_to_central(tACL_CONN& p_acl); void set_default_packet_types_supported(uint16_t packet_types_supported) { btm_cb.acl_cb_.btm_acl_pkt_types_supported = packet_types_supported; } }; struct RoleChangeView { tHCI_ROLE new_role = HCI_ROLE_UNKNOWN; RawAddress bd_addr; }; namespace { StackAclBtmAcl internal_; std::unique_ptr delayed_role_change_ = nullptr; const bluetooth::legacy::hci::Interface& GetLegacyHciInterface() { return bluetooth::legacy::hci::GetInterface(); } } typedef struct { uint16_t handle; uint16_t hci_len; } __attribute__((packed)) acl_header_t; constexpr uint8_t BTM_MAX_SW_ROLE_FAILED_ATTEMPTS = 3; /* Define masks for supported and exception 2.0 ACL packet types */ constexpr uint16_t BTM_ACL_SUPPORTED_PKTS_MASK = (HCI_PKT_TYPES_MASK_DM1 | HCI_PKT_TYPES_MASK_DH1 | HCI_PKT_TYPES_MASK_DM3 | HCI_PKT_TYPES_MASK_DH3 | HCI_PKT_TYPES_MASK_DM5 | HCI_PKT_TYPES_MASK_DH5); constexpr uint16_t BTM_ACL_EXCEPTION_PKTS_MASK = (HCI_PKT_TYPES_MASK_NO_2_DH1 | HCI_PKT_TYPES_MASK_NO_3_DH1 | HCI_PKT_TYPES_MASK_NO_2_DH3 | HCI_PKT_TYPES_MASK_NO_3_DH3 | HCI_PKT_TYPES_MASK_NO_2_DH5 | HCI_PKT_TYPES_MASK_NO_3_DH5); inline bool IsEprAvailable(const tACL_CONN& p_acl) { if (!p_acl.peer_lmp_feature_valid[0]) { LOG_WARN("Checking incomplete feature page read"); return false; } return HCI_ATOMIC_ENCRYPT_SUPPORTED(p_acl.peer_lmp_feature_pages[0]) && controller_get_interface()->supports_encryption_pause(); } static void btm_process_remote_ext_features(tACL_CONN* p_acl_cb, uint8_t max_page_number); static void btm_read_failed_contact_counter_timeout(void* data); static void btm_read_remote_ext_features(uint16_t handle, uint8_t page_number); static void btm_read_rssi_timeout(void* data); static void btm_read_tx_power_timeout(void* data); static void check_link_policy(tLINK_POLICY* settings); void btm_set_link_policy(tACL_CONN* conn, tLINK_POLICY policy); namespace { void NotifyAclLinkUp(tACL_CONN& p_acl) { if (p_acl.link_up_issued) { LOG_INFO("Already notified BTA layer that the link is up"); return; } p_acl.link_up_issued = true; BTA_dm_acl_up(p_acl.remote_addr, p_acl.transport); } void NotifyAclLinkDown(tACL_CONN& p_acl) { /* Only notify if link up has had a chance to be issued */ if (p_acl.link_up_issued) { p_acl.link_up_issued = false; BTA_dm_acl_down(p_acl.remote_addr, p_acl.transport); } } void NotifyAclRoleSwitchComplete(const RawAddress& bda, tHCI_ROLE new_role, tHCI_STATUS hci_status) { BTA_dm_report_role_change(bda, new_role, hci_status); } void NotifyAclFeaturesReadComplete(tACL_CONN& p_acl, UNUSED_ATTR uint8_t max_page_number) { ASSERT_LOG(bluetooth::shim::is_gd_acl_enabled(), "For right now only called with gd_acl support"); btm_process_remote_ext_features(&p_acl, max_page_number); btm_set_link_policy(&p_acl, btm_cb.acl_cb_.DefaultLinkPolicy()); BTA_dm_notify_remote_features_complete(p_acl.remote_addr); } } // namespace static void hci_btsnd_hcic_disconnect(tACL_CONN& p_acl, tHCI_STATUS reason) { LOG_INFO("Disconnecting peer:%s reason:%s", PRIVATE_ADDRESS(p_acl.remote_addr), hci_error_code_text(reason).c_str()); p_acl.disconnect_reason = reason; if (bluetooth::shim::is_gd_acl_enabled()) { return bluetooth::shim::ACL_Disconnect(p_acl.hci_handle, p_acl.is_transport_br_edr(), reason); } else { GetLegacyHciInterface().Disconnect(p_acl.hci_handle, static_cast(reason)); } } void StackAclBtmAcl::hci_start_role_switch_to_central(tACL_CONN& p_acl) { GetLegacyHciInterface().StartRoleSwitch( p_acl.remote_addr, static_cast(HCI_ROLE_CENTRAL)); p_acl.set_switch_role_in_progress(); p_acl.rs_disc_pending = BTM_SEC_RS_PENDING; } void hci_btm_set_link_supervision_timeout(tACL_CONN& link, uint16_t timeout) { if (link.link_role != HCI_ROLE_CENTRAL) { /* Only send if current role is Central; 2.0 spec requires this */ LOG_WARN("Can only set link supervision timeout if central role:%s", RoleText(link.link_role).c_str()); return; } LOG_DEBUG("Setting link supervision timeout:%.2fs peer:%s", double(timeout) * 0.01, PRIVATE_ADDRESS(link.RemoteAddress())); link.link_super_tout = timeout; btsnd_hcic_write_link_super_tout(LOCAL_BR_EDR_CONTROLLER_ID, link.Handle(), timeout); } /* 3 seconds timeout waiting for responses */ #define BTM_DEV_REPLY_TIMEOUT_MS (3 * 1000) void BTM_acl_after_controller_started(const controller_t* controller) { internal_.btm_set_default_link_policy( HCI_ENABLE_CENTRAL_PERIPHERAL_SWITCH | HCI_ENABLE_HOLD_MODE | HCI_ENABLE_SNIFF_MODE | HCI_ENABLE_PARK_MODE); /* Create ACL supported packet types mask */ uint16_t btm_acl_pkt_types_supported = (HCI_PKT_TYPES_MASK_DH1 + HCI_PKT_TYPES_MASK_DM1); if (controller->supports_3_slot_packets()) btm_acl_pkt_types_supported |= (HCI_PKT_TYPES_MASK_DH3 + HCI_PKT_TYPES_MASK_DM3); if (controller->supports_5_slot_packets()) btm_acl_pkt_types_supported |= (HCI_PKT_TYPES_MASK_DH5 + HCI_PKT_TYPES_MASK_DM5); /* Add in EDR related ACL types */ if (!controller->supports_classic_2m_phy()) { btm_acl_pkt_types_supported |= (HCI_PKT_TYPES_MASK_NO_2_DH1 + HCI_PKT_TYPES_MASK_NO_2_DH3 + HCI_PKT_TYPES_MASK_NO_2_DH5); } if (!controller->supports_classic_3m_phy()) { btm_acl_pkt_types_supported |= (HCI_PKT_TYPES_MASK_NO_3_DH1 + HCI_PKT_TYPES_MASK_NO_3_DH3 + HCI_PKT_TYPES_MASK_NO_3_DH5); } /* Check to see if 3 and 5 slot packets are available */ if (controller->supports_classic_2m_phy() || controller->supports_classic_3m_phy()) { if (!controller->supports_3_slot_edr_packets()) btm_acl_pkt_types_supported |= (HCI_PKT_TYPES_MASK_NO_2_DH3 + HCI_PKT_TYPES_MASK_NO_3_DH3); if (!controller->supports_5_slot_edr_packets()) btm_acl_pkt_types_supported |= (HCI_PKT_TYPES_MASK_NO_2_DH5 + HCI_PKT_TYPES_MASK_NO_3_DH5); } internal_.set_default_packet_types_supported(btm_acl_pkt_types_supported); } /******************************************************************************* * * Function btm_bda_to_acl * * Description This function returns the FIRST acl_db entry for the passed * BDA. * * Parameters bda : BD address of the remote device * transport : Physical transport used for ACL connection * (BR/EDR or LE) * * Returns Returns pointer to the ACL DB for the requested BDA if found. * nullptr if not found. * ******************************************************************************/ tACL_CONN* StackAclBtmAcl::btm_bda_to_acl(const RawAddress& bda, tBT_TRANSPORT transport) { tACL_CONN* p_acl = &btm_cb.acl_cb_.acl_db[0]; for (uint8_t index = 0; index < MAX_L2CAP_LINKS; index++, p_acl++) { if ((p_acl->in_use) && p_acl->remote_addr == bda && p_acl->transport == transport) { return p_acl; } } return nullptr; } tACL_CONN* acl_get_connection_from_address(const RawAddress& bd_addr, tBT_TRANSPORT transport) { return internal_.btm_bda_to_acl(bd_addr, transport); } /******************************************************************************* * * Function btm_handle_to_acl_index * * Description This function returns the FIRST acl_db entry for the passed * hci_handle. * * Returns index to the acl_db or MAX_L2CAP_LINKS. * ******************************************************************************/ uint8_t btm_handle_to_acl_index(uint16_t hci_handle) { tACL_CONN* p = &btm_cb.acl_cb_.acl_db[0]; uint8_t xx; for (xx = 0; xx < MAX_L2CAP_LINKS; xx++, p++) { if ((p->in_use) && (p->hci_handle == hci_handle)) { break; } } /* If here, no BD Addr found */ return (xx); } tACL_CONN* StackAclBtmAcl::acl_get_connection_from_handle(uint16_t hci_handle) { uint8_t index = btm_handle_to_acl_index(hci_handle); if (index >= MAX_L2CAP_LINKS) return nullptr; return &btm_cb.acl_cb_.acl_db[index]; } tACL_CONN* acl_get_connection_from_handle(uint16_t handle) { return internal_.acl_get_connection_from_handle(handle); } void btm_acl_process_sca_cmpl_pkt(uint8_t len, uint8_t* data) { uint16_t handle; uint8_t sca; uint8_t status; if (len < 4) { LOG_WARN("Malformatted packet, not containing enough data"); return; } STREAM_TO_UINT8(status, data); if (status != HCI_SUCCESS) { LOG_WARN("Peer SCA Command complete failed:%s", hci_error_code_text(static_cast(status)).c_str()); return; } STREAM_TO_UINT16(handle, data); STREAM_TO_UINT8(sca, data); tACL_CONN* p_acl = internal_.acl_get_connection_from_handle(handle); if (p_acl == nullptr) { LOG_WARN("Unable to find active acl"); return; } p_acl->sca = sca; } tACL_CONN* StackAclBtmAcl::acl_allocate_connection() { tACL_CONN* p_acl = &btm_cb.acl_cb_.acl_db[0]; for (uint8_t xx = 0; xx < MAX_L2CAP_LINKS; xx++, p_acl++) { if (!p_acl->in_use) { return p_acl; } } return nullptr; } void btm_acl_created(const RawAddress& bda, uint16_t hci_handle, tHCI_ROLE link_role, tBT_TRANSPORT transport) { tACL_CONN* p_acl = internal_.btm_bda_to_acl(bda, transport); if (p_acl != (tACL_CONN*)NULL) { p_acl->hci_handle = hci_handle; p_acl->link_role = link_role; p_acl->transport = transport; btm_set_link_policy(p_acl, btm_cb.acl_cb_.DefaultLinkPolicy()); LOG_WARN( "Unable to create duplicate acl when one already exists handle:%hu" " role:%s transport:%s", hci_handle, RoleText(link_role).c_str(), bt_transport_text(transport).c_str()); return; } p_acl = internal_.acl_allocate_connection(); if (p_acl == nullptr) { LOG_WARN("Unable to find active acl"); return; } p_acl->in_use = true; p_acl->hci_handle = hci_handle; p_acl->link_role = link_role; p_acl->link_up_issued = false; p_acl->remote_addr = bda; p_acl->sca = 0xFF; p_acl->transport = transport; p_acl->switch_role_failed_attempts = 0; p_acl->reset_switch_role(); BTM_PM_OnConnected(hci_handle, bda); LOG_DEBUG( "Created new ACL connection peer:%s role:%s handle:0x%04x transport:%s", PRIVATE_ADDRESS(bda), RoleText(p_acl->link_role).c_str(), hci_handle, bt_transport_text(transport).c_str()); btm_set_link_policy(p_acl, btm_cb.acl_cb_.DefaultLinkPolicy()); if (transport == BT_TRANSPORT_LE) { btm_ble_refresh_local_resolvable_private_addr( bda, btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr); } /* if BR/EDR do something more */ if (transport == BT_TRANSPORT_BR_EDR) { btsnd_hcic_read_rmt_clk_offset(hci_handle); if (!bluetooth::shim::is_gd_l2cap_enabled() && !bluetooth::shim::is_gd_acl_enabled()) { // GD L2cap and GD Acl read this automatically btsnd_hcic_rmt_ver_req(hci_handle); } } if (transport == BT_TRANSPORT_LE) { btm_ble_get_acl_remote_addr(hci_handle, p_acl->active_remote_addr, &p_acl->active_remote_addr_type); if (controller_get_interface() ->supports_ble_peripheral_initiated_feature_exchange() || link_role == HCI_ROLE_CENTRAL) { btsnd_hcic_ble_read_remote_feat(p_acl->hci_handle); } else { internal_.btm_establish_continue(p_acl); } } } void btm_acl_update_conn_addr(uint16_t handle, const RawAddress& address) { tACL_CONN* p_acl = internal_.acl_get_connection_from_handle(handle); if (p_acl == nullptr) { LOG_WARN("Unable to find active acl"); return; } p_acl->conn_addr = address; } /******************************************************************************* * * Function btm_acl_removed * * Description This function is called by L2CAP when an ACL connection * is removed. Since only L2CAP creates ACL links, we use * the L2CAP link index as our index into the control blocks. * * Returns void * ******************************************************************************/ void btm_acl_removed(uint16_t handle) { tACL_CONN* p_acl = internal_.acl_get_connection_from_handle(handle); if (p_acl == nullptr) { LOG_WARN("Unable to find active acl"); return; } p_acl->in_use = false; NotifyAclLinkDown(*p_acl); p_acl->Reset(); BTM_PM_OnDisconnected(handle); } /******************************************************************************* * * Function btm_acl_device_down * * Description This function is called when the local device is deemed * to be down. It notifies L2CAP of the failure. * * Returns void * ******************************************************************************/ void btm_acl_device_down(void) { tACL_CONN* p = &btm_cb.acl_cb_.acl_db[0]; uint16_t xx; for (xx = 0; xx < MAX_L2CAP_LINKS; xx++, p++) { if (p->in_use) { l2c_link_hci_disc_comp(p->hci_handle, HCI_ERR_HW_FAILURE); } } BTM_db_reset(); } void btm_acl_set_paging(bool value) { btm_cb.is_paging = value; } void btm_acl_update_inquiry_status(uint8_t status) { btm_cb.is_inquiry = status == BTM_INQUIRY_STARTED; BTIF_dm_report_inquiry_status_change(status); } tBTM_STATUS BTM_GetRole(const RawAddress& remote_bd_addr, tHCI_ROLE* p_role) { if (p_role == nullptr) { return BTM_ILLEGAL_VALUE; } *p_role = HCI_ROLE_UNKNOWN; tACL_CONN* p_acl = internal_.btm_bda_to_acl(remote_bd_addr, BT_TRANSPORT_BR_EDR); if (p_acl == nullptr) { LOG_WARN("Unable to find active acl"); return BTM_UNKNOWN_ADDR; } *p_role = p_acl->link_role; return BTM_SUCCESS; } /******************************************************************************* * * Function BTM_SwitchRoleToCentral * * Description This function is called to switch role between central and * peripheral. If role is already set it will do nothing. * * Returns BTM_SUCCESS if already in specified role. * BTM_CMD_STARTED if command issued to controller. * BTM_NO_RESOURCES if couldn't allocate memory to issue * command * BTM_UNKNOWN_ADDR if no active link with bd addr specified * BTM_MODE_UNSUPPORTED if local device does not support role * switching * BTM_BUSY if the previous command is not completed * ******************************************************************************/ tBTM_STATUS BTM_SwitchRoleToCentral(const RawAddress& remote_bd_addr) { if (bluetooth::shim::is_gd_l2cap_enabled()) { bluetooth::shim::L2CA_SwitchRoleToCentral(remote_bd_addr); return BTM_SUCCESS; } if (!controller_get_interface()->supports_central_peripheral_role_switch()) { LOG_INFO("Local controller does not support role switching"); return BTM_MODE_UNSUPPORTED; } tACL_CONN* p_acl = internal_.btm_bda_to_acl(remote_bd_addr, BT_TRANSPORT_BR_EDR); if (p_acl == nullptr) { LOG_WARN("Unable to find active acl"); return BTM_UNKNOWN_ADDR; } if (p_acl->link_role == HCI_ROLE_CENTRAL) { LOG_INFO("Requested role is already in effect"); return BTM_SUCCESS; } if (interop_match_addr(INTEROP_DISABLE_ROLE_SWITCH, &remote_bd_addr)) { LOG_INFO("Remote device is on list preventing role switch"); return BTM_DEV_RESTRICT_LISTED; } if (BTM_IsScoActiveByBdaddr(remote_bd_addr)) { LOG_INFO("An active SCO to device prevents role switch at this time"); return BTM_NO_RESOURCES; } if (!p_acl->is_switch_role_idle()) { LOG_INFO("Role switch is already progress"); return BTM_BUSY; } tBTM_PM_MODE pwr_mode; if (!BTM_ReadPowerMode(p_acl->remote_addr, &pwr_mode)) { LOG_WARN( "Unable to find device to read current power mode prior to role " "switch"); return BTM_UNKNOWN_ADDR; }; if (pwr_mode == BTM_PM_MD_PARK || pwr_mode == BTM_PM_MD_SNIFF) { if (!BTM_SetLinkPolicyActiveMode(p_acl->remote_addr)) { LOG_WARN("Unable to set link policy active before attempting switch"); return BTM_WRONG_MODE; } p_acl->set_switch_role_changing(); } /* some devices do not support switch while encryption is on */ else { if (p_acl->is_encrypted && !IsEprAvailable(*p_acl)) { /* bypass turning off encryption if change link key is already doing it */ p_acl->set_encryption_off(); p_acl->set_switch_role_encryption_off(); } else { internal_.hci_start_role_switch_to_central(*p_acl); } } return BTM_CMD_STARTED; } /******************************************************************************* * * Function btm_acl_encrypt_change * * Description This function is when encryption of the connection is * completed by the LM. Checks to see if a role switch or * change of link key was active and initiates or continues * process if needed. * * Returns void * ******************************************************************************/ void btm_acl_encrypt_change(uint16_t handle, uint8_t status, uint8_t encr_enable) { tACL_CONN* p = internal_.acl_get_connection_from_handle(handle); if (p == nullptr) { LOG_WARN("Unable to find active acl"); return; } p->is_encrypted = encr_enable; /* Process Role Switch if active */ if (p->is_switch_role_encryption_off()) { /* if encryption turn off failed we still will try to switch role */ if (encr_enable) { p->set_encryption_idle(); p->reset_switch_role(); } else { p->set_encryption_switching(); p->set_switch_role_switching(); } internal_.hci_start_role_switch_to_central(*p); } /* Finished enabling Encryption after role switch */ else if (p->is_switch_role_encryption_on()) { p->reset_switch_role(); p->set_encryption_idle(); NotifyAclRoleSwitchComplete( btm_cb.acl_cb_.switch_role_ref_data.remote_bd_addr, btm_cb.acl_cb_.switch_role_ref_data.role, btm_cb.acl_cb_.switch_role_ref_data.hci_status); /* If a disconnect is pending, issue it now that role switch has completed */ if (p->rs_disc_pending == BTM_SEC_DISC_PENDING) { hci_btsnd_hcic_disconnect(*p, HCI_ERR_PEER_USER); } p->rs_disc_pending = BTM_SEC_RS_NOT_PENDING; /* reset flag */ } } static void check_link_policy(tLINK_POLICY* settings) { const controller_t* controller = controller_get_interface(); if ((*settings & HCI_ENABLE_CENTRAL_PERIPHERAL_SWITCH) && (!controller->supports_role_switch())) { *settings &= (~HCI_ENABLE_CENTRAL_PERIPHERAL_SWITCH); LOG_INFO("Role switch not supported (settings: 0x%04x)", *settings); } if ((*settings & HCI_ENABLE_HOLD_MODE) && (!controller->supports_hold_mode())) { *settings &= (~HCI_ENABLE_HOLD_MODE); LOG_INFO("hold not supported (settings: 0x%04x)", *settings); } if ((*settings & HCI_ENABLE_SNIFF_MODE) && (!controller->supports_sniff_mode())) { *settings &= (~HCI_ENABLE_SNIFF_MODE); LOG_INFO("sniff not supported (settings: 0x%04x)", *settings); } if ((*settings & HCI_ENABLE_PARK_MODE) && (!controller->supports_park_mode())) { *settings &= (~HCI_ENABLE_PARK_MODE); LOG_INFO("park not supported (settings: 0x%04x)", *settings); } } void btm_set_link_policy(tACL_CONN* conn, tLINK_POLICY policy) { conn->link_policy = policy; check_link_policy(&conn->link_policy); if ((conn->link_policy & HCI_ENABLE_CENTRAL_PERIPHERAL_SWITCH) && interop_match_addr(INTEROP_DISABLE_SNIFF, &(conn->remote_addr))) { conn->link_policy &= (~HCI_ENABLE_SNIFF_MODE); } btsnd_hcic_write_policy_set(conn->hci_handle, static_cast(conn->link_policy)); } static void btm_toggle_policy_on_for(const RawAddress& peer_addr, uint16_t flag) { auto conn = internal_.btm_bda_to_acl(peer_addr, BT_TRANSPORT_BR_EDR); if (!conn) { LOG_WARN("Unable to find active acl"); return; } btm_set_link_policy(conn, conn->link_policy | flag); } static void btm_toggle_policy_off_for(const RawAddress& peer_addr, uint16_t flag) { auto conn = internal_.btm_bda_to_acl(peer_addr, BT_TRANSPORT_BR_EDR); if (!conn) { LOG_WARN("Unable to find active acl"); return; } btm_set_link_policy(conn, conn->link_policy & ~flag); } bool BTM_is_sniff_allowed_for(const RawAddress& peer_addr) { auto conn = internal_.btm_bda_to_acl(peer_addr, BT_TRANSPORT_BR_EDR); if (!conn) { LOG_WARN("Unable to find active acl"); return false; } return conn->link_policy & HCI_ENABLE_SNIFF_MODE; } void BTM_unblock_sniff_mode_for(const RawAddress& peer_addr) { btm_toggle_policy_on_for(peer_addr, HCI_ENABLE_SNIFF_MODE); } void BTM_block_sniff_mode_for(const RawAddress& peer_addr) { btm_toggle_policy_off_for(peer_addr, HCI_ENABLE_SNIFF_MODE); } void BTM_unblock_role_switch_for(const RawAddress& peer_addr) { btm_toggle_policy_on_for(peer_addr, HCI_ENABLE_CENTRAL_PERIPHERAL_SWITCH); } void BTM_block_role_switch_for(const RawAddress& peer_addr) { btm_toggle_policy_off_for(peer_addr, HCI_ENABLE_CENTRAL_PERIPHERAL_SWITCH); } void StackAclBtmAcl::btm_set_default_link_policy(tLINK_POLICY settings) { check_link_policy(&settings); btm_cb.acl_cb_.btm_def_link_policy = settings; btsnd_hcic_write_def_policy_set(settings); } void BTM_default_unblock_role_switch() { internal_.btm_set_default_link_policy(btm_cb.acl_cb_.DefaultLinkPolicy() | HCI_ENABLE_CENTRAL_PERIPHERAL_SWITCH); } void BTM_default_block_role_switch() { internal_.btm_set_default_link_policy(btm_cb.acl_cb_.DefaultLinkPolicy() & ~HCI_ENABLE_CENTRAL_PERIPHERAL_SWITCH); } /******************************************************************************* * * Function btm_read_remote_version_complete * * Description This function is called when the command complete message * is received from the HCI for the remote version info. * * Returns void * ******************************************************************************/ static void maybe_chain_more_commands_after_read_remote_version_complete( uint8_t status, uint16_t handle) { tACL_CONN* p_acl_cb = internal_.acl_get_connection_from_handle(handle); if (p_acl_cb == nullptr) { LOG_WARN("Received remote version complete for unknown device"); return; } switch (p_acl_cb->transport) { case BT_TRANSPORT_LE: l2cble_notify_le_connection(p_acl_cb->remote_addr); l2cble_use_preferred_conn_params(p_acl_cb->remote_addr); break; case BT_TRANSPORT_BR_EDR: /** * When running legacy stack continue chain of executing various * read commands. Skip when gd_acl is enabled because that * module handles all remote read functionality. */ if (!bluetooth::shim::is_gd_acl_enabled()) { if (status == HCI_SUCCESS) { internal_.btm_read_remote_features(p_acl_cb->hci_handle); } } } } void btm_process_remote_version_complete(uint8_t status, uint16_t handle, uint8_t lmp_version, uint16_t manufacturer, uint16_t lmp_subversion) { tACL_CONN* p_acl_cb = internal_.acl_get_connection_from_handle(handle); if (p_acl_cb == nullptr) { LOG_WARN("Received remote version complete for unknown acl"); return; } if (status == HCI_SUCCESS) { p_acl_cb->remote_version_info.lmp_version = lmp_version; p_acl_cb->remote_version_info.manufacturer = manufacturer; p_acl_cb->remote_version_info.lmp_subversion = lmp_subversion; p_acl_cb->remote_version_info.valid = true; BTM_update_version_info(p_acl_cb->RemoteAddress(), p_acl_cb->remote_version_info); bluetooth::common::LogRemoteVersionInfo(handle, status, lmp_version, manufacturer, lmp_subversion); } else { bluetooth::common::LogRemoteVersionInfo(handle, status, 0, 0, 0); } } void btm_read_remote_version_complete_raw(uint8_t* p) { uint8_t status; uint16_t handle; uint8_t lmp_version; uint16_t manufacturer; uint16_t lmp_subversion; STREAM_TO_UINT8(status, p); STREAM_TO_UINT16(handle, p); STREAM_TO_UINT8(lmp_version, p); STREAM_TO_UINT16(manufacturer, p); STREAM_TO_UINT16(lmp_subversion, p); ASSERT_LOG(!bluetooth::shim::is_gd_acl_enabled(), "gd acl layer should be receiving this completion"); btm_read_remote_version_complete(static_cast(status), handle, lmp_version, manufacturer, lmp_version); } void btm_read_remote_version_complete(tHCI_STATUS status, uint16_t handle, uint8_t lmp_version, uint16_t manufacturer, uint16_t lmp_subversion) { btm_process_remote_version_complete(status, handle, lmp_version, manufacturer, lmp_subversion); maybe_chain_more_commands_after_read_remote_version_complete(status, handle); } /******************************************************************************* * * Function btm_process_remote_ext_features * * Description Local function called to process all extended features pages * read from a remote device. * * Returns void * ******************************************************************************/ void btm_process_remote_ext_features(tACL_CONN* p_acl_cb, uint8_t max_page_number) { CHECK(p_acl_cb != nullptr); if (!p_acl_cb->peer_lmp_feature_valid[max_page_number]) { LOG_WARN( "Checking remote features but remote feature read is " "incomplete"); } bool ssp_supported = HCI_SSP_HOST_SUPPORTED(p_acl_cb->peer_lmp_feature_pages[1]); bool secure_connections_supported = HCI_SC_HOST_SUPPORTED(p_acl_cb->peer_lmp_feature_pages[1]); bool role_switch_supported = HCI_SWITCH_SUPPORTED(p_acl_cb->peer_lmp_feature_pages[0]); bool br_edr_supported = !HCI_BREDR_NOT_SPT_SUPPORTED(p_acl_cb->peer_lmp_feature_pages[0]); bool le_supported = HCI_LE_SPT_SUPPORTED(p_acl_cb->peer_lmp_feature_pages[0]) && HCI_LE_HOST_SUPPORTED(p_acl_cb->peer_lmp_feature_pages[1]); btm_sec_set_peer_sec_caps(p_acl_cb->hci_handle, ssp_supported, secure_connections_supported, role_switch_supported, br_edr_supported, le_supported); } /******************************************************************************* * * Function btm_read_remote_features * * Description Local function called to send a read remote supported * features/remote extended features page[0]. * * Returns void * ******************************************************************************/ void StackAclBtmAcl::btm_read_remote_features(uint16_t handle) { uint8_t acl_idx; tACL_CONN* p_acl_cb; acl_idx = btm_handle_to_acl_index(handle); if (acl_idx >= MAX_L2CAP_LINKS) { LOG_WARN("Unable to find active acl"); return; } p_acl_cb = &btm_cb.acl_cb_.acl_db[acl_idx]; memset(p_acl_cb->peer_lmp_feature_pages, 0, sizeof(p_acl_cb->peer_lmp_feature_pages)); /* first send read remote supported features HCI command */ /* because we don't know whether the remote support extended feature command */ if (bluetooth::shim::is_gd_l2cap_enabled()) { // GD L2cap reads this automatically return; } btsnd_hcic_rmt_features_req(handle); } /******************************************************************************* * * Function btm_read_remote_ext_features * * Description Local function called to send a read remote extended * features * * Returns void * ******************************************************************************/ void btm_read_remote_ext_features(uint16_t handle, uint8_t page_number) { if (bluetooth::shim::is_gd_l2cap_enabled()) { // GD L2cap reads this automatically return; } btsnd_hcic_rmt_ext_features(handle, page_number); } /******************************************************************************* * * Function btm_read_remote_features_complete * * Description This function is called when the remote supported features * complete event is received from the HCI. * * Returns void * ******************************************************************************/ void btm_read_remote_features_complete_raw(uint8_t* p) { uint8_t status; uint16_t handle; STREAM_TO_UINT8(status, p); if (status != HCI_SUCCESS) { LOG_WARN("Uanble to read remote features status:%s", hci_error_code_text(static_cast(status)).c_str()); return; } STREAM_TO_UINT16(handle, p); btm_read_remote_features_complete(handle, p); } void btm_read_remote_features_complete(uint16_t handle, uint8_t* features) { tACL_CONN* p_acl_cb = internal_.acl_get_connection_from_handle(handle); if (p_acl_cb == nullptr) { LOG_WARN("Unable to find active acl"); return; } /* Copy the received features page */ STREAM_TO_ARRAY(p_acl_cb->peer_lmp_feature_pages[0], features, HCI_FEATURE_BYTES_PER_PAGE); p_acl_cb->peer_lmp_feature_valid[0] = true; if ((HCI_LMP_EXTENDED_SUPPORTED(p_acl_cb->peer_lmp_feature_pages[0])) && (controller_get_interface() ->supports_reading_remote_extended_features())) { /* if the remote controller has extended features and local controller supports HCI_Read_Remote_Extended_Features command then start reading these feature starting with extended features page 1 */ LOG_DEBUG("Start reading remote extended features"); btm_read_remote_ext_features(handle, 1); return; } /* Remote controller has no extended features. Process remote controller supported features (features page 0). */ btm_process_remote_ext_features(p_acl_cb, 0); /* Continue with HCI connection establishment */ internal_.btm_establish_continue(p_acl_cb); } /******************************************************************************* * * Function btm_read_remote_ext_features_complete * * Description This function is called when the remote extended features * complete event is received from the HCI. * * Returns void * ******************************************************************************/ void btm_read_remote_ext_features_complete_raw(uint8_t* p, uint8_t evt_len) { uint8_t page_num, max_page; uint16_t handle; if (evt_len < HCI_EXT_FEATURES_SUCCESS_EVT_LEN) { android_errorWriteLog(0x534e4554, "141552859"); LOG_WARN("Remote extended feature length too short. length=%d", evt_len); return; } ++p; STREAM_TO_UINT16(handle, p); STREAM_TO_UINT8(page_num, p); STREAM_TO_UINT8(max_page, p); if (max_page > HCI_EXT_FEATURES_PAGE_MAX) { LOG_WARN("Too many max pages read page=%d unknown", max_page); return; } if (page_num > HCI_EXT_FEATURES_PAGE_MAX) { android_errorWriteLog(0x534e4554, "141552859"); LOG_WARN("Too many received pages num_page=%d invalid", page_num); return; } if (page_num > max_page) { LOG_WARN("num_page=%d, max_page=%d invalid", page_num, max_page); } btm_read_remote_ext_features_complete(handle, page_num, max_page, p); } void btm_read_remote_ext_features_complete(uint16_t handle, uint8_t page_num, uint8_t max_page, uint8_t* features) { /* Validate parameters */ auto* p_acl_cb = internal_.acl_get_connection_from_handle(handle); if (p_acl_cb == nullptr) { LOG_WARN("Unable to find active acl"); return; } /* Copy the received features page */ STREAM_TO_ARRAY(p_acl_cb->peer_lmp_feature_pages[page_num], features, HCI_FEATURE_BYTES_PER_PAGE); p_acl_cb->peer_lmp_feature_valid[page_num] = true; /* If there is the next remote features page and * we have space to keep this page data - read this page */ if ((page_num < max_page) && (page_num < HCI_EXT_FEATURES_PAGE_MAX)) { page_num++; LOG_DEBUG("BTM reads next remote extended features page (%d)", page_num); btm_read_remote_ext_features(handle, page_num); return; } /* Reading of remote feature pages is complete */ LOG_DEBUG("BTM reached last remote extended features page (%d)", page_num); /* Process the pages */ btm_process_remote_ext_features(p_acl_cb, max_page); /* Continue with HCI connection establishment */ internal_.btm_establish_continue(p_acl_cb); } /******************************************************************************* * * Function btm_read_remote_ext_features_failed * * Description This function is called when the remote extended features * complete event returns a failed status. * * Returns void * ******************************************************************************/ void btm_read_remote_ext_features_failed(uint8_t status, uint16_t handle) { LOG_WARN("status 0x%02x for handle %d", status, handle); tACL_CONN* p_acl_cb = internal_.acl_get_connection_from_handle(handle); if (p_acl_cb == nullptr) { LOG_WARN("Unable to find active acl"); return; } /* Process supported features only */ btm_process_remote_ext_features(p_acl_cb, 0); /* Continue HCI connection establishment */ internal_.btm_establish_continue(p_acl_cb); } /******************************************************************************* * * Function btm_establish_continue * * Description This function is called when the command complete message * is received from the HCI for the read local link policy * request. * * Returns void * ******************************************************************************/ void StackAclBtmAcl::btm_establish_continue(tACL_CONN* p_acl) { CHECK(p_acl != nullptr); if (p_acl->is_transport_br_edr()) { /* For now there are a some devices that do not like sending */ /* commands events and data at the same time. */ /* Set the packet types to the default allowed by the device */ const uint16_t default_packet_type_mask = btm_cb.acl_cb_.DefaultPacketTypes(); if (!internal_.change_connection_packet_types(*p_acl, default_packet_type_mask)) { LOG_ERROR("Unable to change connection packet type types:%04x address:%s", default_packet_type_mask, PRIVATE_ADDRESS(p_acl->RemoteAddress())); } btm_set_link_policy(p_acl, btm_cb.acl_cb_.DefaultLinkPolicy()); } NotifyAclLinkUp(*p_acl); } void btm_establish_continue_from_address(const RawAddress& bda, tBT_TRANSPORT transport) { tACL_CONN* p_acl = internal_.btm_bda_to_acl(bda, transport); if (p_acl == nullptr) { LOG_WARN("Unable to find active acl"); return; } internal_.btm_establish_continue(p_acl); } /******************************************************************************* * * Function BTM_GetLinkSuperTout * * Description Read the link supervision timeout value of the connection * * Returns status of the operation * ******************************************************************************/ tBTM_STATUS BTM_GetLinkSuperTout(const RawAddress& remote_bda, uint16_t* p_timeout) { CHECK(p_timeout != nullptr); const tACL_CONN* p_acl = internal_.btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR); if (p_acl == nullptr) { LOG_WARN("Unable to find active acl"); return BTM_UNKNOWN_ADDR; } *p_timeout = p_acl->link_super_tout; return BTM_SUCCESS; } /******************************************************************************* * * Function BTM_SetLinkSuperTout * * Description Create and send HCI "Write Link Supervision Timeout" command * * Returns status of the operation * ******************************************************************************/ tBTM_STATUS BTM_SetLinkSuperTout(const RawAddress& remote_bda, uint16_t timeout) { tACL_CONN* p_acl = internal_.btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR); if (p_acl == nullptr) { LOG_WARN("Unable to find active acl"); return BTM_UNKNOWN_ADDR; } /* Only send if current role is Central; 2.0 spec requires this */ if (p_acl->link_role == HCI_ROLE_CENTRAL) { p_acl->link_super_tout = timeout; btsnd_hcic_write_link_super_tout(LOCAL_BR_EDR_CONTROLLER_ID, p_acl->hci_handle, timeout); LOG_DEBUG("Set supervision timeout:%.2fms bd_addr:%s", supervision_timeout_to_seconds(timeout), PRIVATE_ADDRESS(remote_bda)); return BTM_CMD_STARTED; } else { LOG_WARN( "Role is peripheral so unable to set supervision timeout:%.2fms " "bd_addr:%s", supervision_timeout_to_seconds(timeout), PRIVATE_ADDRESS(remote_bda)); return BTM_SUCCESS; } } bool BTM_IsAclConnectionUp(const RawAddress& remote_bda, tBT_TRANSPORT transport) { if (bluetooth::shim::is_gd_l2cap_enabled()) { return bluetooth::shim::L2CA_IsLinkEstablished(remote_bda, transport); } return internal_.btm_bda_to_acl(remote_bda, transport) != nullptr; } bool BTM_IsAclConnectionUpAndHandleValid(const RawAddress& remote_bda, tBT_TRANSPORT transport) { if (bluetooth::shim::is_gd_l2cap_enabled()) { return bluetooth::shim::L2CA_IsLinkEstablished(remote_bda, transport); } tACL_CONN* p_acl = internal_.btm_bda_to_acl(remote_bda, transport); if (p_acl == nullptr) { LOG_WARN("Unable to find active acl"); return false; } return p_acl->hci_handle != HCI_INVALID_HANDLE; } bool BTM_IsAclConnectionUpFromHandle(uint16_t hci_handle) { return internal_.acl_get_connection_from_handle(hci_handle) != nullptr; } /******************************************************************************* * * Function BTM_GetNumAclLinks * * Description This function is called to count the number of * ACL links that are active. * * Returns uint16_t Number of active ACL links * ******************************************************************************/ uint16_t BTM_GetNumAclLinks(void) { if (bluetooth::shim::is_gd_l2cap_enabled()) { return bluetooth::shim::L2CA_GetNumLinks(); } return static_cast(btm_cb.acl_cb_.NumberOfActiveLinks()); } /******************************************************************************* * * Function btm_get_acl_disc_reason_code * * Description This function is called to get the disconnection reason code * returned by the HCI at disconnection complete event. * * Returns true if connection is up, else false. * ******************************************************************************/ tHCI_REASON btm_get_acl_disc_reason_code(void) { return btm_cb.acl_cb_.get_disconnect_reason(); } /******************************************************************************* * * Function BTM_GetHCIConnHandle * * Description This function is called to get the handle for an ACL * connection to a specific remote BD Address. * * Returns the handle of the connection, or HCI_INVALID_HANDLE if none. * ******************************************************************************/ uint16_t BTM_GetHCIConnHandle(const RawAddress& remote_bda, tBT_TRANSPORT transport) { if (bluetooth::shim::is_gd_l2cap_enabled()) { return bluetooth::shim::BTM_GetHCIConnHandle(remote_bda, transport); } tACL_CONN* p; p = internal_.btm_bda_to_acl(remote_bda, transport); if (p != (tACL_CONN*)NULL) { return (p->hci_handle); } /* If here, no BD Addr found */ return HCI_INVALID_HANDLE; } /******************************************************************************* * * Function BTM_IsPhy2mSupported * * Description This function is called to check PHY 2M support * from peer device * Returns True when PHY 2M supported false otherwise * ******************************************************************************/ bool BTM_IsPhy2mSupported(const RawAddress& remote_bda, tBT_TRANSPORT transport) { tACL_CONN* p; BTM_TRACE_DEBUG("BTM_IsPhy2mSupported"); p = internal_.btm_bda_to_acl(remote_bda, transport); if (p == (tACL_CONN*)NULL) { BTM_TRACE_DEBUG("BTM_IsPhy2mSupported: no connection"); return false; } if (!p->peer_le_features_valid) { LOG_WARN( "Checking remote features but remote feature read is " "incomplete"); } return HCI_LE_2M_PHY_SUPPORTED(p->peer_le_features); } /******************************************************************************* * * Function BTM_RequestPeerSCA * * Description This function is called to request sleep clock accuracy * from peer device * ******************************************************************************/ void BTM_RequestPeerSCA(const RawAddress& remote_bda, tBT_TRANSPORT transport) { tACL_CONN* p; p = internal_.btm_bda_to_acl(remote_bda, transport); if (p == (tACL_CONN*)NULL) { LOG_WARN("Unable to find active acl"); return; } btsnd_hcic_req_peer_sca(p->hci_handle); } /******************************************************************************* * * Function BTM_GetPeerSCA * * Description This function is called to get peer sleep clock accuracy * * Returns SCA or 0xFF if SCA was never previously requested, request * is not supported by peer device or ACL does not exist * ******************************************************************************/ uint8_t BTM_GetPeerSCA(const RawAddress& remote_bda, tBT_TRANSPORT transport) { tACL_CONN* p; p = internal_.btm_bda_to_acl(remote_bda, transport); if (p != (tACL_CONN*)NULL) { return (p->sca); } LOG_WARN("Unable to find active acl"); /* If here, no BD Addr found */ return (0xFF); } /******************************************************************************* * * Function btm_rejectlist_role_change_device * * Description This function is used to rejectlist the device if the role * switch fails for maximum number of times. It also removes * the device from the black list if the role switch succeeds. * * Input Parms bd_addr - remote BD addr * hci_status - role switch status * * Returns void * *******************************************************************************/ void btm_rejectlist_role_change_device(const RawAddress& bd_addr, uint8_t hci_status) { tACL_CONN* p = internal_.btm_bda_to_acl(bd_addr, BT_TRANSPORT_BR_EDR); if (!p) { LOG_WARN("Unable to find active acl"); return; } if (hci_status == HCI_SUCCESS) { p->switch_role_failed_attempts = 0; return; } /* check for carkits */ const uint32_t cod_audio_device = (BTM_COD_SERVICE_AUDIO | BTM_COD_MAJOR_AUDIO) << 8; const uint8_t* dev_class = btm_get_dev_class(bd_addr); if (dev_class == nullptr) return; const uint32_t cod = ((dev_class[0] << 16) | (dev_class[1] << 8) | dev_class[2]) & 0xffffff; if ((hci_status != HCI_SUCCESS) && (p->is_switch_role_switching_or_in_progress()) && ((cod & cod_audio_device) == cod_audio_device) && (!interop_match_addr(INTEROP_DYNAMIC_ROLE_SWITCH, &bd_addr))) { p->switch_role_failed_attempts++; if (p->switch_role_failed_attempts == BTM_MAX_SW_ROLE_FAILED_ATTEMPTS) { LOG_WARN( "Device %s rejectlisted for role switching - " "multiple role switch failed attempts: %u", bd_addr.ToString().c_str(), p->switch_role_failed_attempts); interop_database_add(INTEROP_DYNAMIC_ROLE_SWITCH, &bd_addr, 3); } } } /******************************************************************************* * * Function btm_acl_role_changed * * Description This function is called whan a link's central/peripheral *role change event or command status event (with error) is received. It updates *the link control block, and calls the registered callback with status and role *(if registered). * * Returns void * ******************************************************************************/ void StackAclBtmAcl::btm_acl_role_changed(tHCI_STATUS hci_status, const RawAddress& bd_addr, tHCI_ROLE new_role) { tACL_CONN* p_acl = internal_.btm_bda_to_acl(bd_addr, BT_TRANSPORT_BR_EDR); if (p_acl == nullptr) { // If we get a role change before connection complete, we cache the new // role here and then propagate it when ACL Link is created. RoleChangeView role_change; role_change.new_role = new_role; role_change.bd_addr = bd_addr; delayed_role_change_ = std::make_unique(std::move(role_change)); LOG_WARN("Unable to find active acl"); return; } tBTM_ROLE_SWITCH_CMPL* p_switch_role = &btm_cb.acl_cb_.switch_role_ref_data; LOG_DEBUG("Role change event received peer:%s hci_status:%s new_role:%s", PRIVATE_ADDRESS(bd_addr), hci_error_code_text(hci_status).c_str(), RoleText(new_role).c_str()); p_switch_role->hci_status = hci_status; if (hci_status == HCI_SUCCESS) { p_switch_role->role = new_role; p_switch_role->remote_bd_addr = bd_addr; /* Update cached value */ p_acl->link_role = new_role; /* Reload LSTO: link supervision timeout is reset in the LM after a role * switch */ if (new_role == HCI_ROLE_CENTRAL) { constexpr uint16_t link_supervision_timeout = 8000; BTM_SetLinkSuperTout(bd_addr, link_supervision_timeout); } } else { new_role = p_acl->link_role; } /* Check if any SCO req is pending for role change */ btm_sco_chk_pend_rolechange(p_acl->hci_handle); /* if switching state is switching we need to turn encryption on */ /* if idle, we did not change encryption */ if (p_acl->is_switch_role_switching()) { p_acl->set_encryption_on(); p_acl->set_switch_role_encryption_on(); return; } /* Set the switch_role_state to IDLE since the reply received from HCI */ /* regardless of its result either success or failed. */ if (p_acl->is_switch_role_in_progress()) { p_acl->set_encryption_idle(); p_acl->reset_switch_role(); } BTA_dm_report_role_change(bd_addr, new_role, hci_status); /* If a disconnect is pending, issue it now that role switch has completed */ if (p_acl->rs_disc_pending == BTM_SEC_DISC_PENDING) { hci_btsnd_hcic_disconnect(*p_acl, HCI_ERR_PEER_USER); } p_acl->rs_disc_pending = BTM_SEC_RS_NOT_PENDING; /* reset flag */ } void btm_acl_role_changed(tHCI_STATUS hci_status, const RawAddress& bd_addr, tHCI_ROLE new_role) { if (hci_status == HCI_SUCCESS) { l2c_link_role_changed(&bd_addr, new_role, hci_status); } else { l2c_link_role_changed(nullptr, HCI_ROLE_UNKNOWN, HCI_ERR_COMMAND_DISALLOWED); } internal_.btm_acl_role_changed(hci_status, bd_addr, new_role); } /******************************************************************************* * * Function change_connection_packet_types * * Description This function sets the packet types used for a specific * ACL connection. It is called internally by btm_acl_created * or by an application/profile by BTM_SetPacketTypes. * * Returns status of the operation * ******************************************************************************/ bool StackAclBtmAcl::change_connection_packet_types( tACL_CONN& link, const uint16_t new_packet_type_mask) { // Start with the default configured packet types const uint16_t default_packet_type_mask = btm_cb.acl_cb_.DefaultPacketTypes(); uint16_t packet_type_mask = default_packet_type_mask & (new_packet_type_mask & BTM_ACL_SUPPORTED_PKTS_MASK); /* OR in any exception packet types if at least 2.0 version of spec */ packet_type_mask |= ((new_packet_type_mask & BTM_ACL_EXCEPTION_PKTS_MASK) | (BTM_ACL_EXCEPTION_PKTS_MASK & default_packet_type_mask)); /* Exclude packet types not supported by the peer */ if (link.peer_lmp_feature_valid[0]) { PeerPacketTypes peer_packet_types(link.peer_lmp_feature_pages[0]); packet_type_mask &= peer_packet_types.acl.supported; packet_type_mask |= peer_packet_types.acl.unsupported; } else { LOG_INFO( "Unable to include remote supported packet types as read feature " "incomplete"); LOG_INFO("TIP: Maybe wait until read feature complete beforehand"); } if (packet_type_mask == 0) { LOG_WARN("Unable to send controller illegal change packet mask:0x%04x", packet_type_mask); return false; } link.pkt_types_mask = packet_type_mask; bluetooth::legacy::hci::GetInterface().ChangeConnectionPacketType( link.Handle(), link.pkt_types_mask); LOG_DEBUG("Started change connection packet type:0x%04x address:%s", link.pkt_types_mask, PRIVATE_ADDRESS(link.RemoteAddress())); return true; } void btm_set_packet_types_from_address(const RawAddress& bd_addr, uint16_t pkt_types) { tACL_CONN* p_acl = internal_.btm_bda_to_acl(bd_addr, BT_TRANSPORT_BR_EDR); if (p_acl == nullptr) { LOG_WARN("Unable to find active acl"); return; } if (!internal_.change_connection_packet_types(*p_acl, pkt_types)) { LOG_ERROR("Unable to change connection packet type types:%04x address:%s", pkt_types, PRIVATE_ADDRESS(bd_addr)); } } /******************************************************************************* * * Function BTM_GetMaxPacketSize * * Returns Returns maximum packet size that can be used for current * connection, 0 if connection is not established * ******************************************************************************/ uint16_t BTM_GetMaxPacketSize(const RawAddress& addr) { tACL_CONN* p = internal_.btm_bda_to_acl(addr, BT_TRANSPORT_BR_EDR); uint16_t pkt_types = 0; uint16_t pkt_size = 0; if (p != NULL) { pkt_types = p->pkt_types_mask; } else { /* Special case for when info for the local device is requested */ if (addr == *controller_get_interface()->get_address()) { pkt_types = btm_cb.acl_cb_.DefaultPacketTypes(); } } if (pkt_types) { if (!(pkt_types & HCI_PKT_TYPES_MASK_NO_3_DH5)) pkt_size = HCI_EDR3_DH5_PACKET_SIZE; else if (!(pkt_types & HCI_PKT_TYPES_MASK_NO_2_DH5)) pkt_size = HCI_EDR2_DH5_PACKET_SIZE; else if (!(pkt_types & HCI_PKT_TYPES_MASK_NO_3_DH3)) pkt_size = HCI_EDR3_DH3_PACKET_SIZE; else if (pkt_types & HCI_PKT_TYPES_MASK_DH5) pkt_size = HCI_DH5_PACKET_SIZE; else if (!(pkt_types & HCI_PKT_TYPES_MASK_NO_2_DH3)) pkt_size = HCI_EDR2_DH3_PACKET_SIZE; else if (pkt_types & HCI_PKT_TYPES_MASK_DM5) pkt_size = HCI_DM5_PACKET_SIZE; else if (pkt_types & HCI_PKT_TYPES_MASK_DH3) pkt_size = HCI_DH3_PACKET_SIZE; else if (pkt_types & HCI_PKT_TYPES_MASK_DM3) pkt_size = HCI_DM3_PACKET_SIZE; else if (!(pkt_types & HCI_PKT_TYPES_MASK_NO_3_DH1)) pkt_size = HCI_EDR3_DH1_PACKET_SIZE; else if (!(pkt_types & HCI_PKT_TYPES_MASK_NO_2_DH1)) pkt_size = HCI_EDR2_DH1_PACKET_SIZE; else if (pkt_types & HCI_PKT_TYPES_MASK_DH1) pkt_size = HCI_DH1_PACKET_SIZE; else if (pkt_types & HCI_PKT_TYPES_MASK_DM1) pkt_size = HCI_DM1_PACKET_SIZE; } return (pkt_size); } /******************************************************************************* * * Function BTM_ReadRemoteVersion * * Returns If connected report peer device info * ******************************************************************************/ bool BTM_ReadRemoteVersion(const RawAddress& addr, uint8_t* lmp_version, uint16_t* manufacturer, uint16_t* lmp_sub_version) { if (bluetooth::shim::is_gd_l2cap_enabled()) { return bluetooth::shim::L2CA_ReadRemoteVersion( addr, lmp_version, manufacturer, lmp_sub_version); } const tACL_CONN* p_acl = internal_.btm_bda_to_acl(addr, BT_TRANSPORT_BR_EDR); if (p_acl == nullptr) { p_acl = internal_.btm_bda_to_acl(addr, BT_TRANSPORT_LE); if (p_acl == nullptr) { LOG_WARN("Unable to find active acl"); return false; } } if (!p_acl->remote_version_info.valid) { LOG_WARN("Remote version information is invalid"); return false; } if (lmp_version) *lmp_version = p_acl->remote_version_info.lmp_version; if (manufacturer) *manufacturer = p_acl->remote_version_info.manufacturer; if (lmp_sub_version) *lmp_sub_version = p_acl->remote_version_info.lmp_subversion; return true; } /******************************************************************************* * * Function BTM_ReadRemoteFeatures * * Returns pointer to the remote supported features mask (8 bytes) * ******************************************************************************/ uint8_t* BTM_ReadRemoteFeatures(const RawAddress& addr) { if (bluetooth::shim::is_gd_l2cap_enabled()) { return bluetooth::shim::L2CA_ReadRemoteFeatures(addr); } tACL_CONN* p = internal_.btm_bda_to_acl(addr, BT_TRANSPORT_BR_EDR); if (p == NULL) { LOG_WARN("Unable to find active acl"); return (NULL); } return (p->peer_lmp_feature_pages[0]); } /******************************************************************************* * * Function BTM_ReadRSSI * * Description This function is called to read the link policy settings. * The address of link policy results are returned in the * callback. * (tBTM_RSSI_RESULT) * * Returns BTM_CMD_STARTED if successfully initiated or error code * ******************************************************************************/ tBTM_STATUS BTM_ReadRSSI(const RawAddress& remote_bda, tBTM_CMPL_CB* p_cb) { tACL_CONN* p = NULL; tBT_DEVICE_TYPE dev_type; tBLE_ADDR_TYPE addr_type; /* If someone already waiting on the version, do not allow another */ if (btm_cb.devcb.p_rssi_cmpl_cb) return (BTM_BUSY); BTM_ReadDevInfo(remote_bda, &dev_type, &addr_type); if (dev_type & BT_DEVICE_TYPE_BLE) { p = internal_.btm_bda_to_acl(remote_bda, BT_TRANSPORT_LE); } if (p == NULL && dev_type & BT_DEVICE_TYPE_BREDR) { p = internal_.btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR); } if (p) { btm_cb.devcb.p_rssi_cmpl_cb = p_cb; alarm_set_on_mloop(btm_cb.devcb.read_rssi_timer, BTM_DEV_REPLY_TIMEOUT_MS, btm_read_rssi_timeout, NULL); btsnd_hcic_read_rssi(p->hci_handle); return (BTM_CMD_STARTED); } LOG_WARN("Unable to find active acl"); /* If here, no BD Addr found */ return (BTM_UNKNOWN_ADDR); } /******************************************************************************* * * Function BTM_ReadFailedContactCounter * * Description This function is called to read the failed contact counter. * The result is returned in the callback. * (tBTM_FAILED_CONTACT_COUNTER_RESULT) * * Returns BTM_CMD_STARTED if successfully initiated or error code * ******************************************************************************/ tBTM_STATUS BTM_ReadFailedContactCounter(const RawAddress& remote_bda, tBTM_CMPL_CB* p_cb) { tACL_CONN* p; tBT_TRANSPORT transport = BT_TRANSPORT_BR_EDR; tBT_DEVICE_TYPE dev_type; tBLE_ADDR_TYPE addr_type; /* If someone already waiting on the result, do not allow another */ if (btm_cb.devcb.p_failed_contact_counter_cmpl_cb) return (BTM_BUSY); BTM_ReadDevInfo(remote_bda, &dev_type, &addr_type); if (dev_type == BT_DEVICE_TYPE_BLE) transport = BT_TRANSPORT_LE; p = internal_.btm_bda_to_acl(remote_bda, transport); if (p != (tACL_CONN*)NULL) { btm_cb.devcb.p_failed_contact_counter_cmpl_cb = p_cb; alarm_set_on_mloop(btm_cb.devcb.read_failed_contact_counter_timer, BTM_DEV_REPLY_TIMEOUT_MS, btm_read_failed_contact_counter_timeout, NULL); btsnd_hcic_read_failed_contact_counter(p->hci_handle); return (BTM_CMD_STARTED); } LOG_WARN("Unable to find active acl"); /* If here, no BD Addr found */ return (BTM_UNKNOWN_ADDR); } /******************************************************************************* * * Function BTM_ReadTxPower * * Description This function is called to read the current * TX power of the connection. The tx power level results * are returned in the callback. * (tBTM_RSSI_RESULT) * * Returns BTM_CMD_STARTED if successfully initiated or error code * ******************************************************************************/ tBTM_STATUS BTM_ReadTxPower(const RawAddress& remote_bda, tBT_TRANSPORT transport, tBTM_CMPL_CB* p_cb) { tACL_CONN* p; #define BTM_READ_RSSI_TYPE_CUR 0x00 #define BTM_READ_RSSI_TYPE_MAX 0X01 VLOG(2) << __func__ << ": RemBdAddr: " << remote_bda; /* If someone already waiting on the version, do not allow another */ if (btm_cb.devcb.p_tx_power_cmpl_cb) return (BTM_BUSY); p = internal_.btm_bda_to_acl(remote_bda, transport); if (p != (tACL_CONN*)NULL) { btm_cb.devcb.p_tx_power_cmpl_cb = p_cb; alarm_set_on_mloop(btm_cb.devcb.read_tx_power_timer, BTM_DEV_REPLY_TIMEOUT_MS, btm_read_tx_power_timeout, NULL); if (p->transport == BT_TRANSPORT_LE) { btm_cb.devcb.read_tx_pwr_addr = remote_bda; btsnd_hcic_ble_read_adv_chnl_tx_power(); } else { btsnd_hcic_read_tx_power(p->hci_handle, BTM_READ_RSSI_TYPE_CUR); } return (BTM_CMD_STARTED); } LOG_WARN("Unable to find active acl"); /* If here, no BD Addr found */ return (BTM_UNKNOWN_ADDR); } /******************************************************************************* * * Function btm_read_tx_power_timeout * * Description Callback when reading the tx power times out. * * Returns void * ******************************************************************************/ void btm_read_tx_power_timeout(UNUSED_ATTR void* data) { tBTM_CMPL_CB* p_cb = btm_cb.devcb.p_tx_power_cmpl_cb; btm_cb.devcb.p_tx_power_cmpl_cb = NULL; if (p_cb) (*p_cb)((void*)NULL); } /******************************************************************************* * * Function btm_read_tx_power_complete * * Description This function is called when the command complete message * is received from the HCI for the read tx power request. * * Returns void * ******************************************************************************/ void btm_read_tx_power_complete(uint8_t* p, bool is_ble) { tBTM_CMPL_CB* p_cb = btm_cb.devcb.p_tx_power_cmpl_cb; tBTM_TX_POWER_RESULT result; alarm_cancel(btm_cb.devcb.read_tx_power_timer); btm_cb.devcb.p_tx_power_cmpl_cb = NULL; /* If there was a registered callback, call it */ if (p_cb) { STREAM_TO_UINT8(result.hci_status, p); if (result.hci_status == HCI_SUCCESS) { result.status = BTM_SUCCESS; if (!is_ble) { uint16_t handle; STREAM_TO_UINT16(handle, p); STREAM_TO_UINT8(result.tx_power, p); tACL_CONN* p_acl_cb = internal_.acl_get_connection_from_handle(handle); if (p_acl_cb != nullptr) { result.rem_bda = p_acl_cb->remote_addr; } } else { STREAM_TO_UINT8(result.tx_power, p); result.rem_bda = btm_cb.devcb.read_tx_pwr_addr; } LOG_DEBUG("Transmit power complete: tx_power:%d hci status:%s", result.tx_power, hci_error_code_text(static_cast(result.hci_status)) .c_str()); } else { result.status = BTM_ERR_PROCESSING; } (*p_cb)(&result); } } /******************************************************************************* * * Function btm_read_rssi_timeout * * Description Callback when reading the RSSI times out. * * Returns void * ******************************************************************************/ void btm_read_rssi_timeout(UNUSED_ATTR void* data) { tBTM_RSSI_RESULT result; tBTM_CMPL_CB* p_cb = btm_cb.devcb.p_rssi_cmpl_cb; btm_cb.devcb.p_rssi_cmpl_cb = NULL; result.status = BTM_DEVICE_TIMEOUT; if (p_cb) (*p_cb)(&result); } /******************************************************************************* * * Function btm_read_rssi_complete * * Description This function is called when the command complete message * is received from the HCI for the read rssi request. * * Returns void * ******************************************************************************/ void btm_read_rssi_complete(uint8_t* p) { tBTM_CMPL_CB* p_cb = btm_cb.devcb.p_rssi_cmpl_cb; tBTM_RSSI_RESULT result; alarm_cancel(btm_cb.devcb.read_rssi_timer); btm_cb.devcb.p_rssi_cmpl_cb = NULL; /* If there was a registered callback, call it */ if (p_cb) { STREAM_TO_UINT8(result.hci_status, p); result.status = BTM_ERR_PROCESSING; if (result.hci_status == HCI_SUCCESS) { uint16_t handle; STREAM_TO_UINT16(handle, p); STREAM_TO_UINT8(result.rssi, p); LOG_DEBUG("Read rrsi complete rssi:%hhd hci status:%s", result.rssi, hci_error_code_text(static_cast(result.hci_status)) .c_str()); tACL_CONN* p_acl_cb = internal_.acl_get_connection_from_handle(handle); if (p_acl_cb != nullptr) { result.rem_bda = p_acl_cb->remote_addr; result.status = BTM_SUCCESS; } } (*p_cb)(&result); } } /******************************************************************************* * * Function btm_read_failed_contact_counter_timeout * * Description Callback when reading the failed contact counter times out. * * Returns void * ******************************************************************************/ void btm_read_failed_contact_counter_timeout(UNUSED_ATTR void* data) { tBTM_FAILED_CONTACT_COUNTER_RESULT result; tBTM_CMPL_CB* p_cb = btm_cb.devcb.p_failed_contact_counter_cmpl_cb; btm_cb.devcb.p_failed_contact_counter_cmpl_cb = NULL; result.status = BTM_DEVICE_TIMEOUT; if (p_cb) (*p_cb)(&result); } /******************************************************************************* * * Function btm_read_failed_contact_counter_complete * * Description This function is called when the command complete message * is received from the HCI for the read failed contact * counter request. * * Returns void * ******************************************************************************/ void btm_read_failed_contact_counter_complete(uint8_t* p) { tBTM_CMPL_CB* p_cb = btm_cb.devcb.p_failed_contact_counter_cmpl_cb; tBTM_FAILED_CONTACT_COUNTER_RESULT result; alarm_cancel(btm_cb.devcb.read_failed_contact_counter_timer); btm_cb.devcb.p_failed_contact_counter_cmpl_cb = NULL; /* If there was a registered callback, call it */ if (p_cb) { uint16_t handle; STREAM_TO_UINT8(result.hci_status, p); if (result.hci_status == HCI_SUCCESS) { result.status = BTM_SUCCESS; STREAM_TO_UINT16(handle, p); STREAM_TO_UINT16(result.failed_contact_counter, p); LOG_DEBUG( "Failed contact counter complete: counter %u, hci status:%s", result.failed_contact_counter, hci_status_code_text(to_hci_status_code(result.hci_status)).c_str()); tACL_CONN* p_acl_cb = internal_.acl_get_connection_from_handle(handle); if (p_acl_cb != nullptr) { result.rem_bda = p_acl_cb->remote_addr; } } else { result.status = BTM_ERR_PROCESSING; } (*p_cb)(&result); } } /******************************************************************************* * * Function btm_read_automatic_flush_timeout_complete * * Description This function is called when the command complete message * is received from the HCI for the read automatic flush * timeout request. * * Returns void * ******************************************************************************/ void btm_read_automatic_flush_timeout_complete(uint8_t* p) { tBTM_CMPL_CB* p_cb = btm_cb.devcb.p_automatic_flush_timeout_cmpl_cb; tBTM_AUTOMATIC_FLUSH_TIMEOUT_RESULT result; alarm_cancel(btm_cb.devcb.read_automatic_flush_timeout_timer); btm_cb.devcb.p_automatic_flush_timeout_cmpl_cb = nullptr; /* If there was a registered callback, call it */ if (p_cb) { uint16_t handle; STREAM_TO_UINT8(result.hci_status, p); result.status = BTM_ERR_PROCESSING; if (result.hci_status == HCI_SUCCESS) { result.status = BTM_SUCCESS; STREAM_TO_UINT16(handle, p); STREAM_TO_UINT16(result.automatic_flush_timeout, p); LOG_DEBUG( "Read automatic flush timeout complete timeout:%hu hci_status:%s", result.automatic_flush_timeout, hci_error_code_text(static_cast(result.hci_status)) .c_str()); tACL_CONN* p_acl_cb = internal_.acl_get_connection_from_handle(handle); if (p_acl_cb != nullptr) { result.rem_bda = p_acl_cb->remote_addr; } } (*p_cb)(&result); } } /******************************************************************************* * * Function btm_read_link_quality_timeout * * Description Callback when reading the link quality times out. * * Returns void * ******************************************************************************/ void btm_read_link_quality_timeout(UNUSED_ATTR void* data) { tBTM_CMPL_CB* p_cb = btm_cb.devcb.p_link_qual_cmpl_cb; btm_cb.devcb.p_link_qual_cmpl_cb = NULL; if (p_cb) (*p_cb)((void*)NULL); } /******************************************************************************* * * Function btm_read_link_quality_complete * * Description This function is called when the command complete message * is received from the HCI for the read link quality. * * Returns void * ******************************************************************************/ void btm_read_link_quality_complete(uint8_t* p) { tBTM_CMPL_CB* p_cb = btm_cb.devcb.p_link_qual_cmpl_cb; tBTM_LINK_QUALITY_RESULT result; alarm_cancel(btm_cb.devcb.read_link_quality_timer); btm_cb.devcb.p_link_qual_cmpl_cb = NULL; /* If there was a registered callback, call it */ if (p_cb) { STREAM_TO_UINT8(result.hci_status, p); if (result.hci_status == HCI_SUCCESS) { uint16_t handle; result.status = BTM_SUCCESS; STREAM_TO_UINT16(handle, p); STREAM_TO_UINT8(result.link_quality, p); LOG_DEBUG("BTM Link Quality Complete: Link Quality %d, hci status:%s", result.link_quality, hci_error_code_text(static_cast(result.hci_status)) .c_str()); tACL_CONN* p_acl_cb = internal_.acl_get_connection_from_handle(handle); if (p_acl_cb != nullptr) { result.rem_bda = p_acl_cb->remote_addr; } } else { result.status = BTM_ERR_PROCESSING; } (*p_cb)(&result); } } /******************************************************************************* * * Function btm_remove_acl * * Description This function is called to disconnect an ACL connection * * Returns BTM_SUCCESS if successfully initiated, otherwise * BTM_NO_RESOURCES. * ******************************************************************************/ tBTM_STATUS btm_remove_acl(const RawAddress& bd_addr, tBT_TRANSPORT transport) { if (bluetooth::shim::is_gd_l2cap_enabled()) { if (transport == BT_TRANSPORT_LE) { LOG(ERROR) << __func__ << ": Unsupported"; } bluetooth::shim::L2CA_DisconnectLink(bd_addr); return BTM_SUCCESS; } tACL_CONN* p_acl = internal_.btm_bda_to_acl(bd_addr, transport); if (p_acl == nullptr) { LOG_WARN("Unable to find active acl"); return BTM_UNKNOWN_ADDR; } if (p_acl->Handle() == HCI_INVALID_HANDLE) { LOG_WARN("Cannot remove unknown acl bd_addr:%s transport:%s", PRIVATE_ADDRESS(bd_addr), bt_transport_text(transport).c_str()); return BTM_UNKNOWN_ADDR; } if (p_acl->rs_disc_pending == BTM_SEC_RS_PENDING) { LOG_DEBUG( "Delay disconnect until role switch is complete bd_addr:%s " "transport:%s", PRIVATE_ADDRESS(bd_addr), bt_transport_text(transport).c_str()); p_acl->rs_disc_pending = BTM_SEC_DISC_PENDING; return BTM_SUCCESS; } hci_btsnd_hcic_disconnect(*p_acl, HCI_ERR_PEER_USER); return BTM_SUCCESS; } /******************************************************************************* * * Function BTM_SetTraceLevel * * Description This function sets the trace level for BTM. If called with * a value of 0xFF, it simply returns the current trace level. * * Returns The new or current trace level * ******************************************************************************/ uint8_t BTM_SetTraceLevel(uint8_t new_level) { if (new_level != 0xFF) btm_cb.trace_level = new_level; return (btm_cb.trace_level); } void btm_cont_rswitch_from_handle(uint16_t hci_handle) { tACL_CONN* p = internal_.acl_get_connection_from_handle(hci_handle); if (p == nullptr) { LOG_WARN("Role switch received but with no active ACL"); return; } /* Check to see if encryption needs to be turned off if pending change of link key or role switch */ if (p->is_switch_role_mode_change()) { /* Must turn off Encryption first if necessary */ /* Some devices do not support switch or change of link key while encryption * is on */ if (p->is_encrypted && !IsEprAvailable(*p)) { p->set_encryption_off(); if (p->is_switch_role_mode_change()) { p->set_switch_role_encryption_off(); } } else /* Encryption not used or EPR supported, continue with switch and/or change of link key */ { if (p->is_switch_role_mode_change()) { internal_.hci_start_role_switch_to_central(*p); } } } } /******************************************************************************* * * Function btm_acl_resubmit_page * * Description send pending page request * ******************************************************************************/ void btm_acl_resubmit_page(void) { BT_HDR* p_buf; uint8_t* pp; /* If there were other page request schedule can start the next one */ p_buf = (BT_HDR*)fixed_queue_try_dequeue(btm_cb.page_queue); if (p_buf != NULL) { /* skip 3 (2 bytes opcode and 1 byte len) to get to the bd_addr * for both create_conn and rmt_name */ pp = (uint8_t*)(p_buf + 1) + p_buf->offset + 3; RawAddress bda; STREAM_TO_BDADDR(bda, pp); btm_cb.connecting_bda = bda; memcpy(btm_cb.connecting_dc, btm_get_dev_class(bda), DEV_CLASS_LEN); btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p_buf); } else { btm_cb.paging = false; } } /******************************************************************************* * * Function btm_acl_reset_paging * * Description set paging to false and free the page queue - called at * hci_reset * ******************************************************************************/ void btm_acl_reset_paging(void) { BT_HDR* p; /* If we sent reset we are definitely not paging any more */ while ((p = (BT_HDR*)fixed_queue_try_dequeue(btm_cb.page_queue)) != NULL) osi_free(p); btm_cb.paging = false; } /******************************************************************************* * * Function btm_acl_paging * * Description send a paging command or queue it in btm_cb * ******************************************************************************/ void btm_acl_paging(BT_HDR* p, const RawAddress& bda) { // This function is called by the device initiating the connection. // If no role change is requested from the remote device, we want // to classify the connection initiator as the central device. if (delayed_role_change_ == nullptr) { RoleChangeView role_change; role_change.bd_addr = bda; role_change.new_role = HCI_ROLE_CENTRAL; delayed_role_change_ = std::make_unique(std::move(role_change)); } if (!BTM_IsAclConnectionUp(bda, BT_TRANSPORT_BR_EDR)) { VLOG(1) << "connecting_bda: " << btm_cb.connecting_bda; if (btm_cb.paging && bda == btm_cb.connecting_bda) { fixed_queue_enqueue(btm_cb.page_queue, p); } else { btm_cb.connecting_bda = bda; memcpy(btm_cb.connecting_dc, btm_get_dev_class(bda), DEV_CLASS_LEN); btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p); } btm_cb.paging = true; } else /* ACL is already up */ { btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p); } } /******************************************************************************* * * Function btm_acl_notif_conn_collision * * Description Send connection collision event to upper layer if registered * * ******************************************************************************/ void btm_acl_notif_conn_collision(const RawAddress& bda) { do_in_main_thread(FROM_HERE, base::Bind(bta_sys_notify_collision, bda)); } bool BTM_BLE_IS_RESOLVE_BDA(const RawAddress& x) { return ((x.address)[0] & BLE_RESOLVE_ADDR_MASK) == BLE_RESOLVE_ADDR_MSB; } bool acl_refresh_remote_address(const RawAddress& identity_address, tBLE_ADDR_TYPE identity_address_type, const RawAddress& bda, tBLE_ADDR_TYPE rra_type, const RawAddress& rpa) { tACL_CONN* p_acl = internal_.btm_bda_to_acl(bda, BT_TRANSPORT_LE); if (p_acl == nullptr) { LOG_WARN("Unable to find active acl"); return false; } if (rra_type == tBTM_SEC_BLE::BTM_BLE_ADDR_PSEUDO) { /* use identity address, resolvable_private_addr is empty */ if (rpa.IsEmpty()) { p_acl->active_remote_addr_type = identity_address_type; p_acl->active_remote_addr = identity_address; } else { p_acl->active_remote_addr_type = BLE_ADDR_RANDOM; p_acl->active_remote_addr = rpa; } } else { p_acl->active_remote_addr_type = rra_type; p_acl->active_remote_addr = rpa; } LOG_DEBUG("active_remote_addr_type: %d ", p_acl->active_remote_addr_type); return true; } bool acl_peer_supports_ble_connection_parameters_request( const RawAddress& remote_bda) { tACL_CONN* p_acl = internal_.btm_bda_to_acl(remote_bda, BT_TRANSPORT_LE); if (p_acl == nullptr) { LOG_WARN("Unable to find active acl"); return false; } if (!p_acl->peer_le_features_valid) { LOG_WARN( "Checking remote features but remote feature read is " "incomplete"); } return HCI_LE_CONN_PARAM_REQ_SUPPORTED(p_acl->peer_le_features); } bool acl_peer_supports_sniff_subrating(const RawAddress& remote_bda) { tACL_CONN* p_acl = internal_.btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR); if (p_acl == nullptr) { LOG_WARN("Unable to find active acl"); return false; } if (!p_acl->peer_lmp_feature_valid[0]) { LOG_WARN( "Checking remote features but remote feature read is " "incomplete"); } return HCI_SNIFF_SUB_RATE_SUPPORTED(p_acl->peer_lmp_feature_pages[0]); } /******************************************************************************* * * Function BTM_ReadConnectionAddr * * Description This function is called to get the local device address * information. * * Returns void * ******************************************************************************/ void BTM_ReadConnectionAddr(const RawAddress& remote_bda, RawAddress& local_conn_addr, tBLE_ADDR_TYPE* p_addr_type) { if (bluetooth::shim::is_gd_shim_enabled()) { return bluetooth::shim::BTM_ReadConnectionAddr(remote_bda, local_conn_addr, p_addr_type); } if (bluetooth::shim::is_gd_l2cap_enabled()) { bluetooth::shim::L2CA_ReadConnectionAddr(remote_bda, local_conn_addr, p_addr_type); return; } else if (bluetooth::shim::is_gd_scanning_enabled()) { bluetooth::shim::ACL_ReadConnectionAddress(remote_bda, local_conn_addr, p_addr_type); return; } tACL_CONN* p_acl = internal_.btm_bda_to_acl(remote_bda, BT_TRANSPORT_LE); if (p_acl == NULL) { LOG_WARN("Unable to find active acl"); return; } local_conn_addr = p_acl->conn_addr; *p_addr_type = p_acl->conn_addr_type; LOG_DEBUG("BTM_ReadConnectionAddr address type: %d addr: 0x%02x", p_acl->conn_addr_type, p_acl->conn_addr.address[0]); } /******************************************************************************* * * Function BTM_IsBleConnection * * Description This function is called to check if the connection handle * for an LE link * * Returns true if connection is LE link, otherwise false. * ******************************************************************************/ bool BTM_IsBleConnection(uint16_t hci_handle) { if (bluetooth::shim::is_gd_shim_enabled()) { ASSERT_LOG(false, "This should not be invoked from code path"); } if (bluetooth::shim::is_gd_l2cap_enabled()) { return bluetooth::shim::L2CA_IsLeLink(hci_handle); } const tACL_CONN* p_acl = internal_.acl_get_connection_from_handle(hci_handle); if (p_acl == nullptr) return false; return p_acl->is_transport_ble(); } const RawAddress acl_address_from_handle(uint16_t handle) { tACL_CONN* p_acl = acl_get_connection_from_handle(handle); if (p_acl == nullptr) { return RawAddress::kEmpty; } return p_acl->remote_addr; } /******************************************************************************* * * Function btm_ble_refresh_local_resolvable_private_addr * * Description This function refresh the currently used resolvable private * address for the active link to the remote device * ******************************************************************************/ void btm_ble_refresh_local_resolvable_private_addr( const RawAddress& pseudo_addr, const RawAddress& local_rpa) { tACL_CONN* p_acl = internal_.btm_bda_to_acl(pseudo_addr, BT_TRANSPORT_LE); if (p_acl == nullptr) { LOG_WARN("Unable to find active acl"); return; } if (btm_cb.ble_ctr_cb.privacy_mode == BTM_PRIVACY_NONE) { p_acl->conn_addr_type = BLE_ADDR_PUBLIC; p_acl->conn_addr = *controller_get_interface()->get_address(); } else { p_acl->conn_addr_type = BLE_ADDR_RANDOM; if (local_rpa.IsEmpty()) { p_acl->conn_addr = btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr; } else { p_acl->conn_addr = local_rpa; } } } bool sco_peer_supports_esco_2m_phy(const RawAddress& remote_bda) { uint8_t* features = BTM_ReadRemoteFeatures(remote_bda); if (features == nullptr) { LOG_WARN( "Checking remote features but remote feature read is " "incomplete"); return false; } return HCI_EDR_ESCO_2MPS_SUPPORTED(features); } bool sco_peer_supports_esco_3m_phy(const RawAddress& remote_bda) { uint8_t* features = BTM_ReadRemoteFeatures(remote_bda); if (features == nullptr) { LOG_WARN( "Checking remote features but remote feature read is " "incomplete"); return false; } return HCI_EDR_ESCO_3MPS_SUPPORTED(features); } bool acl_is_switch_role_idle(const RawAddress& bd_addr, tBT_TRANSPORT transport) { tACL_CONN* p_acl = internal_.btm_bda_to_acl(bd_addr, transport); if (p_acl == nullptr) { LOG_WARN("Unable to find active acl"); return false; } return p_acl->is_switch_role_idle(); } /******************************************************************************* * * Function BTM_ReadRemoteConnectionAddr * * Description This function is read the remote device address currently used * * Parameters pseudo_addr: pseudo random address available * conn_addr:connection address used * p_addr_type : BD Address type, Public or Random of the address * used * * Returns bool, true if connection to remote device exists, else false * ******************************************************************************/ bool BTM_ReadRemoteConnectionAddr(const RawAddress& pseudo_addr, RawAddress& conn_addr, tBLE_ADDR_TYPE* p_addr_type) { if (bluetooth::shim::is_gd_shim_enabled()) { return bluetooth::shim::BTM_ReadRemoteConnectionAddr(pseudo_addr, conn_addr, p_addr_type); } if (bluetooth::shim::is_gd_l2cap_enabled()) { return bluetooth::shim::L2CA_ReadRemoteConnectionAddr( pseudo_addr, conn_addr, p_addr_type); } bool st = true; tACL_CONN* p_acl = internal_.btm_bda_to_acl(pseudo_addr, BT_TRANSPORT_LE); if (p_acl == NULL) { LOG_WARN("Unable to find active acl"); return false; } conn_addr = p_acl->active_remote_addr; *p_addr_type = p_acl->active_remote_addr_type; return st; } uint8_t acl_link_role_from_handle(uint16_t handle) { tACL_CONN* p_acl = internal_.acl_get_connection_from_handle(handle); if (p_acl == nullptr) { return HCI_ROLE_UNKNOWN; } return p_acl->link_role; } bool acl_peer_supports_ble_packet_extension(uint16_t hci_handle) { tACL_CONN* p_acl = internal_.acl_get_connection_from_handle(hci_handle); if (p_acl == nullptr) { return false; } if (!p_acl->peer_le_features_valid) { LOG_WARN( "Checking remote features but remote feature read is " "incomplete"); } return HCI_LE_DATA_LEN_EXT_SUPPORTED(p_acl->peer_le_features); } bool acl_peer_supports_ble_2m_phy(uint16_t hci_handle) { tACL_CONN* p_acl = internal_.acl_get_connection_from_handle(hci_handle); if (p_acl == nullptr) { return false; } if (!p_acl->peer_le_features_valid) { LOG_WARN( "Checking remote features but remote feature read is " "incomplete"); } return HCI_LE_2M_PHY_SUPPORTED(p_acl->peer_le_features); } bool acl_peer_supports_ble_coded_phy(uint16_t hci_handle) { tACL_CONN* p_acl = internal_.acl_get_connection_from_handle(hci_handle); if (p_acl == nullptr) { return false; } if (!p_acl->peer_le_features_valid) { LOG_WARN( "Checking remote features but remote feature read is " "incomplete"); return false; } return HCI_LE_CODED_PHY_SUPPORTED(p_acl->peer_le_features); } void acl_set_disconnect_reason(tHCI_STATUS acl_disc_reason) { btm_cb.acl_cb_.set_disconnect_reason(acl_disc_reason); } bool acl_is_role_switch_allowed() { return btm_cb.acl_cb_.DefaultLinkPolicy() & HCI_ENABLE_CENTRAL_PERIPHERAL_SWITCH; } uint16_t acl_get_supported_packet_types() { return btm_cb.acl_cb_.DefaultPacketTypes(); } bool acl_set_peer_le_features_from_handle(uint16_t hci_handle, const uint8_t* p) { tACL_CONN* p_acl = internal_.acl_get_connection_from_handle(hci_handle); if (p_acl == nullptr) { return false; } STREAM_TO_ARRAY(p_acl->peer_le_features, p, BD_FEATURES_LEN); p_acl->peer_le_features_valid = true; LOG_DEBUG("Completed le feature read request"); return true; } void on_acl_br_edr_connected(const RawAddress& bda, uint16_t handle, uint8_t enc_mode) { if (delayed_role_change_ != nullptr && delayed_role_change_->bd_addr == bda) { btm_sec_connected(bda, handle, HCI_SUCCESS, enc_mode, delayed_role_change_->new_role); } else { btm_sec_connected(bda, handle, HCI_SUCCESS, enc_mode); } delayed_role_change_ = nullptr; btm_acl_set_paging(false); l2c_link_hci_conn_comp(HCI_SUCCESS, handle, bda); constexpr uint16_t link_supervision_timeout = 8000; BTM_SetLinkSuperTout(bda, link_supervision_timeout); tACL_CONN* p_acl = internal_.acl_get_connection_from_handle(handle); if (p_acl == nullptr) { LOG_WARN("Unable to find active acl"); return; } /* * The legacy code path informs the upper layer via the BTA * layer after all relevant read_remote_ commands are complete. * The GD code path has ownership of the read_remote_ commands * and thus may inform the upper layers about the connection. */ if (bluetooth::shim::is_gd_acl_enabled()) { NotifyAclLinkUp(*p_acl); } } void on_acl_br_edr_failed(const RawAddress& bda, tHCI_STATUS status) { ASSERT_LOG(status != HCI_SUCCESS, "Successful connection entering failing code path"); if (delayed_role_change_ != nullptr && delayed_role_change_->bd_addr == bda) { btm_sec_connected(bda, HCI_INVALID_HANDLE, status, false, delayed_role_change_->new_role); } else { btm_sec_connected(bda, HCI_INVALID_HANDLE, status, false); } delayed_role_change_ = nullptr; btm_acl_set_paging(false); l2c_link_hci_conn_comp(status, HCI_INVALID_HANDLE, bda); } void btm_acl_connected(const RawAddress& bda, uint16_t handle, tHCI_STATUS status, uint8_t enc_mode) { switch (status) { case HCI_SUCCESS: return on_acl_br_edr_connected(bda, handle, enc_mode); default: return on_acl_br_edr_failed(bda, status); } } void btm_acl_disconnected(tHCI_STATUS status, uint16_t handle, tHCI_REASON reason) { if (status != HCI_SUCCESS) { LOG_WARN("Received disconnect with error:%s", hci_error_code_text(status).c_str()); } /* There can be a case when we rejected PIN code authentication */ /* otherwise save a new reason */ if (btm_get_acl_disc_reason_code() != HCI_ERR_HOST_REJECT_SECURITY) { acl_set_disconnect_reason(static_cast(reason)); } /* If L2CAP or SCO doesn't know about it, send it to ISO */ if (!l2c_link_hci_disc_comp(handle, reason) && !btm_sco_removed(handle, reason)) { bluetooth::hci::IsoManager::GetInstance()->HandleDisconnect(handle, reason); } /* Notify security manager */ btm_sec_disconnected(handle, reason); } constexpr uint16_t kDefaultPacketTypes = HCI_PKT_TYPES_MASK_DM1 | HCI_PKT_TYPES_MASK_DH1 | HCI_PKT_TYPES_MASK_DM3 | HCI_PKT_TYPES_MASK_DH3 | HCI_PKT_TYPES_MASK_DM5 | HCI_PKT_TYPES_MASK_DH5; void acl_create_classic_connection(const RawAddress& bd_addr, bool there_are_high_priority_channels, bool is_bonding) { if (bluetooth::shim::is_gd_acl_enabled()) { return bluetooth::shim::ACL_CreateClassicConnection(bd_addr); } const bool controller_supports_role_switch = controller_get_interface()->supports_role_switch(); const bool acl_allows_role_switch = acl_is_role_switch_allowed(); /* FW team says that we can participant in 4 piconets * typically 3 piconet + 1 for scanning. * We can enhance the code to count the number of piconets later. */ uint8_t allow_role_switch = HCI_CR_CONN_NOT_ALLOW_SWITCH; if (((acl_allows_role_switch && (BTM_GetNumAclLinks() < 3)) || (is_bonding && !there_are_high_priority_channels && controller_supports_role_switch))) allow_role_switch = HCI_CR_CONN_ALLOW_SWITCH; /* Check with the BT manager if details about remote device are known */ uint8_t page_scan_rep_mode{HCI_PAGE_SCAN_REP_MODE_R1}; uint8_t page_scan_mode{HCI_MANDATARY_PAGE_SCAN_MODE}; uint16_t clock_offset = BTM_GetClockOffset(bd_addr); tBTM_INQ_INFO* p_inq_info = BTM_InqDbRead(bd_addr); if (p_inq_info != nullptr && (p_inq_info->results.inq_result_type & BTM_INQ_RESULT_BR)) { page_scan_rep_mode = p_inq_info->results.page_scan_rep_mode; page_scan_mode = p_inq_info->results.page_scan_mode; clock_offset = p_inq_info->results.clock_offset; } btsnd_hcic_create_conn(bd_addr, kDefaultPacketTypes, page_scan_rep_mode, page_scan_mode, clock_offset, allow_role_switch); btm_acl_set_paging(true); } void btm_acl_connection_request(const RawAddress& bda, uint8_t* dc) { btm_sec_conn_req(bda, dc); l2c_link_hci_conn_req(bda); } void acl_accept_connection_request(const RawAddress& bd_addr, uint8_t role) { btsnd_hcic_accept_conn(bd_addr, role); } void acl_reject_connection_request(const RawAddress& bd_addr, uint8_t reason) { btsnd_hcic_reject_conn(bd_addr, reason); } void acl_disconnect_from_handle(uint16_t handle, tHCI_STATUS reason) { acl_disconnect_after_role_switch(handle, reason); } void acl_disconnect_after_role_switch(uint16_t conn_handle, tHCI_STATUS reason) { tACL_CONN* p_acl = internal_.acl_get_connection_from_handle(conn_handle); if (p_acl == nullptr) { LOG_ERROR("Sending disconnect for unknown acl:%hu PLEASE FIX", conn_handle); GetLegacyHciInterface().Disconnect(conn_handle, reason); return; } /* If a role switch is in progress, delay the HCI Disconnect to avoid * controller problem */ if (p_acl->rs_disc_pending == BTM_SEC_RS_PENDING) { LOG_DEBUG( "Role switch in progress - Set DISC Pending flag in " "btm_sec_send_hci_disconnect " "to delay disconnect"); p_acl->rs_disc_pending = BTM_SEC_DISC_PENDING; } else { LOG_DEBUG("Sending acl disconnect reason:%s [%hu]", hci_error_code_text(reason).c_str(), reason); hci_btsnd_hcic_disconnect(*p_acl, reason); } } constexpr uint16_t kDataPacketEventBrEdr = (BT_EVT_TO_LM_HCI_ACL); constexpr uint16_t kDataPacketEventBle = (BT_EVT_TO_LM_HCI_ACL | LOCAL_BLE_CONTROLLER_ID); void acl_send_data_packet_br_edr(const RawAddress& bd_addr, BT_HDR* p_buf) { if (bluetooth::shim::is_gd_acl_enabled()) { tACL_CONN* p_acl = internal_.btm_bda_to_acl(bd_addr, BT_TRANSPORT_BR_EDR); if (p_acl == nullptr) { LOG_WARN("Acl br_edr data write for unknown device:%s", PRIVATE_ADDRESS(bd_addr)); osi_free(p_buf); return; } return bluetooth::shim::ACL_WriteData(p_acl->hci_handle, p_buf); } bte_main_hci_send(p_buf, kDataPacketEventBrEdr); } void acl_send_data_packet_ble(const RawAddress& bd_addr, BT_HDR* p_buf) { if (bluetooth::shim::is_gd_acl_enabled()) { tACL_CONN* p_acl = internal_.btm_bda_to_acl(bd_addr, BT_TRANSPORT_LE); if (p_acl == nullptr) { LOG_WARN("Acl le data write for unknown device:%s", PRIVATE_ADDRESS(bd_addr)); osi_free(p_buf); return; } return bluetooth::shim::ACL_WriteData(p_acl->hci_handle, p_buf); } bte_main_hci_send(p_buf, kDataPacketEventBle); } void acl_write_automatic_flush_timeout(const RawAddress& bd_addr, uint16_t flush_timeout_in_ticks) { tACL_CONN* p_acl = internal_.btm_bda_to_acl(bd_addr, BT_TRANSPORT_BR_EDR); if (p_acl == nullptr) { LOG_WARN("Unable to find active acl"); return; } if (p_acl->flush_timeout_in_ticks == flush_timeout_in_ticks) { LOG_INFO( "Ignoring since cached value is same as requested flush_timeout:%hd", flush_timeout_in_ticks); return; } flush_timeout_in_ticks &= HCI_MAX_AUTOMATIC_FLUSH_TIMEOUT; p_acl->flush_timeout_in_ticks = flush_timeout_in_ticks; btsnd_hcic_write_auto_flush_tout(p_acl->hci_handle, flush_timeout_in_ticks); } bool acl_create_le_connection_with_id(uint8_t id, const RawAddress& bd_addr) { if (bluetooth::shim::is_gd_acl_enabled()) { tBLE_BD_ADDR address_with_type{ .bda = bd_addr, .type = BLE_ADDR_RANDOM, }; gatt_find_in_device_record(bd_addr, &address_with_type); LOG_DEBUG("Creating le connection to:%s", address_with_type.ToString().c_str()); bluetooth::shim::ACL_AcceptLeConnectionFrom(address_with_type, /* is_direct */ true); return true; } return connection_manager::direct_connect_add(id, bd_addr); } bool acl_create_le_connection(const RawAddress& bd_addr) { return acl_create_le_connection_with_id(CONN_MGR_ID_L2CAP, bd_addr); } void acl_rcv_acl_data(BT_HDR* p_msg) { acl_header_t acl_header{ .handle = HCI_INVALID_HANDLE, .hci_len = 0, }; const uint8_t* p = (uint8_t*)(p_msg + 1) + p_msg->offset; STREAM_TO_UINT16(acl_header.handle, p); acl_header.handle = HCID_GET_HANDLE(acl_header.handle); STREAM_TO_UINT16(acl_header.hci_len, p); if (acl_header.hci_len < L2CAP_PKT_OVERHEAD || acl_header.hci_len != p_msg->len - sizeof(acl_header)) { LOG_WARN("Received mismatched hci header length:%u data_len:%zu", acl_header.hci_len, p_msg->len - sizeof(acl_header)); osi_free(p_msg); return; } l2c_rcv_acl_data(p_msg); } void acl_link_segments_xmitted(BT_HDR* p_msg) { l2c_link_segments_xmitted(p_msg); } void acl_packets_completed(uint16_t handle, uint16_t credits) { l2c_packets_completed(handle, credits); } static void acl_parse_num_completed_pkts(uint8_t* p, uint8_t evt_len) { if (evt_len == 0) { LOG_ERROR("Received num completed packets with zero length"); return; } uint8_t num_handles{0}; STREAM_TO_UINT8(num_handles, p); if (num_handles > evt_len / (2 * sizeof(uint16_t))) { android_errorWriteLog(0x534e4554, "141617601"); num_handles = evt_len / (2 * sizeof(uint16_t)); } for (uint8_t xx = 0; xx < num_handles; xx++) { uint16_t handle{0}; uint16_t num_packets{0}; STREAM_TO_UINT16(handle, p); handle = HCID_GET_HANDLE(handle); STREAM_TO_UINT16(num_packets, p); acl_packets_completed(handle, num_packets); } } void acl_process_num_completed_pkts(uint8_t* p, uint8_t evt_len) { if (bluetooth::shim::is_gd_acl_enabled()) { acl_parse_num_completed_pkts(p, evt_len); } else { l2c_link_process_num_completed_pkts(p, evt_len); } bluetooth::hci::IsoManager::GetInstance()->HandleNumComplDataPkts(p, evt_len); } void acl_process_supported_features(uint16_t handle, uint64_t features) { ASSERT_LOG(bluetooth::shim::is_gd_acl_enabled(), "Should only be called when gd_acl enabled"); tACL_CONN* p_acl = internal_.acl_get_connection_from_handle(handle); if (p_acl == nullptr) { LOG_WARN("Unable to find active acl"); return; } const uint8_t current_page_number = 0; memcpy(p_acl->peer_lmp_feature_pages[current_page_number], (uint8_t*)&features, sizeof(uint64_t)); p_acl->peer_lmp_feature_valid[current_page_number] = true; LOG_DEBUG( "Copied supported feature pages handle:%hu current_page_number:%hhu " "features:%s", handle, current_page_number, bd_features_text(p_acl->peer_lmp_feature_pages[current_page_number]) .c_str()); if ((HCI_LMP_EXTENDED_SUPPORTED(p_acl->peer_lmp_feature_pages[0])) && (controller_get_interface() ->supports_reading_remote_extended_features())) { LOG_DEBUG("Waiting for remote extended feature response to arrive"); } else { LOG_DEBUG("No more remote features outstanding so notify upper layer"); NotifyAclFeaturesReadComplete(*p_acl, current_page_number); } } void acl_process_extended_features(uint16_t handle, uint8_t current_page_number, uint8_t max_page_number, uint64_t features) { ASSERT_LOG(bluetooth::shim::is_gd_acl_enabled(), "Should only be called when gd_acl enabled"); if (current_page_number > HCI_EXT_FEATURES_PAGE_MAX) { LOG_WARN("Unable to process current_page_number:%hhu", current_page_number); return; } tACL_CONN* p_acl = internal_.acl_get_connection_from_handle(handle); if (p_acl == nullptr) { LOG_WARN("Unable to find active acl"); return; } memcpy(p_acl->peer_lmp_feature_pages[current_page_number], (uint8_t*)&features, sizeof(uint64_t)); p_acl->peer_lmp_feature_valid[current_page_number] = true; LOG_DEBUG( "Copied extended feature pages handle:%hu current_page_number:%hhu " "max_page_number:%hhu features:%s", handle, current_page_number, max_page_number, bd_features_text(p_acl->peer_lmp_feature_pages[current_page_number]) .c_str()); if (max_page_number == current_page_number) { NotifyAclFeaturesReadComplete(*p_acl, max_page_number); } } void ACL_RegisterClient(struct acl_client_callback_s* callbacks) { LOG_DEBUG("UNIMPLEMENTED"); } void ACL_UnregisterClient(struct acl_client_callback_s* callbacks) { LOG_DEBUG("UNIMPLEMENTED"); } bool ACL_SupportTransparentSynchronousData(const RawAddress& bd_addr) { const tACL_CONN* p_acl = internal_.btm_bda_to_acl(bd_addr, BT_TRANSPORT_BR_EDR); if (p_acl == nullptr) { LOG_WARN("Unable to find active acl"); return false; } return HCI_LMP_TRANSPNT_SUPPORTED(p_acl->peer_lmp_feature_pages[0]); } void acl_add_to_ignore_auto_connect_after_disconnect( const RawAddress& bd_addr) { btm_cb.acl_cb_.AddToIgnoreAutoConnectAfterDisconnect(bd_addr); } bool acl_check_and_clear_ignore_auto_connect_after_disconnect( const RawAddress& bd_addr) { return btm_cb.acl_cb_.CheckAndClearIgnoreAutoConnectAfterDisconnect(bd_addr); } void acl_clear_all_ignore_auto_connect_after_disconnect() { btm_cb.acl_cb_.ClearAllIgnoreAutoConnectAfterDisconnect(); } /** * Confusingly, immutable device features are stored in the * ephemeral connection data structure while connection security * is stored in the device record. * * This HACK allows legacy security protocols to work as intended under * those conditions. */ void HACK_acl_check_sm4(tBTM_SEC_DEV_REC& record) { // Return if we already know this info if ((record.sm4 & BTM_SM4_TRUE) != BTM_SM4_UNKNOWN) return; tACL_CONN* p_acl = internal_.btm_bda_to_acl(record.RemoteAddress(), BT_TRANSPORT_BR_EDR); if (p_acl == nullptr) { LOG_WARN("Unable to find active acl for authentication device:%s", PRIVATE_ADDRESS(record.RemoteAddress())); } // If we have not received the SSP feature record // we have to wait if (!p_acl->peer_lmp_feature_valid[1]) { LOG_WARN( "Authentication started without extended feature page 1 request " "response"); return; } record.sm4 = (HCI_SSP_HOST_SUPPORTED(p_acl->peer_lmp_feature_pages[1])) ? BTM_SM4_TRUE : BTM_SM4_KNOWN; }