Google Git
Sign in
android / platform / system / bt / ea7ab70a711e642653dd5922b83aa04a53af9e0e / . / stack / l2cap / l2c_api.cc
blob: b0d7d330a96386b555fef3e886a670685c37b123 [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 "main/shim/l2c_api.h"
#include <base/logging.h>
#include <base/strings/stringprintf.h>
#include <cstdint>
#include <string>
#include "btm_sec.h"
#include "device/include/controller.h" // TODO Remove
#include "main/shim/shim.h"
#include "osi/include/allocator.h"
#include "osi/include/log.h"
#include "stack/include/bt_hdr.h"
#include "stack/include/l2c_api.h"
#include "stack/l2cap/l2c_int.h"
#include "types/raw_address.h"
void btsnd_hcic_enhanced_flush(uint16_t handle,
uint8_t packet_type); // TODO Remove
using base::StringPrintf;
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);
BTM_SetSecurityLevel(false, "", 0, sec_level, psm, 0, 0);
return ret;
}
/*******************************************************************************
*
* 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) {
if (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_Register(psm, p_cb_info, enable_snoop,
p_ertm_info, my_mtu,
required_remote_mtu, 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:%u cfg_ind:%u"
" data_ind:%u discon_int:%u",
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) {
if (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_Deregister(psm);
}
tL2C_RCB* p_rcb;
tL2C_CCB* p_ccb;
tL2C_LCB* p_lcb;
int ii;
L2CAP_TRACE_API("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 {
L2CAP_TRACE_WARNING("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) {
if (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_AllocateLePSM();
}
bool done = false;
uint16_t psm = l2cb.le_dyn_psm;
uint16_t count = 0;
L2CAP_TRACE_API("%s: last psm=%d", __func__, psm);
while (!done) {
count++;
if (count > LE_DYNAMIC_PSM_RANGE) {
L2CAP_TRACE_ERROR("%s: Out of free BLE PSM", __func__);
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)) {
L2CAP_TRACE_WARNING("%s: supposedly-free PSM=%d have allocated rcb!",
__func__, psm);
continue;
}
l2cb.le_dyn_psm_assigned[psm - LE_DYNAMIC_PSM_START] = true;
L2CAP_TRACE_DEBUG("%s: assigned PSM=%d", __func__, 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) {
if (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_FreeLePSM(psm);
}
L2CAP_TRACE_API("%s: to free psm=%d", __func__, psm);
if ((psm < LE_DYNAMIC_PSM_START) || (psm > LE_DYNAMIC_PSM_END)) {
L2CAP_TRACE_ERROR("%s: Invalid PSM=%d value!", __func__, psm);
return;
}
if (!l2cb.le_dyn_psm_assigned[psm - LE_DYNAMIC_PSM_START]) {
L2CAP_TRACE_WARNING("%s: PSM=%d was not allocated!", __func__, 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) {
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) {
if (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_ConnectReq(psm, p_bd_addr);
}
VLOG(1) << __func__ << "BDA " << p_bd_addr
<< StringPrintf(" PSM: 0x%04x", psm);
/* Fail if we have not established communications with the controller */
if (!BTM_IsDeviceUp()) {
LOG(WARNING) << __func__ << ": 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(WARNING) << __func__ << ": 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(WARNING) << __func__
<< ": connection not started for PSM=" << loghex(psm)
<< ", p_lcb=" << 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(WARNING) << __func__ << ": 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
*/
L2CAP_TRACE_DEBUG("L2CAP API - link disconnecting: RETRY LATER");
/* Save ccb so it can be started after disconnect is finished */
p_lcb->p_pending_ccb = p_ccb;
}
L2CAP_TRACE_API("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 (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_RegisterLECoc(psm, p_cb_info, sec_level, 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.
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) {
if (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_DeregisterLECoc(psm);
}
L2CAP_TRACE_API("%s called for PSM: 0x%04x", __func__, psm);
tL2C_RCB* p_rcb = l2cu_find_ble_rcb_by_psm(psm);
if (p_rcb == NULL) {
L2CAP_TRACE_WARNING("%s PSM: 0x%04x not found for deregistration", __func__,
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) {
if (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_ConnectLECocReq(psm, p_bd_addr, p_cfg);
}
BTM_SetSecurityLevel(true, "", 0, sec_level, psm, 0, 0);
VLOG(1) << __func__ << " BDA: " << p_bd_addr
<< StringPrintf(" PSM: 0x%04x", psm);
/* Fail if we have not established communications with the controller */
if (!BTM_IsDeviceUp()) {
L2CAP_TRACE_WARNING("%s BTU not ready", __func__);
return 0;
}
/* Fail if the PSM is not registered */
tL2C_RCB* p_rcb = l2cu_find_ble_rcb_by_psm(psm);
if (p_rcb == NULL) {
L2CAP_TRACE_WARNING("%s No BLE RCB, PSM: 0x%04x", __func__, 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))) {
L2CAP_TRACE_WARNING("%s conn not started for PSM: 0x%04x p_lcb: 0x%08x",
__func__, psm, p_lcb);
return 0;
}
}
/* Allocate a channel control block */
tL2C_CCB* p_ccb = l2cu_allocate_ccb(p_lcb, 0);
if (p_ccb == NULL) {
L2CAP_TRACE_WARNING("%s no CCB, PSM: 0x%04x", __func__, 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) {
L2CAP_TRACE_DEBUG("%s LE Link is up", __func__);
l2c_csm_execute(p_ccb, L2CEVT_L2CA_CONNECT_REQ, NULL);
}
}
/* 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) {
L2CAP_TRACE_DEBUG("%s link disconnecting: RETRY LATER", __func__);
/* Save ccb so it can be started after disconnect is finished */
p_lcb->p_pending_ccb = p_ccb;
}
L2CAP_TRACE_API("%s(psm: 0x%04x) returned CID: 0x%04x", __func__, 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) {
if (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_GetPeerLECocConfig(lcid, peer_cfg);
}
L2CAP_TRACE_API("%s CID: 0x%04x", __func__, lcid);
tL2C_CCB* p_ccb = l2cu_find_ccb_by_cid(NULL, lcid);
if (p_ccb == NULL) {
L2CAP_TRACE_ERROR("%s No CCB for CID:0x%04x", __func__, lcid);
return false;
}
if (peer_cfg != NULL)
memcpy(peer_cfg, &p_ccb->peer_conn_cfg, sizeof(tL2CAP_LE_CFG_INFO));
return true;
}
/*******************************************************************************
*
* 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) {
if (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_ConnectCreditBasedRsp(
p_bd_addr, id, accepted_lcids, result, p_cfg);
}
VLOG(1) << __func__ << " BDA: " << p_bd_addr
<< StringPrintf(" num of cids: %d Result: %d",
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 */
L2CAP_TRACE_WARNING("%s no LCB", __func__);
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);
for (uint16_t cid : accepted_lcids) {
tL2C_CCB* temp_p_ccb = l2cu_find_ccb_by_cid(p_lcb, cid);
if (temp_p_ccb == NULL) {
L2CAP_TRACE_WARNING("%s no CCB", __func__);
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) {
L2CAP_TRACE_WARNING("%s bad id. Expected: %d Got: %d", __func__,
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) {
if (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_ConnectCreditBasedReq(psm, p_bd_addr, p_cfg);
}
VLOG(1) << __func__ << " BDA: " << p_bd_addr
<< StringPrintf(" PSM: 0x%04x", psm);
std::vector<uint16_t> allocated_cids;
/* Fail if we have not established communications with the controller */
if (!BTM_IsDeviceUp()) {
L2CAP_TRACE_WARNING("%s BTU not ready", __func__);
return allocated_cids;
}
if (!p_cfg) {
L2CAP_TRACE_WARNING("%s p_cfg is NULL", __func__);
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) {
L2CAP_TRACE_WARNING("%s No BLE RCB, PSM: 0x%04x", __func__, 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) {
L2CAP_TRACE_WARNING("%s No link available", __func__);
return allocated_cids;
}
if (p_lcb->link_state != LST_CONNECTED) {
L2CAP_TRACE_WARNING("%s incorrect link state: %d", __func__,
p_lcb->link_state);
return allocated_cids;
}
L2CAP_TRACE_DEBUG("%s LE Link is up", __func__);
tL2C_CCB* p_ccb_primary;
for (int i = 0; i < 5; i++) {
/* Allocate a channel control block */
tL2C_CCB* p_ccb = l2cu_allocate_ccb(p_lcb, 0);
if (p_ccb == NULL) {
if (i == 0) {
L2CAP_TRACE_WARNING("%s no CCB, PSM: 0x%04x", __func__, 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);
L2CAP_TRACE_API("%s(psm: 0x%04x) returned CID: 0x%04x", __func__, 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
* 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) {
if (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_ReconfigCreditBasedConnsReq(bda, lcids, p_cfg);
}
tL2C_CCB* p_ccb;
L2CAP_TRACE_API("L2CA_ReconfigCreditBasedConnsReq() ");
if (lcids.empty()) {
L2CAP_TRACE_WARNING("L2CAP - no lcids given to %s", __func__);
return (false);
}
for (uint16_t cid : lcids) {
p_ccb = l2cu_find_ccb_by_cid(NULL, cid);
if (!p_ccb) {
L2CAP_TRACE_WARNING("L2CAP - no CCB for L2CA_cfg_req, CID: %d", cid);
return (false);
}
if ((p_ccb->local_conn_cfg.mtu > p_cfg->mtu) ||
(p_ccb->local_conn_cfg.mps > p_cfg->mps)) {
L2CAP_TRACE_WARNING("L2CAP - MPS or MTU reduction, CID: %d", cid);
return (false);
}
}
if (p_cfg->mtu > L2CAP_MTU_SIZE) {
L2CAP_TRACE_WARNING("L2CAP - adjust MTU: %u 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) {
L2CAP_TRACE_API(" cid: %d", cid);
p_ccb = l2cu_find_ccb_by_cid(NULL, cid);
if (!p_ccb) {
LOG(ERROR) << __func__ << "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) {
if (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_DisconnectReq(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: %d", 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) {
if (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_DisconnectLECocReq(cid);
}
return L2CA_DisconnectReq(cid);
}
bool L2CA_GetRemoteCid(uint16_t lcid, uint16_t* rcid) {
if (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_GetRemoteCid(lcid, 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) {
if (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_SetIdleTimeoutByBdAddr(bd_addr, timeout,
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_SetTraceLevel
*
* Description This function sets the trace level for L2CAP. If called with
* a value of 0xFF, it simply reads the current trace level.
*
* Returns the new (current) trace level
*
******************************************************************************/
uint8_t L2CA_SetTraceLevel(uint8_t new_level) {
if (new_level != 0xFF) l2cb.l2cap_trace_level = new_level;
return (l2cb.l2cap_trace_level);
}
/*******************************************************************************
*
* 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) {
if (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_SetAclPriority(bd_addr, priority);
}
VLOG(1) << __func__ << " BDA: " << bd_addr
<< ", priority: " << std::to_string(priority);
return (l2cu_set_acl_priority(bd_addr, priority, false));
}
/*******************************************************************************
*
* 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) {
if (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_SetTxPriority(cid, priority);
}
tL2C_CCB* p_ccb;
L2CAP_TRACE_API("L2CA_SetTxPriority() CID: 0x%04x, priority:%d", 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) {
L2CAP_TRACE_WARNING("L2CAP - no CCB for L2CA_SetTxPriority, CID: %d", 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) {
if (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_GetPeerFeatures(bd_addr, p_ext_feat,
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(WARNING) << __func__ << " No BDA: " << bd_addr;
return false;
}
VLOG(1) << __func__ << " BDA: " << bd_addr
<< StringPrintf(" ExtFea: 0x%08x Chnl_Mask[0]: 0x%02x",
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 (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_RegisterFixedChannel(fixed_cid, 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:%s",
fixed_channel_text(fixed_cid).c_str());
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) {
if (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_ConnectFixedChnl(fixed_cid, 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) {
if (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_SendFixedChnlData(fixed_cid, rem_bda, 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: "
"%zu buff_quota: %u",
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:%hu", 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) {
if (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_RemoveFixedChnl(fixed_cid, 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)) {
L2CAP_TRACE_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(WARNING) << __func__ << " BDA: " << rem_bda
<< StringPrintf(" CID: 0x%04x not connected", fixed_cid);
return (false);
}
VLOG(2) << __func__ << " BDA: " << rem_bda
<< StringPrintf(" CID: 0x%04x", 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) {
if (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_SetLeGattTimeout(rem_bda, 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(WARNING) << __func__ << " BDA: " << rem_bda
<< StringPrintf(" CID: 0x%04x not connected", 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;
}
/*******************************************************************************
*
* 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) {
if (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_DataWrite(cid, p_data);
}
L2CAP_TRACE_API("L2CA_DataWrite() CID: 0x%04x Len: %d", 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) {
if (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_LECocDataWrite(cid, 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) {
if (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_SetChnlFlushability(cid, 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) {
L2CAP_TRACE_WARNING("L2CAP - no CCB for L2CA_SetChnlFlushability, CID: %d",
cid);
return (false);
}
p_ccb->is_flushable = is_flushable;
L2CAP_TRACE_API("L2CA_SetChnlFlushability() CID: 0x%04x is_flushable: %d",
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) {
if (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_FlushChannel(lcid, 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)) {
L2CAP_TRACE_WARNING(
"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) {
L2CAP_TRACE_API(
"L2CA_FlushChannel (FLUSH) CID: 0x%04x NumToFlush: %d QC: %u "
"pFirst: 0x%08x",
lcid, num_to_flush, fixed_queue_length(p_ccb->xmit_hold_q),
fixed_queue_try_peek_first(p_ccb->xmit_hold_q));
} else {
L2CAP_TRACE_API("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) {
const controller_t* controller = controller_get_interface();
if (num_to_flush != L2CAP_FLUSH_CHANS_GET) {
/* If the controller supports enhanced flush, flush the data queued at the
* controller */
if (controller->supports_non_flushable_pb() &&
(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 */
L2CAP_TRACE_DEBUG("L2CA_FlushChannel() flushed: %u + %u, num_left: %u",
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) {
if (bluetooth::shim::is_gd_l2cap_enabled()) {
return bluetooth::shim::L2CA_IsLinkEstablished(bd_addr, transport);
}
return l2cu_find_lcb_by_bd_addr(bd_addr, transport) != nullptr;
}