bta/sdp/bta_sdp_act.cc - platform/system/bt - Git at Google

 /******************************************************************************
  *
  *  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 <arpa/inet.h>
 #include <hardware/bluetooth.h>
 #include <hardware/bt_sdp.h>
 #include <stdlib.h>
 #include <string.h>

 #include "bt_common.h"
 #include "bt_types.h"
 #include "bta_api.h"
 #include "bta_sdp_api.h"
 #include "bta_sdp_int.h"
 #include "bta_sys.h"
 #include "btm_api.h"
 #include "btm_int.h"
 #include "osi/include/allocator.h"
 #include "sdp_api.h"
 #include "utl.h"

 /*****************************************************************************
  *  Constants
  ****************************************************************************/

 static const Uuid UUID_OBEX_OBJECT_PUSH = Uuid::From16Bit(0x1105);
 static const Uuid UUID_PBAP_PSE = Uuid::From16Bit(0x112F);
 static const Uuid UUID_MAP_MAS = Uuid::From16Bit(0x1132);
 static const Uuid UUID_MAP_MNS = Uuid::From16Bit(0x1133);
 static const Uuid UUID_SAP = Uuid::From16Bit(0x112D);

 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_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(uint16_t 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 = BTA_SDP_ACTIVE_NONE;

   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 {
         /* 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_MSG* p_data) {
   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_data->enable.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(tBTA_SDP_MSG* p_data) {
   if (p_data == NULL) {
     APPL_TRACE_DEBUG("SDP control block handle is null");
     return;
   }
   tBTA_SDP_STATUS status = BTA_SDP_FAILURE;

   APPL_TRACE_DEBUG("%s in, sdp_active:%d", __func__, bta_sdp_cb.sdp_active);

   const Uuid& uuid = p_data->get_search.uuid;
   if (bta_sdp_cb.sdp_active != BTA_SDP_ACTIVE_NONE) {
     /* 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 = p_data->get_search.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 = BTA_SDP_ACTIVE_YES;
   bta_sdp_cb.remote_addr = p_data->get_search.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(
           p_data->get_search.bd_addr, p_bta_sdp_cfg->p_sdp_db,
           bta_sdp_search_cback, (void*)bta_sdp_search_uuid)) {
     bta_sdp_cb.sdp_active = BTA_SDP_ACTIVE_NONE;

     /* 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 = p_data->get_search.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(tBTA_SDP_MSG* p_data) {
   APPL_TRACE_DEBUG("%s() event: %d", __func__, p_data->record.hdr.event);
   if (bta_sdp_cb.p_dm_cback)
     bta_sdp_cb.p_dm_cback(BTA_SDP_CREATE_RECORD_USER_EVT, NULL,
                           p_data->record.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(tBTA_SDP_MSG* p_data) {
   APPL_TRACE_DEBUG("%s() event: %d", __func__, p_data->record.hdr.event);
   if (bta_sdp_cb.p_dm_cback)
     bta_sdp_cb.p_dm_cback(BTA_SDP_REMOVE_RECORD_USER_EVT, NULL,
                           p_data->record.user_data);
 }
	/******************************************************************************
	*
	* 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 <arpa/inet.h>
	#include <hardware/bluetooth.h>
	#include <hardware/bt_sdp.h>
	#include <stdlib.h>
	#include <string.h>

	#include "bt_common.h"
	#include "bt_types.h"
	#include "bta_api.h"
	#include "bta_sdp_api.h"
	#include "bta_sdp_int.h"
	#include "bta_sys.h"
	#include "btm_api.h"
	#include "btm_int.h"
	#include "osi/include/allocator.h"
	#include "sdp_api.h"
	#include "utl.h"

	/*****************************************************************************
	* Constants
	****************************************************************************/

	static const Uuid UUID_OBEX_OBJECT_PUSH = Uuid::From16Bit(0x1105);
	static const Uuid UUID_PBAP_PSE = Uuid::From16Bit(0x112F);
	static const Uuid UUID_MAP_MAS = Uuid::From16Bit(0x1132);
	static const Uuid UUID_MAP_MNS = Uuid::From16Bit(0x1133);
	static const Uuid UUID_SAP = Uuid::From16Bit(0x112D);

	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_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(uint16_t 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 = BTA_SDP_ACTIVE_NONE;

	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 {
	/* 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_MSG* p_data) {
	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_data->enable.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(tBTA_SDP_MSG* p_data) {
	if (p_data == NULL) {
	APPL_TRACE_DEBUG("SDP control block handle is null");
	return;
	}
	tBTA_SDP_STATUS status = BTA_SDP_FAILURE;

	APPL_TRACE_DEBUG("%s in, sdp_active:%d", __func__, bta_sdp_cb.sdp_active);

	const Uuid& uuid = p_data->get_search.uuid;
	if (bta_sdp_cb.sdp_active != BTA_SDP_ACTIVE_NONE) {
	/* 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 = p_data->get_search.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 = BTA_SDP_ACTIVE_YES;
	bta_sdp_cb.remote_addr = p_data->get_search.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(
	p_data->get_search.bd_addr, p_bta_sdp_cfg->p_sdp_db,
	bta_sdp_search_cback, (void*)bta_sdp_search_uuid)) {
	bta_sdp_cb.sdp_active = BTA_SDP_ACTIVE_NONE;

	/* 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 = p_data->get_search.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(tBTA_SDP_MSG* p_data) {
	APPL_TRACE_DEBUG("%s() event: %d", __func__, p_data->record.hdr.event);
	if (bta_sdp_cb.p_dm_cback)
	bta_sdp_cb.p_dm_cback(BTA_SDP_CREATE_RECORD_USER_EVT, NULL,
	p_data->record.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(tBTA_SDP_MSG* p_data) {
	APPL_TRACE_DEBUG("%s() event: %d", __func__, p_data->record.hdr.event);
	if (bta_sdp_cb.p_dm_cback)
	bta_sdp_cb.p_dm_cback(BTA_SDP_REMOVE_RECORD_USER_EVT, NULL,
	p_data->record.user_data);
	}