Gitiles
Code Review Sign In
LeafOS / LeafOS-Project / android_packages_modules_Bluetooth / 1abe2173d249f24a9dbda6e6298e402130d0f27a / . / system / stack / gatt / gatt_utils.cc
blob: 575d24f005d10771bdc112496950a6b97ebc6b07 [file] [log] [blame]
/******************************************************************************
*
* Copyright 2009-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 GATT utility functions
*
******************************************************************************/
#define LOG_TAG "gatt_utils"
#include <base/logging.h>
#include <base/strings/stringprintf.h>
#include <bluetooth/log.h>
#include <cstdint>
#include <deque>
#include "hardware/bt_gatt_types.h"
#include "internal_include/bt_target.h"
#include "os/log.h"
#include "osi/include/allocator.h"
#include "rust/src/connection/ffi/connection_shim.h"
#include "stack/btm/btm_sec.h"
#include "stack/eatt/eatt.h"
#include "stack/gatt/connection_manager.h"
#include "stack/gatt/gatt_int.h"
#include "stack/include/bt_hdr.h"
#include "stack/include/bt_psm_types.h"
#include "stack/include/bt_types.h"
#include "stack/include/bt_uuid16.h"
#include "stack/include/l2cdefs.h"
#include "stack/include/sdp_api.h"
#include "types/bluetooth/uuid.h"
#include "types/raw_address.h"
uint8_t btm_ble_read_sec_key_size(const RawAddress& bd_addr);
using namespace bluetooth::legacy::stack::sdp;
using namespace bluetooth;
using bluetooth::Uuid;
using bluetooth::eatt::EattExtension;
using bluetooth::eatt::EattChannel;
/* check if [x, y] and [a, b] have overlapping range */
#define GATT_VALIDATE_HANDLE_RANGE(x, y, a, b) ((y) >= (a) && (x) <= (b))
#define GATT_GET_NEXT_VALID_HANDLE(x) (((x) / 10 + 1) * 10)
const char* const op_code_name[] = {"UNKNOWN",
"ATT_RSP_ERROR",
"ATT_REQ_MTU",
"ATT_RSP_MTU",
"ATT_REQ_READ_INFO",
"ATT_RSP_READ_INFO",
"ATT_REQ_FIND_TYPE_VALUE",
"ATT_RSP_FIND_TYPE_VALUE",
"ATT_REQ_READ_BY_TYPE",
"ATT_RSP_READ_BY_TYPE",
"ATT_REQ_READ",
"ATT_RSP_READ",
"ATT_REQ_READ_BLOB",
"ATT_RSP_READ_BLOB",
"GATT_REQ_READ_MULTI",
"GATT_RSP_READ_MULTI",
"GATT_REQ_READ_BY_GRP_TYPE",
"GATT_RSP_READ_BY_GRP_TYPE",
"ATT_REQ_WRITE",
"ATT_RSP_WRITE",
"ATT_CMD_WRITE",
"ATT_SIGN_CMD_WRITE",
"ATT_REQ_PREPARE_WRITE",
"ATT_RSP_PREPARE_WRITE",
"ATT_REQ_EXEC_WRITE",
"ATT_RSP_EXEC_WRITE",
"Reserved",
"ATT_HANDLE_VALUE_NOTIF",
"Reserved",
"ATT_HANDLE_VALUE_IND",
"ATT_HANDLE_VALUE_CONF",
"ATT_OP_CODE_MAX"};
uint16_t gatt_get_local_mtu(void) {
/* Default ATT MTU must not be greater than GATT_MAX_MTU_SIZE, nor smaller
* than GATT_DEF_BLE_MTU_SIZE */
const static uint16_t ATT_MTU_DEFAULT =
std::max(std::min(bluetooth::common::init_flags::get_att_mtu_default(),
GATT_MAX_MTU_SIZE),
GATT_DEF_BLE_MTU_SIZE);
return ATT_MTU_DEFAULT;
}
/*******************************************************************************
*
* Function gatt_free_pending_ind
*
* Description Free all pending indications
*
* Returns None
*
******************************************************************************/
void gatt_free_pending_ind(tGATT_TCB* p_tcb) {
log::verbose("");
if (p_tcb->pending_ind_q == NULL) return;
/* release all queued indications */
while (!fixed_queue_is_empty(p_tcb->pending_ind_q))
osi_free(fixed_queue_try_dequeue(p_tcb->pending_ind_q));
fixed_queue_free(p_tcb->pending_ind_q, NULL);
p_tcb->pending_ind_q = NULL;
}
/*******************************************************************************
*
* Function gatt_delete_dev_from_srv_chg_clt_list
*
* Description Delete a device from the service changed client lit
*
* Returns None
*
******************************************************************************/
void gatt_delete_dev_from_srv_chg_clt_list(const RawAddress& bd_addr) {
log::verbose("");
tGATTS_SRV_CHG* p_buf = gatt_is_bda_in_the_srv_chg_clt_list(bd_addr);
if (p_buf != NULL) {
if (gatt_cb.cb_info.p_srv_chg_callback) {
/* delete from NV */
tGATTS_SRV_CHG_REQ req;
req.srv_chg.bda = bd_addr;
(*gatt_cb.cb_info.p_srv_chg_callback)(GATTS_SRV_CHG_CMD_REMOVE_CLIENT,
&req, NULL);
}
osi_free(fixed_queue_try_remove_from_queue(gatt_cb.srv_chg_clt_q, p_buf));
}
}
/*******************************************************************************
*
* Function gatt_set_srv_chg
*
* Description Set the service changed flag to true
*
* Returns None
*
******************************************************************************/
void gatt_set_srv_chg(void) {
log::verbose("");
if (fixed_queue_is_empty(gatt_cb.srv_chg_clt_q)) return;
list_t* list = fixed_queue_get_list(gatt_cb.srv_chg_clt_q);
for (const list_node_t* node = list_begin(list); node != list_end(list);
node = list_next(node)) {
log::verbose("found a srv_chg clt");
tGATTS_SRV_CHG* p_buf = (tGATTS_SRV_CHG*)list_node(node);
if (!p_buf->srv_changed) {
log::verbose("set srv_changed to true");
p_buf->srv_changed = true;
tGATTS_SRV_CHG_REQ req;
memcpy(&req.srv_chg, p_buf, sizeof(tGATTS_SRV_CHG));
if (gatt_cb.cb_info.p_srv_chg_callback)
(*gatt_cb.cb_info.p_srv_chg_callback)(GATTS_SRV_CHG_CMD_UPDATE_CLIENT,
&req, NULL);
}
}
}
/** Add a pending indication */
void gatt_add_pending_ind(tGATT_TCB* p_tcb, tGATT_VALUE* p_ind) {
log::verbose("enqueue a pending indication");
tGATT_VALUE* p_buf = (tGATT_VALUE*)osi_malloc(sizeof(tGATT_VALUE));
memcpy(p_buf, p_ind, sizeof(tGATT_VALUE));
fixed_queue_enqueue(p_tcb->pending_ind_q, p_buf);
}
/*******************************************************************************
*
* Function gatt_add_srv_chg_clt
*
* Description Add a service chnage client to the service change client queue
*
* Returns Pointer to the service change client buffer; Null no buffer
* available
*
******************************************************************************/
tGATTS_SRV_CHG* gatt_add_srv_chg_clt(tGATTS_SRV_CHG* p_srv_chg) {
tGATTS_SRV_CHG* p_buf = (tGATTS_SRV_CHG*)osi_malloc(sizeof(tGATTS_SRV_CHG));
log::verbose("enqueue a srv chg client");
memcpy(p_buf, p_srv_chg, sizeof(tGATTS_SRV_CHG));
fixed_queue_enqueue(gatt_cb.srv_chg_clt_q, p_buf);
return p_buf;
}
/**
* Returns pointer to the handle range buffer starting at handle |handle|,
* nullptr
* if no buffer available
*/
tGATT_HDL_LIST_ELEM* gatt_find_hdl_buffer_by_handle(uint16_t handle) {
for (auto& elem : *gatt_cb.hdl_list_info) {
if (elem.asgn_range.s_handle == handle) return &elem;
}
return nullptr;
}
/*******************************************************************************
*
* Description Find handle range buffer by app ID, service and service instance
* ID.
*
* Returns Pointer to the buffer, NULL no buffer available
*
******************************************************************************/
std::list<tGATT_HDL_LIST_ELEM>::iterator gatt_find_hdl_buffer_by_app_id(
const Uuid& app_uuid128, Uuid* p_svc_uuid, uint16_t start_handle) {
auto end_it = gatt_cb.hdl_list_info->end();
auto it = gatt_cb.hdl_list_info->begin();
for (; it != end_it; it++) {
if (app_uuid128 == it->asgn_range.app_uuid128 &&
*p_svc_uuid == it->asgn_range.svc_uuid &&
(start_handle == it->asgn_range.s_handle)) {
return it;
}
}
return it;
}
/**
* free the service attribute database buffers by the owner of the service app
* ID.
*/
void gatt_free_srvc_db_buffer_app_id(const Uuid& app_id) {
auto it = gatt_cb.hdl_list_info->begin();
auto end = gatt_cb.hdl_list_info->end();
while (it != end) {
if (app_id == it->asgn_range.app_uuid128) {
it = gatt_cb.hdl_list_info->erase(it);
} else {
it++;
}
}
}
/*******************************************************************************
*
* Function gatt_find_the_connected_bda
*
* Description This function find the connected bda
*
* Returns true if found
*
******************************************************************************/
bool gatt_find_the_connected_bda(uint8_t start_idx, RawAddress& bda,
uint8_t* p_found_idx,
tBT_TRANSPORT* p_transport) {
uint8_t i;
bool found = false;
log::debug("start_idx={}", start_idx);
for (i = start_idx; i < GATT_MAX_PHY_CHANNEL; i++) {
if (gatt_cb.tcb[i].in_use && gatt_cb.tcb[i].ch_state == GATT_CH_OPEN) {
bda = gatt_cb.tcb[i].peer_bda;
*p_found_idx = i;
*p_transport = gatt_cb.tcb[i].transport;
found = true;
log::debug("bda: {}", ADDRESS_TO_LOGGABLE_CSTR(bda));
break;
}
}
log::debug("found={} found_idx={}", found, i);
return found;
}
/*******************************************************************************
*
* Function gatt_is_srv_chg_ind_pending
*
* Description Check whether a service chnaged is in the indication pending
* queue or waiting for an Ack already
*
* Returns bool
*
******************************************************************************/
bool gatt_is_srv_chg_ind_pending(tGATT_TCB* p_tcb) {
log::verbose("is_queue_empty={}", fixed_queue_is_empty(p_tcb->pending_ind_q));
if (p_tcb->indicate_handle == gatt_cb.handle_of_h_r) return true;
if (p_tcb->eatt && EattExtension::GetInstance()->IsIndicationPending(
p_tcb->peer_bda, gatt_cb.handle_of_h_r))
return true;
if (fixed_queue_is_empty(p_tcb->pending_ind_q)) return false;
list_t* list = fixed_queue_get_list(p_tcb->pending_ind_q);
for (const list_node_t* node = list_begin(list); node != list_end(list);
node = list_next(node)) {
tGATT_VALUE* p_buf = (tGATT_VALUE*)list_node(node);
if (p_buf->handle == gatt_cb.handle_of_h_r) {
return true;
}
}
return false;
}
/*******************************************************************************
*
* Function gatt_is_bda_in_the_srv_chg_clt_list
*
* Description This function check the specified bda is in the srv chg
* client list or not
*
* Returns pointer to the found elemenet otherwise NULL
*
******************************************************************************/
tGATTS_SRV_CHG* gatt_is_bda_in_the_srv_chg_clt_list(const RawAddress& bda) {
log::verbose("{}", ADDRESS_TO_LOGGABLE_STR(bda));
if (fixed_queue_is_empty(gatt_cb.srv_chg_clt_q)) return NULL;
list_t* list = fixed_queue_get_list(gatt_cb.srv_chg_clt_q);
for (const list_node_t* node = list_begin(list); node != list_end(list);
node = list_next(node)) {
tGATTS_SRV_CHG* p_buf = (tGATTS_SRV_CHG*)list_node(node);
if (bda == p_buf->bda) {
log::verbose("bda is in the srv chg clt list");
return p_buf;
}
}
return NULL;
}
/*******************************************************************************
*
* Function gatt_is_bda_connected
*
* Description
*
* Returns GATT_INDEX_INVALID if not found. Otherwise index to the tcb.
*
******************************************************************************/
bool gatt_is_bda_connected(const RawAddress& bda) {
uint8_t i = 0;
bool connected = false;
for (i = 0; i < GATT_MAX_PHY_CHANNEL; i++) {
if (gatt_cb.tcb[i].in_use && gatt_cb.tcb[i].peer_bda == bda) {
connected = true;
break;
}
}
return connected;
}
/*******************************************************************************
*
* Function gatt_find_i_tcb_by_addr
*
* Description Search for an empty tcb entry, and return the index.
*
* Returns GATT_INDEX_INVALID if not found. Otherwise index to the tcb.
*
******************************************************************************/
uint8_t gatt_find_i_tcb_by_addr(const RawAddress& bda,
tBT_TRANSPORT transport) {
uint8_t i = 0;
for (; i < GATT_MAX_PHY_CHANNEL; i++) {
if (gatt_cb.tcb[i].peer_bda == bda &&
gatt_cb.tcb[i].transport == transport) {
return i;
}
}
return GATT_INDEX_INVALID;
}
/*******************************************************************************
*
* Function gatt_get_tcb_by_idx
*
* Description The function get TCB using the TCB index
*
* Returns NULL if not found. Otherwise index to the tcb.
*
******************************************************************************/
tGATT_TCB* gatt_get_tcb_by_idx(uint8_t tcb_idx) {
tGATT_TCB* p_tcb = NULL;
if ((tcb_idx < GATT_MAX_PHY_CHANNEL) && gatt_cb.tcb[tcb_idx].in_use)
p_tcb = &gatt_cb.tcb[tcb_idx];
return p_tcb;
}
/*******************************************************************************
*
* Function gatt_find_tcb_by_addr
*
* Description Search for an empty tcb entry, and return pointer.
*
* Returns NULL if not found. Otherwise index to the tcb.
*
******************************************************************************/
tGATT_TCB* gatt_find_tcb_by_addr(const RawAddress& bda,
tBT_TRANSPORT transport) {
tGATT_TCB* p_tcb = nullptr;
uint8_t i = 0;
i = gatt_find_i_tcb_by_addr(bda, transport);
if (i != GATT_INDEX_INVALID) p_tcb = &gatt_cb.tcb[i];
return p_tcb;
}
/*******************************************************************************
*
* Function gatt_allocate_tcb_by_bdaddr
*
* Description Locate or allocate a new tcb entry for matching bda.
*
* Returns GATT_INDEX_INVALID if not found. Otherwise index to the tcb.
*
******************************************************************************/
tGATT_TCB* gatt_allocate_tcb_by_bdaddr(const RawAddress& bda,
tBT_TRANSPORT transport) {
/* search for existing tcb with matching bda */
uint8_t j = gatt_find_i_tcb_by_addr(bda, transport);
if (j != GATT_INDEX_INVALID) return &gatt_cb.tcb[j];
/* find free tcb */
for (int i = 0; i < GATT_MAX_PHY_CHANNEL; i++) {
tGATT_TCB* p_tcb = &gatt_cb.tcb[i];
if (p_tcb->in_use) continue;
*p_tcb = tGATT_TCB();
p_tcb->pending_ind_q = fixed_queue_new(SIZE_MAX);
p_tcb->conf_timer = alarm_new("gatt.conf_timer");
p_tcb->ind_ack_timer = alarm_new("gatt.ind_ack_timer");
p_tcb->in_use = true;
p_tcb->tcb_idx = i;
p_tcb->transport = transport;
p_tcb->peer_bda = bda;
p_tcb->eatt = 0;
p_tcb->pending_user_mtu_exchange_value = 0;
p_tcb->conn_ids_waiting_for_mtu_exchange = std::list<uint16_t>();
p_tcb->max_user_mtu = 0;
gatt_sr_init_cl_status(*p_tcb);
gatt_cl_init_sr_status(*p_tcb);
return p_tcb;
}
return NULL;
}
uint16_t gatt_get_mtu(const RawAddress& bda, tBT_TRANSPORT transport) {
tGATT_TCB* p_tcb = gatt_find_tcb_by_addr(bda, transport);
if (!p_tcb) return 0;
return p_tcb->payload_size;
}
bool gatt_is_pending_mtu_exchange(tGATT_TCB* p_tcb) {
return p_tcb->pending_user_mtu_exchange_value != 0;
}
void gatt_set_conn_id_waiting_for_mtu_exchange(tGATT_TCB* p_tcb,
uint16_t conn_id) {
auto it = std::find(p_tcb->conn_ids_waiting_for_mtu_exchange.begin(),
p_tcb->conn_ids_waiting_for_mtu_exchange.end(), conn_id);
if (it == p_tcb->conn_ids_waiting_for_mtu_exchange.end()) {
p_tcb->conn_ids_waiting_for_mtu_exchange.push_back(conn_id);
log::info("Put conn_id=0x{:04x} on wait list", conn_id);
} else {
log::info("Conn_id=0x{:04x} already on wait list", conn_id);
}
}
/** gatt_build_uuid_to_stream will convert 32bit UUIDs to 128bit. This function
* will return lenght required to build uuid, either |UUID:kNumBytes16| or
* |UUID::kNumBytes128| */
uint8_t gatt_build_uuid_to_stream_len(const Uuid& uuid) {
size_t len = uuid.GetShortestRepresentationSize();
return len == Uuid::kNumBytes32 ? Uuid::kNumBytes128 : len;
}
/** Add UUID into stream. Returns UUID length. */
uint8_t gatt_build_uuid_to_stream(uint8_t** p_dst, const Uuid& uuid) {
uint8_t* p = *p_dst;
size_t len = uuid.GetShortestRepresentationSize();
if (uuid.IsEmpty()) {
return 0;
}
if (len == Uuid::kNumBytes16) {
UINT16_TO_STREAM(p, uuid.As16Bit());
} else if (len == Uuid::kNumBytes32) {
/* always convert 32 bits into 128 bits */
ARRAY_TO_STREAM(p, uuid.To128BitLE(), (int)Uuid::kNumBytes128);
len = Uuid::kNumBytes128;
} else if (len == Uuid::kNumBytes128) {
ARRAY_TO_STREAM(p, uuid.To128BitLE(), (int)Uuid::kNumBytes128);
}
*p_dst = p;
return len;
}
bool gatt_parse_uuid_from_cmd(Uuid* p_uuid_rec, uint16_t uuid_size,
uint8_t** p_data) {
bool ret = true;
uint8_t* p_uuid = *p_data;
switch (uuid_size) {
case Uuid::kNumBytes16: {
uint16_t val;
STREAM_TO_UINT16(val, p_uuid);
*p_uuid_rec = Uuid::From16Bit(val);
*p_data += Uuid::kNumBytes16;
return true;
}
case Uuid::kNumBytes128: {
*p_uuid_rec = Uuid::From128BitLE(p_uuid);
*p_data += Uuid::kNumBytes128;
return true;
}
/* do not allow 32 bits UUID in ATT PDU now */
case Uuid::kNumBytes32:
log::error("DO NOT ALLOW 32 BITS UUID IN ATT PDU");
return false;
case 0:
default:
if (uuid_size != 0) ret = false;
log::warn("invalid uuid size");
break;
}
return (ret);
}
/*******************************************************************************
*
* Function gatt_start_rsp_timer
*
* Description Start a wait_for_response timer.
*
* Returns void
*
******************************************************************************/
void gatt_start_rsp_timer(tGATT_CLCB* p_clcb) {
uint64_t timeout_ms = GATT_WAIT_FOR_RSP_TIMEOUT_MS;
if (p_clcb->operation == GATTC_OPTYPE_DISCOVERY &&
p_clcb->op_subtype == GATT_DISC_SRVC_ALL) {
timeout_ms = GATT_WAIT_FOR_DISC_RSP_TIMEOUT_MS;
}
// TODO: The tGATT_CLCB memory and state management needs cleanup,
// and then the timers can be allocated elsewhere.
if (p_clcb->gatt_rsp_timer_ent == NULL) {
p_clcb->gatt_rsp_timer_ent = alarm_new("gatt.gatt_rsp_timer_ent");
}
alarm_set_on_mloop(p_clcb->gatt_rsp_timer_ent, timeout_ms, gatt_rsp_timeout,
p_clcb);
}
/*******************************************************************************
*
* Function gatt_stop_rsp_timer
*
* Description Stops a GATT response timer.
*
* Returns void
*
******************************************************************************/
void gatt_stop_rsp_timer(tGATT_CLCB* p_clcb) {
alarm_cancel(p_clcb->gatt_rsp_timer_ent);
}
/*******************************************************************************
*
* Function gatt_start_conf_timer
*
* Description Start a wait_for_confirmation timer.
*
* Returns void
*
******************************************************************************/
void gatt_start_conf_timer(tGATT_TCB* p_tcb, uint16_t cid) {
/* start notification cache timer */
if (p_tcb->eatt && cid != L2CAP_ATT_CID)
EattExtension::GetInstance()->StartIndicationConfirmationTimer(p_tcb->peer_bda, cid);
else
alarm_set_on_mloop(p_tcb->conf_timer, GATT_WAIT_FOR_RSP_TIMEOUT_MS,
gatt_indication_confirmation_timeout, p_tcb);
}
/*******************************************************************************
*
* Function gatt_stop_conf_timer
*
* Description Start a wait_for_confirmation timer.
*
* Returns void
*
******************************************************************************/
void gatt_stop_conf_timer(tGATT_TCB& tcb, uint16_t cid) {
/* start notification cache timer */
if (tcb.eatt && cid != L2CAP_ATT_CID)
EattExtension::GetInstance()->StopIndicationConfirmationTimer(tcb.peer_bda, cid);
else
alarm_cancel(tcb.conf_timer);
}
/*******************************************************************************
*
* Function gatt_start_ind_ack_timer
*
* Description start the application ack timer
*
* Returns void
*
******************************************************************************/
void gatt_start_ind_ack_timer(tGATT_TCB& tcb, uint16_t cid) {
/* start notification cache timer */
if (tcb.eatt && cid != L2CAP_ATT_CID)
EattExtension::GetInstance()->StartAppIndicationTimer(tcb.peer_bda, cid);
else
alarm_set_on_mloop(tcb.ind_ack_timer, GATT_WAIT_FOR_RSP_TIMEOUT_MS,
gatt_ind_ack_timeout, &tcb);
}
/*******************************************************************************
*
* Function gatt_stop_ind_ack_timer
*
* Description stop the application ack timer
*
* Returns void
*
******************************************************************************/
void gatt_stop_ind_ack_timer(tGATT_TCB* p_tcb, uint16_t cid) {
/* start notification cache timer */
if (p_tcb->eatt && cid != L2CAP_ATT_CID) {
EattExtension::GetInstance()->StopAppIndicationTimer(p_tcb->peer_bda, cid);
} else {
alarm_cancel(p_tcb->ind_ack_timer);
p_tcb->ind_count = 0;
}
}
/*******************************************************************************
*
* Function gatt_rsp_timeout
*
* Description Called when GATT wait for ATT command response timer expires
*
* Returns void
*
******************************************************************************/
void gatt_rsp_timeout(void* data) {
tGATT_CLCB* p_clcb = (tGATT_CLCB*)data;
if (p_clcb == NULL || p_clcb->p_tcb == NULL) {
log::warn("clcb is already deleted");
return;
}
if (p_clcb->operation == GATTC_OPTYPE_DISCOVERY &&
p_clcb->op_subtype == GATT_DISC_SRVC_ALL &&
p_clcb->retry_count < GATT_REQ_RETRY_LIMIT) {
uint8_t rsp_code;
log::warn("retry discovery primary service");
if (p_clcb != gatt_cmd_dequeue(*p_clcb->p_tcb, p_clcb->cid, &rsp_code)) {
log::error("command queue out of sync, disconnect");
} else {
p_clcb->retry_count++;
gatt_act_discovery(p_clcb);
return;
}
}
auto eatt_channel = EattExtension::GetInstance()->FindEattChannelByCid(
p_clcb->p_tcb->peer_bda, p_clcb->cid);
if (eatt_channel) {
log::warn("disconnecting EATT cid: {}", p_clcb->cid);
EattExtension::GetInstance()->Disconnect(p_clcb->p_tcb->peer_bda,
p_clcb->cid);
} else {
log::warn("disconnecting GATT...");
gatt_disconnect(p_clcb->p_tcb);
}
}
void gatts_proc_srv_chg_ind_ack(tGATT_TCB tcb);
/*******************************************************************************
*
* Function gatt_indication_confirmation_timeout
*
* Description Called when the indication confirmation timer expires
*
* Returns void
*
******************************************************************************/
void gatt_indication_confirmation_timeout(void* data) {
tGATT_TCB* p_tcb = (tGATT_TCB*)data;
if (p_tcb->indicate_handle == gatt_cb.handle_of_h_r) {
/* There are some GATT Server only devices, that don't implement GATT client
* functionalities, and ignore "Service Changed" indication. Android does
* not have CCC in "Service Changed" characteristic, and sends it to all
* bonded devices. This leads to situation where remote can ignore the
* indication, and trigger 30s timeout, then reconnection in a loop.
*
* Since chances of healthy Client device keeping connection for 30 seconds
* and not responding to "Service Changed" indication are very low, assume
* we are dealing with Server only device, and don't trigger disconnection.
*
* TODO: In future, we should properly expose CCC, and send indication only
* to devices that register for it.
*/
log::warn(
"Service Changed notification timed out in 30 seconds, assuming "
"server-only remote, not disconnecting");
gatts_proc_srv_chg_ind_ack(*p_tcb);
return;
}
log::warn("disconnecting...");
gatt_disconnect(p_tcb);
}
/*******************************************************************************
*
* Function gatt_ind_ack_timeout
*
* Description Called when GATT wait for ATT handle confirmation timeout
*
* Returns void
*
******************************************************************************/
void gatt_ind_ack_timeout(void* data) {
tGATT_TCB* p_tcb = (tGATT_TCB*)data;
CHECK(p_tcb);
log::warn("send ack now");
p_tcb->ind_count = 0;
/*TODO: For now ATT used only, but we need to have timeout per CID
* and use it here corretly.
*/
attp_send_cl_confirmation_msg(*p_tcb, L2CAP_ATT_CID);
}
/*******************************************************************************
*
* Description Search for a service that owns a specific handle.
*
* Returns GATT_MAX_SR_PROFILES if not found. Otherwise the index of
* the service.
*
******************************************************************************/
std::list<tGATT_SRV_LIST_ELEM>::iterator gatt_sr_find_i_rcb_by_handle(
uint16_t handle) {
auto it = gatt_cb.srv_list_info->begin();
for (; it != gatt_cb.srv_list_info->end(); it++) {
if (it->s_hdl <= handle && it->e_hdl >= handle) {
return it;
}
}
return it;
}
/*******************************************************************************
*
* Function gatt_sr_get_sec_info
*
* Description Get the security flag and key size information for the peer
* device.
*
* Returns void
*
******************************************************************************/
void gatt_sr_get_sec_info(const RawAddress& rem_bda, tBT_TRANSPORT transport,
tGATT_SEC_FLAG* p_sec_flag, uint8_t* p_key_size) {
tGATT_SEC_FLAG flags = {};
flags.is_link_key_known = BTM_IsLinkKeyKnown(rem_bda, transport);
flags.is_link_key_authed = BTM_IsLinkKeyAuthed(rem_bda, transport);
flags.is_encrypted = BTM_IsEncrypted(rem_bda, transport);
flags.can_read_discoverable_characteristics =
BTM_CanReadDiscoverableCharacteristics(rem_bda);
*p_key_size = btm_ble_read_sec_key_size(rem_bda);
*p_sec_flag = flags;
}
/*******************************************************************************
*
* Function gatt_sr_send_req_callback
*
* Description
*
*
* Returns void
*
******************************************************************************/
void gatt_sr_send_req_callback(uint16_t conn_id, uint32_t trans_id,
tGATTS_REQ_TYPE type, tGATTS_DATA* p_data) {
tGATT_IF gatt_if = GATT_GET_GATT_IF(conn_id);
tGATT_REG* p_reg = gatt_get_regcb(gatt_if);
if (!p_reg) {
log::error("p_reg not found discard request");
return;
}
if (p_reg->in_use && p_reg->app_cb.p_req_cb) {
(*p_reg->app_cb.p_req_cb)(conn_id, trans_id, type, p_data);
} else {
log::warn("Call back not found for application conn_id={}", conn_id);
}
}
/*******************************************************************************
*
* Function gatt_send_error_rsp
*
* Description This function sends an error response.
*
* Returns void
*
******************************************************************************/
tGATT_STATUS gatt_send_error_rsp(tGATT_TCB& tcb, uint16_t cid, uint8_t err_code,
uint8_t op_code, uint16_t handle, bool deq) {
tGATT_STATUS status;
BT_HDR* p_buf;
tGATT_SR_MSG msg;
msg.error.cmd_code = op_code;
msg.error.reason = err_code;
msg.error.handle = handle;
uint16_t payload_size = gatt_tcb_get_payload_size(tcb, cid);
p_buf = attp_build_sr_msg(tcb, GATT_RSP_ERROR, &msg, payload_size);
if (p_buf != NULL) {
status = attp_send_sr_msg(tcb, cid, p_buf);
} else
status = GATT_INSUF_RESOURCE;
if (deq)
gatt_dequeue_sr_cmd(tcb, cid);
return status;
}
/*******************************************************************************
*
* Function gatt_add_sdp_record
*
* Description This function add a SDP record for a GATT primary service
*
* Returns 0 if error else sdp handle for the record.
*
******************************************************************************/
uint32_t gatt_add_sdp_record(const Uuid& uuid, uint16_t start_hdl,
uint16_t end_hdl) {
uint8_t buff[60];
uint8_t* p = buff;
log::verbose("s_hdl=0x{:x} s_hdl=0x{:x}", start_hdl, end_hdl);
uint32_t sdp_handle = get_legacy_stack_sdp_api()->handle.SDP_CreateRecord();
if (sdp_handle == 0) return 0;
switch (uuid.GetShortestRepresentationSize()) {
case Uuid::kNumBytes16: {
uint16_t tmp = uuid.As16Bit();
get_legacy_stack_sdp_api()->handle.SDP_AddServiceClassIdList(sdp_handle,
1, &tmp);
break;
}
case Uuid::kNumBytes32: {
UINT8_TO_BE_STREAM(p, (UUID_DESC_TYPE << 3) | SIZE_FOUR_BYTES);
uint32_t tmp = uuid.As32Bit();
UINT32_TO_BE_STREAM(p, tmp);
get_legacy_stack_sdp_api()->handle.SDP_AddAttribute(
sdp_handle, ATTR_ID_SERVICE_CLASS_ID_LIST, DATA_ELE_SEQ_DESC_TYPE,
(uint32_t)(p - buff), buff);
break;
}
case Uuid::kNumBytes128:
UINT8_TO_BE_STREAM(p, (UUID_DESC_TYPE << 3) | SIZE_SIXTEEN_BYTES);
ARRAY_TO_BE_STREAM(p, uuid.To128BitBE().data(), (int)Uuid::kNumBytes128);
get_legacy_stack_sdp_api()->handle.SDP_AddAttribute(
sdp_handle, ATTR_ID_SERVICE_CLASS_ID_LIST, DATA_ELE_SEQ_DESC_TYPE,
(uint32_t)(p - buff), buff);
break;
}
/*** Fill out the protocol element sequence for SDP ***/
tSDP_PROTOCOL_ELEM proto_elem_list[2];
proto_elem_list[0].protocol_uuid = UUID_PROTOCOL_L2CAP;
proto_elem_list[0].num_params = 1;
proto_elem_list[0].params[0] = BT_PSM_ATT;
proto_elem_list[1].protocol_uuid = UUID_PROTOCOL_ATT;
proto_elem_list[1].num_params = 2;
proto_elem_list[1].params[0] = start_hdl;
proto_elem_list[1].params[1] = end_hdl;
get_legacy_stack_sdp_api()->handle.SDP_AddProtocolList(sdp_handle, 2,
proto_elem_list);
/* Make the service browseable */
uint16_t list = UUID_SERVCLASS_PUBLIC_BROWSE_GROUP;
get_legacy_stack_sdp_api()->handle.SDP_AddUuidSequence(
sdp_handle, ATTR_ID_BROWSE_GROUP_LIST, 1, &list);
return (sdp_handle);
}
#if GATT_CONFORMANCE_TESTING == TRUE
/*******************************************************************************
*
* Function gatt_set_err_rsp
*
* Description This function is called to set the test confirm value
*
* Returns void
*
******************************************************************************/
void gatt_set_err_rsp(bool enable, uint8_t req_op_code, uint8_t err_status) {
log::verbose("enable={} op_code={}, err_status={}", enable, req_op_code,
err_status);
gatt_cb.enable_err_rsp = enable;
gatt_cb.req_op_code = req_op_code;
gatt_cb.err_status = err_status;
}
#endif
/*******************************************************************************
*
* Function gatt_get_regcb
*
* Description The function returns the registration control block.
*
* Returns pointer to the registration control block or NULL
*
******************************************************************************/
tGATT_REG* gatt_get_regcb(tGATT_IF gatt_if) {
uint8_t ii = (uint8_t)gatt_if;
tGATT_REG* p_reg = NULL;
if (ii < 1 || ii > GATT_MAX_APPS) {
log::warn("gatt_if out of range = {}", ii);
return NULL;
}
// Index for cl_rcb is always 1 less than gatt_if.
p_reg = &gatt_cb.cl_rcb[ii - 1];
if (!p_reg->in_use) {
log::warn("gatt_if found but not in use.");
return NULL;
}
return p_reg;
}
/*******************************************************************************
*
* Function gatt_tcb_is_cid_busy
*
* Description The function check if channel with given cid is busy
*
* Returns True when busy
*
******************************************************************************/
bool gatt_tcb_is_cid_busy(tGATT_TCB& tcb, uint16_t cid) {
if (cid == tcb.att_lcid) return !tcb.cl_cmd_q.empty();
EattChannel* channel =
EattExtension::GetInstance()->FindEattChannelByCid(tcb.peer_bda, cid);
if (channel == nullptr) {
log::warn("{}, cid 0x{:02x} already disconnected",
ADDRESS_TO_LOGGABLE_CSTR(tcb.peer_bda), cid);
return false;
}
return !channel->cl_cmd_q_.empty();
}
/*******************************************************************************
*
* Function gatt_clcb_alloc
*
* Description The function allocates a GATT connection link control block
*
* Returns NULL if not found. Otherwise pointer to the connection link
* block.
*
******************************************************************************/
tGATT_CLCB* gatt_clcb_alloc(uint16_t conn_id) {
tGATT_CLCB clcb = {};
tGATT_IF gatt_if = GATT_GET_GATT_IF(conn_id);
uint8_t tcb_idx = GATT_GET_TCB_IDX(conn_id);
tGATT_TCB* p_tcb = gatt_get_tcb_by_idx(tcb_idx);
tGATT_REG* p_reg = gatt_get_regcb(gatt_if);
clcb.conn_id = conn_id;
clcb.p_reg = p_reg;
clcb.p_tcb = p_tcb;
/* Use eatt only when clients wants that */
clcb.cid = gatt_tcb_get_att_cid(*p_tcb, p_reg->eatt_support);
gatt_cb.clcb_queue.emplace_back(clcb);
auto p_clcb = &(gatt_cb.clcb_queue.back());
if (gatt_cb.clcb_queue.size() > GATT_CL_MAX_LCB) {
/* GATT_CL_MAX_LCB is here from the historical reasons. We believe this
* limitation is not needed. In addition, number of clcb should not be
* bigger than that and also if it is bigger, we believe it should not
* cause the problem. This WARN is just to monitor number of CLCB and will
* help in debugging in case we are wrong */
log::warn("Number of CLCB: {} > {}", gatt_cb.clcb_queue.size(),
GATT_CL_MAX_LCB);
}
return p_clcb;
}
/*******************************************************************************
*
* Function gatt_tcb_get_cid_available_for_indication
*
* Description This function checks if indication can be send
*
* Returns true when stack is busy with waiting on indication
* confirmation, false otherwise
*
******************************************************************************/
bool gatt_tcb_get_cid_available_for_indication(tGATT_TCB* p_tcb,
bool eatt_support,
uint16_t** indicated_handle_p,
uint16_t* cid_p) {
if (p_tcb->eatt && eatt_support) {
EattChannel* channel =
EattExtension::GetInstance()->GetChannelAvailableForIndication(p_tcb->peer_bda);
if (channel) {
*indicated_handle_p = &channel->indicate_handle_;
*cid_p = channel->cid_;
return true;
}
}
if (!GATT_HANDLE_IS_VALID(p_tcb->indicate_handle)) {
*indicated_handle_p = &p_tcb->indicate_handle;
*cid_p = p_tcb->att_lcid;
return true;
}
return false;
}
/*******************************************************************************
*
* Function gatt_tcb_find_indicate_handle
*
* Description This function checks if indication can be send
*
* Returns true when indication handle found, false otherwise
*
******************************************************************************/
bool gatt_tcb_find_indicate_handle(tGATT_TCB& tcb, uint16_t cid,
uint16_t* indicated_handle_p) {
if (cid == tcb.att_lcid) {
*indicated_handle_p = tcb.indicate_handle;
tcb.indicate_handle = 0;
return true;
}
if (tcb.eatt) {
EattChannel* channel =
EattExtension::GetInstance()->FindEattChannelByCid(tcb.peer_bda, cid);
if (channel) {
*indicated_handle_p = channel->indicate_handle_;
channel->indicate_handle_ = 0;
return true;
}
}
return false;
}
/*******************************************************************************
*
* Function gatt_tcb_get_att_cid
*
* Description This function gets cid for the GATT operation
*
* Returns Available CID
*
******************************************************************************/
uint16_t gatt_tcb_get_att_cid(tGATT_TCB& tcb, bool eatt_support) {
if (eatt_support && tcb.eatt) {
EattChannel* channel =
EattExtension::GetInstance()->GetChannelAvailableForClientRequest(tcb.peer_bda);
if (channel) {
return channel->cid_;
}
}
return tcb.att_lcid;
}
/*******************************************************************************
*
* Function gatt_tcb_get_payload_size
*
* Description This function gets payload size for the GATT operation
*
* Returns Payload size for sending/receiving data
*
******************************************************************************/
uint16_t gatt_tcb_get_payload_size(tGATT_TCB& tcb, uint16_t cid) {
if (!tcb.eatt || (cid == tcb.att_lcid)) return tcb.payload_size;
EattChannel* channel =
EattExtension::GetInstance()->FindEattChannelByCid(tcb.peer_bda, cid);
if (channel == nullptr) {
log::warn("{}, cid 0x{:02x} already disconnected",
ADDRESS_TO_LOGGABLE_CSTR(tcb.peer_bda), cid);
return 0;
}
/* ATT MTU for EATT is min from tx and rx mtu*/
return std::min<uint16_t>(channel->tx_mtu_, channel->rx_mtu_);
}
/*******************************************************************************
*
* Function gatt_clcb_dealloc
*
* Description The function de-allocates a GATT connection link control
* block
*
* Returns None
*
******************************************************************************/
static void gatt_clcb_dealloc(tGATT_CLCB* p_clcb) {
if (p_clcb) {
alarm_free(p_clcb->gatt_rsp_timer_ent);
gatt_clcb_invalidate(p_clcb->p_tcb, p_clcb);
for (auto clcb_it = gatt_cb.clcb_queue.begin();
clcb_it != gatt_cb.clcb_queue.end(); clcb_it++) {
if (&(*clcb_it) == p_clcb) {
gatt_cb.clcb_queue.erase(clcb_it);
return;
}
}
}
}
/*******************************************************************************
*
* Function gatt_clcb_invalidate
*
* Description The function invalidates already scheduled p_clcb.
*
* Returns None
*
******************************************************************************/
void gatt_clcb_invalidate(tGATT_TCB* p_tcb, const tGATT_CLCB* p_clcb) {
std::deque<tGATT_CMD_Q>* cl_cmd_q_p;
uint16_t cid = p_clcb->cid;
if (!p_tcb->pending_enc_clcb.empty()) {
for (size_t i = 0; i < p_tcb->pending_enc_clcb.size(); i++) {
if (p_tcb->pending_enc_clcb.at(i) == p_clcb) {
log::warn(
"Removing clcb ({}) for conn id=0x{:04x} from pending_enc_clcb",
fmt::ptr(p_clcb), p_clcb->conn_id);
p_tcb->pending_enc_clcb.at(i) = NULL;
break;
}
}
}
if (cid == p_tcb->att_lcid) {
cl_cmd_q_p = &p_tcb->cl_cmd_q;
} else {
EattChannel* channel = EattExtension::GetInstance()->FindEattChannelByCid(
p_tcb->peer_bda, cid);
if (channel == nullptr) {
log::warn("{}, cid 0x{:02x} already disconnected",
ADDRESS_TO_LOGGABLE_CSTR(p_tcb->peer_bda), cid);
return;
}
cl_cmd_q_p = &channel->cl_cmd_q_;
}
if (cl_cmd_q_p->empty()) {
return;
}
auto iter = std::find_if(cl_cmd_q_p->begin(), cl_cmd_q_p->end(),
[p_clcb](auto& el) { return el.p_clcb == p_clcb; });
if (iter == cl_cmd_q_p->end()) {
return;
}
if (iter->to_send) {
/* If command was not send, just remove the entire element */
cl_cmd_q_p->erase(iter);
log::warn("Removing scheduled clcb ({}) for conn_id=0x{:04x}",
fmt::ptr(p_clcb), p_clcb->conn_id);
} else {
/* If command has been sent, just invalidate p_clcb pointer for proper
* response handling */
iter->p_clcb = NULL;
log::warn(
"Invalidating clcb ({}) for already sent request on conn_id=0x{:04x}",
fmt::ptr(p_clcb), p_clcb->conn_id);
}
}
/*******************************************************************************
*
* Function gatt_find_tcb_by_cid
*
* Description The function searches for an empty entry
* in registration info table for GATT client
*
* Returns NULL if not found. Otherwise pointer to the rcb.
*
******************************************************************************/
tGATT_TCB* gatt_find_tcb_by_cid(uint16_t lcid) {
uint16_t xx = 0;
tGATT_TCB* p_tcb = NULL;
for (xx = 0; xx < GATT_MAX_PHY_CHANNEL; xx++) {
if (gatt_cb.tcb[xx].in_use &&
((gatt_cb.tcb[xx].att_lcid == lcid) ||
((EattExtension::GetInstance()->FindEattChannelByCid(gatt_cb.tcb[xx].peer_bda,
lcid) != nullptr)))) {
p_tcb = &gatt_cb.tcb[xx];
break;
}
}
return p_tcb;
}
/*******************************************************************************
*
* Function gatt_num_clcb_by_bd_addr
*
* Description The function searches all LCB with macthing bd address
*
* Returns total number of clcb found.
*
******************************************************************************/
uint8_t gatt_num_clcb_by_bd_addr(const RawAddress& bda) {
uint8_t num = 0;
for (auto const& clcb : gatt_cb.clcb_queue) {
if (clcb.p_tcb->peer_bda == bda) num++;
}
return num;
}
void gatt_sr_copy_prep_cnt_to_cback_cnt(tGATT_TCB& tcb) {
for (uint8_t i = 0; i < GATT_MAX_APPS; i++) {
if (tcb.prep_cnt[i]) {
tcb.sr_cmd.cback_cnt[i] = 1;
}
}
}
/* Get outstanding server command pointer by the transaction id */
tGATT_SR_CMD* gatt_sr_get_cmd_by_trans_id(tGATT_TCB* p_tcb, uint32_t trans_id) {
if (p_tcb->sr_cmd.trans_id == trans_id) return &p_tcb->sr_cmd;
if (!p_tcb->eatt) return nullptr;
EattChannel* channel =
EattExtension::GetInstance()->FindEattChannelByTransId(p_tcb->peer_bda, trans_id);
if (!channel) return nullptr;
return &channel->server_outstanding_cmd_;
}
/*******************************************************************************
*
* Function gatt_sr_is_cback_cnt_zero
*
* Description The function searches all LCB with macthing bd address
*
* Returns True if thetotal application callback count is zero
*
******************************************************************************/
bool gatt_sr_is_cback_cnt_zero(tGATT_TCB& tcb) {
for (uint8_t i = 0; i < GATT_MAX_APPS; i++) {
if (tcb.sr_cmd.cback_cnt[i]) {
return false;
}
}
return true;
}
/*******************************************************************************
*
* Function gatt_sr_is_prep_cnt_zero
*
* Description Check the prepare write request count is zero or not
*
* Returns True no prepare write request
*
******************************************************************************/
bool gatt_sr_is_prep_cnt_zero(tGATT_TCB& tcb) {
for (uint8_t i = 0; i < GATT_MAX_APPS; i++) {
if (tcb.prep_cnt[i]) {
return false;
}
}
return true;
}
/*******************************************************************************
*
* Function gatt_sr_reset_cback_cnt
*
* Description Reset the application callback count to zero
*
* Returns None
*
******************************************************************************/
void gatt_sr_reset_cback_cnt(tGATT_TCB& tcb, uint16_t cid) {
for (uint8_t i = 0; i < GATT_MAX_APPS; i++) {
if (cid == tcb.att_lcid) {
tcb.sr_cmd.cback_cnt[i] = 0;
} else {
EattChannel* channel =
EattExtension::GetInstance()->FindEattChannelByCid(tcb.peer_bda, cid);
if (channel == nullptr) {
log::warn("{}, cid 0x{:02x} already disconnected",
ADDRESS_TO_LOGGABLE_CSTR(tcb.peer_bda), cid);
return;
}
channel->server_outstanding_cmd_.cback_cnt[i] = 0;
}
}
}
/*******************************************************************************
*
* Function gatt_sr_reset_prep_cnt
*
* Description Reset the prep write count to zero
*
* Returns None
*
******************************************************************************/
void gatt_sr_reset_prep_cnt(tGATT_TCB& tcb) {
for (uint8_t i = 0; i < GATT_MAX_APPS; i++) {
tcb.prep_cnt[i] = 0;
}
}
/* Get pointer to server command on given cid */
tGATT_SR_CMD* gatt_sr_get_cmd_by_cid(tGATT_TCB& tcb, uint16_t cid) {
tGATT_SR_CMD* sr_cmd_p;
log::info("cid: {} tcb cid {}", int(cid), tcb.att_lcid);
if (cid == tcb.att_lcid) {
sr_cmd_p = &tcb.sr_cmd;
} else {
EattChannel* channel =
EattExtension::GetInstance()->FindEattChannelByCid(tcb.peer_bda, cid);
if (channel == nullptr) {
log::warn("{}, cid 0x{:02x} already disconnected",
ADDRESS_TO_LOGGABLE_CSTR(tcb.peer_bda), cid);
return nullptr;
}
sr_cmd_p = &channel->server_outstanding_cmd_;
}
return sr_cmd_p;
}
/* Get pointer to the context of outstanding multi request */
tGATT_READ_MULTI* gatt_sr_get_read_multi(tGATT_TCB& tcb, uint16_t cid) {
tGATT_READ_MULTI* read_multi_p;
log::info("cid: {} tcb cid {}", int(cid), tcb.att_lcid);
if (cid == tcb.att_lcid) {
read_multi_p = &tcb.sr_cmd.multi_req;
} else {
EattChannel* channel =
EattExtension::GetInstance()->FindEattChannelByCid(tcb.peer_bda, cid);
if (channel == nullptr) {
log::warn("{}, cid 0x{:02x} already disconnected",
ADDRESS_TO_LOGGABLE_CSTR(tcb.peer_bda), cid);
return nullptr;
}
read_multi_p = &channel->server_outstanding_cmd_.multi_req;
}
return read_multi_p;
}
/*******************************************************************************
*
* Function gatt_sr_update_cback_cnt
*
* Description Update the teh applicaiton callback count
*
* Returns None
*
******************************************************************************/
void gatt_sr_update_cback_cnt(tGATT_TCB& tcb, uint16_t cid, tGATT_IF gatt_if,
bool is_inc, bool is_reset_first) {
uint8_t idx = ((uint8_t)gatt_if) - 1;
tGATT_SR_CMD* sr_cmd_p;
if (cid == tcb.att_lcid) {
sr_cmd_p = &tcb.sr_cmd;
} else {
EattChannel* channel =
EattExtension::GetInstance()->FindEattChannelByCid(tcb.peer_bda, cid);
if (channel == nullptr) {
log::warn("{}, cid 0x{:02x} already disconnected",
ADDRESS_TO_LOGGABLE_CSTR(tcb.peer_bda), cid);
return;
}
sr_cmd_p = &channel->server_outstanding_cmd_;
}
if (is_reset_first) {
gatt_sr_reset_cback_cnt(tcb, cid);
}
if (is_inc) {
sr_cmd_p->cback_cnt[idx]++;
} else {
if (sr_cmd_p->cback_cnt[idx]) {
sr_cmd_p->cback_cnt[idx]--;
}
}
}
/*******************************************************************************
*
* Function gatt_sr_update_prep_cnt
*
* Description Update the teh prepare write request count
*
* Returns None
*
******************************************************************************/
void gatt_sr_update_prep_cnt(tGATT_TCB& tcb, tGATT_IF gatt_if, bool is_inc,
bool is_reset_first) {
uint8_t idx = ((uint8_t)gatt_if) - 1;
log::verbose("tcb idx={} gatt_if={} is_inc={} is_reset_first={}", tcb.tcb_idx,
gatt_if, is_inc, is_reset_first);
if (is_reset_first) {
gatt_sr_reset_prep_cnt(tcb);
}
if (is_inc) {
tcb.prep_cnt[idx]++;
} else {
if (tcb.prep_cnt[idx]) {
tcb.prep_cnt[idx]--;
}
}
}
/** Cancel LE Create Connection request */
bool gatt_cancel_open(tGATT_IF gatt_if, const RawAddress& bda) {
tGATT_TCB* p_tcb = gatt_find_tcb_by_addr(bda, BT_TRANSPORT_LE);
if (!p_tcb) {
log::warn("Unable to cancel open for unknown connection gatt_if:{} peer:{}",
gatt_if, ADDRESS_TO_LOGGABLE_CSTR(bda));
return true;
}
if (gatt_get_ch_state(p_tcb) == GATT_CH_OPEN) {
log::error("link connected Too late to cancel");
return false;
}
gatt_update_app_use_link_flag(gatt_if, p_tcb, false, false);
if (p_tcb->app_hold_link.empty()) {
log::debug(
"Client reference count is zero disconnecting device gatt_if:{} "
"peer:{}",
gatt_if, ADDRESS_TO_LOGGABLE_CSTR(bda));
gatt_disconnect(p_tcb);
}
if (bluetooth::common::init_flags::
use_unified_connection_manager_is_enabled()) {
bluetooth::connection::GetConnectionManager().stop_direct_connection(
gatt_if, bluetooth::connection::ResolveRawAddress(bda));
} else {
if (!connection_manager::direct_connect_remove(gatt_if, bda)) {
if (!connection_manager::is_background_connection(bda)) {
BTM_AcceptlistRemove(bda);
log::info(
"Gatt connection manager has no background record but removed "
"filter acceptlist gatt_if:{} peer:{}",
gatt_if, ADDRESS_TO_LOGGABLE_CSTR(bda));
} else {
log::info(
"Gatt connection manager maintains a background record preserving "
"filter acceptlist gatt_if:{} peer:{}",
gatt_if, ADDRESS_TO_LOGGABLE_CSTR(bda));
}
}
}
return true;
}
/** Enqueue this command */
bool gatt_cmd_enq(tGATT_TCB& tcb, tGATT_CLCB* p_clcb, bool to_send,
uint8_t op_code, BT_HDR* p_buf) {
tGATT_CMD_Q cmd;
cmd.to_send = to_send; /* waiting to be sent */
cmd.op_code = op_code;
cmd.p_cmd = p_buf;
cmd.p_clcb = p_clcb;
cmd.cid = p_clcb->cid;
if (p_clcb->cid == tcb.att_lcid) {
tcb.cl_cmd_q.push_back(cmd);
} else {
EattChannel* channel =
EattExtension::GetInstance()->FindEattChannelByCid(tcb.peer_bda, cmd.cid);
if (channel == nullptr) {
log::warn("{}, cid 0x{:02x} already disconnected",
ADDRESS_TO_LOGGABLE_CSTR(tcb.peer_bda), cmd.cid);
return false;
}
channel->cl_cmd_q_.push_back(cmd);
}
return true;
}
/** dequeue the command in the client CCB command queue */
tGATT_CLCB* gatt_cmd_dequeue(tGATT_TCB& tcb, uint16_t cid, uint8_t* p_op_code) {
std::deque<tGATT_CMD_Q>* cl_cmd_q_p;
if (cid == tcb.att_lcid) {
cl_cmd_q_p = &tcb.cl_cmd_q;
} else {
EattChannel* channel =
EattExtension::GetInstance()->FindEattChannelByCid(tcb.peer_bda, cid);
if (channel == nullptr) {
log::warn("{}, cid 0x{:02x} already disconnected",
ADDRESS_TO_LOGGABLE_CSTR(tcb.peer_bda), cid);
return nullptr;
}
cl_cmd_q_p = &channel->cl_cmd_q_;
}
if (cl_cmd_q_p->empty()) return nullptr;
tGATT_CMD_Q cmd = cl_cmd_q_p->front();
tGATT_CLCB* p_clcb = cmd.p_clcb;
*p_op_code = cmd.op_code;
/* Note: If GATT client deregistered while the ATT request was on the way to
* peer, device p_clcb will be null.
*/
if (p_clcb && p_clcb->cid != cid) {
log::warn("CID does not match ({}!={}), conn_id=0x{:04x}", p_clcb->cid, cid,
p_clcb->conn_id);
}
cl_cmd_q_p->pop_front();
return p_clcb;
}
/** Send out the ATT message for write */
tGATT_STATUS gatt_send_write_msg(tGATT_TCB& tcb, tGATT_CLCB* p_clcb,
uint8_t op_code, uint16_t handle, uint16_t len,
uint16_t offset, uint8_t* p_data) {
tGATT_CL_MSG msg;
msg.attr_value.handle = handle;
msg.attr_value.len = len;
msg.attr_value.offset = offset;
memcpy(msg.attr_value.value, p_data, len);
/* write by handle */
return attp_send_cl_msg(tcb, p_clcb, op_code, &msg);
}
/*******************************************************************************
*
* Function gatt_is_outstanding_msg_in_att_send_queue
*
* Description checks if there is message on the ATT fixed channel to send
*
* Returns true: on success; false otherwise
*
******************************************************************************/
bool gatt_is_outstanding_msg_in_att_send_queue(const tGATT_TCB& tcb) {
return (!tcb.cl_cmd_q.empty() && (tcb.cl_cmd_q.front()).to_send);
}
/*******************************************************************************
*
* Function gatt_end_operation
*
* Description This function ends a discovery, send callback and finalize
* some control value.
*
* Returns 16 bits uuid.
*
******************************************************************************/
void gatt_end_operation(tGATT_CLCB* p_clcb, tGATT_STATUS status, void* p_data) {
tGATT_CL_COMPLETE cb_data;
tGATT_CMPL_CBACK* p_cmpl_cb =
(p_clcb->p_reg) ? p_clcb->p_reg->app_cb.p_cmpl_cb : NULL;
tGATTC_OPTYPE op = p_clcb->operation;
tGATT_DISC_TYPE disc_type = GATT_DISC_MAX;
tGATT_DISC_CMPL_CB* p_disc_cmpl_cb =
(p_clcb->p_reg) ? p_clcb->p_reg->app_cb.p_disc_cmpl_cb : NULL;
uint16_t conn_id;
uint8_t operation;
log::verbose("status={} op={} subtype={}", status, p_clcb->operation,
p_clcb->op_subtype);
memset(&cb_data.att_value, 0, sizeof(tGATT_VALUE));
if (p_cmpl_cb != NULL && p_clcb->operation != 0) {
if (p_clcb->operation == GATTC_OPTYPE_READ) {
cb_data.att_value.handle = p_clcb->s_handle;
cb_data.att_value.len = p_clcb->counter;
if (cb_data.att_value.len > GATT_MAX_ATTR_LEN) {
log::warn("Large cb_data.att_value, size={}", cb_data.att_value.len);
cb_data.att_value.len = GATT_MAX_ATTR_LEN;
}
if (p_data && p_clcb->counter)
memcpy(cb_data.att_value.value, p_data, cb_data.att_value.len);
}
if (p_clcb->operation == GATTC_OPTYPE_WRITE) {
memset(&cb_data.att_value, 0, sizeof(tGATT_VALUE));
cb_data.handle = cb_data.att_value.handle = p_clcb->s_handle;
if (p_clcb->op_subtype == GATT_WRITE_PREPARE) {
if (p_data) {
cb_data.att_value = *((tGATT_VALUE*)p_data);
} else {
log::verbose("Rcv Prepare write rsp but no data");
}
}
}
if (p_clcb->operation == GATTC_OPTYPE_CONFIG)
cb_data.mtu = p_clcb->p_tcb->payload_size;
if (p_clcb->operation == GATTC_OPTYPE_DISCOVERY) {
disc_type = static_cast<tGATT_DISC_TYPE>(p_clcb->op_subtype);
}
}
osi_free_and_reset((void**)&p_clcb->p_attr_buf);
operation = p_clcb->operation;
conn_id = p_clcb->conn_id;
gatt_stop_rsp_timer(p_clcb);
gatt_clcb_dealloc(p_clcb);
if (p_disc_cmpl_cb && (op == GATTC_OPTYPE_DISCOVERY))
(*p_disc_cmpl_cb)(conn_id, disc_type, status);
else if (p_cmpl_cb && op)
(*p_cmpl_cb)(conn_id, op, status, &cb_data);
else
log::warn("not sent out op={} p_disc_cmpl_cb:{} p_cmpl_cb:{}", operation,
fmt::ptr(p_disc_cmpl_cb), fmt::ptr(p_cmpl_cb));
}
/** This function cleans up the control blocks when L2CAP channel disconnect */
void gatt_cleanup_upon_disc(const RawAddress& bda, tGATT_DISCONN_REASON reason,
tBT_TRANSPORT transport) {
log::verbose("");
tGATT_TCB* p_tcb = gatt_find_tcb_by_addr(bda, transport);
if (!p_tcb) {
log::error(
"Disconnect for unknown connection bd_addr:{} reason:{} transport:{}",
ADDRESS_TO_LOGGABLE_CSTR(bda), gatt_disconnection_reason_text(reason),
bt_transport_text(transport));
return;
}
gatt_set_ch_state(p_tcb, GATT_CH_CLOSE);
/* Notify EATT about disconnection. */
EattExtension::GetInstance()->Disconnect(p_tcb->peer_bda);
for (auto clcb_it = gatt_cb.clcb_queue.begin();
clcb_it != gatt_cb.clcb_queue.end();) {
if (clcb_it->p_tcb != p_tcb) {
++clcb_it;
continue;
}
gatt_stop_rsp_timer(&(*clcb_it));
log::verbose("found p_clcb conn_id={}", clcb_it->conn_id);
if (clcb_it->operation == GATTC_OPTYPE_NONE) {
clcb_it = gatt_cb.clcb_queue.erase(clcb_it);
continue;
}
tGATT_CLCB* p_clcb = &(*clcb_it);
++clcb_it;
gatt_end_operation(p_clcb, GATT_ERROR, NULL);
}
/* Remove the outstanding ATT commnads if any */
p_tcb->cl_cmd_q.clear();
alarm_free(p_tcb->ind_ack_timer);
p_tcb->ind_ack_timer = NULL;
alarm_free(p_tcb->conf_timer);
p_tcb->conf_timer = NULL;
gatt_free_pending_ind(p_tcb);
fixed_queue_free(p_tcb->sr_cmd.multi_rsp_q, NULL);
p_tcb->sr_cmd.multi_rsp_q = NULL;
for (uint8_t i = 0; i < GATT_MAX_APPS; i++) {
tGATT_REG* p_reg = &gatt_cb.cl_rcb[i];
if (p_reg->in_use && p_reg->app_cb.p_conn_cb) {
uint16_t conn_id = GATT_CREATE_CONN_ID(p_tcb->tcb_idx, p_reg->gatt_if);
(*p_reg->app_cb.p_conn_cb)(p_reg->gatt_if, bda, conn_id,
kGattDisconnected, reason, transport);
}
}
*p_tcb = tGATT_TCB();
log::verbose("exit");
}
/*******************************************************************************
*
* Function gatt_dbg_req_op_name
*
* Description Get op code description name, for debug information.
*
* Returns uint8_t *: name of the operation.
*
******************************************************************************/
char const* gatt_dbg_op_name(uint8_t op_code) {
uint8_t pseduo_op_code_idx = op_code & (~GATT_WRITE_CMD_MASK);
if (op_code == GATT_CMD_WRITE) {
pseduo_op_code_idx = 0x14; /* just an index to op_code_name */
}
if (op_code == GATT_SIGN_CMD_WRITE) {
pseduo_op_code_idx = 0x15; /* just an index to op_code_name */
}
#define ARR_SIZE(a) (sizeof(a)/sizeof(a[0]))
if (pseduo_op_code_idx < ARR_SIZE(op_code_name))
return op_code_name[pseduo_op_code_idx];
else
return "Op Code Exceed Max";
#undef ARR_SIZE
}
/** Remove the application interface for the specified background device */
bool gatt_auto_connect_dev_remove(tGATT_IF gatt_if, const RawAddress& bd_addr) {
tGATT_TCB* p_tcb = gatt_find_tcb_by_addr(bd_addr, BT_TRANSPORT_LE);
if (p_tcb) gatt_update_app_use_link_flag(gatt_if, p_tcb, false, false);
if (bluetooth::common::init_flags::
use_unified_connection_manager_is_enabled()) {
bluetooth::connection::GetConnectionManager().remove_background_connection(
gatt_if, bluetooth::connection::ResolveRawAddress(bd_addr));
// TODO(aryarahul): handle failure case
return true;
} else {
return connection_manager::background_connect_remove(gatt_if, bd_addr);
}
}