/* if SBC is used by the SNK as INT, discover req is not sent in bta_av_config_ind.
* call disc_res now */
/* this is called in A2DP SRC path only, In case of SINK we don't need it */
- if (local_sep == AVDT_TSEP_SRC)
+ if (local_sep == AVDT_TSEP_SRC) {
p_scb->p_cos->disc_res(p_scb->hndl, num, num, 0, p_scb->peer_addr,
UUID_SERVCLASS_AUDIO_SOURCE);
+ }
} else {
/* we do not know the peer device and it is using non-SBC codec
* we need to know all the SEPs on SNK */
if (p_data->rc_msg.msg.pass.op_id == AVRC_ID_VENDOR) {
p_data->rc_msg.msg.hdr.ctype = BTA_AV_RSP_NOT_IMPL;
#if (AVRC_METADATA_INCLUDED == TRUE)
- if (p_cb->features & BTA_AV_FEAT_METADATA)
+ if (p_cb->features & BTA_AV_FEAT_METADATA) {
p_data->rc_msg.msg.hdr.ctype =
bta_av_group_navi_supported(p_data->rc_msg.msg.pass.pass_len,
p_data->rc_msg.msg.pass.p_pass_data, is_inquiry);
+ }
#endif
} else {
p_data->rc_msg.msg.hdr.ctype = bta_av_op_supported(p_data->rc_msg.msg.pass.op_id, is_inquiry);
evt = bta_av_proc_meta_cmd (&rc_rsp, &p_data->rc_msg, &ctype);
} else
#endif
+ {
evt = BTA_AV_VENDOR_CMD_EVT;
+ }
}
/* else if configured to support vendor specific and it's a response */
else if ((p_cb->features & BTA_AV_FEAT_VENDOR) &&
evt = BTA_AV_META_MSG_EVT;
} else
#endif
+ {
evt = BTA_AV_VENDOR_RSP_EVT;
+ }
}
/* else if not configured to support vendor specific and it's a command */
** Returns char *
**
*******************************************************************************/
-static char *bta_av_st_code(UINT8 state)
+UNUSED_ATTR static char *bta_av_st_code(UINT8 state)
{
switch (state) {
case BTA_AV_INIT_ST: return "INIT";
#include <string.h>
#include "bta/bta_av_co.h"
#include "bta_av_int.h"
+#include "osi/osi.h"
/*****************************************************************************
** Constants and types
** Returns char *
**
*******************************************************************************/
-static char *bta_av_sst_code(UINT8 state)
+UNUSED_ATTR static char *bta_av_sst_code(UINT8 state)
{
switch (state) {
case BTA_AV_INIT_SST: return "INIT";
/* set modes for Discoverability and connectability if not ignore */
if (p_data->set_visibility.disc_mode != (BTA_DM_IGNORE | BTA_DM_LE_IGNORE)) {
- if ((p_data->set_visibility.disc_mode & BTA_DM_LE_IGNORE) == BTA_DM_LE_IGNORE)
+ if ((p_data->set_visibility.disc_mode & BTA_DM_LE_IGNORE) == BTA_DM_LE_IGNORE) {
p_data->set_visibility.disc_mode =
((p_data->set_visibility.disc_mode & ~BTA_DM_LE_IGNORE) | le_disc_mode);
+ }
- if ((p_data->set_visibility.disc_mode & BTA_DM_IGNORE) == BTA_DM_IGNORE)
+ if ((p_data->set_visibility.disc_mode & BTA_DM_IGNORE) == BTA_DM_IGNORE) {
p_data->set_visibility.disc_mode =
((p_data->set_visibility.disc_mode & ~BTA_DM_IGNORE) | disc_mode);
+ }
BTM_SetDiscoverability(p_data->set_visibility.disc_mode,
bta_dm_cb.inquiry_scan_window,
}
if (p_data->set_visibility.conn_mode != (BTA_DM_IGNORE | BTA_DM_LE_IGNORE)) {
- if ((p_data->set_visibility.conn_mode & BTA_DM_LE_IGNORE) == BTA_DM_LE_IGNORE)
+ if ((p_data->set_visibility.conn_mode & BTA_DM_LE_IGNORE) == BTA_DM_LE_IGNORE) {
p_data->set_visibility.conn_mode =
((p_data->set_visibility.conn_mode & ~BTA_DM_LE_IGNORE) | le_conn_mode);
+ }
- if ((p_data->set_visibility.conn_mode & BTA_DM_IGNORE) == BTA_DM_IGNORE)
+ if ((p_data->set_visibility.conn_mode & BTA_DM_IGNORE) == BTA_DM_IGNORE) {
p_data->set_visibility.conn_mode =
((p_data->set_visibility.conn_mode & ~BTA_DM_IGNORE) | conn_mode);
+ }
BTM_SetConnectability(p_data->set_visibility.conn_mode,
bta_dm_cb.page_scan_window,
#if BLE_INCLUDED == TRUE && BTA_GATT_INCLUDED == TRUE
/* if any BR/EDR service discovery has been done, report the event */
- if ((bta_dm_search_cb.services & ((BTA_ALL_SERVICE_MASK | BTA_USER_SERVICE_MASK ) & ~BTA_BLE_SERVICE_MASK)))
-#endif
+ if ((bta_dm_search_cb.services & ((BTA_ALL_SERVICE_MASK | BTA_USER_SERVICE_MASK ) & ~BTA_BLE_SERVICE_MASK))) {
bta_dm_search_cb.p_search_cback(BTA_DM_DISC_RES_EVT, &p_data->disc_result.result);
-
+ }
+#else
+ bta_dm_search_cb.p_search_cback(BTA_DM_DISC_RES_EVT, &p_data->disc_result.result);
+#endif
tBTA_DM_MSG *p_msg = (tBTA_DM_MSG *) osi_malloc(sizeof(tBTA_DM_MSG));
/* send a message to change state */
}
/* last one? clear the BLE service bit if all discovery has been done */
- if (bta_dm_search_cb.uuid_to_search == 0)
+ if (bta_dm_search_cb.uuid_to_search == 0) {
bta_dm_search_cb.services_to_search &=
(tBTA_SERVICE_MASK)(~(BTA_SERVICE_ID_TO_SERVICE_MASK(bta_dm_search_cb.service_index)));
+ }
} else
#endif
char *p_temp;
/* If the name isn't already stored, try retrieving from BTM */
- if (*p_name == '\0')
+ if (*p_name == '\0') {
if ((p_temp = BTM_SecReadDevName(bta_dm_search_cb.peer_bdaddr)) != NULL) {
p_name = p_temp;
}
-
+ }
return p_name;
}
#endif ///SDP_INCLUDED == TRUE || SMP_INCLUDED == TRUE
p_data->ble_set_storage.ref_value);
}
- if (BTM_CMD_STARTED != btm_status)
+ if (BTM_CMD_STARTED != btm_status) {
bta_ble_scan_setup_cb(BTM_BLE_BATCH_SCAN_CFG_STRG_EVT, p_data->ble_set_storage.ref_value,
btm_status);
+ }
}
/*******************************************************************************
p_data->ble_enable_scan.ref_value);
}
- if (BTM_CMD_STARTED != btm_status)
+ if (BTM_CMD_STARTED != btm_status) {
bta_ble_scan_setup_cb(BTM_BLE_BATCH_SCAN_ENABLE_EVT, p_data->ble_enable_scan.ref_value,
btm_status);
+ }
}
/*******************************************************************************
btm_status = BTM_BleDisableBatchScan(p_data->ble_disable_scan.ref_value);
}
- if (BTM_CMD_STARTED != btm_status)
+ if (BTM_CMD_STARTED != btm_status) {
bta_ble_scan_setup_cb(BTM_BLE_BATCH_SCAN_DISABLE_EVT, p_data->ble_enable_scan.ref_value,
btm_status);
+ }
}
/*******************************************************************************
p_data->ble_read_reports.ref_value);
}
- if (BTM_CMD_STARTED != btm_status)
+ if (BTM_CMD_STARTED != btm_status) {
bta_ble_scan_setup_cb(BTM_BLE_BATCH_SCAN_READ_REPTS_EVT, p_data->ble_enable_scan.ref_value,
btm_status);
+ }
}
/*******************************************************************************
}
}
- if (p_data->ble_cfg_filter_cond.p_filt_cfg_cback)
+ if (p_data->ble_cfg_filter_cond.p_filt_cfg_cback) {
p_data->ble_cfg_filter_cond.p_filt_cfg_cback(BTA_DM_BLE_PF_CONFIG_EVT,
p_data->ble_cfg_filter_cond.cond_type, 0, status,
p_data->ble_cfg_filter_cond.ref_value);
+ }
return;
}
return;
}
- if (p_data->ble_enable_scan_filt.p_filt_status_cback)
+ if (p_data->ble_enable_scan_filt.p_filt_status_cback) {
p_data->ble_enable_scan_filt.p_filt_status_cback (BTA_DM_BLE_PF_ENABLE_EVT,
p_data->ble_enable_scan_filt.ref_value, status);
+ }
}
}
}
- if (p_data->ble_scan_filt_param_setup.p_filt_param_cback)
+ if (p_data->ble_scan_filt_param_setup.p_filt_param_cback) {
p_data->ble_scan_filt_param_setup.p_filt_param_cback (BTA_DM_BLE_PF_ENABLE_EVT, 0,
p_data->ble_scan_filt_param_setup.ref_value, status);
+ }
return;
}
((p2[0]) << 24) + ((p2[1]) << 16) + ((p2[2]) << 8) + (p2[3]),
((p2[4]) << 8) + p2[5]);
+ UNUSED(p1);
+ UNUSED(p2);
APPL_TRACE_DEBUG("BTA_GATTC_OPEN_EVT conn_id = %d client_if=%d status = %d" ,
p_data->conn_id,
p_data->client_if,
bta_dm_pm_set_sniff_policy( bta_dm_find_peer_device(bta_dm_conn_srvcs.conn_srvc[j].peer_bdaddr), bScoActive);
/* if we had disabled link policy, seems like the hid device stop retrying SNIFF after a few tries. force sniff if needed */
- if (!bScoActive)
+ if (!bScoActive) {
bta_dm_pm_set_mode(bta_dm_conn_srvcs.conn_srvc[j].peer_bdaddr, BTA_DM_PM_NO_ACTION,
BTA_DM_PM_RESTART);
+ }
}
}
bta_gattc_reset_discover_st(p_clcb->p_srcb, BTA_GATT_OK);
//register service change
bta_gattc_register_service_change_notify(p_clcb->bta_conn_id, p_clcb->bda);
- } else
+ } else
#endif
{ /* cache is building */
p_clcb->p_srcb->state = BTA_GATTC_SERV_DISC;
*******************************************************************************/
void bta_gattc_read(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data)
{
- if (!bta_gattc_enqueue(p_clcb, p_data))
+ if (!bta_gattc_enqueue(p_clcb, p_data)) {
return;
+ }
tGATT_READ_PARAM read_param;
memset (&read_param, 0 ,sizeof(tGATT_READ_PARAM));
*******************************************************************************/
void bta_gattc_write(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data)
{
- if (!bta_gattc_enqueue(p_clcb, p_data))
+ if (!bta_gattc_enqueue(p_clcb, p_data)) {
return;
+ }
tBTA_GATT_STATUS status = BTA_GATT_OK;
tGATT_VALUE attr;
tBTA_GATTC gattc_cb = {0};
gattc_cb.set_assoc.client_if = p_msg->api_assoc.client_if;
BOOLEAN state = FALSE;
- tBTA_GATTC_CLCB *p_assoc_clcb = bta_gattc_find_clcb_by_cif(p_msg->api_assoc.client_if,
+ tBTA_GATTC_CLCB *p_assoc_clcb = bta_gattc_find_clcb_by_cif(p_msg->api_assoc.client_if,
p_msg->api_assoc.assoc_addr, BTA_TRANSPORT_LE);
tBTA_GATTC_RCB *p_clrcb = bta_gattc_cl_get_regcb(p_msg->api_assoc.client_if);
if (p_assoc_clcb != NULL) {
}
return;
-
+
}
void bta_gattc_process_api_cache_get_addr_list(tBTA_GATTC_CB *p_cb, tBTA_GATTC_DATA *p_msg)
{
};
/* utility functions */
-bool display_cache_attribute(void *data, void *context)
+bool display_cache_attribute(void *data, void *context)
{
//tBTA_GATTC_CACHE_ATTR *p_attr = data;
//APPL_TRACE_ERROR("\t Attr handle[%d] uuid[0x%04x] type[%s] prop[0x%1x]",
return true;
}
-bool display_cache_service(void *data, void *context)
+bool display_cache_service(void *data, void *context)
{
tBTA_GATTC_SERVICE *p_cur_srvc = data;
APPL_TRACE_API("Service: handle[%d ~ %d] %s[0x%04x] inst[%d]",
osi_free(ptr);
}
-void bta_gattc_insert_sec_service_to_cache(list_t *services, tBTA_GATTC_SERVICE *p_new_srvc)
+void bta_gattc_insert_sec_service_to_cache(list_t *services, tBTA_GATTC_SERVICE *p_new_srvc)
{
- // services/p_new_srvc is NULL
+ // services/p_new_srvc is NULL
if (!services || !p_new_srvc) {
APPL_TRACE_ERROR("%s services/p_new_srvc is NULL", __func__);
return;
return;
}
}
- }
+ }
}
}
/* TODO(jpawlowski): We should use attribute handle, not value handle to refer to characteristic.
This is just a temporary workaround.
*/
- if (service->e_handle < value_handle)
+ if (service->e_handle < value_handle) {
service->e_handle = value_handle;
+ }
tBTA_GATTC_CHARACTERISTIC *characteristic = osi_malloc(sizeof(tBTA_GATTC_CHARACTERISTIC));
if (!characteristic) {
if(include_service && !include_service->included_service) {
//update
include_service->included_service = bta_gattc_find_matching_service(services, include_service->incl_srvc_s_handle);
- if(!include_service->included_service) {
+ if(!include_service->included_service) {
//not match, free it
list_remove(service->included_svc, include_service);
- osi_free(include_service);
+ osi_free(include_service);
}
}
}
p_data->value.incl_service.e_handle,
p_data->value.incl_service.service_type);
- if (!pri_srvc)
+ if (!pri_srvc) {
bta_gattc_add_srvc_to_list(p_srvc_cb,
p_data->value.incl_service.s_handle,
p_data->value.incl_service.e_handle,
p_data->value.incl_service.service_type,
FALSE);
+ }
/* add into database */
bta_gattc_add_attr_to_cache(p_srvc_cb,
p_data->handle,
case GATT_DISC_CHAR_DSCPT:
bta_gattc_add_attr_to_cache(p_srvc_cb,
- p_data->handle,
- &p_data->type,
+ p_data->handle,
+ &p_data->type,
0,
0 /* incl_srvc_s_handle */,
0 /* incl_srvc_e_handle */,
tBTA_GATTC_CLCB *p_clcb = bta_gattc_find_clcb_by_conn_id(conn_id);
if ( p_clcb && (status != GATT_SUCCESS || p_clcb->status != GATT_SUCCESS) ) {
- if (status == GATT_SUCCESS)
+ if (status == GATT_SUCCESS) {
p_clcb->status = status;
+ }
bta_gattc_sm_execute(p_clcb, BTA_GATTC_DISCOVER_CMPL_EVT, NULL);
return;
}
{
tBTA_GATTC cb_data;
- if (!p_clcb->p_srcb->p_srvc_cache || list_is_empty(p_clcb->p_srcb->p_srvc_cache))
+ if (!p_clcb->p_srcb->p_srvc_cache || list_is_empty(p_clcb->p_srcb->p_srvc_cache)) {
return;
+ }
for (list_node_t *sn = list_begin(p_clcb->p_srcb->p_srvc_cache);
sn != list_end(p_clcb->p_srcb->p_srvc_cache); sn = list_next(sn)) {
tBTA_GATTC_SERVICE *p_cache = list_node(sn);
- if (!bta_gattc_uuid_compare(p_uuid, &p_cache->uuid, FALSE))
+ if (!bta_gattc_uuid_compare(p_uuid, &p_cache->uuid, FALSE)) {
continue;
+ }
#if (defined BTA_GATT_DEBUG && BTA_GATT_DEBUG == TRUE)
APPL_TRACE_DEBUG("found service [0x%04x], inst[%d] handle [%d]",
p_cache->handle,
p_cache->s_handle);
#endif
- if (!p_clcb->p_rcb->p_cback)
+ if (!p_clcb->p_rcb->p_cback) {
continue;
+ }
memset(&cb_data, 0, sizeof(tBTA_GATTC));
}
list_t* bta_gattc_get_services_srcb(tBTA_GATTC_SERV *p_srcb) {
- if (!p_srcb || !p_srcb->p_srvc_cache || list_is_empty(p_srcb->p_srvc_cache))
+ if (!p_srcb || !p_srcb->p_srvc_cache || list_is_empty(p_srcb->p_srvc_cache)) {
return NULL;
+ }
return p_srcb->p_srvc_cache;
}
const list_t* bta_gattc_get_services(UINT16 conn_id) {
tBTA_GATTC_CLCB *p_clcb = bta_gattc_find_clcb_by_conn_id(conn_id);
- if (p_clcb == NULL )
+ if (p_clcb == NULL ) {
return NULL;
+ }
tBTA_GATTC_SERV *p_srcb = p_clcb->p_srcb;
}
tBTA_GATTC_SERVICE* bta_gattc_find_matching_service(const list_t *services, UINT16 handle) {
- if (!services || list_is_empty(services))
+ if (!services || list_is_empty(services)) {
return NULL;
+ }
for (list_node_t *sn = list_begin(services);
sn != list_end(services); sn = list_next(sn)) {
tBTA_GATTC_SERVICE *service = list_node(sn);
- if (handle >= service->s_handle && handle <= service->e_handle)
+ if (handle >= service->s_handle && handle <= service->e_handle) {
return service;
+ }
}
return NULL;
}
-const tBTA_GATTC_SERVICE* bta_gattc_get_service_for_handle_srcb(tBTA_GATTC_SERV *p_srcb, UINT16 handle)
+const tBTA_GATTC_SERVICE* bta_gattc_get_service_for_handle_srcb(tBTA_GATTC_SERV *p_srcb, UINT16 handle)
{
const list_t *services = bta_gattc_get_services_srcb(p_srcb);
return bta_gattc_find_matching_service(services, handle);
}
-const tBTA_GATTC_SERVICE* bta_gattc_get_service_for_handle(UINT16 conn_id, UINT16 handle)
+const tBTA_GATTC_SERVICE* bta_gattc_get_service_for_handle(UINT16 conn_id, UINT16 handle)
{
const list_t *services = bta_gattc_get_services(conn_id);
return bta_gattc_find_matching_service(services, handle);
}
-tBTA_GATTC_CHARACTERISTIC* bta_gattc_get_characteristic_srcb(tBTA_GATTC_SERV *p_srcb, UINT16 handle)
+tBTA_GATTC_CHARACTERISTIC* bta_gattc_get_characteristic_srcb(tBTA_GATTC_SERV *p_srcb, UINT16 handle)
{
const tBTA_GATTC_SERVICE* service = bta_gattc_get_service_for_handle_srcb(p_srcb, handle);
- if (!service)
+ if (!service) {
return NULL;
+ }
for (list_node_t *cn = list_begin(service->characteristics);
cn != list_end(service->characteristics); cn = list_next(cn)) {
tBTA_GATTC_CHARACTERISTIC *p_char = list_node(cn);
- if (handle == p_char->handle)
+ if (handle == p_char->handle) {
return p_char;
+ }
}
return NULL;
}
-tBTA_GATTC_CHARACTERISTIC* bta_gattc_get_characteristic(UINT16 conn_id, UINT16 handle)
+tBTA_GATTC_CHARACTERISTIC* bta_gattc_get_characteristic(UINT16 conn_id, UINT16 handle)
{
tBTA_GATTC_CLCB *p_clcb = bta_gattc_find_clcb_by_conn_id(conn_id);
- if (p_clcb == NULL )
+ if (p_clcb == NULL ) {
return NULL;
+ }
tBTA_GATTC_SERV *p_srcb = p_clcb->p_srcb;
return bta_gattc_get_characteristic_srcb(p_srcb, handle);
}
-tBTA_GATTC_DESCRIPTOR* bta_gattc_get_descriptor_srcb(tBTA_GATTC_SERV *p_srcb, UINT16 handle)
+tBTA_GATTC_DESCRIPTOR* bta_gattc_get_descriptor_srcb(tBTA_GATTC_SERV *p_srcb, UINT16 handle)
{
const tBTA_GATTC_SERVICE* service = bta_gattc_get_service_for_handle_srcb(p_srcb, handle);
for (list_node_t *dn = list_begin(p_char->descriptors);
dn != list_end(p_char->descriptors); dn = list_next(dn)) {
tBTA_GATTC_DESCRIPTOR *p_desc = list_node(dn);
- if (handle == p_desc->handle)
+ if (handle == p_desc->handle) {
return p_desc;
+ }
}
}
return NULL;
}
-tBTA_GATTC_DESCRIPTOR* bta_gattc_get_descriptor(UINT16 conn_id, UINT16 handle)
+tBTA_GATTC_DESCRIPTOR* bta_gattc_get_descriptor(UINT16 conn_id, UINT16 handle)
{
tBTA_GATTC_CLCB *p_clcb = bta_gattc_find_clcb_by_conn_id(conn_id);
- if (p_clcb == NULL )
+ if (p_clcb == NULL ) {
return NULL;
+ }
tBTA_GATTC_SERV *p_srcb = p_clcb->p_srcb;
return bta_gattc_get_descriptor_srcb(p_srcb, handle);
}
}
}
-
+
}
}
}
if (type == BTGATT_DB_PRIMARY_SERVICE || type == BTGATT_DB_SECONDARY_SERVICE) {
- if ((type == BTGATT_DB_PRIMARY_SERVICE && p_cur_srvc->is_primary) ||
+ if ((type == BTGATT_DB_PRIMARY_SERVICE && p_cur_srvc->is_primary) ||
(type == BTGATT_DB_SECONDARY_SERVICE && !p_cur_srvc->is_primary)) {
// if the current service is the last service in the db, need to ensure the current service start handle is not less than the start_handle.
if (!svc_length) {
** Returns number of elements inside db from start_handle to end_handle
*******************************************************************************/
static size_t bta_gattc_get_db_size(list_t *services,
- UINT16 start_handle, UINT16 end_handle)
+ UINT16 start_handle, UINT16 end_handle)
{
- if (!services || list_is_empty(services))
+ if (!services || list_is_empty(services)) {
return 0;
+ }
size_t db_size = 0;
UINT16 svc_length = list_length(services) - 1;
} else {
db_size++;
}
-
- if (!p_cur_srvc->characteristics || list_is_empty(p_cur_srvc->characteristics))
+
+ if (!p_cur_srvc->characteristics || list_is_empty(p_cur_srvc->characteristics)) {
continue;
+ }
for (list_node_t *cn = list_begin(p_cur_srvc->characteristics);
cn != list_end(p_cur_srvc->characteristics); cn = list_next(cn)) {
*count = 0;
return;
}
-
+
tBTA_GATTC_SERV *p_srcb = p_clcb->p_srcb;
if (!p_srcb->p_srvc_cache || list_is_empty(p_srcb->p_srvc_cache)) {
*count = 0;
*count = 0;
return;
}
-
+
tBTA_GATTC_SERV *p_srcb = p_clcb->p_srcb;
if (!p_srcb->p_srvc_cache || list_is_empty(p_srcb->p_srvc_cache)) {
*count = 0;
}
}
*count = bta_gattc_get_db_size_with_type(p_srcb->p_srvc_cache, type, NULL, start_handle, end_handle);
-
+
}
/*******************************************************************************
p_char->properties);
curr_db_attr++;
- if (!p_char->descriptors || list_is_empty(p_char->descriptors))
+ if (!p_char->descriptors || list_is_empty(p_char->descriptors)) {
continue;
+ }
for (list_node_t *dn = list_begin(p_char->descriptors);
dn != list_end(p_char->descriptors); dn = list_next(dn)) {
}
}
- if (!p_cur_srvc->included_svc || list_is_empty(p_cur_srvc->included_svc))
+ if (!p_cur_srvc->included_svc || list_is_empty(p_cur_srvc->included_svc)) {
continue;
+ }
for (list_node_t *isn = list_begin(p_cur_srvc->included_svc);
isn != list_end(p_cur_srvc->included_svc); isn = list_next(isn)) {
*******************************************************************************/
void bta_gattc_cache_save(tBTA_GATTC_SERV *p_srvc_cb, UINT16 conn_id)
{
- if (!p_srvc_cb->p_srvc_cache || list_is_empty(p_srvc_cb->p_srvc_cache))
+ if (!p_srvc_cb->p_srvc_cache || list_is_empty(p_srvc_cb->p_srvc_cache)) {
return;
+ }
int i = 0;
size_t db_size = bta_gattc_get_db_size(p_srvc_cb->p_srvc_cache, 0x0000, 0xFFFF);
sn != list_end(p_srvc_cb->p_srvc_cache); sn = list_next(sn)) {
tBTA_GATTC_SERVICE *p_cur_srvc = list_node(sn);
- if (!p_cur_srvc->characteristics || list_is_empty(p_cur_srvc->characteristics))
+ if (!p_cur_srvc->characteristics || list_is_empty(p_cur_srvc->characteristics)) {
continue;
+ }
for (list_node_t *cn = list_begin(p_cur_srvc->characteristics);
cn != list_end(p_cur_srvc->characteristics); cn = list_next(cn)) {
0 /* incl_srvc_e_handle */,
FALSE);
- if (!p_char->descriptors || list_is_empty(p_char->descriptors))
+ if (!p_char->descriptors || list_is_empty(p_char->descriptors)) {
continue;
+ }
for (list_node_t *dn = list_begin(p_char->descriptors);
dn != list_end(p_char->descriptors); dn = list_next(dn)) {
}
}
- if (!p_cur_srvc->included_svc || list_is_empty(p_cur_srvc->included_svc))
+ if (!p_cur_srvc->included_svc || list_is_empty(p_cur_srvc->included_svc)) {
continue;
+ }
for (list_node_t *an = list_begin(p_cur_srvc->included_svc);
an != list_end(p_cur_srvc->included_svc); an = list_next(an)) {
if (p_tcb != NULL)
{
- if (p_tcb->p_srvc_cache != NULL)
+ if (p_tcb->p_srvc_cache != NULL) {
list_free(p_tcb->p_srvc_cache);
+ }
osi_free(p_tcb->p_srvc_list);
p_tcb->p_srvc_list = NULL;
//osi_free_and_reset((void **)&p_tcb->p_srvc_list);
* clear boundaries are always around service.
*/
handle = p_clrcb->notif_reg[i].handle;
- if (handle >= start_handle && handle <= end_handle)
+ if (handle >= start_handle && handle <= end_handle) {
memset(&p_clrcb->notif_reg[i], 0, sizeof(tBTA_GATTC_NOTIF_REG));
+ }
}
}
}
if (p_src->len == LEN_UUID_16 || p_src->len == LEN_UUID_32)
{
- for(i=0; i != 16; ++i)
+ for(i=0; i != 16; ++i) {
p_dest->uu[i] = base_uuid[i];
+ }
}
switch (p_src->len)
UINT16 attr_id = 0;
tBTA_GATTS cb_data;
- tGATT_ATTR_VAL *p_attr_val = NULL;
+ tGATT_ATTR_VAL *p_attr_val = NULL;
tGATTS_ATTR_CONTROL *p_control = NULL;
if(p_msg->api_add_char.attr_val.attr_max_len != 0){
&gatt_if, remote_bda, &transport)) {
p_rcb = bta_gatts_find_app_rcb_by_app_if(gatt_if);
- if (p_msg->api_indicate.need_confirm)
+ if (p_msg->api_indicate.need_confirm) {
status = GATTS_HandleValueIndication (p_msg->api_indicate.hdr.layer_specific,
p_msg->api_indicate.attr_id,
p_msg->api_indicate.len,
p_msg->api_indicate.value);
- else
+ } else {
status = GATTS_HandleValueNotification (p_msg->api_indicate.hdr.layer_specific,
p_msg->api_indicate.attr_id,
p_msg->api_indicate.len,
p_msg->api_indicate.value);
+ }
/* if over BR_EDR, inform PM for mode change */
if (transport == BTA_TRANSPORT_BR_EDR) {
memcpy(bd_addr, p_msg->api_send_service_change.remote_bda, BD_ADDR_LEN);
status = GATT_SendServiceChangeIndication(bd_addr);
} else {
- status = GATT_SendServiceChangeIndication(NULL);
+ status = GATT_SendServiceChangeIndication(NULL);
}
if (p_rcb && p_rcb->p_cback) {
service_change.status = status;
service_change.server_if = p_msg->api_send_service_change.server_if;
(*p_rcb->p_cback)(BTA_GATTS_SEND_SERVICE_CHANGE_EVT, (tBTA_GATTS *)&service_change);
- }
+ }
}
/*******************************************************************************
cb_data.req_data.p_data = (tBTA_GATTS_REQ_DATA *)p_data;
if(req_type == BTA_GATTS_CONF_EVT) {
- cb_data.req_data.handle = p_data->handle;
+ cb_data.req_data.handle = p_data->handle;
}
(*p_rcb->p_cback)(req_type, &cb_data);
} else {
buffer = tmp + 2;
APPL_TRACE_DEBUG("%s %.*s", __FUNCTION__, buffer - start - 2, start);
+ UNUSED(start);
return buffer;
}
#if (BTM_SCO_HCI_INCLUDED == TRUE )
tBTM_STATUS status = BTM_ConfigScoPath(BTM_SCO_ROUTE_PCM, NULL, NULL, TRUE);
APPL_TRACE_DEBUG("%s close config status = %d", __FUNCTION__, status);
+ UNUSED(status);
/* SCO clean up here */
bta_hf_client_sco_co_close();
#endif
bta_hh_le_enable();
} else
#endif
+ {
/* signal BTA call back event */
(* bta_hh_cb.p_cback)(BTA_HH_ENABLE_EVT, (tBTA_HH *)&status);
+ }
}
/*******************************************************************************
**
bta_hh_le_get_dscp_act(p_cb);
} else
#endif
+ {
(*bta_hh_cb.p_cback)(BTA_HH_GET_DSCP_EVT, (tBTA_HH *)&p_cb->dscp_info);
+ }
}
/*******************************************************************************
dev_info.status = BTA_HH_OK;
} else
#endif
-
+ {
if (HID_HostAddDev(p_dev_info->bda, p_dev_info->attr_mask, &dev_handle)\
== HID_SUCCESS) {
dev_info.handle = dev_handle;
- dev_info.status = BTA_HH_OK;
#if (defined BTA_HH_LE_INCLUDED && BTA_HH_LE_INCLUDED == TRUE)
/* update DI information */
/* update cb_index[] map */
bta_hh_cb.cb_index[dev_handle] = p_cb->index;
}
+ }
} else { /* device already been added */
dev_info.handle = p_cb->hid_handle;
dev_info.status = BTA_HH_OK;
case GATT_UUID_HID_BT_KB_INPUT:
case GATT_UUID_HID_BT_MOUSE_INPUT:
case GATT_UUID_HID_REPORT:
- if (p_data->status == BTA_GATT_OK)
+ if (p_data->status == BTA_GATT_OK) {
p_dev_cb->hid_srvc[hid_inst_id].report[p_dev_cb->clt_cfg_idx].client_cfg_value =
BTA_GATT_CLT_CONFIG_NOTIFICATION;
+ }
p_dev_cb->clt_cfg_idx ++;
bta_hh_le_write_rpt_clt_cfg(p_dev_cb, hid_inst_id);
return xx;
}
#if BTA_HH_DEBUG
- else
+ else {
APPL_TRACE_DEBUG("in_use ? [%d] kdev[%d].hid_handle = %d state = [%d]",
bta_hh_cb.kdev[xx].in_use, xx,
bta_hh_cb.kdev[xx].hid_handle,
bta_hh_cb.kdev[xx].state);
+ }
#endif
}
bta_hh_cb.le_cb_index[BTA_HH_GET_LE_CB_IDX(p_cb->hid_handle)] = BTA_HH_IDX_INVALID;
} else
#endif
+ {
bta_hh_cb.cb_index[p_cb->hid_handle] = BTA_HH_IDX_INVALID;
+ }
}
/* reset device control block */
#endif
} else
#endif
+ {
/* regular HID device checking */
if (dev_handle < BTA_HH_MAX_KNOWN ) {
index = bta_hh_cb.cb_index[dev_handle];
}
-
+ }
return index;
}
#include <stdlib.h>
#include "osi/allocator.h"
+#include "osi/osi.h"
#include "stack/bt_types.h"
#include "bta/utl.h"
#include "bta/bta_sys.h"
return ret;
}
-static int get_sec_id_used(void)
+UNUSED_ATTR static int get_sec_id_used(void)
{
int i;
int used = 0;
used++;
}
}
- if (used == BTA_JV_NUM_SERVICE_ID)
+ if (used == BTA_JV_NUM_SERVICE_ID) {
APPL_TRACE_ERROR("get_sec_id_used, sec id exceeds the limit:%d",
BTA_JV_NUM_SERVICE_ID);
+ }
return used;
}
-static int get_rfc_cb_used(void)
+UNUSED_ATTR static int get_rfc_cb_used(void)
{
int i;
int used = 0;
used++;
}
}
- if (used == BTA_JV_MAX_RFC_CONN)
+ if (used == BTA_JV_MAX_RFC_CONN) {
APPL_TRACE_ERROR("get_sec_id_used, rfc ctrl block exceeds the limit:%d",
BTA_JV_MAX_RFC_CONN);
+ }
return used;
}
< BTA_JV_MAX_RFC_SR_SESSION && bta_jv_cb.rfc_cb[hi].rfc_hdl[si]) {
tBTA_JV_PCB *p_pcb = bta_jv_rfc_port_to_pcb(bta_jv_cb.rfc_cb[hi].rfc_hdl[si]);
if (p_pcb) {
- if (NULL == p_pcb->p_pm_cb)
+ if (NULL == p_pcb->p_pm_cb) {
APPL_TRACE_WARNING("%s(jv_handle:"
" 0x%x):port_handle: 0x%x, p_pm_cb: %d: no link to "
"pm_cb?", __func__, jv_handle, p_pcb->port_handle, i);
+ }
p_cb = &p_pcb->p_pm_cb;
}
}
} else {
if (jv_handle < BTA_JV_MAX_L2C_CONN) {
tBTA_JV_L2C_CB *p_l2c_cb = &bta_jv_cb.l2c_cb[jv_handle];
- if (NULL == p_l2c_cb->p_pm_cb)
+ if (NULL == p_l2c_cb->p_pm_cb) {
APPL_TRACE_WARNING("%s(jv_handle: "
"0x%x): p_pm_cb: %d: no link to pm_cb?", __func__, jv_handle, i);
+ }
p_cb = &p_l2c_cb->p_pm_cb;
}
}
bta_jv_cb.scn[channel - 1] = TRUE;
scn = (UINT8) channel;
}
- if (bta_jv_cb.p_dm_cback)
+ if (bta_jv_cb.p_dm_cback) {
bta_jv_cb.p_dm_cback(BTA_JV_GET_SCN_EVT, (tBTA_JV *)&scn,
p_data->alloc_channel.user_data);
+ }
return;
}
case BTA_JV_CONN_TYPE_L2CAP:
APPL_TRACE_DEBUG("create_base_record: successfully created base service "
"record, handle: 0x%08x, scn: %d, name: %s, with_obex: %d",
sdp_handle, channel, name, with_obex);
+
+ UNUSED(stage);
+
return TRUE;
}
APPL_TRACE_DEBUG("add_spp_sdp: service registered successfully, "
"service_name: %s, handle 0x%08x)", name, handle);
+ UNUSED(stage);
+
return handle;
}
tBTA_JV_PCB *p_pcb = bta_jv_rfc_port_to_pcb(port_handle);
int ret = 0;
APPL_TRACE_DEBUG("%s, p_cb:%p, p_pcb:%p, len:%d, type:%d", __func__, p_cb, p_pcb, len, type);
+ UNUSED(p_cb);
if (p_pcb != NULL) {
switch (type) {
case DATA_CO_CALLBACK_TYPE_INCOMING:
int frames_to_process = ((freq_multiple) / (num_blocks * num_subbands)) + 1;
APPL_TRACE_EVENT(" Frames to be processed in 20 ms %d\n", frames_to_process);
+ UNUSED(frames_to_process);
}
/*******************************************************************************
static void log_tstamps_us(char *comment)
{
static UINT64 prev_us = 0;
- const UINT64 now_us = time_now_us();
+ UINT64 now_us = time_now_us();
APPL_TRACE_DEBUG("[%s] ts %08llu, diff : %08llu, queue sz %d", comment, now_us, now_us - prev_us,
fixed_queue_length(btc_aa_src_cb.TxAaQ));
prev_us = now_us;
+ UNUSED(prev_us);
}
/* when true media task discards any tx frames */
BTC_TRACE_ERROR("ERROR dump_codec_info A2D_ParsSbcInfo fail:%d\n", a2d_status);
}
}
+ UNUSED(que_len);
}
#else
static void bte_av_media_callback(tBTA_AV_EVT event, tBTA_AV_MEDIA *p_data)
{
+ UNUSED(event);
+ UNUSED(p_data);
BTC_TRACE_WARNING("%s : event %u\n", __func__, event);
}
#endif
} else {
BTC_TRACE_ERROR("%s DUT does not support AVRCP controller role", __FUNCTION__);
}
+
+ UNUSED(status);
#else
BTC_TRACE_ERROR("%s AVRCP controller role is not enabled", __FUNCTION__);
#endif
*******************************************************************************/
static bt_status_t connect_int( bt_bdaddr_t *bd_addr, uint16_t uuid )
{
- if (is_connected(bd_addr))
+ if (is_connected(bd_addr)) {
return BT_STATUS_BUSY;
+ }
btc_hf_client_cb.state = ESP_HF_CLIENT_CONNECTION_STATE_CONNECTING;
bdcpy(btc_hf_client_cb.connected_bda.address, bd_addr->address);
{
esp_hf_client_cb_param_t param;
memset(¶m, 0, sizeof(esp_hf_client_cb_param_t));
-
+
switch (ind->type)
{
case BTA_HF_CLIENT_IND_CALL:
param.call.status = ind->value;
btc_hf_client_cb_to_app(ESP_HF_CLIENT_CIND_CALL_EVT, ¶m);
break;
-
+
case BTA_HF_CLIENT_IND_CALLSETUP:
param.call_setup.status = ind->value;
btc_hf_client_cb_to_app(ESP_HF_CLIENT_CIND_CALL_SETUP_EVT, ¶m);
{
BTC_TRACE_WARNING("%s: HF CLient open failed, but another device connected. status=%d state=%d connected device=%s",
__FUNCTION__, p_data->open.status, btc_hf_client_cb.state, bdaddr_to_string(&btc_hf_client_cb.connected_bda, bdstr, sizeof(bdstr)));
+ UNUSED(bdstr);
break;
}
param.conn_stat.state = btc_hf_client_cb.state;
param.conn_stat.peer_feat = 0;
param.conn_stat.chld_feat = 0;
-
+
memcpy(param.conn_stat.remote_bda, &btc_hf_client_cb.connected_bda,
sizeof(esp_bd_addr_t));
btc_hf_client_cb_to_app(ESP_HF_CLIENT_CONNECTION_STATE_EVT, ¶m);
} while (0);
-
- if (btc_hf_client_cb.state == ESP_HF_CLIENT_CONNECTION_STATE_DISCONNECTED)
+
+ if (btc_hf_client_cb.state == ESP_HF_CLIENT_CONNECTION_STATE_DISCONNECTED) {
bdsetany(btc_hf_client_cb.connected_bda.address);
+ }
- if (p_data->open.status != BTA_HF_CLIENT_SUCCESS)
+ if (p_data->open.status != BTA_HF_CLIENT_SUCCESS) {
btc_queue_advance();
+ }
break;
param.conn_stat.state = btc_hf_client_cb.state;
param.conn_stat.peer_feat = btc_hf_client_cb.peer_feat;
param.conn_stat.chld_feat = btc_hf_client_cb.chld_feat;
-
+
memcpy(param.conn_stat.remote_bda, &btc_hf_client_cb.connected_bda,
sizeof(esp_bd_addr_t));
btc_hf_client_cb_to_app(ESP_HF_CLIENT_CONNECTION_STATE_EVT, ¶m);
} while (0);
-
+
/* Inform the application about in-band ringtone */
if (btc_hf_client_cb.peer_feat & BTA_HF_CLIENT_PEER_INBAND)
{
btc_queue_advance();
break;
-
+
case BTA_HF_CLIENT_CLOSE_EVT:
btc_hf_client_cb.state = ESP_HF_CLIENT_CONNECTION_STATE_DISCONNECTED;
do {
param.conn_stat.state = ESP_HF_CLIENT_CONNECTION_STATE_DISCONNECTED;
param.conn_stat.peer_feat = 0;
param.conn_stat.chld_feat = 0;
-
+
memcpy(param.conn_stat.remote_bda, &btc_hf_client_cb.connected_bda,
sizeof(esp_bd_addr_t));
memset(¶m, 0, sizeof(esp_hf_client_cb_param_t));
param.audio_stat.state = ESP_HF_CLIENT_AUDIO_STATE_CONNECTED;
memcpy(param.audio_stat.remote_bda, &btc_hf_client_cb.connected_bda,
- sizeof(esp_bd_addr_t));
+ sizeof(esp_bd_addr_t));
btc_hf_client_cb_to_app(ESP_HF_CLIENT_AUDIO_STATE_EVT, ¶m);
} while (0);
break;
memset(¶m, 0, sizeof(esp_hf_client_cb_param_t));
param.audio_stat.state = ESP_HF_CLIENT_AUDIO_STATE_CONNECTED_MSBC;
memcpy(param.audio_stat.remote_bda, &btc_hf_client_cb.connected_bda,
- sizeof(esp_bd_addr_t));
+ sizeof(esp_bd_addr_t));
btc_hf_client_cb_to_app(ESP_HF_CLIENT_AUDIO_STATE_EVT, ¶m);
} while (0);
break;
for (s32Sb = 0; s32Sb < s32NumOfSubBands; s32Sb++) {
if (*(ps16GenBufPtr) < s32BitSlice + 2) {
*(ps16GenArrPtr) = 0;
- } else
+ } else {
*(ps16GenArrPtr) = ((*(ps16GenBufPtr) - s32BitSlice) < 16) ?
(SINT16)(*(ps16GenBufPtr) - s32BitSlice) : 16;
+ }
ps16GenBufPtr++;
ps16GenArrPtr++;
for (s32Sb = 0; s32Sb < s32NumOfSubBands; s32Sb++) {
if (*ps16GenBufPtr < s32BitSlice + 2) {
*ps16GenArrPtr = 0;
- } else
+ } else {
*ps16GenArrPtr = ((*(ps16GenBufPtr) - s32BitSlice) < 16) ?
(SINT16)(*(ps16GenBufPtr) - s32BitSlice) : 16;
+ }
ps16GenBufPtr++;
ps16GenArrPtr++;
}
assert(data != NULL);
for (const list_node_t *node = list_begin(list); node != list_end(list); node = list_next(node)) {
- if (list_node(node) == data)
+ if (list_node(node) == data) {
return true;
+ }
}
return false;
for (list_node_t *node = list->head; node; ) {
list_node_t *next = node->next;
- if (!callback(node->data, context))
+ if (!callback(node->data, context)) {
return node;
+ }
node = next;
}
return NULL;
{
UNUSED(p_lcb);
- if (p_data == NULL)
+ if (p_data == NULL) {
return;
+ }
osi_free(p_data->p_buf);
p_data->p_buf = NULL;
p += 2;
BE_STREAM_TO_UINT32(ssrc, p);
+ UNUSED(ssrc);
UNUSED(o_p);
UNUSED(o_v);
+ UNUSED(o_cc);
switch (pt) {
case AVDT_RTCP_PT_SR: /* the packet type - SR (Sender Report) */
avdt_scb_hdl_pkt_frag(p_scb, p_data);
} else
#endif
+ {
#if AVDT_REPORTING == TRUE
if (p_data->p_pkt->layer_specific == AVDT_CHAN_REPORT) {
p = (UINT8 *)(p_data->p_pkt + 1) + p_data->p_pkt->offset;
avdt_scb_hdl_report(p_scb, p, p_data->p_pkt->len);
- osi_free(p_data->p_pkt);
- p_data->p_pkt = NULL;
+ osi_free(p_data->p_pkt);
+ p_data->p_pkt = NULL;
} else
#endif
+ {
avdt_scb_hdl_pkt_no_frag(p_scb, p_data);
+ }
+ }
}
/*******************************************************************************
#if AVDT_MULTIPLEXING == TRUE
if (fixed_queue_is_empty(p_scb->frag_q))
#endif
+ {
avdt_scb_hdl_write_req_no_frag(p_scb, p_data);
+ }
#if AVDT_MULTIPLEXING == TRUE
else {
avdt_scb_hdl_write_req_frag(p_scb, p_data);
result = TRUE;
}
- if (!result)
+ if (!result) {
AVRC_TRACE_ERROR(
"avrc_is_valid_player_attrib_value() found not matching attrib(x%x)-value(x%x) pair!",
attrib, value);
+ }
return result;
}
#if BLE_INCLUDED == TRUE
p->transport = transport;
#if BLE_PRIVACY_SPT == TRUE
- if (transport == BT_TRANSPORT_LE)
+ if (transport == BT_TRANSPORT_LE) {
btm_ble_refresh_local_resolvable_private_addr(bda,
btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr);
+ }
#else
p->conn_addr_type = BLE_ADDR_PUBLIC;
memcpy(p->conn_addr, &controller_get_interface()->get_address()->address, BD_ADDR_LEN);
}
/* 2 and 3 MPS support? */
- if (!HCI_EDR_ACL_2MPS_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
+ if (!HCI_EDR_ACL_2MPS_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0])) {
/* Not supported. Add 'not_supported' mask for all 2MPS packet types */
*p_pkt_type |= (BTM_ACL_PKT_TYPES_MASK_NO_2_DH1 + BTM_ACL_PKT_TYPES_MASK_NO_2_DH3 +
BTM_ACL_PKT_TYPES_MASK_NO_2_DH5);
+ }
- if (!HCI_EDR_ACL_3MPS_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
+ if (!HCI_EDR_ACL_3MPS_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0])) {
/* Not supported. Add 'not_supported' mask for all 3MPS packet types */
*p_pkt_type |= (BTM_ACL_PKT_TYPES_MASK_NO_3_DH1 + BTM_ACL_PKT_TYPES_MASK_NO_3_DH3 +
BTM_ACL_PKT_TYPES_MASK_NO_3_DH5);
+ }
/* EDR 3 and 5 slot support? */
if (HCI_EDR_ACL_2MPS_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0])
** bd_name - Name of the peer device. NULL if unknown.
** dev_type - Remote device's device type.
** addr_type - LE device address type.
-** auth_mode - auth mode
+** auth_mode - auth mode
**
** Returns TRUE if added OK, else FALSE
**
return BTM_SEC_OK;
}
- if (security_required & BTM_SEC_OUT_MITM)
+ if (security_required & BTM_SEC_OUT_MITM) {
auth_req |= BTM_LE_AUTH_REQ_MITM;
+ }
}
else
{
return BTM_SEC_OK;
}
- if (security_required & BTM_SEC_IN_MITM)
+ if (security_required & BTM_SEC_IN_MITM) {
auth_req |= BTM_LE_AUTH_REQ_MITM;
+ }
}
tBTM_BLE_SEC_REQ_ACT ble_sec_act = BTM_BLE_SEC_REQ_ACT_NONE;
BTM_TRACE_DEBUG ("%s ble_sec_act %d", __func__ , ble_sec_act);
- if (ble_sec_act == BTM_BLE_SEC_REQ_ACT_DISCARD)
+ if (ble_sec_act == BTM_BLE_SEC_REQ_ACT_DISCARD) {
return BTM_SEC_ENC_PENDING;
+ }
- if (ble_sec_act == BTM_BLE_SEC_REQ_ACT_NONE)
+ if (ble_sec_act == BTM_BLE_SEC_REQ_ACT_NONE) {
return BTM_SEC_OK;
+ }
UINT8 sec_flag = 0;
BTM_GetSecurityFlagsByTransport(bdaddr, &sec_flag, BT_TRANSPORT_LE);
BOOLEAN is_key_mitm = FALSE;
if (sec_flag & (BTM_SEC_FLAG_ENCRYPTED| BTM_SEC_FLAG_LKEY_KNOWN))
{
- if (sec_flag & BTM_SEC_FLAG_ENCRYPTED)
+ if (sec_flag & BTM_SEC_FLAG_ENCRYPTED) {
is_link_encrypted = TRUE;
+ }
- if (sec_flag & BTM_SEC_FLAG_LKEY_AUTHED)
+ if (sec_flag & BTM_SEC_FLAG_LKEY_AUTHED) {
is_key_mitm = TRUE;
+ }
}
if (auth_req & BTM_LE_AUTH_REQ_MITM)
{
return BTM_SEC_ENCRYPT_MITM;
} else {
- if (is_link_encrypted)
+ if (is_link_encrypted) {
return BTM_SEC_OK;
- else
+ } else {
return BTM_SEC_ENCRYPT;
+ }
}
} else {
- if (is_link_encrypted)
+ if (is_link_encrypted) {
return BTM_SEC_OK;
- else
+ } else {
return BTM_SEC_ENCRYPT_NO_MITM;
+ }
}
return BTM_SEC_OK;
break;
}
- if (ble_sec_act == BTM_BLE_SEC_NONE)
+ if (ble_sec_act == BTM_BLE_SEC_NONE) {
return status;
+ }
tL2C_LCB *p_lcb = l2cu_find_lcb_by_bd_addr(bd_addr, BT_TRANSPORT_LE);
p_lcb->sec_act = sec_act;
if (HCI_SUCCESS == status) {
if (memcmp(&btm_ble_adv_filt_cb.cur_filter_target.bda, &na_bda, BD_ADDR_LEN) == 0) {
btm_ble_cs_update_pf_counter(action, cond_type, NULL, num_avail);
- } else
+ } else {
btm_ble_cs_update_pf_counter(action, cond_type,
&btm_ble_adv_filt_cb.cur_filter_target, num_avail);
+ }
}
/* send ADV PF operation complete */
len,
param,
btm_ble_scan_pf_cmpl_cback)) != BTM_NO_RESOURCES) {
- if (p_uuid_cond && p_uuid_cond->p_target_addr)
+ if (p_uuid_cond && p_uuid_cond->p_target_addr) {
memcpy(&btm_ble_adv_filt_cb.cur_filter_target, p_uuid_cond->p_target_addr,
sizeof(tBLE_BD_ADDR));
+ }
else {
memset(&btm_ble_adv_filt_cb.cur_filter_target, 0, sizeof(tBLE_BD_ADDR));
}
/* clear manufactuer data filter */
st = btm_ble_update_pf_manu_data(BTM_BLE_SCAN_COND_CLEAR, filt_index, NULL,
BTM_BLE_PF_MANU_DATA, cb_evt, ref_value);
- if (BTM_CMD_STARTED == st)
+ if (BTM_CMD_STARTED == st) {
btm_ble_advfilt_enq_op_q(action, BTM_BLE_META_PF_MANU_DATA, cb_evt,
ref_value, NULL, NULL);
+ }
/* clear local name filter */
st = btm_ble_update_pf_local_name(BTM_BLE_SCAN_COND_CLEAR, filt_index, NULL);
- if (BTM_CMD_STARTED == st)
+ if (BTM_CMD_STARTED == st) {
btm_ble_advfilt_enq_op_q(action, BTM_BLE_META_PF_LOCAL_NAME, cb_evt,
ref_value, NULL, NULL);
+ }
/* update the counter for service data */
st = btm_ble_update_srvc_data_change(BTM_BLE_SCAN_COND_CLEAR, filt_index, NULL);
st = btm_ble_update_uuid_filter(BTM_BLE_SCAN_COND_CLEAR, filt_index,
BTM_BLE_PF_SRVC_SOL_UUID, NULL, cb_evt, ref_value);
- if (BTM_CMD_STARTED == st)
+ if (BTM_CMD_STARTED == st) {
btm_ble_advfilt_enq_op_q(action, BTM_BLE_META_PF_SOL_UUID, cb_evt,
ref_value, NULL, NULL);
+ }
/* clear service data filter */
st = btm_ble_update_pf_manu_data(BTM_BLE_SCAN_COND_CLEAR, filt_index, NULL,
BTM_BLE_PF_SRVC_DATA_PATTERN, cb_evt, ref_value);
- if (BTM_CMD_STARTED == st)
+ if (BTM_CMD_STARTED == st) {
btm_ble_advfilt_enq_op_q(action, BTM_BLE_META_PF_SRVC_DATA, cb_evt,
ref_value, NULL, NULL);
+ }
}
/* select feature based on control block settings */
if (cmn_ble_vsc_cb.version_supported == BTM_VSC_CHIP_CAPABILITY_L_VERSION) {
len = BTM_BLE_ADV_FILT_META_HDR_LENGTH + BTM_BLE_ADV_FILT_FEAT_SELN_LEN;
- } else
+ } else {
len = BTM_BLE_ADV_FILT_META_HDR_LENGTH + BTM_BLE_ADV_FILT_FEAT_SELN_LEN +
BTM_BLE_ADV_FILT_TRACK_NUM;
+ }
if ((st = BTM_VendorSpecificCommand (HCI_BLE_ADV_FILTER_OCF,
(UINT8)len,
if (0 == num_records) {
btm_ble_batchscan_deq_rep_data(report_format, &ref_value, &num_records,
&p_data, &data_len);
- if (NULL != ble_batchscan_cb.p_scan_rep_cback)
+ if (NULL != ble_batchscan_cb.p_scan_rep_cback) {
ble_batchscan_cb.p_scan_rep_cback(ref_value, report_format, num_records,
data_len, p_data, status);
+ }
} else {
if ((len - 4) > 0) {
btm_ble_batchscan_enq_rep_data(report_format, num_records, p, len - 4);
btm_ble_batchscan_deq_rep_data(report_format, &ref_value, &num_records,
&p_data, &data_len);
/* Send whatever is available, in case of a command failure */
- if (NULL != ble_batchscan_cb.p_scan_rep_cback && NULL != p_data)
+ if (NULL != ble_batchscan_cb.p_scan_rep_cback && NULL != p_data) {
ble_batchscan_cb.p_scan_rep_cback(ref_value, report_format,
num_records, data_len, p_data, status);
+ }
}
}
}
BTM_TRACE_DEBUG("energy_info status=%d,tx_t=%u, rx_t=%u, ener_used=%u, idle_t=%u",
status, total_tx_time, total_rx_time, total_energy_used, total_idle_time);
- if (NULL != ble_energy_info_cb.p_ener_cback)
+ if (NULL != ble_energy_info_cb.p_ener_cback) {
ble_energy_info_cb.p_ener_cback(total_tx_time, total_rx_time, total_idle_time,
total_energy_used, status);
+ }
return;
}
osi_sem_new(&adv_data_sem, 1, 0);
osi_sem_new(&adv_param_sem, 1, 0);
osi_sem_new(&scan_enable_sem, 1, 0);
- osi_sem_new(&scan_param_sem, 1, 0);
+ osi_sem_new(&scan_param_sem, 1, 0);
}
void btm_sem_free(void)
/* if adv active, stop and restart */
btm_ble_stop_adv ();
- if (p_cb->connectable_mode & BTM_BLE_CONNECTABLE)
+ if (p_cb->connectable_mode & BTM_BLE_CONNECTABLE) {
p_cb->evt_type = btm_set_conn_mode_adv_init_addr(p_cb, p_addr_ptr, &init_addr_type,
&p_cb->adv_addr_type);
+ }
btsnd_hcic_ble_write_adv_params ((UINT16)(p_cb->adv_interval_min ? p_cb->adv_interval_min :
BTM_BLE_GAP_ADV_SLOW_INT),
{
BTM_VendorSpecificCommand (HCI_VENDOR_COMMON_ECHO_CMD_OPCODE,
1,
- &echo,
+ &echo,
BTM_VendorHciEchoCmdCallback);
}
}
if(own_bda_type == BLE_ADDR_RANDOM) {
- if((btm_cb.ble_ctr_cb.addr_mgnt_cb.exist_addr_bit & BTM_BLE_GAP_ADDR_BIT_RANDOM) == BTM_BLE_GAP_ADDR_BIT_RANDOM) {
+ if((btm_cb.ble_ctr_cb.addr_mgnt_cb.exist_addr_bit & BTM_BLE_GAP_ADDR_BIT_RANDOM) == BTM_BLE_GAP_ADDR_BIT_RANDOM) {
//close privacy
#if BLE_PRIVACY_SPT == TRUE
if (btm_cb.ble_ctr_cb.privacy_mode != BTM_PRIVACY_NONE) {
#endif
btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type = BLE_ADDR_RANDOM;
memcpy(btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr, btm_cb.ble_ctr_cb.addr_mgnt_cb.static_rand_addr, BD_ADDR_LEN);
- // set address to controller
+ // set address to controller
btsnd_hcic_ble_set_random_addr(btm_cb.ble_ctr_cb.addr_mgnt_cb.static_rand_addr);
-
+
} else if((btm_cb.ble_ctr_cb.addr_mgnt_cb.exist_addr_bit & BTM_BLE_GAP_ADDR_BIT_RESOLVABLE) == BTM_BLE_GAP_ADDR_BIT_RESOLVABLE) {
btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type = BLE_ADDR_RANDOM;
memcpy(btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr, btm_cb.ble_ctr_cb.addr_mgnt_cb.resolvale_addr, BD_ADDR_LEN);
if(adv_cb) {
(* adv_cb)(HCI_ERR_ESP_VENDOR_FAIL);
}
- return BTM_ILLEGAL_VALUE;
+ return BTM_ILLEGAL_VALUE;
}
} else if(own_bda_type == BLE_ADDR_PUBLIC_ID || own_bda_type == BLE_ADDR_RANDOM_ID) {
if((btm_cb.ble_ctr_cb.addr_mgnt_cb.exist_addr_bit & BTM_BLE_GAP_ADDR_BIT_RESOLVABLE) == BTM_BLE_GAP_ADDR_BIT_RESOLVABLE) {
if(adv_cb) {
(* adv_cb)(HCI_ERR_ESP_VENDOR_FAIL);
}
- return BTM_ILLEGAL_VALUE;
+ return BTM_ILLEGAL_VALUE;
}
#endif
if(own_bda_type == BLE_ADDR_PUBLIC_ID) {
if(adv_cb) {
(* adv_cb)(HCI_ERR_ESP_VENDOR_FAIL);
}
- return BTM_ILLEGAL_VALUE;
+ return BTM_ILLEGAL_VALUE;
}
}
}
} else {
- btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type = BLE_ADDR_PUBLIC;
+ btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type = BLE_ADDR_PUBLIC;
}
if (!BTM_BLE_ISVALID_PARAM(adv_int_min, BTM_BLE_ADV_INT_MIN, BTM_BLE_ADV_INT_MAX) ||
!BTM_BLE_ISVALID_PARAM(adv_int_max, BTM_BLE_ADV_INT_MIN, BTM_BLE_ADV_INT_MAX)) {
- BTM_TRACE_ERROR ("adv_int_min or adv_int_max is invalid\n");
+ BTM_TRACE_ERROR ("adv_int_min or adv_int_max is invalid\n");
if(adv_cb) {
(* adv_cb)(HCI_ERR_ESP_VENDOR_FAIL);
}
}
BTM_TRACE_EVENT ("update params for an active adv\n");
-
+
tBTM_STATUS status = BTM_SUCCESS;
/* update adv params */
if (btsnd_hcic_ble_write_adv_params (adv_int_min,
}
btm_ble_stop_adv();
-
+
status = btm_ble_start_adv();
return status;
BTM_BleConfigPrivacy(FALSE, NULL);
}
#endif
- btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type = BLE_ADDR_RANDOM;
+ btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type = BLE_ADDR_RANDOM;
memcpy(btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr, btm_cb.ble_ctr_cb.addr_mgnt_cb.static_rand_addr, BD_ADDR_LEN);
- // set address to controller
+ // set address to controller
btsnd_hcic_ble_set_random_addr(btm_cb.ble_ctr_cb.addr_mgnt_cb.static_rand_addr);
-
+
} else if((btm_cb.ble_ctr_cb.addr_mgnt_cb.exist_addr_bit & BTM_BLE_GAP_ADDR_BIT_RESOLVABLE) == BTM_BLE_GAP_ADDR_BIT_RESOLVABLE) {
btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type = BLE_ADDR_RANDOM;
memcpy(btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr, btm_cb.ble_ctr_cb.addr_mgnt_cb.resolvale_addr, BD_ADDR_LEN);
btsnd_hcic_ble_set_random_addr(btm_cb.ble_ctr_cb.addr_mgnt_cb.resolvale_addr);
}else {
BTM_TRACE_ERROR ("No random address yet, please set random address and try\n");
- return BTM_ILLEGAL_VALUE;
+ return BTM_ILLEGAL_VALUE;
}
} else if(addr_type_own == BLE_ADDR_PUBLIC_ID || addr_type_own == BLE_ADDR_RANDOM_ID) {
if((btm_cb.ble_ctr_cb.addr_mgnt_cb.exist_addr_bit & BTM_BLE_GAP_ADDR_BIT_RESOLVABLE) == BTM_BLE_GAP_ADDR_BIT_RESOLVABLE) {
addr_type_own = BLE_ADDR_RANDOM;
- btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type = BLE_ADDR_RANDOM;
+ btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type = BLE_ADDR_RANDOM;
memcpy(btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr, btm_cb.ble_ctr_cb.addr_mgnt_cb.resolvale_addr, BD_ADDR_LEN);
btsnd_hcic_ble_set_random_addr(btm_cb.ble_ctr_cb.addr_mgnt_cb.resolvale_addr);
} else {
#if BLE_PRIVACY_SPT == TRUE
if(btm_cb.ble_ctr_cb.privacy_mode != BTM_PRIVACY_NONE) {
BTM_TRACE_ERROR ("Error state\n");
- return BTM_ILLEGAL_VALUE;
+ return BTM_ILLEGAL_VALUE;
}
#endif
if(addr_type_own == BLE_ADDR_PUBLIC_ID) {
addr_type_own = BLE_ADDR_PUBLIC;
- btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type = BLE_ADDR_PUBLIC;
+ btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type = BLE_ADDR_PUBLIC;
} else {
//own_bda_type == BLE_ADDR_RANDOM_ID
if((btm_cb.ble_ctr_cb.addr_mgnt_cb.exist_addr_bit & BTM_BLE_GAP_ADDR_BIT_RANDOM) == BTM_BLE_GAP_ADDR_BIT_RANDOM) {
btsnd_hcic_ble_set_random_addr(btm_cb.ble_ctr_cb.addr_mgnt_cb.static_rand_addr);
} else {
BTM_TRACE_ERROR ("No RPA and no random address yet, please set RPA or random address and try\n");
- return BTM_ILLEGAL_VALUE;
+ return BTM_ILLEGAL_VALUE;
}
}
}
} else {
- btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type = BLE_ADDR_PUBLIC;
+ btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type = BLE_ADDR_PUBLIC;
}
/* If not supporting extended scan support, use the older range for checking */
** Returns status
**
*******************************************************************************/
-tBTM_STATUS BTM_UpdateBleDuplicateExceptionalList(uint8_t subcode, uint32_t type, BD_ADDR device_info,
+tBTM_STATUS BTM_UpdateBleDuplicateExceptionalList(uint8_t subcode, uint32_t type, BD_ADDR device_info,
tBTM_UPDATE_DUPLICATE_EXCEPTIONAL_LIST_CMPL_CBACK update_exceptional_list_cmp_cb)
{
tBTM_BLE_CB *ble_cb = &btm_cb.ble_ctr_cb;
*******************************************************************************/
tBTM_STATUS BTM_BleSetRandAddress(BD_ADDR rand_addr)
{
- if (rand_addr == NULL)
+ if (rand_addr == NULL) {
return BTM_SET_STATIC_RAND_ADDR_FAIL;
+ }
if (!(btm_cb.ble_ctr_cb.inq_var.state == BTM_BLE_STOP_SCAN || btm_cb.ble_ctr_cb.inq_var.state == BTM_BLE_STOP_ADV || btm_cb.ble_ctr_cb.inq_var.state == BTM_BLE_IDLE)) {
BTM_TRACE_ERROR("Advertising or scaning now, can't set randaddress %d", btm_cb.ble_ctr_cb.inq_var.state);
memset(addr, 0, BD_ADDR_LEN);
return FALSE;
}
- return TRUE;
+ return TRUE;
}
/*******************************************************************************
memset(p_le_inq_cb->adv_data_cache, 0, BTM_BLE_CACHE_ADV_DATA_MAX);
p_cur->adv_data_len = 0;
p_cur->scan_rsp_len = 0;
- }
+ }
//Clear the adv cache if the addresses are not equal
if(memcmp(bda, p_le_inq_cb->adv_addr, BD_ADDR_LEN) != 0) {
#if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)
temp_addr_type = addr_type;
memcpy(temp_bda, bda, BD_ADDR_LEN);
-
+
/* map address to security record */
match = btm_identity_addr_to_random_pseudo(bda, &addr_type, FALSE);
0x02 Scannable undirected advertising (ADV_SCAN_IND)
0x03 Non connectable undirected advertising (ADV_NONCONN_IND)
0x04 Scan Response (SCAN_RSP)
- 0x05-0xFF Reserved for future use
+ 0x05-0xFF Reserved for future use
*/
//if scan duplicate is enabled, the adv packet without scan response is allowed to report to higher layer
if(p_le_inq_cb->scan_duplicate_filter == BTM_BLE_SCAN_DUPLICATE_ENABLE) {
/*
Bluedroid will put the advertising packet and scan response into a packet and send it to the higher layer.
- If two advertising packets are not with the same address, or can't be combined into a packet, then the first advertising
+ If two advertising packets are not with the same address, or can't be combined into a packet, then the first advertising
packet will be discarded. So we added the following judgment:
1. For different addresses, send the last advertising packet to higher layer
2. For same address and same advertising type (not scan response), send the last advertising packet to higher layer
btm_execute_wl_dev_operation();
btm_cb.ble_ctr_cb.wl_state |= BTM_BLE_WL_ADV;
}
- /* The complete event comes up immediately after the 'btsnd_hcic_ble_set_adv_enable' being called in dual core,
+ /* The complete event comes up immediately after the 'btsnd_hcic_ble_set_adv_enable' being called in dual core,
this causes the 'adv_mode' and 'state' not be set yet, so we set the state first */
tBTM_BLE_GAP_STATE temp_state = p_cb->state;
UINT8 adv_mode = p_cb->adv_mode;
**
** Description Get BLE topology bit mask
**
-** Returns state mask.
+** Returns state mask.
**
*******************************************************************************/
tBTM_BLE_STATE_MASK btm_ble_get_topology_mask (void)
btm_ble_resolving_list_vsc_op_cmpl);
}
- if (st == BTM_CMD_STARTED)
+ if (st == BTM_CMD_STARTED) {
btm_ble_enq_resolving_list_pending(p_dev_rec->bd_addr,
BTM_BLE_META_READ_IRK_ENTRY);
+ }
return st;
}
}
}
- if (rt)
+ if (rt) {
btm_ble_enq_resolving_list_pending(p_dev_rec->bd_addr,
BTM_BLE_META_ADD_IRK_ENTRY);
+ }
/* if resolving list has been turned on, re-enable it */
if (rl_mask) {
extern void BTM_SecClearSecurityFlags (BD_ADDR bd_addr)
{
tBTM_SEC_DEV_REC *p_dev_rec = btm_find_dev(bd_addr);
- if (p_dev_rec == NULL)
+ if (p_dev_rec == NULL) {
return;
+ }
p_dev_rec->sec_flags = 0;
p_dev_rec->sec_state = BTM_SEC_STATE_IDLE;
btm_cb.btm_acl_pkt_types_supported = (BTM_ACL_PKT_TYPES_MASK_DH1 +
BTM_ACL_PKT_TYPES_MASK_DM1);
- if (HCI_3_SLOT_PACKETS_SUPPORTED(p_features))
+ if (HCI_3_SLOT_PACKETS_SUPPORTED(p_features)) {
btm_cb.btm_acl_pkt_types_supported |= (BTM_ACL_PKT_TYPES_MASK_DH3 +
BTM_ACL_PKT_TYPES_MASK_DM3);
+ }
- if (HCI_5_SLOT_PACKETS_SUPPORTED(p_features))
+ if (HCI_5_SLOT_PACKETS_SUPPORTED(p_features)) {
btm_cb.btm_acl_pkt_types_supported |= (BTM_ACL_PKT_TYPES_MASK_DH5 +
BTM_ACL_PKT_TYPES_MASK_DM5);
+ }
/* Add in EDR related ACL types */
if (!HCI_EDR_ACL_2MPS_SUPPORTED(p_features)) {
/* Check to see if 3 and 5 slot packets are available */
if (HCI_EDR_ACL_2MPS_SUPPORTED(p_features) ||
HCI_EDR_ACL_3MPS_SUPPORTED(p_features)) {
- if (!HCI_3_SLOT_EDR_ACL_SUPPORTED(p_features))
+ if (!HCI_3_SLOT_EDR_ACL_SUPPORTED(p_features)) {
btm_cb.btm_acl_pkt_types_supported |= (BTM_ACL_PKT_TYPES_MASK_NO_2_DH3 +
BTM_ACL_PKT_TYPES_MASK_NO_3_DH3);
+ }
- if (!HCI_5_SLOT_EDR_ACL_SUPPORTED(p_features))
+ if (!HCI_5_SLOT_EDR_ACL_SUPPORTED(p_features)) {
btm_cb.btm_acl_pkt_types_supported |= (BTM_ACL_PKT_TYPES_MASK_NO_2_DH5 +
BTM_ACL_PKT_TYPES_MASK_NO_3_DH5);
+ }
}
BTM_TRACE_DEBUG("Local supported ACL packet types: 0x%04x",
return btm_ble_read_remote_name(remote_bda, p_cur, p_cb);
} else
#endif
-
+ {
return (btm_initiate_rem_name (remote_bda, p_cur, BTM_RMT_NAME_EXT,
BTM_EXT_RMT_NAME_TIMEOUT, p_cb));
+ }
}
/*******************************************************************************
}
} else
#endif
+ {
if (btsnd_hcic_rmt_name_req_cancel (p_inq->remname_bda)) {
return (BTM_CMD_STARTED);
} else {
return (BTM_NO_RESOURCES);
}
+ }
} else {
return (BTM_WRONG_MODE);
}
#ifdef APPL_AUTH_WRITE_EXCEPTION
if (!(APPL_AUTH_WRITE_EXCEPTION)(p_dev_rec->bd_addr))
#endif
+ {
btsnd_hcic_write_auth_enable (TRUE);
+ }
btm_cb.acl_disc_reason = 0xff ;
btm_sec_change_pairing_state (BTM_PAIR_STATE_IDLE);
p_dev_rec->sec_flags &= ~BTM_SEC_LINK_KEY_AUTHED;
- if (btm_cb.api.p_auth_complete_callback)
+ if (btm_cb.api.p_auth_complete_callback) {
(*btm_cb.api.p_auth_complete_callback) (p_dev_rec->bd_addr, p_dev_rec->dev_class,
p_dev_rec->sec_bd_name, HCI_ERR_AUTH_FAILURE);
+ }
}
return;
}
}
} else
#endif
+ {
rc = btm_sec_execute_procedure (p_dev_rec);
+ }
if (rc != BTM_CMD_STARTED && rc != BTM_BUSY) {
if (p_callback) {
"rmt_support_for_sc : %d -> fail pairing\n", __FUNCTION__,
local_supports_sc,
p_dev_rec->remote_supports_secure_connections);
- if (p_callback)
+ if (p_callback) {
(*p_callback) (bd_addr, transport, (void *)p_ref_data,
BTM_MODE4_LEVEL4_NOT_SUPPORTED);
+ }
return (BTM_MODE4_LEVEL4_NOT_SUPPORTED);
}
"remote_support_for_sc %d: fail pairing\n", __FUNCTION__,
local_supports_sc, p_dev_rec->remote_supports_secure_connections);
- if (p_callback)
+ if (p_callback) {
(*p_callback) (bd_addr, transport, (void *)p_ref_data,
BTM_MODE4_LEVEL4_NOT_SUPPORTED);
+ }
return (BTM_MODE4_LEVEL4_NOT_SUPPORTED);
}
/* Notify all clients waiting for name to be resolved */
for (i = 0; i < BTM_SEC_MAX_RMT_NAME_CALLBACKS; i++) {
- if (btm_cb.p_rmt_name_callback[i] && p_bd_addr)
+ if (btm_cb.p_rmt_name_callback[i] && p_bd_addr) {
(*btm_cb.p_rmt_name_callback[i])(p_bd_addr, p_dev_rec->dev_class,
p_dev_rec->sec_bd_name);
+ }
}
} else {
dev_class[0] = 0;
btm_sec_change_pairing_state (BTM_PAIR_STATE_IDLE);
- if (btm_cb.api.p_auth_complete_callback)
+ if (btm_cb.api.p_auth_complete_callback) {
(*btm_cb.api.p_auth_complete_callback) (p_dev_rec->bd_addr, p_dev_rec->dev_class,
p_dev_rec->sec_bd_name, HCI_ERR_MEMORY_FULL);
+ }
}
}
return;
/* that some authentication has been completed */
/* This is required when different entities receive link notification and auth complete */
if (!(p_dev_rec->security_required & BTM_SEC_OUT_AUTHENTICATE)) {
- if (btm_cb.api.p_auth_complete_callback)
+ if (btm_cb.api.p_auth_complete_callback) {
(*btm_cb.api.p_auth_complete_callback) (p_dev_rec->bd_addr,
p_dev_rec->dev_class,
p_dev_rec->sec_bd_name, HCI_SUCCESS);
+ }
}
}
/* User probably Disabled the keyboard while it was asleap. Let her try */
if (btm_cb.api.p_auth_complete_callback) {
/* report the suthentication status */
- if (old_state != BTM_PAIR_STATE_IDLE)
+ if (old_state != BTM_PAIR_STATE_IDLE) {
(*btm_cb.api.p_auth_complete_callback) (p_dev_rec->bd_addr,
p_dev_rec->dev_class,
p_dev_rec->sec_bd_name, status);
+ }
}
p_dev_rec->sec_state = BTM_SEC_STATE_IDLE;
btm_sec_change_pairing_state (BTM_PAIR_STATE_IDLE);
- if (btm_cb.api.p_auth_complete_callback)
+ if (btm_cb.api.p_auth_complete_callback) {
(*btm_cb.api.p_auth_complete_callback) (p_dev_rec->bd_addr, p_dev_rec->dev_class,
p_dev_rec->sec_bd_name, HCI_ERR_MEMORY_FULL);
+ }
}
}
#endif ///SMP_INCLUDED == TRUE
res = FALSE;
}
- if (btm_cb.api.p_auth_complete_callback)
+ if (btm_cb.api.p_auth_complete_callback) {
(*btm_cb.api.p_auth_complete_callback) (p_dev_rec->bd_addr,
p_dev_rec->dev_class,
p_dev_rec->sec_bd_name, HCI_SUCCESS);
+ }
btm_sec_change_pairing_state (BTM_PAIR_STATE_IDLE);
if (!(p_dev_rec->security_required & BTM_SEC_OUT_AUTHENTICATE)
/* for derived key, always send authentication callback for BR channel */
|| ltk_derived_lk) {
- if (btm_cb.api.p_auth_complete_callback)
+ if (btm_cb.api.p_auth_complete_callback) {
(*btm_cb.api.p_auth_complete_callback) (p_dev_rec->bd_addr, p_dev_rec->dev_class,
p_dev_rec->sec_bd_name, HCI_SUCCESS);
+ }
}
/* We will save link key only if the user authorized it - BTE report link key in all cases */
(*btm_cb.api.p_auth_complete_callback) (p_cb->pairing_bda,
NULL,
name, HCI_ERR_CONNECTION_TOUT);
- } else
+ } else {
(*btm_cb.api.p_auth_complete_callback) (p_dev_rec->bd_addr,
p_dev_rec->dev_class,
p_dev_rec->sec_bd_name, HCI_ERR_CONNECTION_TOUT);
+ }
}
break;
(*btm_cb.api.p_auth_complete_callback) (p_cb->pairing_bda,
NULL,
name, HCI_ERR_CONNECTION_TOUT);
- } else
+ } else {
(*btm_cb.api.p_auth_complete_callback) (p_dev_rec->bd_addr,
p_dev_rec->dev_class,
p_dev_rec->sec_bd_name, HCI_ERR_CONNECTION_TOUT);
+ }
}
break;
*******************************************************************************/
static void btm_send_link_key_notif (tBTM_SEC_DEV_REC *p_dev_rec)
{
- if (btm_cb.api.p_link_key_callback)
+ if (btm_cb.api.p_link_key_callback) {
(*btm_cb.api.p_link_key_callback) (p_dev_rec->bd_addr, p_dev_rec->dev_class,
p_dev_rec->sec_bd_name, p_dev_rec->link_key,
p_dev_rec->link_key_type);
+ }
}
#endif ///SMP_INCLUDED == TRUE
(*p_callback) (p_dev_rec->ble.pseudo_addr, BT_TRANSPORT_LE, p_dev_rec->p_ref_data, res);
} else
#endif
+ {
(*p_callback) (p_dev_rec->bd_addr, BT_TRANSPORT_BR_EDR, p_dev_rec->p_ref_data, res);
+ }
}
#if (SMP_INCLUDED == TRUE)
btm_sec_check_pending_reqs();
#ifdef APPL_AUTH_WRITE_EXCEPTION
if (!(APPL_AUTH_WRITE_EXCEPTION)(p_dev_rec->bd_addr))
#endif
+ {
btsnd_hcic_write_auth_enable (TRUE);
+ }
}
} else {
btm_sec_change_pairing_state (BTM_PAIR_STATE_WAIT_LOCAL_PIN);
static void btm_sec_check_pending_enc_req (tBTM_SEC_DEV_REC *p_dev_rec, tBT_TRANSPORT transport,
UINT8 encr_enable)
{
- if (fixed_queue_is_empty(btm_cb.sec_pending_q))
+ if (fixed_queue_is_empty(btm_cb.sec_pending_q)) {
return;
+ }
UINT8 res = encr_enable ? BTM_SUCCESS : BTM_ERR_PROCESSING;
list_t *list = fixed_queue_get_list(btm_cb.sec_pending_q);
**
*******************************************************************************/
UINT16 GATTS_AddCharacteristic (UINT16 service_handle, tBT_UUID *p_char_uuid,
- tGATT_PERM perm, tGATT_CHAR_PROP property,
+ tGATT_PERM perm, tGATT_CHAR_PROP property,
tGATT_ATTR_VAL *attr_val, tGATTS_ATTR_CONTROL *control)
{
tGATT_HDL_LIST_ELEM *p_decl;
return gatts_add_characteristic(&p_decl->svc_db,
perm,
property,
- p_char_uuid,
+ p_char_uuid,
attr_val, control);
}
/*******************************************************************************
return GATT_INVALID_ATTR_LEN;
}
if ((p_decl = gatt_find_hdl_buffer_by_attr_handle(attr_handle)) == NULL) {
- GATT_TRACE_DEBUG("Service not created\n");
+ GATT_TRACE_DEBUG("Service not created\n");
return GATT_INVALID_HANDLE;
}
if (p_tcb->att_lcid == L2CAP_ATT_CID) {
status = L2CA_SetFixedChannelTout (bd_addr, L2CAP_ATT_CID, idle_tout);
- if (idle_tout == GATT_LINK_IDLE_TIMEOUT_WHEN_NO_APP)
+ if (idle_tout == GATT_LINK_IDLE_TIMEOUT_WHEN_NO_APP) {
L2CA_SetIdleTimeoutByBdAddr(p_tcb->peer_bda,
GATT_LINK_IDLE_TIMEOUT_WHEN_NO_APP, BT_TRANSPORT_LE);
+ }
} else {
status = L2CA_SetIdleTimeout (p_tcb->att_lcid, idle_tout, FALSE);
}
srv_chg_ind_pending = gatt_is_srv_chg_ind_pending(p_tcb);
if (!srv_chg_ind_pending) {
- status = gatt_send_srv_chg_ind(addr);
+ status = gatt_send_srv_chg_ind(addr);
} else {
status = GATT_BUSY;
GATT_TRACE_DEBUG("discard srv chg - already has one in the queue");
p_ccb->ertm_info = *p_ertm_info;
/* Replace default indicators with the actual default pool */
- if (p_ccb->ertm_info.fcr_rx_buf_size == L2CAP_INVALID_ERM_BUF_SIZE)
+ if (p_ccb->ertm_info.fcr_rx_buf_size == L2CAP_INVALID_ERM_BUF_SIZE) {
p_ccb->ertm_info.fcr_rx_buf_size = L2CAP_FCR_RX_BUF_SIZE;
+ }
- if (p_ccb->ertm_info.fcr_tx_buf_size == L2CAP_INVALID_ERM_BUF_SIZE)
+ if (p_ccb->ertm_info.fcr_tx_buf_size == L2CAP_INVALID_ERM_BUF_SIZE) {
p_ccb->ertm_info.fcr_tx_buf_size = L2CAP_FCR_TX_BUF_SIZE;
+ }
- if (p_ccb->ertm_info.user_rx_buf_size == L2CAP_INVALID_ERM_BUF_SIZE)
+ if (p_ccb->ertm_info.user_rx_buf_size == L2CAP_INVALID_ERM_BUF_SIZE) {
p_ccb->ertm_info.user_rx_buf_size = L2CAP_USER_RX_BUF_SIZE;
+ }
- if (p_ccb->ertm_info.user_tx_buf_size == L2CAP_INVALID_ERM_BUF_SIZE)
+ if (p_ccb->ertm_info.user_tx_buf_size == L2CAP_INVALID_ERM_BUF_SIZE) {
p_ccb->ertm_info.user_tx_buf_size = L2CAP_USER_TX_BUF_SIZE;
+ }
p_ccb->max_rx_mtu = p_ertm_info->user_rx_buf_size -
(L2CAP_MIN_OFFSET + L2CAP_SDU_LEN_OFFSET + L2CAP_FCS_LEN);
p_ccb->ertm_info = *p_ertm_info;
/* Replace default indicators with the actual default pool */
- if (p_ccb->ertm_info.fcr_rx_buf_size == L2CAP_INVALID_ERM_BUF_SIZE)
+ if (p_ccb->ertm_info.fcr_rx_buf_size == L2CAP_INVALID_ERM_BUF_SIZE) {
p_ccb->ertm_info.fcr_rx_buf_size = L2CAP_FCR_RX_BUF_SIZE;
+ }
- if (p_ccb->ertm_info.fcr_tx_buf_size == L2CAP_INVALID_ERM_BUF_SIZE)
+ if (p_ccb->ertm_info.fcr_tx_buf_size == L2CAP_INVALID_ERM_BUF_SIZE) {
p_ccb->ertm_info.fcr_tx_buf_size = L2CAP_FCR_TX_BUF_SIZE;
+ }
- if (p_ccb->ertm_info.user_rx_buf_size == L2CAP_INVALID_ERM_BUF_SIZE)
+ if (p_ccb->ertm_info.user_rx_buf_size == L2CAP_INVALID_ERM_BUF_SIZE) {
p_ccb->ertm_info.user_rx_buf_size = L2CAP_USER_RX_BUF_SIZE;
+ }
- if (p_ccb->ertm_info.user_tx_buf_size == L2CAP_INVALID_ERM_BUF_SIZE)
+ if (p_ccb->ertm_info.user_tx_buf_size == L2CAP_INVALID_ERM_BUF_SIZE) {
p_ccb->ertm_info.user_tx_buf_size = L2CAP_USER_TX_BUF_SIZE;
+ }
p_ccb->max_rx_mtu = p_ertm_info->user_rx_buf_size -
(L2CAP_MIN_OFFSET + L2CAP_SDU_LEN_OFFSET + L2CAP_FCS_LEN);
for (vpsm = 0x0080; vpsm < 0x0100; vpsm++)
{
p_rcb = l2cu_find_ble_rcb_by_psm(vpsm);
- if (p_rcb == NULL)
+ if (p_rcb == NULL) {
break;
+ }
}
L2CAP_TRACE_API("%s Real PSM: 0x%04x Virtual PSM: 0x%04x", __func__, psm, vpsm);
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)
+ 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))
+ 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))
+ p_ccb->chnl_state == CST_W4_L2CA_DISCONNECT_RSP)) {
continue;
+ }
- if (p_ccb->p_rcb == p_rcb)
+ if (p_ccb->p_rcb == p_rcb) {
l2c_csm_execute(p_ccb, L2CEVT_L2CA_DISCONNECT_REQ, NULL);
+ }
}
l2cu_release_rcb (p_rcb);
p_ccb->p_rcb = p_rcb;
/* Save the configuration */
- if (p_cfg)
+ if (p_cfg) {
memcpy(&p_ccb->local_conn_cfg, p_cfg, sizeof(tL2CAP_LE_CFG_INFO));
+ }
/* If link is up, start the L2CAP connection */
if (p_lcb->link_state == LST_CONNECTED)
return FALSE;
}
- if (p_cfg)
+ if (p_cfg) {
memcpy(&p_ccb->local_conn_cfg, p_cfg, sizeof(tL2CAP_LE_CFG_INFO));
+ }
if (result == L2CAP_CONN_OK)
l2c_csm_execute (p_ccb, L2CEVT_L2CA_CONNECT_RSP, NULL);
return FALSE;
}
- if (peer_cfg != NULL)
+ if (peer_cfg != NULL) {
memcpy(peer_cfg, &p_ccb->peer_conn_cfg, sizeof(tL2CAP_LE_CFG_INFO));
+ }
return TRUE;
}
peer_channel_mask = l2cb.l2c_ble_fixed_chnls_mask;
} else
#endif
+ {
peer_channel_mask = p_lcb->peer_chnl_mask[0];
+ }
// Check for supported channel
if (!(peer_channel_mask & (1 << fixed_cid))) {
peer_channel_mask = l2cb.l2c_ble_fixed_chnls_mask;
} else
#endif
+ {
peer_channel_mask = p_lcb->peer_chnl_mask[0];
+ }
if ((peer_channel_mask & (1 << fixed_cid)) == 0) {
L2CAP_TRACE_WARNING ("L2CA_SendFixedChnlData() - peer does not support fixed chnl: 0x%04x", fixed_cid);
*******************************************************************************/
void l2cble_credit_based_conn_req (tL2C_CCB *p_ccb)
{
- if (!p_ccb)
+ if (!p_ccb) {
return;
+ }
if (p_ccb->p_lcb && p_ccb->p_lcb->transport != BT_TRANSPORT_LE)
{
*******************************************************************************/
void l2cble_credit_based_conn_res (tL2C_CCB *p_ccb, UINT16 result)
{
- if (!p_ccb)
+ if (!p_ccb) {
return;
+ }
if (p_ccb->p_lcb && p_ccb->p_lcb->transport != BT_TRANSPORT_LE)
{
*******************************************************************************/
void l2cble_send_flow_control_credit(tL2C_CCB *p_ccb, UINT16 credit_value)
{
- if (!p_ccb)
+ if (!p_ccb) {
return;
+ }
if (p_ccb->p_lcb && p_ccb->p_lcb->transport != BT_TRANSPORT_LE)
{
void l2cble_send_peer_disc_req(tL2C_CCB *p_ccb)
{
L2CAP_TRACE_DEBUG ("%s",__func__);
- if (!p_ccb)
+ if (!p_ccb) {
return;
+ }
if (p_ccb->p_lcb && p_ccb->p_lcb->transport != BT_TRANSPORT_LE)
{
if (sec_act == BTM_SEC_ENCRYPT_MITM)
{
BTM_GetSecurityFlagsByTransport(p_bda, &sec_flag, transport);
- if (sec_flag & BTM_SEC_FLAG_LKEY_AUTHED)
+ if (sec_flag & BTM_SEC_FLAG_LKEY_AUTHED) {
(*(p_buf->p_callback))(p_bda, BT_TRANSPORT_LE, p_buf->p_ref_data, status);
+ }
else
{
L2CAP_TRACE_DEBUG ("%s MITM Protection Not present", __func__);
{
p_buf = (tL2CAP_SEC_DATA*) fixed_queue_dequeue(p_lcb->le_sec_pending_q);
- if (status != BTM_SUCCESS)
+ if (status != BTM_SUCCESS) {
(*(p_buf->p_callback))(p_bda, BT_TRANSPORT_LE, p_buf->p_ref_data, status);
- else
+ } else {
l2ble_sec_access_req(p_bda, p_buf->psm, p_buf->is_originator,
p_buf->p_callback, p_buf->p_ref_data);
+ }
osi_free(p_buf);
}
if (p_ccb->local_cid >= L2CAP_FIRST_FIXED_CHNL &&
p_ccb->local_cid <= L2CAP_LAST_FIXED_CHNL) {
if (p_ccb->local_cid < L2CAP_BASE_APPL_CID) {
- if (l2cb.fixed_reg[p_ccb->local_cid - L2CAP_FIRST_FIXED_CHNL].pL2CA_FixedData_Cb)
+ if (l2cb.fixed_reg[p_ccb->local_cid - L2CAP_FIRST_FIXED_CHNL].pL2CA_FixedData_Cb) {
(*l2cb.fixed_reg[p_ccb->local_cid - L2CAP_FIRST_FIXED_CHNL].pL2CA_FixedData_Cb)
(p_ccb->local_cid, p_ccb->p_lcb->remote_bd_addr, (BT_HDR *)p_data);
- else {
+ } else {
osi_free (p_data);
}
break;
fixed_queue_free(p_fcrb->retrans_q, osi_free_func);
p_fcrb->retrans_q = NULL;
-
+
btu_free_quick_timer (&p_fcrb->ack_timer);
memset(&p_fcrb->ack_timer, 0, sizeof(TIMER_LIST_ENT));
-
+
btu_free_quick_timer (&p_ccb->fcrb.mon_retrans_timer);
memset(&p_fcrb->mon_retrans_timer, 0, sizeof(TIMER_LIST_ENT));
-
+
#if (L2CAP_ERTM_STATS == TRUE)
if ( (p_ccb->local_cid >= L2CAP_BASE_APPL_CID) && (p_ccb->peer_cfg.fcr.mode == L2CAP_FCR_ERTM_MODE) ) {
UINT32 dur = osi_time_get_os_boottime_ms() - p_ccb->fcrb.connect_tick_count;
(p_ccb->local_cid, p_ccb->p_lcb->remote_bd_addr, p_buf);
} else
#endif
+ {
l2c_csm_execute (p_ccb, L2CEVT_L2CAP_DATA, p_buf);
+ }
}
return (packet_ok);
/* update sum, max and min of round trip delay of acking */
list_t *list = NULL;
- if (! fixed_queue_is_empty(p_ccb->fcrb.waiting_for_ack_q))
+ if (! fixed_queue_is_empty(p_ccb->fcrb.waiting_for_ack_q)) {
list = fixed_queue_get_list(p_ccb->fcrb.waiting_for_ack_q);
+ }
if (list != NULL) {
for (const list_node_t *node = list_begin(list), xx = 0;
(node != list_end(list)) && (xx < num_bufs_acked);
l2cu_send_peer_info_req (p_lcb, L2CAP_EXTENDED_FEATURES_INFO_TYPE);
/* Tell BTM Acl management about the link */
- if ((p_dev_info = btm_find_dev (p_bda)) != NULL)
+ if ((p_dev_info = btm_find_dev (p_bda)) != NULL) {
btm_acl_created (ci.bd_addr, p_dev_info->dev_class,
p_dev_info->sec_bd_name, handle,
p_lcb->link_role, BT_TRANSPORT_BR_EDR);
- else {
+ } else {
btm_acl_created (ci.bd_addr, NULL, NULL, handle, p_lcb->link_role, BT_TRANSPORT_BR_EDR);
}
#if (BLE_INCLUDED == TRUE)
if (p_lcb->transport == BT_TRANSPORT_BR_EDR)
#endif
+ {
/* Tell SCO management to drop any SCOs on this ACL */
btm_sco_acl_removed (p_lcb->remote_bd_addr);
+ }
#endif
/* If waiting for disconnect and reconnect is pending start the reconnect now
}
}
}
-#endif ///CLASSIC_BT_INCLUDED == TRUE
+#endif ///CLASSIC_BT_INCLUDED == TRUE
}
}
l2cb.ble_check_round_robin = TRUE;
} else
#endif
+ {
l2cb.check_round_robin = TRUE;
+ }
}
}
/* nothing to do */
} else
#endif
+ {
osi_free (p_msg);
+ }
}
#if (BLE_INCLUDED == TRUE)
else if (rcv_cid == L2CAP_BLE_SIGNALLING_CID) {
#if (CLASSIC_BT_INCLUDED == TRUE)
l2c_fcr_proc_pdu (p_ccb, p_msg);
#endif ///CLASSIC_BT_INCLUDED == TRUE
- } else
+ } else {
(*l2cb.fixed_reg[rcv_cid - L2CAP_FIRST_FIXED_CHNL].pL2CA_FixedData_Cb)
(rcv_cid, p_lcb->remote_bd_addr, p_msg);
+ }
} else {
osi_free (p_msg);
}
STREAM_TO_UINT16 (rej_mtu, p);
/* What to do with the MTU reject ? We have negotiated an MTU. For now */
/* we will ignore it and let a higher protocol timeout take care of it */
-
L2CAP_TRACE_WARNING ("L2CAP - MTU rej Handle: %d MTU: %d", p_lcb->handle, rej_mtu);
}
if (rej_reason == L2CAP_CMD_REJ_INVALID_CID) {
}
}
+ UNUSED(rej_mtu);
}
#endif ///CLASSIC_BT_INCLUDED == TRUE
l2cb.rcv_pending_q = NULL;
#if L2C_DYNAMIC_MEMORY
FREE_AND_RESET(l2c_cb_ptr);
-#endif
+#endif
}
/*******************************************************************************
#if (BLE_INCLUDED == TRUE)
if (p_lcb->transport == BT_TRANSPORT_BR_EDR)
#endif
+ {
/* Release all SCO links */
btm_remove_sco_links(p_lcb->remote_bd_addr);
+ }
#endif
if (p_lcb->sent_not_acked > 0) {
}
/* Tell BTM Acl management the link was removed */
- if ((p_lcb->link_state == LST_CONNECTED) || (p_lcb->link_state == LST_DISCONNECTING))
+ if ((p_lcb->link_state == LST_CONNECTED) || (p_lcb->link_state == LST_DISCONNECTING)) {
#if (BLE_INCLUDED == TRUE)
btm_acl_removed (p_lcb->remote_bd_addr, p_lcb->transport);
#else
btm_acl_removed (p_lcb->remote_bd_addr, BT_TRANSPORT_BR_EDR);
#endif
+ }
/* Release any held buffers */
if (p_lcb->link_xmit_data_q) {
while (!fixed_queue_is_empty(p_lcb->le_sec_pending_q))
{
tL2CAP_SEC_DATA *p_buf = (tL2CAP_SEC_DATA*) fixed_queue_dequeue(p_lcb->le_sec_pending_q);
- if (p_buf->p_callback)
+ if (p_buf->p_callback) {
p_buf->p_callback(p_lcb->remote_bd_addr, p_lcb->transport, p_buf->p_ref_data, BTM_DEV_RESET);
+ }
osi_free(p_buf);
}
fixed_queue_free(p_lcb->le_sec_pending_q, NULL);
for (xx = 0; xx < BLE_MAX_L2CAP_CLIENTS; xx++, p_rcb++)
{
- if ((p_rcb->in_use) && (p_rcb->psm == psm))
+ if ((p_rcb->in_use) && (p_rcb->psm == psm)) {
return (p_rcb);
+ }
}
/* If here, no match found */
#endif
}
} else if ( (peer_channel_mask & (1 << (xx + L2CAP_FIRST_FIXED_CHNL)))
- && (l2cb.fixed_reg[xx].pL2CA_FixedConn_Cb != NULL) )
+ && (l2cb.fixed_reg[xx].pL2CA_FixedConn_Cb != NULL) ) {
#if BLE_INCLUDED == TRUE
(*l2cb.fixed_reg[xx].pL2CA_FixedConn_Cb)(xx + L2CAP_FIRST_FIXED_CHNL,
p_lcb->remote_bd_addr, FALSE, p_lcb->disc_reason, p_lcb->transport);
(*l2cb.fixed_reg[xx].pL2CA_FixedConn_Cb)(xx + L2CAP_FIRST_FIXED_CHNL,
p_lcb->remote_bd_addr, FALSE, p_lcb->disc_reason, BT_TRANSPORT_BR_EDR);
#endif
+ }
}
#endif
}
UINT16 mps;
UINT16 initial_credit;
- if (!p_ccb)
+ if (!p_ccb) {
return;
+ }
p_lcb = p_ccb->p_lcb;
/* Create an identifier for this packet */
UINT8 *p;
tL2C_LCB *p_lcb = NULL;
- if (!p_ccb)
+ if (!p_ccb) {
return;
+ }
p_lcb = p_ccb->p_lcb;
/* Create an identifier for this packet */
tL2C_LCB *p_lcb = NULL;
L2CAP_TRACE_DEBUG ("%s",__func__);
- if (!p_ccb)
+ if (!p_ccb) {
return;
+ }
p_lcb = p_ccb->p_lcb;
/* Create an identifier for this packet */
while (max_len)
{
p_buf = (BT_HDR *)fixed_queue_try_peek_first(p_port->rx.queue);
- if (p_buf == NULL)
+ if (p_buf == NULL){
break;
+ }
if (p_buf->len > max_len) {
memcpy (p_data, (UINT8 *)(p_buf + 1) + p_buf->offset, max_len);
init_uuid.len = 2;
init_uuid.uu.uuid16 = di_uuid;
- if ( SDP_InitDiscoveryDb(p_db, len, num_uuids, &init_uuid, 0, NULL) )
+ if ( SDP_InitDiscoveryDb(p_db, len, num_uuids, &init_uuid, 0, NULL) ) {
if ( SDP_ServiceSearchRequest(remote_device, p_db, p_cb) ) {
result = SDP_SUCCESS;
}
-
+ }
return result;
#else
return SDP_DI_DISC_FAILED;
SDP_TRACE_EVENT ("SDP - Rcvd L2CAP disc, CID: 0x%x\n", l2cap_cid);
#if SDP_CLIENT_ENABLED == TRUE
/* Tell the user if he has a callback */
- if (p_ccb->p_cb)
+ if (p_ccb->p_cb) {
(*p_ccb->p_cb) ((UINT16) ((p_ccb->con_state == SDP_STATE_CONNECTED) ?
SDP_SUCCESS : SDP_CONN_FAILED));
- else if (p_ccb->p_cb2)
+ } else if (p_ccb->p_cb2) {
(*p_ccb->p_cb2) ((UINT16) ((p_ccb->con_state == SDP_STATE_CONNECTED) ?
SDP_SUCCESS : SDP_CONN_FAILED), p_ccb->user_data);
+ }
#endif
sdpu_release_ccb (p_ccb);
} else
#endif /* 0xFFFF - 0xFF */
+ {
#if (SDP_MAX_ATTR_LEN > 0xFF)
if (p_attr->len > 0xFF) {
UINT8_TO_BE_STREAM (p_out, (p_attr->type << 3) | SIZE_IN_NEXT_WORD);
UINT8_TO_BE_STREAM (p_out, (p_attr->type << 3) | SIZE_IN_NEXT_BYTE);
UINT8_TO_BE_STREAM (p_out, p_attr->len);
}
-
+ }
if (p_attr->value_ptr != NULL) {
ARRAY_TO_BE_STREAM (p_out, p_attr->value_ptr, (int)p_attr->len);
}
if (len1 == 2) {
return ((p_uuid1[0] == p_uuid2[0]) && (p_uuid1[1] == p_uuid2[1]));
}
- if (len1 == 4)
+ if (len1 == 4) {
return ( (p_uuid1[0] == p_uuid2[0]) && (p_uuid1[1] == p_uuid2[1])
&& (p_uuid1[2] == p_uuid2[2]) && (p_uuid1[3] == p_uuid2[3]) );
- else {
+ } else {
return (memcmp (p_uuid1, p_uuid2, (size_t)len1) == 0);
}
} else if (len1 > len2) {
} else
#endif/* 0xFFFF - 0xFF */
+ {
#if (SDP_MAX_ATTR_LEN > 0xFF)
if (p_attr->len > 0xFF) {
len += 3;
{
len += 2;
}
+ }
len += p_attr->len;
return len;
}
}
for ( ; ; ) {
- if (n1)
+ if (n1) {
while (n2 >= n1) { /* divide polynomial p2 by p1 */
n2 /= n1; /* shift smaller polynomial left */
p2 ^= (p1 * n2) & 0xff; /* and remove from larger one */
v2 ^= (v1 * n2); /* shift accumulated value and */
n2 = hibit(p2); /* add into result */
}
- else {
+ } else {
return v1;
}
- if (n2) /* repeat with values swapped */
+ if (n2) { /* repeat with values swapped */
while (n1 >= n2) {
n1 /= n2;
p1 ^= p2 * n1;
v1 ^= v2 * n1;
n1 = hibit(p1);
}
- else {
+ } else {
return v2;
}
}
le_key.key_size = p_cb->loc_enc_size;
le_key.sec_level = p_cb->sec_level;
- if ((p_cb->peer_auth_req & SMP_AUTH_BOND) && (p_cb->loc_auth_req & SMP_AUTH_BOND))
+ if ((p_cb->peer_auth_req & SMP_AUTH_BOND) && (p_cb->loc_auth_req & SMP_AUTH_BOND)) {
btm_sec_save_le_key(p_cb->pairing_bda, BTM_LE_KEY_LENC,
(tBTM_LE_KEY_VALUE *)&le_key, TRUE);
+ }
SMP_TRACE_DEBUG ("%s\n", __func__);
smp_send_cmd(SMP_OPCODE_IDENTITY_INFO, p_cb);
smp_send_cmd(SMP_OPCODE_ID_ADDR, p_cb);
- if ((p_cb->peer_auth_req & SMP_AUTH_BOND) && (p_cb->loc_auth_req & SMP_AUTH_BOND))
+ if ((p_cb->peer_auth_req & SMP_AUTH_BOND) && (p_cb->loc_auth_req & SMP_AUTH_BOND)) {
btm_sec_save_le_key(p_cb->pairing_bda, BTM_LE_KEY_LID,
&le_key, TRUE);
+ }
smp_key_distribution_by_transport(p_cb, NULL);
}
auth = 0;
}
return auth;
-}
+}
/*******************************************************************************
** Function smp_proc_pair_cmd
STREAM_TO_ARRAY(p_cb->peer_publ_key.x, p, BT_OCTET32_LEN);
STREAM_TO_ARRAY(p_cb->peer_publ_key.y, p, BT_OCTET32_LEN);
- /* In order to prevent the x and y coordinates of the public key from being modified,
+ /* In order to prevent the x and y coordinates of the public key from being modified,
we need to check whether the x and y coordinates are on the given elliptic curve. */
if (!ECC_CheckPointIsInElliCur_P256((Point *)&p_cb->peer_publ_key)) {
SMP_TRACE_ERROR("%s, Invalid Public key.", __func__);
le_key.sec_level = p_cb->sec_level;
le_key.key_size = p_cb->loc_enc_size;
- if ((p_cb->peer_auth_req & SMP_AUTH_BOND) && (p_cb->loc_auth_req & SMP_AUTH_BOND))
+ if ((p_cb->peer_auth_req & SMP_AUTH_BOND) && (p_cb->loc_auth_req & SMP_AUTH_BOND)) {
btm_sec_save_le_key(p_cb->pairing_bda,
BTM_LE_KEY_PENC,
(tBTM_LE_KEY_VALUE *)&le_key, TRUE);
+ }
smp_key_distribution(p_cb, NULL);
}
memcpy(p_cb->id_addr, pid_key.static_addr, BD_ADDR_LEN);
/* store the ID key from peer device */
- if ((p_cb->peer_auth_req & SMP_AUTH_BOND) && (p_cb->loc_auth_req & SMP_AUTH_BOND))
+ if ((p_cb->peer_auth_req & SMP_AUTH_BOND) && (p_cb->loc_auth_req & SMP_AUTH_BOND)) {
btm_sec_save_le_key(p_cb->pairing_bda, BTM_LE_KEY_PID,
(tBTM_LE_KEY_VALUE *)&pid_key, TRUE);
+ }
smp_key_distribution_by_transport(p_cb, NULL);
}
memcpy (le_key.csrk, p_data, BT_OCTET16_LEN); /* get peer CSRK */
le_key.counter = 0; /* initialize the peer counter */
- if ((p_cb->peer_auth_req & SMP_AUTH_BOND) && (p_cb->loc_auth_req & SMP_AUTH_BOND))
+ if ((p_cb->peer_auth_req & SMP_AUTH_BOND) && (p_cb->loc_auth_req & SMP_AUTH_BOND)) {
btm_sec_save_le_key(p_cb->pairing_bda,
BTM_LE_KEY_PCSRK,
(tBTM_LE_KEY_VALUE *)&le_key, TRUE);
+ }
smp_key_distribution_by_transport(p_cb, NULL);
}
{
if(p_cb->role == BTM_ROLE_MASTER) {
L2CA_EnableUpdateBleConnParams(p_cb->pairing_bda, FALSE);
- }
+ }
#if (SMP_SLAVE_CON_PARAMS_UPD_ENABLE == TRUE)
else {
tBTM_SEC_DEV_REC *p_rec = btm_find_dev (p_cb->pairing_bda);
}
smp_sm_event(&smp_cb, SMP_ENCRYPTED_EVT, &encr_enable);
- }
- else if(p_dev_rec && !p_dev_rec->enc_init_by_we){
+ }
+ else if(p_dev_rec && !p_dev_rec->enc_init_by_we){
- /*
+ /*
if enc_init_by_we is false, it means that client initiates encryption before slave calls esp_ble_set_encryption()
we need initiate pairing_bda and p_cb->role then encryption, for example iPhones
*/
projects / esp-idf / commitdiff