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 #include "utl.h" 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 *******************************************************************************/ 38 BOOLEAN 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 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 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 *******************************************************************************/ 95 int 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 *******************************************************************************/ 144 BOOLEAN bta_hl_add_sup_feature_list (UINT32 handle, UINT16 num_elem, 145 const tBTA_HL_SUP_FEATURE_ELEM *p_elem_list) 146 { 147 int offset; 148 BOOLEAN result; 149 UINT8 *p_buf = (UINT8 *)osi_malloc(BTA_HL_SUP_FEATURE_SDP_BUF_SIZE); 150 151 offset = bta_hl_compose_supported_feature_list(p_buf, num_elem, 152 p_elem_list); 153 result = SDP_AddAttribute(handle, ATTR_ID_HDP_SUP_FEAT_LIST, 154 DATA_ELE_SEQ_DESC_TYPE, (UINT32) offset, p_buf); 155 osi_free(p_buf); 156 157 return result; 158 } 159 160 /***************************************************************************** 161 ** 162 ** Function: bta_hl_sdp_update 163 ** 164 ** Purpose: Register an HDP application with SDP 165 ** 166 ** Parameters: 167 ** 168 ** Returns: void 169 ** 170 *****************************************************************************/ 171 tBTA_HL_STATUS bta_hl_sdp_update (UINT8 app_id) 172 { 173 UINT16 svc_class_id_list[BTA_HL_NUM_SVC_ELEMS]; 174 tSDP_PROTOCOL_ELEM proto_elem_list[BTA_HL_NUM_PROTO_ELEMS]; 175 tSDP_PROTO_LIST_ELEM add_proto_list; 176 tBTA_HL_SUP_FEATURE_LIST_ELEM sup_feature_list; 177 UINT16 browse_list[] = {UUID_SERVCLASS_PUBLIC_BROWSE_GROUP}; 178 UINT8 i,j, cnt,mdep_id, mdep_role; 179 UINT8 data_exchange_spec = BTA_HL_SDP_IEEE_11073_20601; 180 UINT8 mcap_sup_proc = BTA_HL_MCAP_SUP_PROC_MASK; 181 UINT16 profile_uuid = UUID_SERVCLASS_HDP_PROFILE; 182 UINT16 version = BTA_HL_VERSION; 183 UINT8 num_services=1; 184 tBTA_HL_APP_CB *p_cb = BTA_HL_GET_APP_CB_PTR(0); 185 BOOLEAN result = TRUE; 186 tBTA_HL_STATUS status = BTA_HL_STATUS_OK; 187 UNUSED(app_id); 188 189 if ((p_cb->sup_feature.app_role_mask == BTA_HL_MDEP_ROLE_MASK_SOURCE) && 190 (!p_cb->sup_feature.advertize_source_sdp)) 191 { 192 return BTA_HL_STATUS_OK; 193 } 194 195 num_services=1; 196 svc_class_id_list[0]= UUID_SERVCLASS_HDP_SOURCE; 197 if (p_cb->sup_feature.app_role_mask == BTA_HL_MDEP_ROLE_MASK_SINK) 198 { 199 svc_class_id_list[0]= UUID_SERVCLASS_HDP_SINK; 200 } 201 else 202 { 203 if (p_cb->sup_feature.app_role_mask != BTA_HL_MDEP_ROLE_MASK_SOURCE) 204 { 205 /* dual role */ 206 num_services=2; 207 svc_class_id_list[1]= UUID_SERVCLASS_HDP_SINK; 208 } 209 } 210 result &= SDP_AddServiceClassIdList(p_cb->sdp_handle, num_services, svc_class_id_list); 211 212 if (result) 213 { 214 /* add the protocol element sequence */ 215 proto_elem_list[0].protocol_uuid = UUID_PROTOCOL_L2CAP; 216 proto_elem_list[0].num_params = 1; 217 proto_elem_list[0].params[0] = p_cb->ctrl_psm; 218 proto_elem_list[1].protocol_uuid = UUID_PROTOCOL_MCAP_CTRL; 219 proto_elem_list[1].num_params = 1; 220 proto_elem_list[1].params[0] = version; 221 result &= SDP_AddProtocolList(p_cb->sdp_handle, BTA_HL_NUM_PROTO_ELEMS, proto_elem_list); 222 223 result &= SDP_AddProfileDescriptorList(p_cb->sdp_handle, profile_uuid, version); 224 } 225 226 if (result) 227 { 228 add_proto_list.num_elems = BTA_HL_NUM_ADD_PROTO_ELEMS; 229 add_proto_list.list_elem[0].protocol_uuid = UUID_PROTOCOL_L2CAP; 230 add_proto_list.list_elem[0].num_params = 1; 231 add_proto_list.list_elem[0].params[0] = p_cb->data_psm; 232 add_proto_list.list_elem[1].protocol_uuid = UUID_PROTOCOL_MCAP_DATA; 233 add_proto_list.list_elem[1].num_params = 0; 234 result &= SDP_AddAdditionProtoLists(p_cb->sdp_handle, BTA_HL_NUM_ADD_PROTO_LISTS, 235 (tSDP_PROTO_LIST_ELEM *)&add_proto_list); 236 } 237 238 if (result) 239 { 240 if (p_cb->srv_name[0] ) 241 { 242 result &= SDP_AddAttribute(p_cb->sdp_handle, 243 (UINT16)ATTR_ID_SERVICE_NAME, 244 (UINT8)TEXT_STR_DESC_TYPE, 245 (UINT32)(strlen(p_cb->srv_name) + 1), 246 (UINT8 *)p_cb->srv_name); 247 } /* end of setting optional service name */ 248 } 249 250 if (result) 251 { 252 if (p_cb->srv_desp[0] ) 253 { 254 result &= SDP_AddAttribute(p_cb->sdp_handle, 255 (UINT16)ATTR_ID_SERVICE_DESCRIPTION, 256 (UINT8)TEXT_STR_DESC_TYPE, 257 (UINT32)(strlen(p_cb->srv_desp) + 1), 258 (UINT8 *)p_cb->srv_desp); 259 260 } /* end of setting optional service description */ 261 262 } 263 264 if (result) 265 { 266 if (p_cb->provider_name[0] ) 267 { 268 result &= SDP_AddAttribute(p_cb->sdp_handle, 269 (UINT16)ATTR_ID_PROVIDER_NAME, 270 (UINT8)TEXT_STR_DESC_TYPE, 271 (UINT32)(strlen(p_cb->provider_name) + 1), 272 (UINT8 *)p_cb->provider_name); 273 } /* end of setting optional provider name */ 274 } 275 276 /* add supported feture list */ 277 278 if (result) 279 { 280 cnt=0; 281 for (i=1; i< BTA_HL_NUM_MDEPS; i++) 282 { 283 if (p_cb->sup_feature.mdep[i].mdep_id) 284 { 285 mdep_id = (UINT8)p_cb->sup_feature.mdep[i].mdep_id; 286 mdep_role = (UINT8)p_cb->sup_feature.mdep[i].mdep_cfg.mdep_role; 287 288 APPL_TRACE_DEBUG("num_of_mdep_data_types %d ", p_cb->sup_feature.mdep[i].mdep_cfg.num_of_mdep_data_types); 289 for (j=0; j<p_cb->sup_feature.mdep[i].mdep_cfg.num_of_mdep_data_types; j++) 290 { 291 sup_feature_list.list_elem[cnt].mdep_id = mdep_id; 292 sup_feature_list.list_elem[cnt].mdep_role = mdep_role; 293 sup_feature_list.list_elem[cnt].data_type = p_cb->sup_feature.mdep[i].mdep_cfg.data_cfg[j].data_type; 294 if (p_cb->sup_feature.mdep[i].mdep_cfg.data_cfg[j].desp[0] != '\0') 295 { 296 sup_feature_list.list_elem[cnt].p_mdep_desp = p_cb->sup_feature.mdep[i].mdep_cfg.data_cfg[j].desp; 297 } 298 else 299 { 300 sup_feature_list.list_elem[cnt].p_mdep_desp = NULL; 301 } 302 303 cnt++; 304 if (cnt==BTA_HL_NUM_SUP_FEATURE_ELEMS) 305 { 306 result = FALSE; 307 break; 308 } 309 } 310 } 311 } 312 sup_feature_list.num_elems = cnt; 313 result &= bta_hl_add_sup_feature_list (p_cb->sdp_handle, 314 sup_feature_list.num_elems, 315 sup_feature_list.list_elem); 316 } 317 if (result) 318 { 319 result &= SDP_AddAttribute(p_cb->sdp_handle, ATTR_ID_HDP_DATA_EXCH_SPEC, UINT_DESC_TYPE, 320 (UINT32)1, (UINT8*)&data_exchange_spec); 321 } 322 323 if (result) 324 { 325 326 result &= SDP_AddAttribute(p_cb->sdp_handle, ATTR_ID_HDP_MCAP_SUP_PROC, UINT_DESC_TYPE, 327 (UINT32)1, (UINT8*)&mcap_sup_proc); 328 } 329 330 if (result) 331 { 332 result &= SDP_AddUuidSequence(p_cb->sdp_handle, ATTR_ID_BROWSE_GROUP_LIST, 1, browse_list); 333 } 334 335 if (result) 336 { 337 for(i=0; i < num_services; i++) 338 { 339 bta_sys_add_uuid(svc_class_id_list[i]); 340 APPL_TRACE_DEBUG("dbg bta_sys_add_uuid i=%d uuid=0x%x", i, svc_class_id_list[i]); //todo 341 } 342 } 343 else 344 { 345 if (p_cb->sdp_handle) 346 { 347 SDP_DeleteRecord(p_cb->sdp_handle); 348 p_cb->sdp_handle = 0; 349 } 350 status = BTA_HL_STATUS_SDP_FAIL; 351 } 352 #if BTA_HL_DEBUG == TRUE 353 APPL_TRACE_DEBUG("bta_hl_sdp_update status=%s", bta_hl_status_code(status)); 354 #endif 355 return status; 356 } 357 358 359 /***************************************************************************** 360 ** 361 ** Function: bta_hl_sdp_register 362 ** 363 ** Purpose: Register an HDP application with SDP 364 ** 365 ** Parameters: p_cb - Pointer to MA instance control block 366 ** p_service_name - MA server name 367 ** inst_id - MAS instance ID 368 ** msg_type - Supported message type(s) 369 ** 370 ** 371 ** Returns: void 372 ** 373 *****************************************************************************/ 374 tBTA_HL_STATUS bta_hl_sdp_register (UINT8 app_idx) 375 { 376 UINT16 svc_class_id_list[BTA_HL_NUM_SVC_ELEMS]; 377 tSDP_PROTOCOL_ELEM proto_elem_list[BTA_HL_NUM_PROTO_ELEMS]; 378 tSDP_PROTO_LIST_ELEM add_proto_list; 379 tBTA_HL_SUP_FEATURE_LIST_ELEM sup_feature_list; 380 UINT16 browse_list[] = {UUID_SERVCLASS_PUBLIC_BROWSE_GROUP}; 381 UINT8 i,j, cnt,mdep_id, mdep_role; 382 UINT8 data_exchange_spec = BTA_HL_SDP_IEEE_11073_20601; 383 UINT8 mcap_sup_proc = BTA_HL_MCAP_SUP_PROC_MASK; 384 UINT16 profile_uuid = UUID_SERVCLASS_HDP_PROFILE; 385 UINT16 version = BTA_HL_VERSION; 386 UINT8 num_services=1; 387 tBTA_HL_APP_CB *p_cb = BTA_HL_GET_APP_CB_PTR(app_idx); 388 BOOLEAN result = TRUE; 389 tBTA_HL_STATUS status = BTA_HL_STATUS_OK; 390 391 #if BTA_HL_DEBUG == TRUE 392 APPL_TRACE_DEBUG("bta_hl_sdp_register app_idx=%d",app_idx); 393 #endif 394 395 if ((p_cb->sup_feature.app_role_mask == BTA_HL_MDEP_ROLE_MASK_SOURCE) && 396 (!p_cb->sup_feature.advertize_source_sdp)) 397 { 398 return BTA_HL_STATUS_OK; 399 } 400 401 if ((p_cb->sdp_handle = SDP_CreateRecord()) == 0) 402 { 403 return BTA_HL_STATUS_SDP_NO_RESOURCE; 404 } 405 406 num_services=1; 407 svc_class_id_list[0]= UUID_SERVCLASS_HDP_SOURCE; 408 if (p_cb->sup_feature.app_role_mask == BTA_HL_MDEP_ROLE_MASK_SINK) 409 { 410 svc_class_id_list[0]= UUID_SERVCLASS_HDP_SINK; 411 } 412 else 413 { 414 if (p_cb->sup_feature.app_role_mask != BTA_HL_MDEP_ROLE_MASK_SOURCE) 415 { 416 /* dual role */ 417 num_services=2; 418 svc_class_id_list[1]= UUID_SERVCLASS_HDP_SINK; 419 } 420 } 421 result &= SDP_AddServiceClassIdList(p_cb->sdp_handle, num_services, svc_class_id_list); 422 423 if (result) 424 { 425 /* add the protocol element sequence */ 426 proto_elem_list[0].protocol_uuid = UUID_PROTOCOL_L2CAP; 427 proto_elem_list[0].num_params = 1; 428 proto_elem_list[0].params[0] = p_cb->ctrl_psm; 429 proto_elem_list[1].protocol_uuid = UUID_PROTOCOL_MCAP_CTRL; 430 proto_elem_list[1].num_params = 1; 431 proto_elem_list[1].params[0] = version; 432 result &= SDP_AddProtocolList(p_cb->sdp_handle, BTA_HL_NUM_PROTO_ELEMS, proto_elem_list); 433 434 result &= SDP_AddProfileDescriptorList(p_cb->sdp_handle, profile_uuid, version); 435 } 436 437 if (result) 438 { 439 add_proto_list.num_elems = BTA_HL_NUM_ADD_PROTO_ELEMS; 440 add_proto_list.list_elem[0].protocol_uuid = UUID_PROTOCOL_L2CAP; 441 add_proto_list.list_elem[0].num_params = 1; 442 add_proto_list.list_elem[0].params[0] = p_cb->data_psm; 443 add_proto_list.list_elem[1].protocol_uuid = UUID_PROTOCOL_MCAP_DATA; 444 add_proto_list.list_elem[1].num_params = 0; 445 result &= SDP_AddAdditionProtoLists(p_cb->sdp_handle, BTA_HL_NUM_ADD_PROTO_LISTS, 446 (tSDP_PROTO_LIST_ELEM *)&add_proto_list); 447 } 448 449 if (result) 450 { 451 if (p_cb->srv_name[0] ) 452 { 453 result &= SDP_AddAttribute(p_cb->sdp_handle, 454 (UINT16)ATTR_ID_SERVICE_NAME, 455 (UINT8)TEXT_STR_DESC_TYPE, 456 (UINT32)(strlen(p_cb->srv_name) + 1), 457 (UINT8 *)p_cb->srv_name); 458 } /* end of setting optional service name */ 459 } 460 461 if (result) 462 { 463 if (p_cb->srv_desp[0] ) 464 { 465 result &= SDP_AddAttribute(p_cb->sdp_handle, 466 (UINT16)ATTR_ID_SERVICE_DESCRIPTION, 467 (UINT8)TEXT_STR_DESC_TYPE, 468 (UINT32)(strlen(p_cb->srv_desp) + 1), 469 (UINT8 *)p_cb->srv_desp); 470 471 } /* end of setting optional service description */ 472 473 } 474 475 if (result) 476 { 477 if (p_cb->provider_name[0] ) 478 { 479 result &= SDP_AddAttribute(p_cb->sdp_handle, 480 (UINT16)ATTR_ID_PROVIDER_NAME, 481 (UINT8)TEXT_STR_DESC_TYPE, 482 (UINT32)(strlen(p_cb->provider_name) + 1), 483 (UINT8 *)p_cb->provider_name); 484 } /* end of setting optional provider name */ 485 } 486 487 /* add supported feture list */ 488 489 if (result) 490 { 491 cnt=0; 492 for (i=1; i<= p_cb->sup_feature.num_of_mdeps; i++) 493 { 494 mdep_id = (UINT8)p_cb->sup_feature.mdep[i].mdep_id; 495 mdep_role = (UINT8)p_cb->sup_feature.mdep[i].mdep_cfg.mdep_role; 496 497 for (j=0; j<p_cb->sup_feature.mdep[i].mdep_cfg.num_of_mdep_data_types; j++) 498 { 499 sup_feature_list.list_elem[cnt].mdep_id = mdep_id; 500 sup_feature_list.list_elem[cnt].mdep_role = mdep_role; 501 sup_feature_list.list_elem[cnt].data_type = p_cb->sup_feature.mdep[i].mdep_cfg.data_cfg[j].data_type; 502 if (p_cb->sup_feature.mdep[i].mdep_cfg.data_cfg[j].desp[0] != '\0') 503 { 504 sup_feature_list.list_elem[cnt].p_mdep_desp = p_cb->sup_feature.mdep[i].mdep_cfg.data_cfg[j].desp; 505 } 506 else 507 { 508 sup_feature_list.list_elem[cnt].p_mdep_desp = NULL; 509 } 510 511 cnt++; 512 if (cnt==BTA_HL_NUM_SUP_FEATURE_ELEMS) 513 { 514 result = FALSE; 515 break; 516 } 517 } 518 } 519 sup_feature_list.num_elems = cnt; 520 result &= bta_hl_add_sup_feature_list (p_cb->sdp_handle, 521 sup_feature_list.num_elems, 522 sup_feature_list.list_elem); 523 } 524 if (result) 525 { 526 result &= SDP_AddAttribute(p_cb->sdp_handle, ATTR_ID_HDP_DATA_EXCH_SPEC, UINT_DESC_TYPE, 527 (UINT32)1, (UINT8*)&data_exchange_spec); 528 } 529 530 if (result) 531 { 532 533 result &= SDP_AddAttribute(p_cb->sdp_handle, ATTR_ID_HDP_MCAP_SUP_PROC, UINT_DESC_TYPE, 534 (UINT32)1, (UINT8*)&mcap_sup_proc); 535 } 536 537 if (result) 538 { 539 result &= SDP_AddUuidSequence(p_cb->sdp_handle, ATTR_ID_BROWSE_GROUP_LIST, 1, browse_list); 540 } 541 542 if (result) 543 { 544 for(i=0; i < num_services; i++) 545 { 546 bta_sys_add_uuid(svc_class_id_list[i]); 547 APPL_TRACE_DEBUG("dbg bta_sys_add_uuid i=%d uuid=0x%x", i, svc_class_id_list[i]); //todo 548 } 549 } 550 else 551 { 552 if (p_cb->sdp_handle) 553 { 554 SDP_DeleteRecord(p_cb->sdp_handle); 555 p_cb->sdp_handle = 0; 556 } 557 status = BTA_HL_STATUS_SDP_FAIL; 558 } 559 #if BTA_HL_DEBUG == TRUE 560 APPL_TRACE_DEBUG("bta_hl_sdp_register status=%s", bta_hl_status_code(status)); 561 #endif 562 return status; 563 } 564 565 /******************************************************************************* 566 ** 567 ** Function bta_hl_find_sink_or_src_srv_class_in_db 568 ** 569 ** Description This function queries an SDP database for either a HDP Sink or 570 ** Source service class ID. 571 ** If the p_start_rec pointer is NULL, it looks from the beginning 572 ** of the database, else it continues from the next record after 573 ** p_start_rec. 574 ** 575 ** Returns Pointer to record containing service class, or NULL 576 ** 577 *******************************************************************************/ 578 tSDP_DISC_REC *bta_hl_find_sink_or_src_srv_class_in_db (const tSDP_DISCOVERY_DB *p_db, 579 const tSDP_DISC_REC *p_start_rec) 580 { 581 #if SDP_CLIENT_ENABLED == TRUE 582 tSDP_DISC_REC *p_rec; 583 tSDP_DISC_ATTR *p_attr, *p_sattr; 584 585 /* Must have a valid database */ 586 if (p_db == NULL) 587 return(NULL); 588 589 590 if (!p_start_rec) 591 { 592 593 p_rec = p_db->p_first_rec; 594 } 595 else 596 { 597 p_rec = p_start_rec->p_next_rec; 598 } 599 600 while (p_rec) 601 { 602 p_attr = p_rec->p_first_attr; 603 while (p_attr) 604 { 605 if ((p_attr->attr_id == ATTR_ID_SERVICE_CLASS_ID_LIST) 606 && (SDP_DISC_ATTR_TYPE(p_attr->attr_len_type) == DATA_ELE_SEQ_DESC_TYPE)) 607 { 608 for (p_sattr = p_attr->attr_value.v.p_sub_attr; p_sattr; p_sattr = p_sattr->p_next_attr) 609 { 610 if ((SDP_DISC_ATTR_TYPE(p_sattr->attr_len_type) == UUID_DESC_TYPE) 611 && (SDP_DISC_ATTR_LEN(p_sattr->attr_len_type) == 2) 612 && ( (p_sattr->attr_value.v.u16 == UUID_SERVCLASS_HDP_SINK) || 613 (p_sattr->attr_value.v.u16 == UUID_SERVCLASS_HDP_SOURCE)) ) 614 { 615 return(p_rec); 616 } 617 } 618 break; 619 } 620 621 p_attr = p_attr->p_next_attr; 622 } 623 624 p_rec = p_rec->p_next_rec; 625 } 626 #endif 627 /* If here, no matching UUID found */ 628 629 #if BTA_HL_DEBUG == TRUE 630 APPL_TRACE_DEBUG("bta_hl_find_sink_or_src_srv_class_in_db failed"); 631 #endif 632 633 return(NULL); 634 } 635 #endif /* HL_INCLUDED */ 636
