bdroid_CFLAGS += \
-fvisibility=hidden \
-Wall \
- -Wno-unused-parameter \
-Wunused-but-set-variable \
-UNDEBUG \
-DLOG_NDEBUG=1
"//",
"//utils/include",
]
-
- # TODO(armansito): Fix the warnings and remove the flag below.
- cflags = [
- "-Wno-unused-variable",
- ]
}
{
int ret;
int skt_fd;
- struct sockaddr_un remote;
int len;
INFO("connect to %s (sz %zu)", path, buffer_sz);
static int skt_read(int fd, void *p, size_t len)
{
int read;
- struct pollfd pfd;
- struct timespec ts;
FNLOG();
static int a2dp_read_audio_config(struct a2dp_stream_common *common)
{
- char cmd = A2DP_CTRL_GET_AUDIO_CONFIG;
uint32_t sample_rate;
uint8_t channel_count;
static int out_set_format(struct audio_stream *stream, audio_format_t format)
{
+ UNUSED(stream);
UNUSED(format);
- struct a2dp_stream_out *out = (struct a2dp_stream_out *)stream;
DEBUG("setting format not yet supported (0x%x)", format);
return -ENOSYS;
}
static int out_dump(const struct audio_stream *stream, int fd)
{
+ UNUSED(stream);
UNUSED(fd);
- struct a2dp_stream_out *out = (struct a2dp_stream_out *)stream;
FNLOG();
return 0;
}
static char * out_get_parameters(const struct audio_stream *stream, const char *keys)
{
+ UNUSED(stream);
UNUSED(keys);
- struct a2dp_stream_out *out = (struct a2dp_stream_out *)stream;
-
FNLOG();
/* add populating param here */
struct a2dp_audio_device *a2dp_dev = (struct a2dp_audio_device *)dev;
struct a2dp_stream_out *out;
int ret = 0;
- int i;
UNUSED(address);
UNUSED(handle);
UNUSED(devices);
static int adev_init_check(const struct audio_hw_device *dev)
{
- struct a2dp_audio_device *a2dp_dev = (struct a2dp_audio_device*)dev;
-
+ UNUSED(dev);
FNLOG();
return 0;
hw_device_t** device)
{
struct a2dp_audio_device *adev;
- int ret;
INFO(" adev_open in A2dp_hw module");
FNLOG();
# TODO(armansito): Remove all of the flags below, since we want to enable all
# warnings.
cflags = [
- "-Wno-unused-variable",
- "-Wno-unused-value",
- "-Wno-unused-function",
"-Wno-int-to-pointer-cast",
]
}
/*******************************************************************************
-**
-** Function bta_av_free_scb
-**
-** Description free stream control block,
-**
-**
-** Returns void
-**
-*******************************************************************************/
-static void bta_av_free_scb(tBTA_AV_SCB *p_scb)
-{
- // NOTE(google) This free currently is not called
- assert(p_scb != NULL);
-
- list_free(p_scb->a2d_list);
- GKI_freebuf(p_scb);
-}
-
-/*******************************************************************************
*******************************************************************************/
void bta_av_conn_cback(UINT8 handle, BD_ADDR bd_addr, UINT8 event, tAVDT_CTRL *p_data)
{
{
tSDP_UUID uuid;
- UINT16 num_attrs = 1;
tBTA_DM_MSG *p_msg;
memset (&uuid, 0, sizeof(tSDP_UUID));
tBTM_STATUS status = BTM_SUCCESS;
tBTA_DM_SEC sec_event;
char *p_name = NULL;
- UINT8 i;
- tBT_DEVICE_TYPE dev_type;
if (!bta_dm_cb.p_sec_cback)
return BTM_NOT_AUTHORIZED;
{
UINT8 i,j;
- UINT16 policy_setting;
UINT8 *p = NULL;
#if (BTM_SSR_INCLUDED == TRUE)
int index = BTA_DM_PM_SSR0;
{
return(FALSE);
}
- SDP_DISC_ATTR_LEN(p_attr->attr_len_type);
+
item_cnt=0;
for (p_sattr = p_attr->attr_value.v.p_sub_attr; p_sattr && (item_cnt < 4) ; p_sattr = p_sattr->p_next_attr)
for (i=0; i < BTA_HL_NUM_MCLS ; i ++)
{
- BTA_HL_GET_MCL_CB_PTR(app_idx, i);
-
if (bta_hl_cb.acb[app_idx].mcb[i].in_use &&
(!memcmp (bta_hl_cb.acb[app_idx].mcb[i].bd_addr, p_bd_addr, BD_ADDR_LEN)))
{
static struct fc_client *fc_clients;
static struct fc_channel *fc_channels;
static uint32_t fc_next_id;
-static pthread_once_t fc_init_once = PTHREAD_ONCE_INIT;
-
-
-static void fc_init_work(void)
-{
- fc_clients = NULL;
- fc_channels = NULL;
- fc_next_id = 0;
-
- //more init here if needed...
-}
-
-static void fc_init(void)
-{
- pthread_once(&fc_init_once, fc_init_work);
-}
static void fcchan_conn_chng_cbk(UINT16 chan, BD_ADDR bd_addr, BOOLEAN connected,
/* rfc handle bd addr retrieval requires core stack handle */
if (bRfcHandle)
{
- UINT32 hi = ((jv_handle & BTA_JV_RFC_HDL_MASK) & ~BTA_JV_RFCOMM_MASK) - 1;
- UINT32 si = BTA_JV_RFC_HDL_TO_SIDX(jv_handle);
for (j = 0; j < BTA_JV_MAX_RFC_CONN; j++)
{
if (jv_handle == bta_jv_cb.port_cb[j].handle)
static void bta_jv_start_discovery_cback(UINT16 result, void * user_data)
{
tBTA_JV_STATUS status;
- UINT8 old_sdp_act = bta_jv_cb.sdp_active;
APPL_TRACE_DEBUG("bta_jv_start_discovery_cback res: 0x%x", result);
tL2CAP_CFG_INFO cfg;
tBTA_JV_L2CAP_START evt_data;
tBTA_JV_API_L2CAP_SERVER *ls = &(p_data->l2cap_server);
- INT32 use_etm = FALSE;
UINT8 chan_mode_mask = GAP_FCR_CHAN_OPT_BASIC;
tL2CAP_ERTM_INFO *ertm_info = NULL;
/*******************************************************************************
**
-** Function bta_jv_get_num_rfc_listen
-**
-** Description when a RFCOMM connection goes down, make sure that there's only
-** one port stays listening on this scn.
-**
-** Returns
-**
-*******************************************************************************/
-static UINT8 bta_jv_get_num_rfc_listen(tBTA_JV_RFC_CB *p_cb)
-{
- UINT8 listen=1;
-
- if (p_cb->max_sess > 1)
- {
- listen = 0;
- for (UINT8 i=0; i<p_cb->max_sess; i++)
- {
- if (p_cb->rfc_hdl[i] != 0)
- {
- const tBTA_JV_PCB *p_pcb = &bta_jv_cb.port_cb[p_cb->rfc_hdl[i] - 1];
- if (BTA_JV_ST_SR_LISTEN == p_pcb->state)
- {
- listen++;
- }
- }
- }
- }
- return listen;
-}
-
-/*******************************************************************************
-**
** Function bta_jv_port_mgmt_sr_cback
**
** Description callback for port mamangement function of rfcomm
static void fcchan_data_cbk(UINT16 chan, BD_ADDR bd_addr, BT_HDR *p_buf)
{
tBTA_JV evt_data;
- tBTA_JV evt_open;
struct fc_channel *tc;
struct fc_client *t = NULL;
tBTA_JV_L2CAP_CBACK *sock_cback = NULL;
tBTA_JV_API_L2CAP_SERVER *ss = &(p_data->l2cap_server);
tBTA_JV_L2CAP_START evt_data;
struct fc_client *t;
- uint16_t handle;
evt_data.handle = GAP_INVALID_HANDLE;
evt_data.status = BTA_JV_FAILURE;
static void bta_create_mns_sdp_record(bluetooth_sdp_record *record, tSDP_DISC_REC *p_rec)
{
- tSDP_DISCOVERY_DB *db = p_bta_sdp_cfg->p_sdp_db;
tSDP_DISC_ATTR *p_attr;
tSDP_PROTOCOL_ELEM pe;
UINT16 pversion = 0;
- UINT8 offset = 0;
record->mns.hdr.type = SDP_TYPE_MAP_MNS;
record->mns.hdr.service_name_length = 0;
record->mns.hdr.service_name = NULL;
static void bta_create_mas_sdp_record(bluetooth_sdp_record *record, tSDP_DISC_REC *p_rec)
{
- tSDP_DISCOVERY_DB *db = p_bta_sdp_cfg->p_sdp_db;
tSDP_DISC_ATTR *p_attr;
tSDP_PROTOCOL_ELEM pe;
UINT16 pversion = -1;
static void bta_create_pse_sdp_record(bluetooth_sdp_record *record, tSDP_DISC_REC *p_rec)
{
- tSDP_DISCOVERY_DB *db = p_bta_sdp_cfg->p_sdp_db;
tSDP_DISC_ATTR *p_attr;
UINT16 pversion;
tSDP_PROTOCOL_ELEM pe;
static void bta_create_ops_sdp_record(bluetooth_sdp_record *record, tSDP_DISC_REC *p_rec)
{
- tSDP_DISCOVERY_DB *db = p_bta_sdp_cfg->p_sdp_db;
tSDP_DISC_ATTR *p_attr, *p_sattr;
tSDP_PROTOCOL_ELEM pe;
UINT16 pversion = -1;
static void bta_create_raw_sdp_record(bluetooth_sdp_record *record, tSDP_DISC_REC *p_rec)
{
- tSDP_DISCOVERY_DB *db = p_bta_sdp_cfg->p_sdp_db;
tSDP_DISC_ATTR *p_attr;
- UINT16 pversion;
tSDP_PROTOCOL_ELEM pe;
record->hdr.type = SDP_TYPE_RAW;
tSDP_DISC_REC *p_rec = NULL;
tBTA_SDP_SEARCH_COMP evt_data = {0}; // We need to zero-initialize
tBTA_SDP_STATUS status = BTA_SDP_FAILURE;
- UINT16 uuid16 = 0;
int count = 0;
tBT_UUID su;
APPL_TRACE_DEBUG("bta_sdp_search_cback res: 0x%x", result);
# TODO(armansito): Remove all of these flags below. We want to enable all
# warnings that we can.
cflags = [
- "-Wno-unused-variable",
- "-Wno-unused-value",
- "-Wno-unused-function",
"-Wno-int-to-pointer-cast",
]
{
UNUSED(app_id);
- unsigned idx = 0;
-
bdstr_t bdstr;
sprintf(bdstr, "%02x:%02x:%02x:%02x:%02x:%02x",
remote_bda[0], remote_bda[1], remote_bda[2],
if (btif_hl_find_app_idx(app_id, &app_idx) )
{
- BTIF_HL_GET_APP_CB_PTR(app_idx);
if (btif_hl_find_mcl_idx(app_idx, bd_addr, &mcl_idx))
{
- p_mcb =BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
+ p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
BTIF_TRACE_DEBUG("app_idx=%d mcl_idx=%d",app_idx, mcl_idx);
BTIF_TRACE_DEBUG("valid_spd_idx=%d sdp_idx=%d",p_mcb->valid_sdp_idx, p_mcb->sdp_idx);
num_mdeps = p_rec->num_mdeps;
BTIF_TRACE_DEBUG("num_mdeps=%d", num_mdeps);
- for (i=0; i< num_mdeps; i++)
+ for (i = 0; i < num_mdeps; i++)
{
BTIF_TRACE_DEBUG("p_rec->mdep_cfg[%d].mdep_role=%d",i, p_rec->mdep_cfg[i].mdep_role);
BTIF_TRACE_DEBUG("p_rec->mdep_cfg[%d].data_type =%d",i, p_rec->mdep_cfg[i].data_type );
BTIF_TRACE_DEBUG("app_idx=%d", app_idx);
if (btif_hl_find_mcl_idx(app_idx, p_data->cch_open_cfm.bd_addr, &mcl_idx))
{
- BTIF_HL_GET_APP_CB_PTR(app_idx);
-
p_mcb = BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
BTIF_TRACE_DEBUG("mcl_idx=%d, mcl_handle=%d", mcl_idx,p_data->cch_open_cfm.mcl_handle);
p_mcb->mcl_handle = p_data->cch_open_cfm.mcl_handle;
if (btif_hl_find_mcl_idx_using_app_idx(p_data->dch_open_ind.mcl_handle, orig_app_idx, &mcl_idx ))
{
- BTIF_HL_GET_APP_CB_PTR(orig_app_idx);
- BTIF_HL_GET_MCL_CB_PTR(orig_app_idx, mcl_idx);
-
if (btif_hl_find_avail_mdl_idx(orig_app_idx, mcl_idx, &mdl_idx))
{
p_dcb = BTIF_HL_GET_MDL_CB_PTR(orig_app_idx, mcl_idx, mdl_idx);
if (btif_hl_find_mcl_idx_using_app_idx(p_data->dch_open_cfm.mcl_handle, app_idx, &mcl_idx ))
{
- BTIF_HL_GET_APP_CB_PTR(app_idx);
- BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx);
if (btif_hl_find_avail_mdl_idx(app_idx, mcl_idx, &mdl_idx))
if (btif_hl_find_mcl_idx_using_app_idx(p_data->dch_reconnect_cfm.mcl_handle, app_idx, &mcl_idx ))
{
- BTIF_HL_GET_APP_CB_PTR(app_idx);
- BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
p_pcb = BTIF_HL_GET_PCB_PTR(app_idx, mcl_idx);
if (btif_hl_find_avail_mdl_idx(app_idx, mcl_idx, &mdl_idx))
p_acb = BTIF_HL_GET_APP_CB_PTR(app_idx);
BTIF_TRACE_DEBUG("btif_hl_proc_dch_reconnect_ind: app_idx = %d, mcl_idx = %d",
app_idx, mcl_idx);
- BTIF_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
if (btif_hl_find_avail_mdl_idx(app_idx, mcl_idx, &mdl_idx))
{
BOOLEAN send_chan_cb=TRUE;
tBTA_HL_REG_PARAM reg_param;
btif_hl_app_cb_t *p_acb;
- bthl_app_reg_state_t reg_state = BTHL_APP_REG_STATE_REG_FAILED;
- UINT8 preg_idx;
- bt_status_t bt_status;
BTIF_TRACE_DEBUG("%s event %d", __FUNCTION__, event);
btif_hl_display_calling_process_name();
if (btif_hl_find_app_idx(((UINT8)app_id), &app_idx))
{
evt_param.unreg.app_idx = app_idx;
- BTIF_HL_GET_APP_CB_PTR(app_idx);
reg_counter --;
len = sizeof(btif_hl_unreg_t);
status = btif_transfer_context (btif_hl_proc_cb_evt, BTIF_HL_UNREG_APP,
if(btif_hl_find_app_idx_using_mdepId(mdep_id,&app_idx))
{
-
- BTIF_HL_GET_APP_CB_PTR(app_idx);
-
p_mdl = BTIF_HL_GET_MDL_CFG_PTR(app_idx, item_idx);
if (p_mdl)
{
static bt_status_t search(bt_bdaddr_t *bd_addr, const uint8_t *uuid)
{
- bdstr_t bdstr;
tSDP_UUID sdp_uuid;
sdp_uuid.len = 16;
memcpy(sdp_uuid.uu.uuid128, uuid, sizeof(sdp_uuid.uu.uuid128));
* user2_ptr. */
static int alloc_sdp_slot(bluetooth_sdp_record* in_record) {
int i;
- char* tmp_ptr = NULL;
int record_size = get_sdp_records_size(in_record, 1);
bluetooth_sdp_record* record = osi_malloc(record_size);
#define asrt(s) if (!(s)) APPL_TRACE_ERROR("## %s assert %s failed at line:%d ##",__FUNCTION__, \
#s, __LINE__)
-static pthread_mutex_t slot_lock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
-
-
struct packet {
struct packet *next, *prev;
uint32_t len;
osi_free(sock);
}
-static void btsock_l2cap_free(l2cap_socket *sock)
-{
- pthread_mutex_lock(&state_lock);
- btsock_l2cap_free_l(sock);
- pthread_mutex_unlock(&state_lock);
-}
-
static l2cap_socket *btsock_l2cap_alloc_l(const char *name, const bt_bdaddr_t *addr,
char is_server, int flags)
{
return NULL;
}
-static l2cap_socket *btsock_l2cap_alloc(const char *name, const bt_bdaddr_t *addr,
- char is_server, int flags)
-{
- l2cap_socket *ret;
-
- pthread_mutex_lock(&state_lock);
- ret = btsock_l2cap_alloc_l(name, addr, is_server, flags);
- pthread_mutex_unlock(&state_lock);
-
- return ret;
-}
-
bt_status_t btsock_l2cap_init(int handle)
{
APPL_TRACE_DEBUG("btsock_l2cap_init...");
} else {
- tBTA_JV_DATA_IND *p_data_ind = &evt->data_ind;
UINT8 buffer[L2CAP_MAX_SDU_LENGTH];
UINT32 count;
static void btsock_l2cap_cbk(tBTA_JV_EVT event, tBTA_JV *p_data, void *user_data)
{
- int rc;
-
switch (event) {
case BTA_JV_L2CAP_START_EVT:
on_srv_l2cap_listen_started(&p_data->l2c_start, (uint32_t)user_data);
{
int device_type;
int addr_type;
- UINT32 i;
bt_bdaddr_t bd_addr;
BD_ADDR bta_bd_addr;
bool device_added = false;
"//stack/include",
]
- cflags = [
- "-Wno-unused-variable",
- ]
-
deps = [
"//hci",
"//osi",
# TODO(armansito): Remove all of the flags below, as we want to be able to
# compile the source code with as many warnings enabled as possible.
cflags = [
- "-Wno-unused-variable",
- "-Wno-unused-value",
- "-Wno-unused-function",
"-Wno-int-to-pointer-cast",
]
# TODO(armansito): Remove all of these flags.
cflags = [
- "-Wno-unused-variable",
- "-Wno-unused-value",
- "-Wno-unused-function",
"-Wno-pointer-to-int-cast",
"-Wno-int-to-pointer-cast",
]
status = A2D_INVALID_PARAMS;
else
{
- losc = *p_info++;
- *p_info++;
+ losc = *p_info;
+ *p_info += 2;
+
/* If the function is called for the wrong Media Type or Media Codec Type */
if(losc != A2D_SBC_INFO_LEN || *p_info != A2D_MEDIA_CT_SBC)
status = A2D_WRONG_CODEC;
BOOLEAN BTM_ReadConnectedTransportAddress(BD_ADDR remote_bda, tBT_TRANSPORT transport)
{
tBTM_SEC_DEV_REC *p_dev_rec = btm_find_dev(remote_bda);
- tACL_CONN *p = btm_bda_to_acl(remote_bda, transport);
/* if no device can be located, return */
if (p_dev_rec == NULL)
}
/*******************************************************************************
-** Function btm_enc_proc_ltk
-** Description send LTK reply when it's ready.
-*******************************************************************************/
-static void btm_enc_proc_ltk(tSMP_ENC *p)
-{
- UINT8 i;
- BTM_TRACE_DEBUG ("btm_enc_proc_ltk");
- if (p && p->param_len == BT_OCTET16_LEN)
- {
- for (i = 0; i < (BT_OCTET16_LEN - btm_cb.key_size); i ++)
- p->param_buf[BT_OCTET16_LEN - i - 1] = 0;
- btsnd_hcic_ble_ltk_req_reply(btm_cb.enc_handle, p->param_buf);
- }
-}
-
-/*******************************************************************************
-** Function btm_enc_proc_slave_y
-** Description calculate LTK when Y is ready
-*******************************************************************************/
-static void btm_enc_proc_slave_y(tSMP_ENC *p)
-{
- UINT16 div, y;
- UINT8 *pp = p->param_buf;
- tBTM_CB *p_cb = &btm_cb;
- tSMP_ENC output;
- tBTM_SEC_DEV_REC *p_dev_rec;
-
- BTM_TRACE_DEBUG ("btm_enc_proc_slave_y");
- if (p != NULL)
- {
- STREAM_TO_UINT16(y, pp);
-
- div = p_cb->ediv ^ y;
- p_dev_rec = btm_find_dev_by_handle (p_cb->enc_handle);
-
- if ( p_dev_rec &&
- p_dev_rec->ble.keys.div == div )
- {
- BTM_TRACE_DEBUG ("LTK request OK");
- /* calculating LTK , LTK = E er(div) */
- SMP_Encrypt(p_cb->devcb.ble_encryption_key_value, BT_OCTET16_LEN, (UINT8 *)&div, 2, &output);
- btm_enc_proc_ltk(&output);
- }
- else
- {
- BTM_TRACE_DEBUG ("LTK request failed - send negative reply");
- btsnd_hcic_ble_ltk_req_neg_reply(p_cb->enc_handle);
- if (p_dev_rec)
- btm_ble_link_encrypted(p_dev_rec->bd_addr, 0);
-
- }
- }
-}
-
-/*******************************************************************************
**
** Function btm_ble_ltk_request_reply
**
{
tBTM_SEC_DEV_REC *p_rec = btm_find_dev (bda);
tBTM_CB *p_cb = &btm_cb;
- tSMP_ENC output;
if (p_rec == NULL)
{
return status;
}
+#if BLE_VND_INCLUDED == TRUE
/*******************************************************************************
**
** Function btm_vsc_brcm_features_complete
*******************************************************************************/
static void btm_ble_vendor_capability_vsc_cmpl_cback (tBTM_VSC_CMPL *p_vcs_cplt_params)
{
-#if BLE_VND_INCLUDED == TRUE
UINT8 status = 0xFF;
UINT8 *p;
if (btm_cb.cmn_ble_vsc_cb.max_irk_list_sz > 0 &&
controller_get_interface()->get_ble_resolving_list_max_size() == 0)
btm_ble_resolving_list_init(btm_cb.cmn_ble_vsc_cb.max_irk_list_sz);
-#endif
+#endif /* (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE) */
if (btm_cb.cmn_ble_vsc_cb.tot_scan_results_strg > 0)
btm_ble_batchscan_init();
if (p_ctrl_le_feature_rd_cmpl_cback != NULL)
p_ctrl_le_feature_rd_cmpl_cback(status);
-#endif
}
+#endif /* BLE_VND_INCLUDED == TRUE */
/*******************************************************************************
**
#if BLE_INCLUDED == TRUE
tBTM_SEC_DEV_REC *p_dev_rec = &btm_cb.sec_dev_rec[0];
tBTM_SEC_DEV_REC temp_rec = *p_target_rec;
- BD_ADDR dummy_bda = {0};
BTM_TRACE_DEBUG("%s", __func__);
*******************************************************************************/
static void btm_decode_ext_features_page (UINT8 page_number, const UINT8 *p_features)
{
- UINT8 last;
- UINT8 first;
-
BTM_TRACE_DEBUG ("btm_decode_ext_features_page page: %d", page_number);
switch (page_number)
{
static BOOLEAN btm_sec_queue_encrypt_request (BD_ADDR bd_addr, tBT_TRANSPORT transport,
tBTM_SEC_CALLBACK *p_callback, void *p_ref_data);
-static void btm_sec_clean_pending_req_queue (BD_ADDR remote_bda, tBT_TRANSPORT transport) ;
static void btm_sec_check_pending_enc_req (tBTM_SEC_DEV_REC *p_dev_rec, tBT_TRANSPORT transport,
UINT8 encr_enable);
-static BOOLEAN btm_sec_acceptor_rejects_bonding (tBTM_SEC_DEV_REC *p_dev_rec);
static BOOLEAN btm_sec_use_smp_br_chnl(tBTM_SEC_DEV_REC *p_dev_rec);
static BOOLEAN btm_sec_is_master(tBTM_SEC_DEV_REC *p_dev_rec);
/*******************************************************************************
**
-** Function btm_sec_clean_pending_req_queue
-**
-** Description This function cleans up the pending security request when the
-** link to the target device dropped.
-**
-** Returns void
-**
-*******************************************************************************/
-static void btm_sec_clean_pending_req_queue (BD_ADDR remote_bda, tBT_TRANSPORT transport)
-{
- tBTM_SEC_QUEUE_ENTRY *p_e;
- BUFFER_Q *bq = &btm_cb.sec_pending_q;
-
- p_e = (tBTM_SEC_QUEUE_ENTRY *)GKI_getfirst(bq);
-
- if (p_e != NULL)
- {
- if (memcmp(p_e->bd_addr, remote_bda, BD_ADDR_LEN) == 0
-#if BLE_INCLUDED == TRUE
- && p_e->transport == transport
-#endif
- )
- {
- (*p_e->p_callback) (remote_bda, transport, p_e->p_ref_data, BTM_ERR_PROCESSING);
- GKI_remove_from_queue(bq, (void *)p_e);
- }
- p_e = (tBTM_SEC_QUEUE_ENTRY *) GKI_getnext ((void *)p_e);
- }
-}
-
-/*******************************************************************************
-**
** Function btm_sec_is_serv_level0
**
** Description This function is called to check if the service corresponding
{
tGAP_CCB *p_ccb;
UINT16 cid;
- tBT_UUID bt_uuid = {2, {GAP_PROTOCOL_ID}};
GAP_TRACE_EVENT ("GAP_CONN - Open Request");
p_ccb->con_flags |= GAP_CCB_FLAGS_SEC_DONE;
/* Check if L2CAP started the connection process */
- if (p_rem_bda && ((cid = L2CA_CONNECT_REQ (p_ccb->psm, p_rem_bda, &p_ccb->ertm_info, &bt_uuid)) != 0))
+ if (p_rem_bda && ((cid = L2CA_CONNECT_REQ (p_ccb->psm, p_rem_bda, &p_ccb->ertm_info)) != 0))
{
p_ccb->connection_id = cid;
return (p_ccb->gap_handle);
{
UINT16 xx;
tGAP_CCB *p_ccb;
- tBT_UUID bt_uuid = {2, {GAP_PROTOCOL_ID}};
/* See if we have a CCB listening for the connection */
for (xx = 0, p_ccb = gap_cb.conn.ccb_pool; xx < GAP_MAX_CONNECTIONS; xx++, p_ccb++)
p_ccb->connection_id = l2cap_cid;
/* Send response to the L2CAP layer. */
- L2CA_CONNECT_RSP (bd_addr, l2cap_id, l2cap_cid, L2CAP_CONN_OK, L2CAP_CONN_OK, &p_ccb->ertm_info, &bt_uuid);
+ L2CA_CONNECT_RSP (bd_addr, l2cap_id, l2cap_cid, L2CAP_CONN_OK, L2CAP_CONN_OK, &p_ccb->ertm_info);
GAP_TRACE_EVENT("GAP_CONN - Rcvd L2CAP conn ind, CID: 0x%x", p_ccb->connection_id);
*******************************************************************************/
void GATT_ConfigServiceChangeCCC (BD_ADDR remote_bda, BOOLEAN enable, tBT_TRANSPORT transport)
{
- UINT16 conn_id = GATT_INVALID_CONN_ID;
tGATT_PROFILE_CLCB *p_clcb = gatt_profile_find_clcb_by_bd_addr (remote_bda, transport);
if (p_clcb == NULL)
{
tHID_HOST_DEV_CTB *p_dev = (tHID_HOST_DEV_CTB *) p_ref_data;
UINT8 dhandle;
- UINT32 reason;
UNUSED(bd_addr);
UNUSED (transport);
#define L2CA_REGISTER(a,b,c) L2CA_Register(a,(tL2CAP_APPL_INFO *)b)
#define L2CA_DEREGISTER(a) L2CA_Deregister(a)
-#define L2CA_CONNECT_REQ(a,b,c,d) L2CA_ErtmConnectReq(a,b,c)
-#define L2CA_CONNECT_RSP(a,b,c,d,e,f,g) L2CA_ErtmConnectRsp(a,b,c,d,e,f)
+#define L2CA_CONNECT_REQ(a,b,c) L2CA_ErtmConnectReq(a,b,c)
+#define L2CA_CONNECT_RSP(a,b,c,d,e,f) L2CA_ErtmConnectRsp(a,b,c,d,e,f)
#define L2CA_CONFIG_REQ(a,b) L2CA_ConfigReq(a,b)
#define L2CA_CONFIG_RSP(a,b) L2CA_ConfigRsp(a,b)
#define L2CA_DISCONNECT_REQ(a) L2CA_DisconnectReq(a)
void l2cble_scanner_conn_comp (UINT16 handle, BD_ADDR bda, tBLE_ADDR_TYPE type,
UINT16 conn_interval, UINT16 conn_latency, UINT16 conn_timeout)
{
- int i;
tL2C_LCB *p_lcb;
tBTM_SEC_DEV_REC *p_dev_rec = btm_find_or_alloc_dev (bda);
void l2cble_advertiser_conn_comp (UINT16 handle, BD_ADDR bda, tBLE_ADDR_TYPE type,
UINT16 conn_interval, UINT16 conn_latency, UINT16 conn_timeout)
{
- int i;
tL2C_LCB *p_lcb;
tBTM_SEC_DEV_REC *p_dev_rec;
UNUSED(type);
static void l2cble_start_conn_update (tL2C_LCB *p_lcb)
{
UINT16 min_conn_int, max_conn_int, slave_latency, supervision_tout;
- tBTM_SEC_DEV_REC *p_dev_rec = btm_find_or_alloc_dev(p_lcb->remote_bd_addr);
tACL_CONN *p_acl_cb = btm_bda_to_acl(p_lcb->remote_bd_addr, BT_TRANSPORT_LE);
+ // TODO(armansito): The return value of this call wasn't being used but the
+ // logic of this function might be depending on its side effects. We should
+ // verify if this call is needed at all and remove it otherwise.
+ btm_find_or_alloc_dev(p_lcb->remote_bd_addr);
+
if (p_lcb->conn_update_mask & L2C_BLE_UPDATE_PENDING) return;
if (p_lcb->conn_update_mask & L2C_BLE_CONN_UPDATE_DISABLE)