king
/
v811_spc009
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '1344b61cf0'
${ noResults }
v811_spc009/system/bt/bta/sdp/bta_sdp_act.cc

549 lines
19 KiB
Raw Blame History

/******************************************************************************
*
* Copyright 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
******************************************************************************/
/******************************************************************************
* This file contains action functions for SDP search.
******************************************************************************/
#include <hardware/bt_sdp.h>
#include <cstdint>
#include "bta/include/bta_sdp_api.h"
#include "bta/sdp/bta_sdp_int.h"
#include "btif/include/btif_sock_sdp.h"
#include "osi/include/allocator.h"
#include "stack/include/sdp_api.h"
#include "types/bluetooth/uuid.h"
#include "types/raw_address.h"
static void bta_create_mns_sdp_record(bluetooth_sdp_record* record,
tSDP_DISC_REC* p_rec) {
tSDP_DISC_ATTR* p_attr;
tSDP_PROTOCOL_ELEM pe;
uint16_t pversion = 0;
record->mns.hdr.type = SDP_TYPE_MAP_MNS;
record->mns.hdr.service_name_length = 0;
record->mns.hdr.service_name = NULL;
record->mns.hdr.rfcomm_channel_number = 0;
record->mns.hdr.l2cap_psm = -1;
record->mns.hdr.profile_version = 0;
record->mns.supported_features = 0x0000001F; // default value if not found
p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_MAP_SUPPORTED_FEATURES);
if (p_attr != NULL) {
record->mns.supported_features = p_attr->attr_value.v.u32;
}
p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_SERVICE_NAME);
if (p_attr != NULL) {
record->mns.hdr.service_name_length =
SDP_DISC_ATTR_LEN(p_attr->attr_len_type);
record->mns.hdr.service_name = (char*)p_attr->attr_value.v.array;
}
if (SDP_FindProfileVersionInRec(p_rec, UUID_SERVCLASS_MAP_PROFILE,
&pversion)) {
record->mns.hdr.profile_version = pversion;
}
if (SDP_FindProtocolListElemInRec(p_rec, UUID_PROTOCOL_RFCOMM, &pe)) {
record->mns.hdr.rfcomm_channel_number = pe.params[0];
}
p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_GOEP_L2CAP_PSM);
if (p_attr != NULL) {
record->mns.hdr.l2cap_psm = p_attr->attr_value.v.u16;
}
}
static void bta_create_mas_sdp_record(bluetooth_sdp_record* record,
tSDP_DISC_REC* p_rec) {
tSDP_DISC_ATTR* p_attr;
tSDP_PROTOCOL_ELEM pe;
uint16_t pversion = -1;
record->mas.hdr.type = SDP_TYPE_MAP_MAS;
record->mas.hdr.service_name_length = 0;
record->mas.hdr.service_name = NULL;
record->mas.hdr.rfcomm_channel_number = 0;
record->mas.hdr.l2cap_psm = -1;
record->mas.hdr.profile_version = 0;
record->mas.mas_instance_id = 0;
record->mas.supported_features = 0x0000001F;
record->mas.supported_message_types = 0;
p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_MAS_INSTANCE_ID);
if (p_attr != NULL) {
record->mas.mas_instance_id = p_attr->attr_value.v.u8;
}
p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_SUPPORTED_MSG_TYPE);
if (p_attr != NULL) {
record->mas.supported_message_types = p_attr->attr_value.v.u8;
}
p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_MAP_SUPPORTED_FEATURES);
if (p_attr != NULL) {
record->mas.supported_features = p_attr->attr_value.v.u32;
}
p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_SERVICE_NAME);
if (p_attr != NULL) {
record->mas.hdr.service_name_length =
SDP_DISC_ATTR_LEN(p_attr->attr_len_type);
record->mas.hdr.service_name = (char*)p_attr->attr_value.v.array;
}
if (SDP_FindProfileVersionInRec(p_rec, UUID_SERVCLASS_MAP_PROFILE,
&pversion)) {
record->mas.hdr.profile_version = pversion;
}
if (SDP_FindProtocolListElemInRec(p_rec, UUID_PROTOCOL_RFCOMM, &pe)) {
record->mas.hdr.rfcomm_channel_number = pe.params[0];
}
p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_GOEP_L2CAP_PSM);
if (p_attr != NULL) {
record->mas.hdr.l2cap_psm = p_attr->attr_value.v.u16;
}
}
static void bta_create_pse_sdp_record(bluetooth_sdp_record* record,
tSDP_DISC_REC* p_rec) {
tSDP_DISC_ATTR* p_attr;
uint16_t pversion;
tSDP_PROTOCOL_ELEM pe;
record->pse.hdr.type = SDP_TYPE_PBAP_PSE;
record->pse.hdr.service_name_length = 0;
record->pse.hdr.service_name = NULL;
record->pse.hdr.rfcomm_channel_number = 0;
record->pse.hdr.l2cap_psm = -1;
record->pse.hdr.profile_version = 0;
record->pse.supported_features = 0x00000003;
record->pse.supported_repositories = 0;
p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_SUPPORTED_REPOSITORIES);
if (p_attr != NULL) {
record->pse.supported_repositories = p_attr->attr_value.v.u8;
}
p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_PBAP_SUPPORTED_FEATURES);
if (p_attr != NULL) {
record->pse.supported_features = p_attr->attr_value.v.u32;
}
p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_SERVICE_NAME);
if (p_attr != NULL) {
record->pse.hdr.service_name_length =
SDP_DISC_ATTR_LEN(p_attr->attr_len_type);
record->pse.hdr.service_name = (char*)p_attr->attr_value.v.array;
}
if (SDP_FindProfileVersionInRec(p_rec, UUID_SERVCLASS_PHONE_ACCESS,
&pversion)) {
record->pse.hdr.profile_version = pversion;
}
if (SDP_FindProtocolListElemInRec(p_rec, UUID_PROTOCOL_RFCOMM, &pe)) {
record->pse.hdr.rfcomm_channel_number = pe.params[0];
}
p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_GOEP_L2CAP_PSM);
if (p_attr != NULL) {
record->pse.hdr.l2cap_psm = p_attr->attr_value.v.u16;
}
}
static void bta_create_ops_sdp_record(bluetooth_sdp_record* record,
tSDP_DISC_REC* p_rec) {
tSDP_DISC_ATTR *p_attr, *p_sattr;
tSDP_PROTOCOL_ELEM pe;
uint16_t pversion = -1;
record->ops.hdr.type = SDP_TYPE_OPP_SERVER;
record->ops.hdr.service_name_length = 0;
record->ops.hdr.service_name = NULL;
record->ops.hdr.rfcomm_channel_number = 0;
record->ops.hdr.l2cap_psm = -1;
record->ops.hdr.profile_version = 0;
record->ops.supported_formats_list_len = 0;
p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_SERVICE_NAME);
if (p_attr != NULL) {
record->ops.hdr.service_name_length =
SDP_DISC_ATTR_LEN(p_attr->attr_len_type);
record->ops.hdr.service_name = (char*)p_attr->attr_value.v.array;
}
if (SDP_FindProfileVersionInRec(p_rec, UUID_SERVCLASS_OBEX_OBJECT_PUSH,
&pversion)) {
record->ops.hdr.profile_version = pversion;
}
if (SDP_FindProtocolListElemInRec(p_rec, UUID_PROTOCOL_RFCOMM, &pe)) {
record->ops.hdr.rfcomm_channel_number = pe.params[0];
}
p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_GOEP_L2CAP_PSM);
if (p_attr != NULL) {
record->ops.hdr.l2cap_psm = p_attr->attr_value.v.u16;
}
p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_SUPPORTED_FORMATS_LIST);
if (p_attr != NULL) {
/* Safety check - each entry should itself be a sequence */
if (SDP_DISC_ATTR_TYPE(p_attr->attr_len_type) != DATA_ELE_SEQ_DESC_TYPE) {
record->ops.supported_formats_list_len = 0;
APPL_TRACE_ERROR(
"%s() - supported_formats_list - wrong attribute length/type:"
" 0x%02x - expected 0x06",
__func__, p_attr->attr_len_type);
} else {
int count = 0;
/* 1 byte for type/length 1 byte for value */
record->ops.supported_formats_list_len =
SDP_DISC_ATTR_LEN(p_attr->attr_len_type) / 2;
/* Extract each value into */
for (p_sattr = p_attr->attr_value.v.p_sub_attr; p_sattr != NULL;
p_sattr = p_sattr->p_next_attr) {
if ((SDP_DISC_ATTR_TYPE(p_sattr->attr_len_type) == UINT_DESC_TYPE) &&
(SDP_DISC_ATTR_LEN(p_sattr->attr_len_type) == 1)) {
if (count == sizeof(record->ops.supported_formats_list)) {
APPL_TRACE_ERROR(
"%s() - supported_formats_list - count overflow - "
"too many sub attributes!!",
__func__);
/* If you hit this, new formats have been added,
* update SDP_OPP_SUPPORTED_FORMATS_MAX_LENGTH */
break;
}
record->ops.supported_formats_list[count] = p_sattr->attr_value.v.u8;
count++;
} else {
APPL_TRACE_ERROR(
"%s() - supported_formats_list - wrong sub attribute "
"length/type: 0x%02x - expected 0x80",
__func__, p_sattr->attr_len_type);
break;
}
}
if (record->ops.supported_formats_list_len != count) {
APPL_TRACE_WARNING(
"%s() - supported_formats_list - Length of attribute different "
"from the actual number of sub-attributes in the sequence "
"att-length: %d - number of elements: %d",
__func__, record->ops.supported_formats_list_len, count);
}
record->ops.supported_formats_list_len = count;
}
}
}
static void bta_create_sap_sdp_record(bluetooth_sdp_record* record,
tSDP_DISC_REC* p_rec) {
tSDP_DISC_ATTR* p_attr;
tSDP_PROTOCOL_ELEM pe;
uint16_t pversion = -1;
record->sap.hdr.type = SDP_TYPE_MAP_MAS;
record->sap.hdr.service_name_length = 0;
record->sap.hdr.service_name = NULL;
record->sap.hdr.rfcomm_channel_number = 0;
record->sap.hdr.l2cap_psm = -1;
record->sap.hdr.profile_version = 0;
p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_SERVICE_NAME);
if (p_attr != NULL) {
record->sap.hdr.service_name_length =
SDP_DISC_ATTR_LEN(p_attr->attr_len_type);
record->sap.hdr.service_name = (char*)p_attr->attr_value.v.array;
}
if (SDP_FindProfileVersionInRec(p_rec, UUID_SERVCLASS_SAP, &pversion)) {
record->sap.hdr.profile_version = pversion;
}
if (SDP_FindProtocolListElemInRec(p_rec, UUID_PROTOCOL_RFCOMM, &pe)) {
record->sap.hdr.rfcomm_channel_number = pe.params[0];
}
}
static void bta_create_dip_sdp_record(bluetooth_sdp_record* record,
tSDP_DISC_REC* p_rec) {
tSDP_DISC_ATTR* p_attr;
APPL_TRACE_DEBUG("%s()", __func__);
/* hdr is redundancy in dip */
record->dip.hdr.type = SDP_TYPE_DIP;
record->dip.hdr.service_name_length = 0;
record->dip.hdr.service_name = nullptr;
record->dip.hdr.rfcomm_channel_number = 0;
record->dip.hdr.l2cap_psm = -1;
record->dip.hdr.profile_version = 0;
p_attr =
SDP_FindAttributeInRec(p_rec, ATTR_ID_SPECIFICATION_ID);
if (p_attr != nullptr)
record->dip.spec_id = p_attr->attr_value.v.u16;
else
APPL_TRACE_ERROR("%s() ATTR_ID_SPECIFICATION_ID not found", __func__);
p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_VENDOR_ID);
if (p_attr != nullptr)
record->dip.vendor = p_attr->attr_value.v.u16;
else
APPL_TRACE_ERROR("%s() ATTR_ID_VENDOR_ID not found", __func__);
p_attr =
SDP_FindAttributeInRec(p_rec, ATTR_ID_VENDOR_ID_SOURCE);
if (p_attr != nullptr)
record->dip.vendor_id_source = p_attr->attr_value.v.u16;
else
APPL_TRACE_ERROR("%s() ATTR_ID_VENDOR_ID_SOURCE not found", __func__);
p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_PRODUCT_ID);
if (p_attr != nullptr)
record->dip.product = p_attr->attr_value.v.u16;
else
APPL_TRACE_ERROR("%s() ATTR_ID_PRODUCT_ID not found", __func__);
p_attr =
SDP_FindAttributeInRec(p_rec, ATTR_ID_PRODUCT_VERSION);
if (p_attr != nullptr)
record->dip.version = p_attr->attr_value.v.u16;
else
APPL_TRACE_ERROR("%s() ATTR_ID_PRODUCT_VERSION not found", __func__);
p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_PRIMARY_RECORD);
if (p_attr != nullptr)
record->dip.primary_record = !(!p_attr->attr_value.v.u8);
else
APPL_TRACE_ERROR("%s() ATTR_ID_PRIMARY_RECORD not found", __func__);
}
static void bta_create_raw_sdp_record(bluetooth_sdp_record* record,
tSDP_DISC_REC* p_rec) {
tSDP_DISC_ATTR* p_attr;
tSDP_PROTOCOL_ELEM pe;
record->hdr.type = SDP_TYPE_RAW;
record->hdr.service_name_length = 0;
record->hdr.service_name = NULL;
record->hdr.rfcomm_channel_number = -1;
record->hdr.l2cap_psm = -1;
record->hdr.profile_version = -1;
/* Try to extract a service name */
p_attr = SDP_FindAttributeInRec(p_rec, ATTR_ID_SERVICE_NAME);
if (p_attr != NULL) {
record->pse.hdr.service_name_length =
SDP_DISC_ATTR_LEN(p_attr->attr_len_type);
record->pse.hdr.service_name = (char*)p_attr->attr_value.v.array;
}
/* Try to extract an RFCOMM channel */
if (SDP_FindProtocolListElemInRec(p_rec, UUID_PROTOCOL_RFCOMM, &pe)) {
record->pse.hdr.rfcomm_channel_number = pe.params[0];
}
record->hdr.user1_ptr_len = p_bta_sdp_cfg->p_sdp_db->raw_size;
record->hdr.user1_ptr = p_bta_sdp_cfg->p_sdp_db->raw_data;
}
/** Callback from btm after search is completed */
static void bta_sdp_search_cback(tSDP_RESULT result, void* user_data) {
tBTA_SDP_STATUS status = BTA_SDP_FAILURE;
int count = 0;
APPL_TRACE_DEBUG("%s() - res: 0x%x", __func__, result);
bta_sdp_cb.sdp_active = false;
if (bta_sdp_cb.p_dm_cback == NULL) return;
Uuid& uuid = *(reinterpret_cast<Uuid*>(user_data));
tBTA_SDP_SEARCH_COMP evt_data;
memset(&evt_data, 0, sizeof(evt_data));
evt_data.remote_addr = bta_sdp_cb.remote_addr;
evt_data.uuid = uuid;
if (result == SDP_SUCCESS || result == SDP_DB_FULL) {
tSDP_DISC_REC* p_rec = NULL;
do {
p_rec = SDP_FindServiceUUIDInDb(p_bta_sdp_cfg->p_sdp_db, uuid, p_rec);
/* generate the matching record data pointer */
if (!p_rec) {
APPL_TRACE_DEBUG("%s() - UUID not found", __func__);
continue;
}
status = BTA_SDP_SUCCESS;
if (uuid == UUID_MAP_MAS) {
APPL_TRACE_DEBUG("%s() - found MAP (MAS) uuid", __func__);
bta_create_mas_sdp_record(&evt_data.records[count], p_rec);
} else if (uuid == UUID_MAP_MNS) {
APPL_TRACE_DEBUG("%s() - found MAP (MNS) uuid", __func__);
bta_create_mns_sdp_record(&evt_data.records[count], p_rec);
} else if (uuid == UUID_PBAP_PSE) {
APPL_TRACE_DEBUG("%s() - found PBAP (PSE) uuid", __func__);
bta_create_pse_sdp_record(&evt_data.records[count], p_rec);
} else if (uuid == UUID_OBEX_OBJECT_PUSH) {
APPL_TRACE_DEBUG("%s() - found Object Push Server (OPS) uuid",
__func__);
bta_create_ops_sdp_record(&evt_data.records[count], p_rec);
} else if (uuid == UUID_SAP) {
APPL_TRACE_DEBUG("%s() - found SAP uuid", __func__);
bta_create_sap_sdp_record(&evt_data.records[count], p_rec);
} else if (uuid == UUID_DIP) {
APPL_TRACE_DEBUG("%s() - found DIP uuid", __func__);
bta_create_dip_sdp_record(&evt_data.records[count], p_rec);
} else {
/* we do not have specific structure for this */
APPL_TRACE_DEBUG("%s() - profile not identified. using raw data",
__func__);
bta_create_raw_sdp_record(&evt_data.records[count], p_rec);
p_rec = NULL; // Terminate loop
/* For raw, we only extract the first entry, and then return the
entire raw data chunk.
TODO: Find a way to split the raw data into record chunks, and
iterate to extract generic data for each chunk - e.g. rfcomm
channel and service name. */
}
count++;
} while (p_rec != NULL && count < BTA_SDP_MAX_RECORDS);
evt_data.record_count = count;
}
evt_data.status = status;
tBTA_SDP bta_sdp;
bta_sdp.sdp_search_comp = evt_data;
bta_sdp_cb.p_dm_cback(BTA_SDP_SEARCH_COMP_EVT, &bta_sdp, (void*)&uuid);
osi_free(user_data); // We no longer need the user data to track the search
}
/*******************************************************************************
*
* Function bta_sdp_enable
*
* Description Initializes the SDP I/F
*
* Returns void
*
******************************************************************************/
void bta_sdp_enable(tBTA_SDP_DM_CBACK* p_cback) {
APPL_TRACE_DEBUG("%s in, sdp_active:%d", __func__, bta_sdp_cb.sdp_active);
tBTA_SDP_STATUS status = BTA_SDP_SUCCESS;
bta_sdp_cb.p_dm_cback = p_cback;
tBTA_SDP bta_sdp;
bta_sdp.status = status;
bta_sdp_cb.p_dm_cback(BTA_SDP_ENABLE_EVT, &bta_sdp, NULL);
}
/*******************************************************************************
*
* Function bta_sdp_search
*
* Description Discovers all sdp records for an uuid on remote device
*
* Returns void
*
******************************************************************************/
void bta_sdp_search(const RawAddress bd_addr, const bluetooth::Uuid uuid) {
tBTA_SDP_STATUS status = BTA_SDP_FAILURE;
APPL_TRACE_DEBUG("%s in, sdp_active:%d", __func__, bta_sdp_cb.sdp_active);
if (bta_sdp_cb.sdp_active) {
/* SDP is still in progress */
status = BTA_SDP_BUSY;
if (bta_sdp_cb.p_dm_cback) {
tBTA_SDP_SEARCH_COMP result;
memset(&result, 0, sizeof(result));
result.uuid = uuid;
result.remote_addr = bd_addr;
result.status = status;
tBTA_SDP bta_sdp;
bta_sdp.sdp_search_comp = result;
bta_sdp_cb.p_dm_cback(BTA_SDP_SEARCH_COMP_EVT, &bta_sdp, NULL);
}
return;
}
bta_sdp_cb.sdp_active = true;
bta_sdp_cb.remote_addr = bd_addr;
/* initialize the search for the uuid */
APPL_TRACE_DEBUG("%s init discovery with UUID: %s", __func__,
uuid.ToString().c_str());
SDP_InitDiscoveryDb(p_bta_sdp_cfg->p_sdp_db, p_bta_sdp_cfg->sdp_db_size, 1,
&uuid, 0, NULL);
Uuid* bta_sdp_search_uuid = (Uuid*)osi_malloc(sizeof(Uuid));
*bta_sdp_search_uuid = uuid;
if (!SDP_ServiceSearchAttributeRequest2(bd_addr, p_bta_sdp_cfg->p_sdp_db,
bta_sdp_search_cback,
(void*)bta_sdp_search_uuid)) {
bta_sdp_cb.sdp_active = false;
/* failed to start SDP. report the failure right away */
if (bta_sdp_cb.p_dm_cback) {
tBTA_SDP_SEARCH_COMP result;
memset(&result, 0, sizeof(result));
result.uuid = uuid;
result.remote_addr = bd_addr;
result.status = status;
tBTA_SDP bta_sdp;
bta_sdp.sdp_search_comp = result;
bta_sdp_cb.p_dm_cback(BTA_SDP_SEARCH_COMP_EVT, &bta_sdp, NULL);
}
}
/*
else report the result when the cback is called
*/
}
/*******************************************************************************
*
* Function bta_sdp_record
*
* Description Discovers all sdp records for an uuid on remote device
*
* Returns void
*
******************************************************************************/
void bta_sdp_create_record(void* user_data) {
if (bta_sdp_cb.p_dm_cback)
bta_sdp_cb.p_dm_cback(BTA_SDP_CREATE_RECORD_USER_EVT, NULL, user_data);
}
/*******************************************************************************
*
* Function bta_sdp_create_record
*
* Description Discovers all sdp records for an uuid on remote device
*
* Returns void
*
******************************************************************************/
void bta_sdp_remove_record(void* user_data) {
if (bta_sdp_cb.p_dm_cback)
bta_sdp_cb.p_dm_cback(BTA_SDP_REMOVE_RECORD_USER_EVT, NULL, user_data);
}
Reference in new issue View Git Blame Copy Permalink