Gitiles
Code Review Sign In
LeafOS / LeafOS-Project / android_packages_modules_Bluetooth / 1abe2173d249f24a9dbda6e6298e402130d0f27a / . / system / stack / l2cap / l2c_api.cc
blob: 83d9b93901f5157a19c1f233ff31462d2aa5ff6b [file] [log] [blame]
/******************************************************************************
*
* Copyright 1999-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.
*
******************************************************************************/
/******************************************************************************
*
* This file contains the L2CAP API code
*
******************************************************************************/
#define LOG_TAG "bt_l2cap"
#include "stack/include/l2c_api.h"
#include <base/location.h>
#include <base/logging.h>
#include <base/strings/stringprintf.h>
#include <bluetooth/log.h>
#include <cstdint>
#include <string>
#include "common/init_flags.h"
#include "hal/snoop_logger.h"
#include "hci/controller_interface.h"
#include "include/check.h"
#include "internal_include/bt_target.h"
#include "internal_include/bt_trace.h"
#include "main/shim/entry.h"
#include "os/log.h"
#include "os/system_properties.h"
#include "osi/include/allocator.h"
#include "stack/btm/btm_sec.h"
#include "stack/include/bt_hdr.h"
#include "stack/include/bt_psm_types.h"
#include "stack/include/btm_api.h"
#include "stack/include/btm_client_interface.h"
#include "stack/include/l2c_api.h"
#include "stack/include/main_thread.h"
#include "stack/l2cap/l2c_int.h"
#include "types/raw_address.h"
using namespace bluetooth;
void btsnd_hcic_enhanced_flush(uint16_t handle,
uint8_t packet_type); // TODO Remove
using base::StringPrintf;
extern fixed_queue_t* btu_general_alarm_queue;
tL2C_AVDT_CHANNEL_INFO av_media_channels[MAX_ACTIVE_AVDT_CONN];
tBT_TRANSPORT l2c_get_transport_from_fixed_cid(uint16_t fixed_cid) {
if (fixed_cid >= L2CAP_ATT_CID && fixed_cid <= L2CAP_SMP_CID)
return BT_TRANSPORT_LE;
return BT_TRANSPORT_BR_EDR;
}
uint16_t L2CA_Register2(uint16_t psm, const tL2CAP_APPL_INFO& p_cb_info,
bool enable_snoop, tL2CAP_ERTM_INFO* p_ertm_info,
uint16_t my_mtu, uint16_t required_remote_mtu,
uint16_t sec_level) {
auto ret = L2CA_Register(psm, p_cb_info, enable_snoop, p_ertm_info, my_mtu,
required_remote_mtu, sec_level);
get_btm_client_interface().security.BTM_SetSecurityLevel(
false, "", 0, sec_level, psm, 0, 0);
return ret;
}
uint16_t L2CA_LeCreditDefault() {
static const uint16_t sL2CAP_LE_CREDIT_DEFAULT =
bluetooth::os::GetSystemPropertyUint32Base(
"bluetooth.l2cap.le.credit_default.value", 0xffff);
return sL2CAP_LE_CREDIT_DEFAULT;
}
uint16_t L2CA_LeCreditThreshold() {
static const uint16_t sL2CAP_LE_CREDIT_THRESHOLD =
bluetooth::os::GetSystemPropertyUint32Base(
"bluetooth.l2cap.le.credit_threshold.value", 0x0040);
return sL2CAP_LE_CREDIT_THRESHOLD;
}
static bool check_l2cap_credit() {
CHECK(L2CA_LeCreditThreshold() < L2CA_LeCreditDefault())
<< "Threshold must be smaller than default credits";
return true;
}
// Replace static assert with startup assert depending of the config
static const bool enforce_assert = check_l2cap_credit();
/*******************************************************************************
*
* Function L2CA_Register
*
* Description Other layers call this function to register for L2CAP
* services.
*
* Returns PSM to use or zero if error. Typically, the PSM returned
* is the same as was passed in, but for an outgoing-only
* connection to a dynamic PSM, a "virtual" PSM is returned
* and should be used in the calls to L2CA_ConnectReq(),
* L2CA_ErtmConnectReq() and L2CA_Deregister()
*
******************************************************************************/
uint16_t L2CA_Register(uint16_t psm, const tL2CAP_APPL_INFO& p_cb_info,
bool enable_snoop, tL2CAP_ERTM_INFO* p_ertm_info,
uint16_t my_mtu, uint16_t required_remote_mtu,
uint16_t sec_level) {
const bool config_cfm_cb = (p_cb_info.pL2CA_ConfigCfm_Cb != nullptr);
const bool config_ind_cb = (p_cb_info.pL2CA_ConfigInd_Cb != nullptr);
const bool data_ind_cb = (p_cb_info.pL2CA_DataInd_Cb != nullptr);
const bool disconnect_ind_cb = (p_cb_info.pL2CA_DisconnectInd_Cb != nullptr);
tL2C_RCB* p_rcb;
uint16_t vpsm = psm;
/* Verify that the required callback info has been filled in
** Note: Connection callbacks are required but not checked
** for here because it is possible to be only a client
** or only a server.
*/
if (!config_cfm_cb || !data_ind_cb || !disconnect_ind_cb) {
log::error(
"L2CAP - no cb registering PSM: 0x{:04x} cfg_cfm:{} cfg_ind:{} "
"data_ind:{} discon_int:{}",
psm, config_cfm_cb, config_ind_cb, data_ind_cb, disconnect_ind_cb);
return (0);
}
/* Verify PSM is valid */
if (L2C_INVALID_PSM(psm)) {
log::error("L2CAP - invalid PSM value, PSM: 0x{:04x}", psm);
return (0);
}
/* Check if this is a registration for an outgoing-only connection to */
/* a dynamic PSM. If so, allocate a "virtual" PSM for the app to use. */
if ((psm >= 0x1001) && (p_cb_info.pL2CA_ConnectInd_Cb == NULL)) {
for (vpsm = 0x1002; vpsm < 0x8000; vpsm += 2) {
p_rcb = l2cu_find_rcb_by_psm(vpsm);
if (p_rcb == NULL) break;
}
log::debug("L2CAP - Real PSM: 0x{:04x} Virtual PSM: 0x{:04x}", psm, vpsm);
}
/* If registration block already there, just overwrite it */
p_rcb = l2cu_find_rcb_by_psm(vpsm);
if (p_rcb == NULL) {
p_rcb = l2cu_allocate_rcb(vpsm);
if (p_rcb == NULL) {
log::warn("L2CAP - no RCB available, PSM: 0x{:04x} vPSM: 0x{:04x}", psm,
vpsm);
return (0);
}
}
log::info("L2CAP Registered service classic PSM: 0x{:04x}", psm);
p_rcb->log_packets = enable_snoop;
p_rcb->api = p_cb_info;
p_rcb->real_psm = psm;
p_rcb->ertm_info = p_ertm_info == nullptr
? tL2CAP_ERTM_INFO{L2CAP_FCR_BASIC_MODE}
: *p_ertm_info;
p_rcb->my_mtu = my_mtu;
p_rcb->required_remote_mtu =
std::max<uint16_t>(required_remote_mtu, L2CAP_MIN_MTU);
return (vpsm);
}
/*******************************************************************************
*
* Function L2CA_Deregister
*
* Description Other layers call this function to de-register for L2CAP
* services.
*
* Returns void
*
******************************************************************************/
void L2CA_Deregister(uint16_t psm) {
tL2C_RCB* p_rcb;
tL2C_CCB* p_ccb;
tL2C_LCB* p_lcb;
int ii;
log::verbose("L2CAP - L2CA_Deregister() called for PSM: 0x{:04x}", psm);
p_rcb = l2cu_find_rcb_by_psm(psm);
if (p_rcb != NULL) {
p_lcb = &l2cb.lcb_pool[0];
for (ii = 0; ii < MAX_L2CAP_LINKS; ii++, p_lcb++) {
if (p_lcb->in_use) {
p_ccb = p_lcb->ccb_queue.p_first_ccb;
if ((p_ccb == NULL) || (p_lcb->link_state == LST_DISCONNECTING)) {
continue;
}
if ((p_ccb->in_use) &&
((p_ccb->chnl_state == CST_W4_L2CAP_DISCONNECT_RSP) ||
(p_ccb->chnl_state == CST_W4_L2CA_DISCONNECT_RSP))) {
continue;
}
if (p_ccb->p_rcb == p_rcb) {
l2c_csm_execute(p_ccb, L2CEVT_L2CA_DISCONNECT_REQ, NULL);
}
}
}
l2cu_release_rcb(p_rcb);
} else {
log::warn("L2CAP - PSM: 0x{:04x} not found for deregistration", psm);
}
}
/*******************************************************************************
*
* Function L2CA_AllocateLePSM
*
* Description To find an unused LE PSM for L2CAP services.
*
* Returns LE_PSM to use if success. Otherwise returns 0.
*
******************************************************************************/
uint16_t L2CA_AllocateLePSM(void) {
bool done = false;
uint16_t psm = l2cb.le_dyn_psm;
uint16_t count = 0;
log::verbose("last psm={}", psm);
while (!done) {
count++;
if (count > LE_DYNAMIC_PSM_RANGE) {
log::error("Out of free BLE PSM");
return 0;
}
psm++;
if (psm > LE_DYNAMIC_PSM_END) {
psm = LE_DYNAMIC_PSM_START;
}
if (!l2cb.le_dyn_psm_assigned[psm - LE_DYNAMIC_PSM_START]) {
/* make sure the newly allocated psm is not used right now */
if (l2cu_find_ble_rcb_by_psm(psm)) {
log::warn("supposedly-free PSM={} have allocated rcb!", psm);
continue;
}
l2cb.le_dyn_psm_assigned[psm - LE_DYNAMIC_PSM_START] = true;
log::verbose("assigned PSM={}", psm);
done = true;
break;
}
}
l2cb.le_dyn_psm = psm;
return (psm);
}
/*******************************************************************************
*
* Function L2CA_FreeLePSM
*
* Description Free an assigned LE PSM.
*
* Returns void
*
******************************************************************************/
void L2CA_FreeLePSM(uint16_t psm) {
log::verbose("to free psm={}", psm);
if ((psm < LE_DYNAMIC_PSM_START) || (psm > LE_DYNAMIC_PSM_END)) {
log::error("Invalid PSM={} value!", psm);
return;
}
if (!l2cb.le_dyn_psm_assigned[psm - LE_DYNAMIC_PSM_START]) {
log::warn("PSM={} was not allocated!", psm);
}
l2cb.le_dyn_psm_assigned[psm - LE_DYNAMIC_PSM_START] = false;
}
uint16_t L2CA_ConnectReq2(uint16_t psm, const RawAddress& p_bd_addr,
uint16_t sec_level) {
get_btm_client_interface().security.BTM_SetSecurityLevel(
true, "", 0, sec_level, psm, 0, 0);
return L2CA_ConnectReq(psm, p_bd_addr);
}
/*******************************************************************************
*
* Function L2CA_ConnectReq
*
* Description Higher layers call this function to create an L2CAP
* connection.
* Note that the connection is not established at this time,
* but connection establishment gets started. The callback
* will be invoked when connection establishes or fails.
*
* Returns the CID of the connection, or 0 if it failed to start
*
******************************************************************************/
uint16_t L2CA_ConnectReq(uint16_t psm, const RawAddress& p_bd_addr) {
log::verbose("BDA {} PSM: 0x{:04x}", ADDRESS_TO_LOGGABLE_STR(p_bd_addr), psm);
/* Fail if we have not established communications with the controller */
if (!BTM_IsDeviceUp()) {
log::warn("BTU not ready");
return 0;
}
/* Fail if the PSM is not registered */
tL2C_RCB* p_rcb = l2cu_find_rcb_by_psm(psm);
if (p_rcb == nullptr) {
log::warn("no RCB, PSM={}", loghex(psm));
return 0;
}
/* First, see if we already have a link to the remote */
/* assume all ERTM l2cap connection is going over BR/EDR for now */
tL2C_LCB* p_lcb = l2cu_find_lcb_by_bd_addr(p_bd_addr, BT_TRANSPORT_BR_EDR);
if (p_lcb == nullptr) {
/* No link. Get an LCB and start link establishment */
p_lcb = l2cu_allocate_lcb(p_bd_addr, false, BT_TRANSPORT_BR_EDR);
/* currently use BR/EDR for ERTM mode l2cap connection */
if (p_lcb == nullptr) {
log::warn("connection not started for PSM={}, p_lcb={}", loghex(psm),
fmt::ptr(p_lcb));
return 0;
}
l2cu_create_conn_br_edr(p_lcb);
}
/* Allocate a channel control block */
tL2C_CCB* p_ccb = l2cu_allocate_ccb(p_lcb, 0);
if (p_ccb == nullptr) {
log::warn("no CCB, PSM={}", loghex(psm));
return 0;
}
/* Save registration info */
p_ccb->p_rcb = p_rcb;
p_ccb->connection_initiator = L2CAP_INITIATOR_LOCAL;
/* If link is up, start the L2CAP connection */
if (p_lcb->link_state == LST_CONNECTED) {
l2c_csm_execute(p_ccb, L2CEVT_L2CA_CONNECT_REQ, nullptr);
} else if (p_lcb->link_state == LST_DISCONNECTING) {
/* If link is disconnecting, save link info to retry after disconnect
* Possible Race condition when a reconnect occurs
* on the channel during a disconnect of link. This
* ccb will be automatically retried after link disconnect
* arrives
*/
log::verbose("L2CAP API - link disconnecting: RETRY LATER");
/* Save ccb so it can be started after disconnect is finished */
p_lcb->p_pending_ccb = p_ccb;
}
log::verbose("L2CAP - L2CA_conn_req(psm: 0x{:04x}) returned CID: 0x{:04x}",
psm, p_ccb->local_cid);
/* Return the local CID as our handle */
return p_ccb->local_cid;
}
/*******************************************************************************
*
* Function L2CA_RegisterLECoc
*
* Description Other layers call this function to register for L2CAP
* Connection Oriented Channel.
*
* Returns PSM to use or zero if error. Typically, the PSM returned
* is the same as was passed in, but for an outgoing-only
* connection to a dynamic PSM, a "virtual" PSM is returned
* and should be used in the calls to L2CA_ConnectLECocReq()
* and L2CA_DeregisterLECoc()
*
******************************************************************************/
uint16_t L2CA_RegisterLECoc(uint16_t psm, const tL2CAP_APPL_INFO& p_cb_info,
uint16_t sec_level, tL2CAP_LE_CFG_INFO cfg) {
if (p_cb_info.pL2CA_ConnectInd_Cb != nullptr || psm < LE_DYNAMIC_PSM_START) {
// If we register LE COC for outgoing connection only, don't register with
// BTM_Sec, because it's handled by L2CA_ConnectLECocReq.
get_btm_client_interface().security.BTM_SetSecurityLevel(
false, "", 0, sec_level, psm, 0, 0);
}
/* Verify that the required callback info has been filled in
** Note: Connection callbacks are required but not checked
** for here because it is possible to be only a client
** or only a server.
*/
if ((!p_cb_info.pL2CA_DataInd_Cb) || (!p_cb_info.pL2CA_DisconnectInd_Cb)) {
log::error("No cb registering BLE PSM: 0x{:04x}", psm);
return 0;
}
/* Verify PSM is valid */
if (!L2C_IS_VALID_LE_PSM(psm)) {
log::error("Invalid BLE PSM value, PSM: 0x{:04x}", psm);
return 0;
}
tL2C_RCB* p_rcb;
uint16_t vpsm = psm;
/* Check if this is a registration for an outgoing-only connection to */
/* a dynamic PSM. If so, allocate a "virtual" PSM for the app to use. */
if ((psm >= LE_DYNAMIC_PSM_START) &&
(p_cb_info.pL2CA_ConnectInd_Cb == NULL)) {
vpsm = L2CA_AllocateLePSM();
if (vpsm == 0) {
log::error("Out of free BLE PSM");
return 0;
}
log::debug("Real PSM: 0x{:04x} Virtual PSM: 0x{:04x}", psm, vpsm);
}
/* If registration block already there, just overwrite it */
p_rcb = l2cu_find_ble_rcb_by_psm(vpsm);
if (p_rcb == NULL) {
log::debug("Allocate rcp for Virtual PSM: 0x{:04x}", vpsm);
p_rcb = l2cu_allocate_ble_rcb(vpsm);
if (p_rcb == NULL) {
log::warn("No BLE RCB available, PSM: 0x{:04x} vPSM: 0x{:04x}", psm,
vpsm);
return 0;
}
}
log::info("Registered service LE COC PSM: 0x{:04x}", psm);
p_rcb->api = p_cb_info;
p_rcb->real_psm = psm;
p_rcb->coc_cfg = cfg;
return vpsm;
}
/*******************************************************************************
*
* Function L2CA_DeregisterLECoc
*
* Description Other layers call this function to de-register for L2CAP
* Connection Oriented Channel.
*
* Returns void
*
******************************************************************************/
void L2CA_DeregisterLECoc(uint16_t psm) {
log::verbose("called for PSM: 0x{:04x}", psm);
tL2C_RCB* p_rcb = l2cu_find_ble_rcb_by_psm(psm);
if (p_rcb == NULL) {
log::warn("PSM: 0x{:04x} not found for deregistration", psm);
return;
}
tL2C_LCB* p_lcb = &l2cb.lcb_pool[0];
for (int i = 0; i < MAX_L2CAP_LINKS; i++, p_lcb++) {
if (!p_lcb->in_use || p_lcb->transport != BT_TRANSPORT_LE) continue;
tL2C_CCB* p_ccb = p_lcb->ccb_queue.p_first_ccb;
if ((p_ccb == NULL) || (p_lcb->link_state == LST_DISCONNECTING)) continue;
if (p_ccb->in_use && (p_ccb->chnl_state == CST_W4_L2CAP_DISCONNECT_RSP ||
p_ccb->chnl_state == CST_W4_L2CA_DISCONNECT_RSP))
continue;
if (p_ccb->p_rcb == p_rcb)
l2c_csm_execute(p_ccb, L2CEVT_L2CA_DISCONNECT_REQ, NULL);
}
l2cu_release_ble_rcb(p_rcb);
}
/*******************************************************************************
*
* Function L2CA_ConnectLECocReq
*
* Description Higher layers call this function to create an L2CAP
* connection. Note that the connection is not established at
* this time, but connection establishment gets started. The
* callback function will be invoked when connection
* establishes or fails.
*
* Parameters: PSM: L2CAP PSM for the connection
* BD address of the peer
* Local Coc configurations
* Returns the CID of the connection, or 0 if it failed to start
*
******************************************************************************/
uint16_t L2CA_ConnectLECocReq(uint16_t psm, const RawAddress& p_bd_addr,
tL2CAP_LE_CFG_INFO* p_cfg, uint16_t sec_level) {
get_btm_client_interface().security.BTM_SetSecurityLevel(
true, "", 0, sec_level, psm, 0, 0);
log::verbose("BDA: {} PSM: 0x{:04x}", ADDRESS_TO_LOGGABLE_STR(p_bd_addr),
psm);
/* Fail if we have not established communications with the controller */
if (!BTM_IsDeviceUp()) {
log::warn("BTU not ready");
return 0;
}
/* Fail if the PSM is not registered */
tL2C_RCB* p_rcb = l2cu_find_ble_rcb_by_psm(psm);
if (p_rcb == NULL) {
log::warn("No BLE RCB, PSM: 0x{:04x}", psm);
return 0;
}
/* First, see if we already have a le link to the remote */
tL2C_LCB* p_lcb = l2cu_find_lcb_by_bd_addr(p_bd_addr, BT_TRANSPORT_LE);
if (p_lcb == NULL) {
/* No link. Get an LCB and start link establishment */
p_lcb = l2cu_allocate_lcb(p_bd_addr, false, BT_TRANSPORT_LE);
if ((p_lcb == NULL)
/* currently use BR/EDR for ERTM mode l2cap connection */
|| (!l2cu_create_conn_le(p_lcb))) {
log::warn("conn not started for PSM: 0x{:04x} p_lcb: 0x{}", psm,
fmt::ptr(p_lcb));
return 0;
}
}
/* Allocate a channel control block */
tL2C_CCB* p_ccb = l2cu_allocate_ccb(p_lcb, 0);
if (p_ccb == NULL) {
log::warn("no CCB, PSM: 0x{:04x}", psm);
return 0;
}
/* Save registration info */
p_ccb->p_rcb = p_rcb;
p_ccb->connection_initiator = L2CAP_INITIATOR_LOCAL;
/* Save the configuration */
if (p_cfg) {
p_ccb->local_conn_cfg = *p_cfg;
p_ccb->remote_credit_count = p_cfg->credits;
}
/* If link is up, start the L2CAP connection */
if (p_lcb->link_state == LST_CONNECTED) {
if (p_ccb->p_lcb->transport == BT_TRANSPORT_LE) {
log::verbose("LE Link is up");
// post this asynchronously to avoid out-of-order callback invocation
// should this operation fail
do_in_main_thread(
FROM_HERE, base::BindOnce(&l2c_csm_execute, base::Unretained(p_ccb),
L2CEVT_L2CA_CONNECT_REQ, nullptr));
}
}
/* If link is disconnecting, save link info to retry after disconnect
* Possible Race condition when a reconnect occurs
* on the channel during a disconnect of link. This
* ccb will be automatically retried after link disconnect
* arrives
*/
else if (p_lcb->link_state == LST_DISCONNECTING) {
log::verbose("link disconnecting: RETRY LATER");
/* Save ccb so it can be started after disconnect is finished */
p_lcb->p_pending_ccb = p_ccb;
}
log::verbose("(psm: 0x{:04x}) returned CID: 0x{:04x}", psm, p_ccb->local_cid);
/* Return the local CID as our handle */
return p_ccb->local_cid;
}
/*******************************************************************************
*
* Function L2CA_GetPeerLECocConfig
*
* Description Get a peers configuration for LE Connection Oriented
* Channel.
*
* Parameters: local channel id
* Pointers to peers configuration storage area
*
* Return value: true if peer is connected
*
******************************************************************************/
bool L2CA_GetPeerLECocConfig(uint16_t lcid, tL2CAP_LE_CFG_INFO* peer_cfg) {
log::verbose("CID: 0x{:04x}", lcid);
tL2C_CCB* p_ccb = l2cu_find_ccb_by_cid(NULL, lcid);
if (p_ccb == NULL) {
log::error("No CCB for CID:0x{:04x}", lcid);
return false;
}
if (peer_cfg != NULL)
memcpy(peer_cfg, &p_ccb->peer_conn_cfg, sizeof(tL2CAP_LE_CFG_INFO));
return true;
}
/*******************************************************************************
*
* Function L2CA_GetPeerLECocCredit
*
* Description Get peers current credit for LE Connection Oriented
* Channel.
*
* Return value: Number of the peer current credit
*
******************************************************************************/
uint16_t L2CA_GetPeerLECocCredit(const RawAddress& bd_addr, uint16_t lcid) {
/* First, find the link control block */
tL2C_LCB* p_lcb = l2cu_find_lcb_by_bd_addr(bd_addr, BT_TRANSPORT_LE);
if (p_lcb == NULL) {
/* No link. Get an LCB and start link establishment */
log::warn("no LCB");
return L2CAP_LE_CREDIT_MAX;
}
tL2C_CCB* p_ccb = l2cu_find_ccb_by_cid(p_lcb, lcid);
if (p_ccb == NULL) {
log::error("No CCB for CID:0x{:04x}", lcid);
return L2CAP_LE_CREDIT_MAX;
}
return p_ccb->peer_conn_cfg.credits;
}
/*******************************************************************************
*
* Function L2CA_ConnectCreditBasedRsp
*
* Description Response for the pL2CA_CreditBasedConnectInd_Cb which is the
* indication for peer requesting credit based connection.
*
* Parameters: BD address of the peer
* Identifier of the transaction
* Vector of accepted lcids by upper layer
* L2CAP result
* Local channel configuration
*
* Returns true for success, false for failure
*
******************************************************************************/
bool L2CA_ConnectCreditBasedRsp(const RawAddress& p_bd_addr, uint8_t id,
std::vector<uint16_t>& accepted_lcids,
uint16_t result, tL2CAP_LE_CFG_INFO* p_cfg) {
log::verbose("BDA: {} num of cids: {} Result: {}",
ADDRESS_TO_LOGGABLE_STR(p_bd_addr), int(accepted_lcids.size()),
result);
/* First, find the link control block */
tL2C_LCB* p_lcb = l2cu_find_lcb_by_bd_addr(p_bd_addr, BT_TRANSPORT_LE);
if (p_lcb == NULL) {
/* No link. Get an LCB and start link establishment */
log::warn("no LCB");
return false;
}
/* Now, find the channel control block. We kept lead cid.
*/
tL2C_CCB* p_ccb = l2cu_find_ccb_by_cid(p_lcb, p_lcb->pending_lead_cid);
if (!p_ccb) {
log::error("No CCB for CID:0x{:04x}", p_lcb->pending_lead_cid);
return false;
}
for (uint16_t cid : accepted_lcids) {
tL2C_CCB* temp_p_ccb = l2cu_find_ccb_by_cid(p_lcb, cid);
if (temp_p_ccb == NULL) {
log::warn("no CCB");
return false;
}
if (p_cfg) {
temp_p_ccb->local_conn_cfg = *p_cfg;
temp_p_ccb->remote_credit_count = p_cfg->credits;
}
}
/* The IDs must match */
if (p_ccb->remote_id != id) {
log::warn("bad id. Expected: {} Got: {}", p_ccb->remote_id, id);
return false;
}
tL2C_CONN_INFO conn_info;
conn_info.lcids = accepted_lcids;
conn_info.bd_addr = p_bd_addr;
conn_info.l2cap_result = result;
if (accepted_lcids.size() > 0) {
l2c_csm_execute(p_ccb, L2CEVT_L2CA_CREDIT_BASED_CONNECT_RSP, &conn_info);
} else {
l2c_csm_execute(p_ccb, L2CEVT_L2CA_CREDIT_BASED_CONNECT_RSP_NEG,
&conn_info);
}
return true;
}
/*******************************************************************************
*
* Function L2CA_ConnectCreditBasedReq
*
* Description Initiate Create Credit Based connections.
*
* Parameters: PSM for the L2CAP channel
* BD address of the peer
* Local channel configuration
*
* Return value: Vector of allocated local cids.
*
******************************************************************************/
std::vector<uint16_t> L2CA_ConnectCreditBasedReq(uint16_t psm,
const RawAddress& p_bd_addr,
tL2CAP_LE_CFG_INFO* p_cfg) {
log::verbose("BDA: {} PSM: 0x{:04x}", ADDRESS_TO_LOGGABLE_STR(p_bd_addr),
psm);
std::vector<uint16_t> allocated_cids;
/* Fail if we have not established communications with the controller */
if (!BTM_IsDeviceUp()) {
log::warn("BTU not ready");
return allocated_cids;
}
if (!p_cfg) {
log::warn("p_cfg is NULL");
return allocated_cids;
}
/* Fail if the PSM is not registered */
tL2C_RCB* p_rcb = l2cu_find_ble_rcb_by_psm(psm);
if (p_rcb == NULL) {
log::warn("No BLE RCB, PSM: 0x{:04x}", psm);
return allocated_cids;
}
/* First, see if we already have a le link to the remote */
tL2C_LCB* p_lcb = l2cu_find_lcb_by_bd_addr(p_bd_addr, BT_TRANSPORT_LE);
if (p_lcb == NULL) {
log::warn("No link available");
return allocated_cids;
}
if (p_lcb->link_state != LST_CONNECTED) {
log::warn("incorrect link state: {}", p_lcb->link_state);
return allocated_cids;
}
log::verbose("LE Link is up");
/* Check if there is no ongoing connection request */
if (p_lcb->pending_ecoc_conn_cnt > 0) {
log::warn("There is ongoing connection request, PSM: 0x{:04x}", psm);
return allocated_cids;
}
tL2C_CCB* p_ccb_primary;
/* Make sure user set proper value for number of cids */
if (p_cfg->number_of_channels > L2CAP_CREDIT_BASED_MAX_CIDS ||
p_cfg->number_of_channels == 0) {
p_cfg->number_of_channels = L2CAP_CREDIT_BASED_MAX_CIDS;
}
for (int i = 0; i < p_cfg->number_of_channels; i++) {
/* Allocate a channel control block */
tL2C_CCB* p_ccb =
l2cu_allocate_ccb(p_lcb, 0, psm == BT_PSM_EATT /* is_eatt */);
if (p_ccb == NULL) {
if (i == 0) {
log::warn("no CCB, PSM: 0x{:04x}", psm);
return allocated_cids;
} else {
break;
}
}
p_ccb->ecoc = true;
p_ccb->local_conn_cfg = *p_cfg;
p_ccb->remote_credit_count = p_cfg->credits;
/* Save registration info */
p_ccb->p_rcb = p_rcb;
if (i == 0) {
p_ccb_primary = p_ccb;
} else {
/* Only primary channel we keep in closed state, as in that
* context we will run state machine where security is checked etc.
* Others we can directly put into waiting for connect
* response, so those are not confused by system as incomming connections
*/
p_ccb->chnl_state = CST_W4_L2CAP_CONNECT_RSP;
}
allocated_cids.push_back(p_ccb->local_cid);
}
for (int i = 0; i < (int)(allocated_cids.size()); i++)
p_lcb->pending_ecoc_connection_cids[i] = allocated_cids[i];
p_lcb->pending_ecoc_conn_cnt = (uint16_t)(allocated_cids.size());
l2c_csm_execute(p_ccb_primary, L2CEVT_L2CA_CREDIT_BASED_CONNECT_REQ, NULL);
log::verbose("(psm: 0x{:04x}) returned CID: 0x{:04x}", psm,
p_ccb_primary->local_cid);
return allocated_cids;
}
/*******************************************************************************
*
* Function L2CA_ReconfigCreditBasedConnsReq
*
* Description Start reconfigure procedure on Connection Oriented Channel.
*
* Parameters: Vector of channels for which configuration should be
* changed to new local channel configuration
*
* Return value: true if peer is connected
*
******************************************************************************/
bool L2CA_ReconfigCreditBasedConnsReq(const RawAddress& bda,
std::vector<uint16_t>& lcids,
tL2CAP_LE_CFG_INFO* p_cfg) {
tL2C_CCB* p_ccb;
log::verbose("L2CA_ReconfigCreditBasedConnsReq() ");
if (lcids.empty()) {
log::warn("L2CAP - empty lcids");
return (false);
}
for (uint16_t cid : lcids) {
p_ccb = l2cu_find_ccb_by_cid(NULL, cid);
if (!p_ccb) {
log::warn("L2CAP - no CCB for L2CA_cfg_req, CID: {}", cid);
return (false);
}
if ((p_ccb->local_conn_cfg.mtu > p_cfg->mtu) ||
(p_ccb->local_conn_cfg.mps > p_cfg->mps)) {
log::warn("L2CAP - MPS or MTU reduction, CID: {}", cid);
return (false);
}
}
if (p_cfg->mtu > L2CAP_MTU_SIZE) {
log::warn("L2CAP - adjust MTU: {} too large", p_cfg->mtu);
p_cfg->mtu = L2CAP_MTU_SIZE;
}
/* Mark all the p_ccbs which going to be reconfigured */
for (uint16_t cid : lcids) {
log::verbose("cid: {}", cid);
p_ccb = l2cu_find_ccb_by_cid(NULL, cid);
if (!p_ccb) {
log::error("Missing cid? {}", int(cid));
return (false);
}
p_ccb->reconfig_started = true;
}
tL2C_LCB* p_lcb = p_ccb->p_lcb;
/* Hack warning - the whole reconfig we are doing in the context of the first
* p_ccb. In the p_lcp we store configuration and cid in which context we are
* doing reconfiguration.
*/
for (p_ccb = p_lcb->ccb_queue.p_first_ccb; p_ccb; p_ccb = p_ccb->p_next_ccb)
if ((p_ccb->in_use) && (p_ccb->ecoc) && (p_ccb->reconfig_started)) {
p_ccb->p_lcb->pending_ecoc_reconfig_cfg = *p_cfg;
p_ccb->p_lcb->pending_ecoc_reconfig_cnt = lcids.size();
break;
}
l2c_csm_execute(p_ccb, L2CEVT_L2CA_CREDIT_BASED_RECONFIG_REQ, p_cfg);
return (true);
}
/*******************************************************************************
*
* Function L2CA_DisconnectReq
*
* Description Higher layers call this function to disconnect a channel.
*
* Returns true if disconnect sent, else false
*
******************************************************************************/
bool L2CA_DisconnectReq(uint16_t cid) {
tL2C_CCB* p_ccb;
/* Find the channel control block. We don't know the link it is on. */
p_ccb = l2cu_find_ccb_by_cid(NULL, cid);
if (p_ccb == NULL) {
log::warn("L2CAP - no CCB for L2CA_disc_req, CID: {}", cid);
return (false);
}
log::debug("L2CAP Local disconnect request CID: 0x{:04x}", cid);
l2c_csm_execute(p_ccb, L2CEVT_L2CA_DISCONNECT_REQ, NULL);
return (true);
}
bool L2CA_DisconnectLECocReq(uint16_t cid) { return L2CA_DisconnectReq(cid); }
bool L2CA_GetRemoteCid(uint16_t lcid, uint16_t* rcid) {
tL2C_CCB* control_block = l2cu_find_ccb_by_cid(NULL, lcid);
if (!control_block) return false;
if (rcid) *rcid = control_block->remote_cid;
return true;
}
/*******************************************************************************
*
* Function L2CA_SetIdleTimeoutByBdAddr
*
* Description Higher layers call this function to set the idle timeout for
* a connection. The "idle timeout" is the amount of time that
* a connection can remain up with no L2CAP channels on it.
* A timeout of zero means that the connection will be torn
* down immediately when the last channel is removed.
* A timeout of 0xFFFF means no timeout. Values are in seconds.
* A bd_addr is the remote BD address. If bd_addr =
* RawAddress::kAny, then the idle timeouts for all active
* l2cap links will be changed.
*
* Returns true if command succeeded, false if failed
*
* NOTE This timeout applies to all logical channels active on the
* ACL link.
******************************************************************************/
bool L2CA_SetIdleTimeoutByBdAddr(const RawAddress& bd_addr, uint16_t timeout,
tBT_TRANSPORT transport) {
tL2C_LCB* p_lcb;
if (RawAddress::kAny != bd_addr) {
p_lcb = l2cu_find_lcb_by_bd_addr(bd_addr, transport);
if ((p_lcb) && (p_lcb->in_use) && (p_lcb->link_state == LST_CONNECTED)) {
p_lcb->idle_timeout = timeout;
if (!p_lcb->ccb_queue.p_first_ccb) l2cu_no_dynamic_ccbs(p_lcb);
} else
return false;
} else {
int xx;
tL2C_LCB* p_lcb = &l2cb.lcb_pool[0];
for (xx = 0; xx < MAX_L2CAP_LINKS; xx++, p_lcb++) {
if ((p_lcb->in_use) && (p_lcb->link_state == LST_CONNECTED)) {
p_lcb->idle_timeout = timeout;
if (!p_lcb->ccb_queue.p_first_ccb) l2cu_no_dynamic_ccbs(p_lcb);
}
}
}
return true;
}
/*******************************************************************************
*
* Function L2CA_UseLatencyMode
*
* Description Sets acl use latency mode.
*
* Returns true if a valid channel, else false
*
******************************************************************************/
bool L2CA_UseLatencyMode(const RawAddress& bd_addr, bool use_latency_mode) {
/* Find the link control block for the acl channel */
tL2C_LCB* p_lcb = l2cu_find_lcb_by_bd_addr(bd_addr, BT_TRANSPORT_BR_EDR);
if (p_lcb == nullptr) {
log::warn("L2CAP - no LCB for L2CA_SetUseLatencyMode, BDA: {}",
ADDRESS_TO_LOGGABLE_CSTR(bd_addr));
return false;
}
log::info("BDA: {}, use_latency_mode: {}", ADDRESS_TO_LOGGABLE_CSTR(bd_addr),
use_latency_mode ? "true" : "false");
p_lcb->use_latency_mode = use_latency_mode;
return true;
}
/*******************************************************************************
*
* Function L2CA_SetAclPriority
*
* Description Sets the transmission priority for a channel.
* (For initial implementation only two values are valid.
* L2CAP_PRIORITY_NORMAL and L2CAP_PRIORITY_HIGH).
*
* Returns true if a valid channel, else false
*
******************************************************************************/
bool L2CA_SetAclPriority(const RawAddress& bd_addr, tL2CAP_PRIORITY priority) {
log::verbose("BDA: {}, priority: {}", ADDRESS_TO_LOGGABLE_STR(bd_addr),
priority);
return (l2cu_set_acl_priority(bd_addr, priority, false));
}
/*******************************************************************************
*
* Function L2CA_SetAclLatency
*
* Description Sets the transmission latency for a channel.
*
* Returns true if a valid channel, else false
*
******************************************************************************/
bool L2CA_SetAclLatency(const RawAddress& bd_addr, tL2CAP_LATENCY latency) {
log::info("BDA: {}, latency: {}", ADDRESS_TO_LOGGABLE_CSTR(bd_addr),
std::to_string(latency));
return l2cu_set_acl_latency(bd_addr, latency);
}
/*******************************************************************************
*
* Function L2CA_SetTxPriority
*
* Description Sets the transmission priority for a channel.
*
* Returns true if a valid channel, else false
*
******************************************************************************/
bool L2CA_SetTxPriority(uint16_t cid, tL2CAP_CHNL_PRIORITY priority) {
tL2C_CCB* p_ccb;
log::verbose("L2CA_SetTxPriority() CID: 0x{:04x}, priority:{}", cid,
priority);
/* Find the channel control block. We don't know the link it is on. */
p_ccb = l2cu_find_ccb_by_cid(NULL, cid);
if (p_ccb == NULL) {
log::warn("L2CAP - no CCB for L2CA_SetTxPriority, CID: {}", cid);
return (false);
}
/* it will update the order of CCB in LCB by priority and update round robin
* service variables */
l2cu_change_pri_ccb(p_ccb, priority);
return (true);
}
/*******************************************************************************
*
* Function L2CA_GetPeerFeatures
*
* Description Get a peers features and fixed channel map
*
* Parameters: BD address of the peer
* Pointers to features and channel mask storage area
*
* Return value: true if peer is connected
*
******************************************************************************/
bool L2CA_GetPeerFeatures(const RawAddress& bd_addr, uint32_t* p_ext_feat,
uint8_t* p_chnl_mask) {
tL2C_LCB* p_lcb;
/* We must already have a link to the remote */
p_lcb = l2cu_find_lcb_by_bd_addr(bd_addr, BT_TRANSPORT_BR_EDR);
if (p_lcb == NULL) {
log::warn("No BDA: {}", ADDRESS_TO_LOGGABLE_STR(bd_addr));
return false;
}
log::verbose("BDA: {} ExtFea: 0x{:08x} Chnl_Mask[0]: 0x{:02x}",
ADDRESS_TO_LOGGABLE_STR(bd_addr), p_lcb->peer_ext_fea,
p_lcb->peer_chnl_mask[0]);
*p_ext_feat = p_lcb->peer_ext_fea;
memcpy(p_chnl_mask, p_lcb->peer_chnl_mask, L2CAP_FIXED_CHNL_ARRAY_SIZE);
return true;
}
/*******************************************************************************
*
* Function L2CA_RegisterFixedChannel
*
* Description Register a fixed channel.
*
* Parameters: Fixed Channel #
* Channel Callbacks and config
*
* Return value: -
*
******************************************************************************/
static std::string fixed_channel_text(const uint16_t& fixed_cid) {
switch (fixed_cid) {
case L2CAP_SIGNALLING_CID:
return std::string("br_edr signalling");
case L2CAP_CONNECTIONLESS_CID:
return std::string("connectionless");
case L2CAP_AMP_CID:
return std::string("amp");
case L2CAP_ATT_CID:
return std::string("att");
case L2CAP_BLE_SIGNALLING_CID:
return std::string("ble signalling");
case L2CAP_SMP_CID:
return std::string("smp");
case L2CAP_SMP_BR_CID:
return std::string("br_edr smp");
default:
return std::string("unknown");
}
}
bool L2CA_RegisterFixedChannel(uint16_t fixed_cid,
tL2CAP_FIXED_CHNL_REG* p_freg) {
if ((fixed_cid < L2CAP_FIRST_FIXED_CHNL) ||
(fixed_cid > L2CAP_LAST_FIXED_CHNL)) {
log::error("Invalid fixed CID: 0x{:04x}", fixed_cid);
return false;
}
l2cb.fixed_reg[fixed_cid - L2CAP_FIRST_FIXED_CHNL] = *p_freg;
log::debug("Registered fixed channel:{}", fixed_channel_text(fixed_cid));
return true;
}
/*******************************************************************************
*
* Function L2CA_ConnectFixedChnl
*
* Description Connect an fixed signalling channel to a remote device.
*
* Parameters: Fixed CID
* BD Address of remote
*
* Return value: true if connection started
*
******************************************************************************/
bool L2CA_ConnectFixedChnl(uint16_t fixed_cid, const RawAddress& rem_bda) {
tL2C_LCB* p_lcb;
tBT_TRANSPORT transport = BT_TRANSPORT_BR_EDR;
log::debug("fixed_cid:0x{:04x}", fixed_cid);
// Check CID is valid and registered
if ((fixed_cid < L2CAP_FIRST_FIXED_CHNL) ||
(fixed_cid > L2CAP_LAST_FIXED_CHNL) ||
(l2cb.fixed_reg[fixed_cid - L2CAP_FIRST_FIXED_CHNL].pL2CA_FixedData_Cb ==
NULL)) {
log::error("Invalid fixed_cid:0x{:04x}", fixed_cid);
return (false);
}
// Fail if BT is not yet up
if (!BTM_IsDeviceUp()) {
log::warn("Bt controller is not ready fixed_cid:0x{:04x}", fixed_cid);
return (false);
}
if (fixed_cid >= L2CAP_ATT_CID && fixed_cid <= L2CAP_SMP_CID)
transport = BT_TRANSPORT_LE;
tL2C_BLE_FIXED_CHNLS_MASK peer_channel_mask;
// If we already have a link to the remote, check if it supports that CID
p_lcb = l2cu_find_lcb_by_bd_addr(rem_bda, transport);
if (p_lcb != NULL) {
// Fixed channels are mandatory on LE transports so ignore the received
// channel mask and use the locally cached LE channel mask.
if (transport == BT_TRANSPORT_LE)
peer_channel_mask = l2cb.l2c_ble_fixed_chnls_mask;
else
peer_channel_mask = p_lcb->peer_chnl_mask[0];
// Check for supported channel
if (!(peer_channel_mask & (1 << fixed_cid))) {
log::info("Peer device does not support fixed_cid:0x{:04x}", fixed_cid);
return false;
}
// Get a CCB and link the lcb to it
if (!l2cu_initialize_fixed_ccb(p_lcb, fixed_cid)) {
log::warn("Unable to allocate fixed channel resource fixed_cid:0x{:04x}",
fixed_cid);
return false;
}
// racing with disconnecting, queue the connection request
if (p_lcb->link_state == LST_DISCONNECTING) {
log::debug(
"Link is disconnecting so deferring connection fixed_cid:0x{:04x}",
fixed_cid);
/* Save ccb so it can be started after disconnect is finished */
p_lcb->p_pending_ccb =
p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL];
return true;
}
(*l2cb.fixed_reg[fixed_cid - L2CAP_FIRST_FIXED_CHNL].pL2CA_FixedConn_Cb)(
fixed_cid, p_lcb->remote_bd_addr, true, 0, p_lcb->transport);
return true;
}
// No link. Get an LCB and start link establishment
p_lcb = l2cu_allocate_lcb(rem_bda, false, transport);
if (p_lcb == NULL) {
log::warn(
"Unable to allocate link resource for connection fixed_cid:0x{:04x}",
fixed_cid);
return false;
}
// Get a CCB and link the lcb to it
if (!l2cu_initialize_fixed_ccb(p_lcb, fixed_cid)) {
log::warn("Unable to allocate fixed channel resource fixed_cid:0x{:04x}",
fixed_cid);
l2cu_release_lcb(p_lcb);
return false;
}
if (transport == BT_TRANSPORT_LE) {
bool ret = l2cu_create_conn_le(p_lcb);
if (!ret) {
log::warn(
"Unable to create fixed channel le connection fixed_cid:0x{:04x}",
fixed_cid);
l2cu_release_lcb(p_lcb);
return false;
}
} else {
l2cu_create_conn_br_edr(p_lcb);
}
return true;
}
/*******************************************************************************
*
* Function L2CA_SendFixedChnlData
*
* Description Write data on a fixed channel.
*
* Parameters: Fixed CID
* BD Address of remote
* Pointer to buffer of type BT_HDR
*
* Return value L2CAP_DW_SUCCESS, if data accepted
* L2CAP_DW_FAILED, if error
*
******************************************************************************/
uint16_t L2CA_SendFixedChnlData(uint16_t fixed_cid, const RawAddress& rem_bda,
BT_HDR* p_buf) {
tL2C_LCB* p_lcb;
tBT_TRANSPORT transport = BT_TRANSPORT_BR_EDR;
if (fixed_cid >= L2CAP_ATT_CID && fixed_cid <= L2CAP_SMP_CID)
transport = BT_TRANSPORT_LE;
if ((fixed_cid < L2CAP_FIRST_FIXED_CHNL) ||
(fixed_cid > L2CAP_LAST_FIXED_CHNL) ||
(l2cb.fixed_reg[fixed_cid - L2CAP_FIRST_FIXED_CHNL].pL2CA_FixedData_Cb ==
NULL)) {
log::warn("No service registered or invalid CID: 0x{:04x}", fixed_cid);
osi_free(p_buf);
return (L2CAP_DW_FAILED);
}
if (!BTM_IsDeviceUp()) {
log::warn("Controller is not ready CID: 0x{:04x}", fixed_cid);
osi_free(p_buf);
return (L2CAP_DW_FAILED);
}
p_lcb = l2cu_find_lcb_by_bd_addr(rem_bda, transport);
if (p_lcb == NULL || p_lcb->link_state == LST_DISCONNECTING) {
/* if link is disconnecting, also report data sending failure */
log::warn("Link is disconnecting or does not exist CID: 0x{:04x}",
fixed_cid);
osi_free(p_buf);
return (L2CAP_DW_FAILED);
}
tL2C_BLE_FIXED_CHNLS_MASK peer_channel_mask;
// Select peer channels mask to use depending on transport
if (transport == BT_TRANSPORT_LE)
peer_channel_mask = l2cb.l2c_ble_fixed_chnls_mask;
else
peer_channel_mask = p_lcb->peer_chnl_mask[0];
if ((peer_channel_mask & (1 << fixed_cid)) == 0) {
log::warn("Peer does not support fixed channel CID: 0x{:04x}", fixed_cid);
osi_free(p_buf);
return (L2CAP_DW_FAILED);
}
p_buf->event = 0;
p_buf->layer_specific = L2CAP_FLUSHABLE_CH_BASED;
if (!p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL]) {
if (!l2cu_initialize_fixed_ccb(p_lcb, fixed_cid)) {
log::warn("No channel control block found for CID: 0x{:4x}", fixed_cid);
osi_free(p_buf);
return (L2CAP_DW_FAILED);
}
}
if (p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL]->cong_sent) {
log::warn(
"Unable to send data due to congestion CID: 0x{:04x} "
"xmit_hold_q.count: {} buff_quota: {}",
fixed_cid,
fixed_queue_length(
p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL]
->xmit_hold_q),
p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL]->buff_quota);
osi_free(p_buf);
return (L2CAP_DW_FAILED);
}
log::debug("Enqueued data for CID: 0x{:04x} len:{}", fixed_cid, p_buf->len);
l2c_enqueue_peer_data(p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL],
p_buf);
l2c_link_check_send_pkts(p_lcb, 0, NULL);
// If there is no dynamic CCB on the link, restart the idle timer each time
// something is sent
if (p_lcb->in_use && p_lcb->link_state == LST_CONNECTED &&
!p_lcb->ccb_queue.p_first_ccb) {
l2cu_no_dynamic_ccbs(p_lcb);
}
if (p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL]->cong_sent) {
log::debug("Link congested for CID: 0x{:04x}", fixed_cid);
return (L2CAP_DW_CONGESTED);
}
return (L2CAP_DW_SUCCESS);
}
/*******************************************************************************
*
* Function L2CA_RemoveFixedChnl
*
* Description Remove a fixed channel to a remote device.
*
* Parameters: Fixed CID
* BD Address of remote
* Idle timeout to use (or 0xFFFF if don't care)
*
* Return value: true if channel removed
*
******************************************************************************/
bool L2CA_RemoveFixedChnl(uint16_t fixed_cid, const RawAddress& rem_bda) {
tL2C_LCB* p_lcb;
tL2C_CCB* p_ccb;
tBT_TRANSPORT transport = BT_TRANSPORT_BR_EDR;
/* Check CID is valid and registered */
if ((fixed_cid < L2CAP_FIRST_FIXED_CHNL) ||
(fixed_cid > L2CAP_LAST_FIXED_CHNL) ||
(l2cb.fixed_reg[fixed_cid - L2CAP_FIRST_FIXED_CHNL].pL2CA_FixedData_Cb ==
NULL)) {
log::error("L2CA_RemoveFixedChnl() Invalid CID: 0x{:04x}", fixed_cid);
return (false);
}
if (fixed_cid >= L2CAP_ATT_CID && fixed_cid <= L2CAP_SMP_CID)
transport = BT_TRANSPORT_LE;
/* Is a fixed channel connected to the remote BDA ?*/
p_lcb = l2cu_find_lcb_by_bd_addr(rem_bda, transport);
if (((p_lcb) == NULL) ||
(!p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL])) {
log::warn("BDA: {} CID: 0x{:04x} not connected",
ADDRESS_TO_LOGGABLE_STR(rem_bda), fixed_cid);
return (false);
}
log::verbose("BDA: {} CID: 0x{:04x}", ADDRESS_TO_LOGGABLE_STR(rem_bda),
fixed_cid);
/* Release the CCB, starting an inactivity timeout on the LCB if no other CCBs
* exist */
p_ccb = p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL];
p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL] = NULL;
p_lcb->SetDisconnectReason(HCI_ERR_CONN_CAUSE_LOCAL_HOST);
// Retain the link for a few more seconds after SMP pairing is done, since
// the Android platform always does service discovery after pairing is
// complete. This will avoid the link down (pairing is complete) and an
// immediate re-connection for service discovery.
// Some devices do not do auto advertising when link is dropped, thus fail
// the second connection and service discovery.
if ((fixed_cid == L2CAP_ATT_CID) && !p_lcb->ccb_queue.p_first_ccb)
p_lcb->idle_timeout = 0;
l2cu_release_ccb(p_ccb);
return (true);
}
/*******************************************************************************
*
* Function L2CA_SetLeGattTimeout
*
* Description Higher layers call this function to set the idle timeout for
* a fixed channel. The "idle timeout" is the amount of time
* that a connection can remain up with no L2CAP channels on
* it. A timeout of zero means that the connection will be torn
* down immediately when the last channel is removed.
* A timeout of 0xFFFF means no timeout. Values are in seconds.
* A bd_addr is the remote BD address.
*
* Returns true if command succeeded, false if failed
*
******************************************************************************/
bool L2CA_SetLeGattTimeout(const RawAddress& rem_bda, uint16_t idle_tout) {
constexpr uint16_t kAttCid = 4;
/* Is a fixed channel connected to the remote BDA ?*/
tL2C_LCB* p_lcb = l2cu_find_lcb_by_bd_addr(rem_bda, BT_TRANSPORT_LE);
if (((p_lcb) == NULL) ||
(!p_lcb->p_fixed_ccbs[kAttCid - L2CAP_FIRST_FIXED_CHNL])) {
log::warn("BDA: {} CID: 0x{:04x} not connected",
ADDRESS_TO_LOGGABLE_STR(rem_bda), kAttCid);
return (false);
}
p_lcb->p_fixed_ccbs[kAttCid - L2CAP_FIRST_FIXED_CHNL]->fixed_chnl_idle_tout =
idle_tout;
if (p_lcb->in_use && p_lcb->link_state == LST_CONNECTED &&
!p_lcb->ccb_queue.p_first_ccb) {
/* If there are no dynamic CCBs, (re)start the idle timer in case we changed
* it */
l2cu_no_dynamic_ccbs(p_lcb);
}
return true;
}
bool L2CA_MarkLeLinkAsActive(const RawAddress& rem_bda) {
tL2C_LCB* p_lcb = l2cu_find_lcb_by_bd_addr(rem_bda, BT_TRANSPORT_LE);
if (p_lcb == NULL) {
return false;
}
log::info("setting link to {} as active", ADDRESS_TO_LOGGABLE_STR(rem_bda));
p_lcb->with_active_local_clients = true;
return true;
}
/*******************************************************************************
*
* Function L2CA_DataWrite
*
* Description Higher layers call this function to write data.
*
* Returns L2CAP_DW_SUCCESS, if data accepted, else false
* L2CAP_DW_CONGESTED, if data accepted and the channel is
* congested
* L2CAP_DW_FAILED, if error
*
******************************************************************************/
uint8_t L2CA_DataWrite(uint16_t cid, BT_HDR* p_data) {
log::verbose("L2CA_DataWrite() CID: 0x{:04x} Len: {}", cid, p_data->len);
return l2c_data_write(cid, p_data, L2CAP_FLUSHABLE_CH_BASED);
}
uint8_t L2CA_LECocDataWrite(uint16_t cid, BT_HDR* p_data) {
return L2CA_DataWrite(cid, p_data);
}
/*******************************************************************************
*
* Function L2CA_SetChnlFlushability
*
* Description Higher layers call this function to set a channels
* flushability flags
*
* Returns true if CID found, else false
*
******************************************************************************/
bool L2CA_SetChnlFlushability(uint16_t cid, bool is_flushable) {
tL2C_CCB* p_ccb;
/* Find the channel control block. We don't know the link it is on. */
p_ccb = l2cu_find_ccb_by_cid(NULL, cid);
if (p_ccb == NULL) {
log::warn("L2CAP - no CCB for L2CA_SetChnlFlushability, CID: {}", cid);
return (false);
}
p_ccb->is_flushable = is_flushable;
log::verbose("L2CA_SetChnlFlushability() CID: 0x{:04x} is_flushable: {}",
cid, is_flushable);
return (true);
}
/*******************************************************************************
*
* Function L2CA_FlushChannel
*
* Description This function flushes none, some or all buffers queued up
* for xmission for a particular CID. If called with
* L2CAP_FLUSH_CHANS_GET (0), it simply returns the number
* of buffers queued for that CID L2CAP_FLUSH_CHANS_ALL (0xffff)
* flushes all buffers. All other values specifies the maximum
* buffers to flush.
*
* Returns Number of buffers left queued for that CID
*
******************************************************************************/
uint16_t L2CA_FlushChannel(uint16_t lcid, uint16_t num_to_flush) {
tL2C_CCB* p_ccb;
tL2C_LCB* p_lcb;
uint16_t num_left = 0, num_flushed1 = 0, num_flushed2 = 0;
p_ccb = l2cu_find_ccb_by_cid(NULL, lcid);
if (!p_ccb || (p_ccb->p_lcb == NULL)) {
log::warn("L2CA_FlushChannel() abnormally returning 0 CID: 0x{:04x}",
lcid);
return (0);
}
p_lcb = p_ccb->p_lcb;
if (num_to_flush != L2CAP_FLUSH_CHANS_GET) {
log::verbose(
"L2CA_FlushChannel (FLUSH) CID: 0x{:04x} NumToFlush: {} QC: {} "
"pFirst: 0x{}",
lcid, num_to_flush, fixed_queue_length(p_ccb->xmit_hold_q),
fmt::ptr(fixed_queue_try_peek_first(p_ccb->xmit_hold_q)));
} else {
log::verbose("L2CA_FlushChannel (QUERY) CID: 0x{:04x}", lcid);
}
/* Cannot flush eRTM buffers once they have a sequence number */
if (p_ccb->peer_cfg.fcr.mode != L2CAP_FCR_ERTM_MODE) {
// Don't need send enhanced_flush to controller if it is LE transport.
if (p_lcb->transport != BT_TRANSPORT_LE &&
num_to_flush != L2CAP_FLUSH_CHANS_GET) {
/* If the controller supports enhanced flush, flush the data queued at the
* controller */
if (bluetooth::shim::GetController()->SupportsNonFlushablePb() &&
(BTM_GetNumScoLinks() == 0)) {
/* The only packet type defined - 0 - Automatically-Flushable Only */
btsnd_hcic_enhanced_flush(p_lcb->Handle(), 0);
}
}
// Iterate though list and flush the amount requested from
// the transmit data queue that satisfy the layer and event conditions.
for (const list_node_t* node = list_begin(p_lcb->link_xmit_data_q);
(num_to_flush > 0) && node != list_end(p_lcb->link_xmit_data_q);) {
BT_HDR* p_buf = (BT_HDR*)list_node(node);
node = list_next(node);
if ((p_buf->layer_specific == 0) && (p_buf->event == lcid)) {
num_to_flush--;
num_flushed1++;
list_remove(p_lcb->link_xmit_data_q, p_buf);
osi_free(p_buf);
}
}
}
/* If needed, flush buffers in the CCB xmit hold queue */
while ((num_to_flush != 0) && (!fixed_queue_is_empty(p_ccb->xmit_hold_q))) {
BT_HDR* p_buf = (BT_HDR*)fixed_queue_try_dequeue(p_ccb->xmit_hold_q);
osi_free(p_buf);
num_to_flush--;
num_flushed2++;
}
/* If app needs to track all packets, call it */
if ((p_ccb->p_rcb) && (p_ccb->p_rcb->api.pL2CA_TxComplete_Cb) &&
(num_flushed2))
(*p_ccb->p_rcb->api.pL2CA_TxComplete_Cb)(p_ccb->local_cid, num_flushed2);
/* Now count how many are left */
for (const list_node_t* node = list_begin(p_lcb->link_xmit_data_q);
node != list_end(p_lcb->link_xmit_data_q); node = list_next(node)) {
BT_HDR* p_buf = (BT_HDR*)list_node(node);
if (p_buf->event == lcid) num_left++;
}
/* Add in the number in the CCB xmit queue */
num_left += fixed_queue_length(p_ccb->xmit_hold_q);
/* Return the local number of buffers left for the CID */
log::verbose("L2CA_FlushChannel() flushed: {} + {}, num_left: {}",
num_flushed1, num_flushed2, num_left);
/* If we were congested, and now we are not, tell the app */
l2cu_check_channel_congestion(p_ccb);
return (num_left);
}
bool L2CA_IsLinkEstablished(const RawAddress& bd_addr,
tBT_TRANSPORT transport) {
return l2cu_find_lcb_by_bd_addr(bd_addr, transport) != nullptr;
}
/*******************************************************************************
**
** Function L2CA_SetMediaStreamChannel
**
** Description This function is called to set/reset the ccb of active media
** streaming channel
**
** Parameters: local_media_cid: The local cid provided to A2DP to be used
** for streaming
** status: The status of media streaming on this channel
**
** Returns void
**
*******************************************************************************/
void L2CA_SetMediaStreamChannel(uint16_t local_media_cid, bool status) {
uint16_t i;
int set_channel = -1;
bluetooth::hal::SnoopLogger* snoop_logger = bluetooth::shim::GetSnoopLogger();
if (snoop_logger == nullptr) {
log::error("bluetooth::shim::GetSnoopLogger() is nullptr");
return;
}
if (snoop_logger->GetBtSnoopMode() != snoop_logger->kBtSnoopLogModeFiltered) {
return;
}
log::debug("local_media_cid={}, status={}", local_media_cid,
(status ? "add" : "remove"));
if (status) {
for (i = 0; i < MAX_ACTIVE_AVDT_CONN; i++) {
if (!(av_media_channels[i].is_active)) {
set_channel = i;
break;
}
}
if (set_channel < 0) {
log::error("No empty slot found to set media channel");
return;
}
av_media_channels[set_channel].p_ccb =
l2cu_find_ccb_by_cid(NULL, local_media_cid);
if (!av_media_channels[set_channel].p_ccb ||
!av_media_channels[set_channel].p_ccb->p_lcb) {
return;
}
av_media_channels[set_channel].local_cid = local_media_cid;
snoop_logger->AddA2dpMediaChannel(
av_media_channels[set_channel].p_ccb->p_lcb->Handle(),
av_media_channels[set_channel].local_cid,
av_media_channels[set_channel].p_ccb->remote_cid);
log::verbose(
"Set A2DP media snoop filtering for local_cid: {}, remote_cid: {}",
local_media_cid, av_media_channels[set_channel].p_ccb->remote_cid);
} else {
for (i = 0; i < MAX_ACTIVE_AVDT_CONN; i++) {
if (av_media_channels[i].is_active &&
av_media_channels[i].local_cid == local_media_cid) {
set_channel = i;
break;
}
}
if (set_channel < 0) {
log::error("The channel {} not found in active media channels",
local_media_cid);
return;
}
if (!av_media_channels[set_channel].p_ccb ||
!av_media_channels[set_channel].p_ccb->p_lcb) {
return;
}
snoop_logger->RemoveA2dpMediaChannel(
av_media_channels[set_channel].p_ccb->p_lcb->Handle(),
av_media_channels[set_channel].local_cid);
log::verbose("Reset A2DP media snoop filtering for local_cid: {}",
local_media_cid);
}
av_media_channels[set_channel].is_active = status;
}
/*******************************************************************************
**
** Function L2CA_isMediaChannel
**
** Description This function returns if the channel id passed as parameter
** is an A2DP streaming channel
**
** Parameters: handle: Connection handle with the remote device
** channel_id: Channel ID
** is_local_cid: Signifies if the channel id passed is local
** cid or remote cid (true if local, remote otherwise)
**
** Returns bool
**
*******************************************************************************/
bool L2CA_isMediaChannel(uint16_t handle, uint16_t channel_id,
bool is_local_cid) {
int i;
bool ret = false;
for (i = 0; i < MAX_ACTIVE_AVDT_CONN; i++) {
if (av_media_channels[i].is_active) {
if (!av_media_channels[i].p_ccb || !av_media_channels[i].p_ccb->p_lcb) {
continue;
}
if (((!is_local_cid &&
channel_id == av_media_channels[i].p_ccb->remote_cid) ||
(is_local_cid &&
channel_id == av_media_channels[i].p_ccb->local_cid)) &&
handle == av_media_channels[i].p_ccb->p_lcb->Handle()) {
ret = true;
break;
}
}
}
return ret;
}