1/****************************************************************************** 2 * 3 * Copyright (C) 1998-2012 Broadcom Corporation 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at: 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 ******************************************************************************/ 18 19#include <string.h> 20 21#include "bt_target.h" 22#if defined(HL_INCLUDED) && (HL_INCLUDED == TRUE) 23 24#include "sdp_api.h" 25#include "bta_hl_int.h" 26 27 28/******************************************************************************* 29** 30** Function bta_hl_fill_sup_feature_list 31** 32** Description Fill the supported features from teh SDP record 33** 34** Returns TRUE if found, FALSE if not 35** If found, the passed protocol list element is filled in. 36** 37*******************************************************************************/ 38BOOLEAN bta_hl_fill_sup_feature_list( const tSDP_DISC_ATTR *p_attr, 39 tBTA_HL_SUP_FEATURE_LIST_ELEM *p_list) 40{ 41 tSDP_DISC_ATTR *p_sattr; 42 UINT8 seq_len, item_cnt; 43 UINT8 list_cnt=0; 44 BOOLEAN status=TRUE; 45 46 for (p_attr = p_attr->attr_value.v.p_sub_attr; p_attr; p_attr = p_attr->p_next_attr) 47 { 48 /* mdep sequence */ 49 if (SDP_DISC_ATTR_TYPE(p_attr->attr_len_type) != DATA_ELE_SEQ_DESC_TYPE) 50 { 51 return(FALSE); 52 } 53 seq_len =SDP_DISC_ATTR_LEN(p_attr->attr_len_type); 54 item_cnt=0; 55 56 for (p_sattr = p_attr->attr_value.v.p_sub_attr; p_sattr && (item_cnt < 4) ; p_sattr = p_sattr->p_next_attr) 57 { 58 /* for each mdep list */ 59 60 p_list->list_elem[list_cnt].p_mdep_desp = NULL; 61 switch (item_cnt) 62 { 63 case 0: 64 p_list->list_elem[list_cnt].mdep_id = p_sattr->attr_value.v.u8; 65 break; 66 case 1: 67 p_list->list_elem[list_cnt].data_type = p_sattr->attr_value.v.u16; 68 break; 69 case 2: 70 p_list->list_elem[list_cnt].mdep_role = (tBTA_HL_MDEP_ROLE) p_sattr->attr_value.v.u8; 71 break; 72 case 3: 73 p_list->list_elem[list_cnt].p_mdep_desp = (char *) p_sattr->attr_value.v.array; 74 break; 75 } 76 77 item_cnt++; 78 } 79 list_cnt++; 80 } 81 p_list->num_elems = list_cnt; 82 return(status); 83} 84 85/******************************************************************************* 86** 87** Function bta_hl_compose_supported_feature_list 88** 89** Description This function is called to compose a data sequence from 90** the supported feature element list struct pointer 91** 92** Returns the length of the data sequence 93** 94*******************************************************************************/ 95int bta_hl_compose_supported_feature_list( UINT8 *p, UINT16 num_elem, 96 const tBTA_HL_SUP_FEATURE_ELEM *p_elem_list) 97{ 98 UINT16 xx, str_len, seq_len; 99 UINT8 *p_head = p; 100 101 for (xx = 0; xx < num_elem; xx++, p_elem_list++) 102 { 103 UINT8_TO_BE_STREAM (p, (DATA_ELE_SEQ_DESC_TYPE << 3) | SIZE_IN_NEXT_BYTE); 104 seq_len=7; 105 str_len=0; 106 if (p_elem_list->p_mdep_desp) 107 { 108 str_len = strlen(p_elem_list->p_mdep_desp)+1; 109 seq_len += str_len+2; /* todo add a # symbol for 2 */ 110 } 111 112 *p++ = (UINT8) seq_len; 113 114 UINT8_TO_BE_STREAM (p, (UINT_DESC_TYPE << 3) | SIZE_ONE_BYTE); 115 UINT8_TO_BE_STREAM (p, p_elem_list->mdep_id); 116 UINT8_TO_BE_STREAM (p, (UINT_DESC_TYPE << 3) | SIZE_TWO_BYTES); 117 UINT16_TO_BE_STREAM (p, p_elem_list->data_type); 118 UINT8_TO_BE_STREAM (p, (UINT_DESC_TYPE << 3) | SIZE_ONE_BYTE); 119 UINT8_TO_BE_STREAM (p, p_elem_list->mdep_role); 120 121 if (str_len) 122 { 123 UINT8_TO_BE_STREAM (p, (TEXT_STR_DESC_TYPE << 3) | SIZE_IN_NEXT_BYTE); 124 UINT8_TO_BE_STREAM (p, str_len); 125 ARRAY_TO_BE_STREAM(p, p_elem_list->p_mdep_desp, str_len); 126 } 127 } 128 129 return(p - p_head); 130} 131 132/******************************************************************************* 133** 134** Function bta_hl_add_sup_feature_list 135** 136** Description This function is called to add a protocol descriptor list to 137** a record. This would be through the SDP database maintenance API. 138** If the protocol list already exists in the record, it is replaced 139** with the new list. 140** 141** Returns TRUE if added OK, else FALSE 142** 143*******************************************************************************/ 144BOOLEAN bta_hl_add_sup_feature_list (UINT32 handle, UINT16 num_elem, 145 const tBTA_HL_SUP_FEATURE_ELEM *p_elem_list) 146{ 147 UINT8 *p_buf; 148 int offset; 149 BOOLEAN result = FALSE; 150 151 if ((p_buf = (UINT8 *)GKI_getbuf(BTA_HL_SUP_FEATURE_SDP_BUF_SIZE)) != NULL) 152 { 153 offset = bta_hl_compose_supported_feature_list(p_buf, num_elem, p_elem_list); 154 result = SDP_AddAttribute (handle, ATTR_ID_HDP_SUP_FEAT_LIST, 155 DATA_ELE_SEQ_DESC_TYPE, (UINT32) offset, p_buf); 156 GKI_freebuf(p_buf); 157 } 158 return result; 159} 160/***************************************************************************** 161** 162** Function: bta_hl_sdp_register 163** 164** Purpose: Register an HDP application with SDP 165** 166** Parameters: p_cb - Pointer to MA instance control block 167** p_service_name - MA server name 168** inst_id - MAS instance ID 169** msg_type - Supported message type(s) 170** 171** 172** Returns: void 173** 174*****************************************************************************/ 175tBTA_HL_STATUS bta_hl_sdp_register (UINT8 app_idx) 176{ 177 UINT16 svc_class_id_list[BTA_HL_NUM_SVC_ELEMS]; 178 tSDP_PROTOCOL_ELEM proto_elem_list[BTA_HL_NUM_PROTO_ELEMS]; 179 tSDP_PROTO_LIST_ELEM add_proto_list; 180 tBTA_HL_SUP_FEATURE_LIST_ELEM sup_feature_list; 181 UINT16 browse_list[] = {UUID_SERVCLASS_PUBLIC_BROWSE_GROUP}; 182 UINT8 i,j, cnt,mdep_id, mdep_role; 183 UINT8 data_exchange_spec = BTA_HL_SDP_IEEE_11073_20601; 184 UINT8 mcap_sup_proc = BTA_HL_MCAP_SUP_PROC_MASK; 185 UINT16 profile_uuid = UUID_SERVCLASS_HDP_PROFILE; 186 UINT16 version = BTA_HL_VERSION_01_00; 187 UINT8 num_services=1; 188 tBTA_HL_APP_CB *p_cb = BTA_HL_GET_APP_CB_PTR(app_idx); 189 BOOLEAN result = TRUE; 190 tBTA_HL_STATUS status = BTA_HL_STATUS_OK; 191 192#if BTA_HL_DEBUG == TRUE 193 APPL_TRACE_DEBUG1("bta_hl_sdp_register app_idx=%d",app_idx); 194#endif 195 196 if ((p_cb->sup_feature.app_role_mask == BTA_HL_MDEP_ROLE_MASK_SOURCE) && 197 (!p_cb->sup_feature.advertize_source_sdp)) 198 { 199 return BTA_HL_STATUS_OK; 200 } 201 202 if ((p_cb->sdp_handle = SDP_CreateRecord()) == 0) 203 { 204 return BTA_HL_STATUS_SDP_NO_RESOURCE; 205 } 206 207 num_services=1; 208 svc_class_id_list[0]= UUID_SERVCLASS_HDP_SOURCE; 209 if (p_cb->sup_feature.app_role_mask == BTA_HL_MDEP_ROLE_MASK_SINK) 210 { 211 svc_class_id_list[0]= UUID_SERVCLASS_HDP_SINK; 212 } 213 else 214 { 215 if (p_cb->sup_feature.app_role_mask != BTA_HL_MDEP_ROLE_MASK_SOURCE) 216 { 217 /* dual role */ 218 num_services=2; 219 svc_class_id_list[1]= UUID_SERVCLASS_HDP_SINK; 220 } 221 } 222 result &= SDP_AddServiceClassIdList(p_cb->sdp_handle, num_services, svc_class_id_list); 223 224 if (result) 225 { 226 /* add the protocol element sequence */ 227 proto_elem_list[0].protocol_uuid = UUID_PROTOCOL_L2CAP; 228 proto_elem_list[0].num_params = 1; 229 proto_elem_list[0].params[0] = p_cb->ctrl_psm; 230 proto_elem_list[1].protocol_uuid = UUID_PROTOCOL_MCAP_CTRL; 231 proto_elem_list[1].num_params = 1; 232 proto_elem_list[1].params[0] = version; 233 result &= SDP_AddProtocolList(p_cb->sdp_handle, BTA_HL_NUM_PROTO_ELEMS, proto_elem_list); 234 235 result &= SDP_AddProfileDescriptorList(p_cb->sdp_handle, profile_uuid, version); 236 } 237 238 if (result) 239 { 240 add_proto_list.num_elems = BTA_HL_NUM_ADD_PROTO_ELEMS; 241 add_proto_list.list_elem[0].protocol_uuid = UUID_PROTOCOL_L2CAP; 242 add_proto_list.list_elem[0].num_params = 1; 243 add_proto_list.list_elem[0].params[0] = p_cb->data_psm; 244 add_proto_list.list_elem[1].protocol_uuid = UUID_PROTOCOL_MCAP_DATA; 245 add_proto_list.list_elem[1].num_params = 0; 246 result &= SDP_AddAdditionProtoLists(p_cb->sdp_handle, BTA_HL_NUM_ADD_PROTO_LISTS, 247 (tSDP_PROTO_LIST_ELEM *)&add_proto_list); 248 } 249 250 if (result) 251 { 252 if (p_cb->srv_name[0] ) 253 { 254 result &= SDP_AddAttribute(p_cb->sdp_handle, 255 (UINT16)ATTR_ID_SERVICE_NAME, 256 (UINT8)TEXT_STR_DESC_TYPE, 257 (UINT32)(strlen(p_cb->srv_name) + 1), 258 (UINT8 *)p_cb->srv_name); 259 } /* end of setting optional service name */ 260 } 261 262 if (result) 263 { 264 if (p_cb->srv_desp[0] ) 265 { 266 result &= SDP_AddAttribute(p_cb->sdp_handle, 267 (UINT16)ATTR_ID_SERVICE_DESCRIPTION, 268 (UINT8)TEXT_STR_DESC_TYPE, 269 (UINT32)(strlen(p_cb->srv_desp) + 1), 270 (UINT8 *)p_cb->srv_desp); 271 272 } /* end of setting optional service description */ 273 274 } 275 276 if (result) 277 { 278 if (p_cb->provider_name[0] ) 279 { 280 result &= SDP_AddAttribute(p_cb->sdp_handle, 281 (UINT16)ATTR_ID_PROVIDER_NAME, 282 (UINT8)TEXT_STR_DESC_TYPE, 283 (UINT32)(strlen(p_cb->provider_name) + 1), 284 (UINT8 *)p_cb->provider_name); 285 } /* end of setting optional provider name */ 286 } 287 288 /* add supported feture list */ 289 290 if (result) 291 { 292 cnt=0; 293 for (i=1; i<= p_cb->sup_feature.num_of_mdeps; i++) 294 { 295 mdep_id = (UINT8)p_cb->sup_feature.mdep[i].mdep_id; 296 mdep_role = (UINT8)p_cb->sup_feature.mdep[i].mdep_cfg.mdep_role; 297 298 for (j=0; j<p_cb->sup_feature.mdep[i].mdep_cfg.num_of_mdep_data_types; j++) 299 { 300 sup_feature_list.list_elem[cnt].mdep_id = mdep_id; 301 sup_feature_list.list_elem[cnt].mdep_role = mdep_role; 302 sup_feature_list.list_elem[cnt].data_type = p_cb->sup_feature.mdep[i].mdep_cfg.data_cfg[j].data_type; 303 if (p_cb->sup_feature.mdep[i].mdep_cfg.data_cfg[j].desp[0] != '\0') 304 { 305 sup_feature_list.list_elem[cnt].p_mdep_desp = p_cb->sup_feature.mdep[i].mdep_cfg.data_cfg[j].desp; 306 } 307 else 308 { 309 sup_feature_list.list_elem[cnt].p_mdep_desp = NULL; 310 } 311 312 cnt++; 313 if (cnt>BTA_HL_NUM_SUP_FEATURE_ELEMS) 314 { 315 result = FALSE; 316 break; 317 } 318 } 319 } 320 sup_feature_list.num_elems = cnt; 321 result &= bta_hl_add_sup_feature_list (p_cb->sdp_handle, 322 sup_feature_list.num_elems, 323 sup_feature_list.list_elem); 324 } 325 if (result) 326 { 327 result &= SDP_AddAttribute(p_cb->sdp_handle, ATTR_ID_HDP_DATA_EXCH_SPEC, UINT_DESC_TYPE, 328 (UINT32)1, (UINT8*)&data_exchange_spec); 329 } 330 331 if (result) 332 { 333 334 result &= SDP_AddAttribute(p_cb->sdp_handle, ATTR_ID_HDP_MCAP_SUP_PROC, UINT_DESC_TYPE, 335 (UINT32)1, (UINT8*)&mcap_sup_proc); 336 } 337 338 if (result) 339 { 340 result &= SDP_AddUuidSequence(p_cb->sdp_handle, ATTR_ID_BROWSE_GROUP_LIST, 1, browse_list); 341 } 342 343 if (result) 344 { 345 for(i=0; i < num_services; i++) 346 { 347 bta_sys_add_uuid(svc_class_id_list[i]); 348 APPL_TRACE_DEBUG2("dbg bta_sys_add_uuid i=%d uuid=0x%x", i, svc_class_id_list[i]); //todo 349 } 350 } 351 else 352 { 353 if (p_cb->sdp_handle) 354 { 355 SDP_DeleteRecord(p_cb->sdp_handle); 356 p_cb->sdp_handle = 0; 357 } 358 status = BTA_HL_STATUS_SDP_FAIL; 359 } 360#if BTA_HL_DEBUG == TRUE 361 APPL_TRACE_DEBUG1("bta_hl_sdp_register status=%s", bta_hl_status_code(status)); 362#endif 363 return status; 364} 365 366/******************************************************************************* 367** 368** Function bta_hl_find_sink_or_src_srv_class_in_db 369** 370** Description This function queries an SDP database for either a HDP Sink or 371** Source service class ID. 372** If the p_start_rec pointer is NULL, it looks from the beginning 373** of the database, else it continues from the next record after 374** p_start_rec. 375** 376** Returns Pointer to record containing service class, or NULL 377** 378*******************************************************************************/ 379tSDP_DISC_REC *bta_hl_find_sink_or_src_srv_class_in_db (const tSDP_DISCOVERY_DB *p_db, 380 const tSDP_DISC_REC *p_start_rec) 381{ 382#if SDP_CLIENT_ENABLED == TRUE 383 tSDP_DISC_REC *p_rec; 384 tSDP_DISC_ATTR *p_attr, *p_sattr; 385 386 /* Must have a valid database */ 387 if (p_db == NULL) 388 return(NULL); 389 390 391 if (!p_start_rec) 392 { 393 394 p_rec = p_db->p_first_rec; 395 } 396 else 397 { 398 p_rec = p_start_rec->p_next_rec; 399 } 400 401 while (p_rec) 402 { 403 p_attr = p_rec->p_first_attr; 404 while (p_attr) 405 { 406 if ((p_attr->attr_id == ATTR_ID_SERVICE_CLASS_ID_LIST) 407 && (SDP_DISC_ATTR_TYPE(p_attr->attr_len_type) == DATA_ELE_SEQ_DESC_TYPE)) 408 { 409 for (p_sattr = p_attr->attr_value.v.p_sub_attr; p_sattr; p_sattr = p_sattr->p_next_attr) 410 { 411 if ((SDP_DISC_ATTR_TYPE(p_sattr->attr_len_type) == UUID_DESC_TYPE) 412 && (SDP_DISC_ATTR_LEN(p_sattr->attr_len_type) == 2) 413 && ( (p_sattr->attr_value.v.u16 == UUID_SERVCLASS_HDP_SINK) || 414 (p_sattr->attr_value.v.u16 == UUID_SERVCLASS_HDP_SOURCE)) ) 415 { 416 return(p_rec); 417 } 418 } 419 break; 420 } 421 422 p_attr = p_attr->p_next_attr; 423 } 424 425 p_rec = p_rec->p_next_rec; 426 } 427#endif 428 /* If here, no matching UUID found */ 429 430#if BTA_HL_DEBUG == TRUE 431 APPL_TRACE_DEBUG0("bta_hl_find_sink_or_src_srv_class_in_db failed"); 432#endif 433 434 return(NULL); 435} 436#endif /* HL_INCLUDED */ 437