1 /****************************************************************************** 2 * 3 * Copyright (C) 2014 Google, Inc. 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 #define LOG_TAG "bt_btif_sock_sdp" 20 21 #include <stdint.h> 22 #include <stdbool.h> 23 #include <string.h> 24 #include <sys/types.h> 25 #include <sys/socket.h> 26 #include <errno.h> 27 28 #include <hardware/bluetooth.h> 29 #include <hardware/bt_sock.h> 30 31 #include "btif_common.h" 32 #include "btif_util.h" 33 #include "btif_sock_util.h" 34 #include "bta_api.h" 35 #include "bt_target.h" 36 #include "gki.h" 37 #include "hcimsgs.h" 38 #include "sdp_api.h" 39 #include "btu.h" 40 #include "btm_api.h" 41 #include "btm_int.h" 42 #include "btif_sock_sdp.h" 43 #include "utl.h" 44 #include "../bta/pb/bta_pbs_int.h" 45 #include "../include/bta_op_api.h" 46 #include "bta_jv_api.h" 47 48 // This module provides an abstraction on top of the lower-level SDP database 49 // code for registration and discovery of various bluetooth sockets. 50 // 51 // This code also provides for on-demand registration of "pre-registered" 52 // services as a backwards compatibility function to third-party applications 53 // expecting a bluez stack. 54 55 // Realm Character Set -- 0 is ASCII 56 #define BTA_PBS_REALM_CHARSET 0 57 58 // Specifies whether or not client's user id is required during obex 59 // authentication 60 #define BTA_PBS_USERID_REQ FALSE 61 62 static const tBTA_PBS_CFG bta_pbs_cfg = { 63 BTA_PBS_REALM_CHARSET, // realm_charset: Server only 64 BTA_PBS_USERID_REQ, // userid_req: Server only 65 (BTA_PBS_SUPF_DOWNLOAD | BTA_PBS_SURF_BROWSE), // supported_features 66 BTA_PBS_REPOSIT_LOCAL, // supported_repositories 67 }; 68 69 // object format lookup table 70 #define OBEX_PUSH_NUM_FORMATS 7 71 72 static const tBTA_OP_FMT bta_ops_obj_fmt[OBEX_PUSH_NUM_FORMATS] = { 73 BTA_OP_VCARD21_FMT, 74 BTA_OP_VCARD30_FMT, 75 BTA_OP_VCAL_FMT, 76 BTA_OP_ICAL_FMT, 77 BTA_OP_VNOTE_FMT, 78 BTA_OP_VMSG_FMT, 79 BTA_OP_OTHER_FMT 80 }; 81 82 // TODO(jtgans): Figure out if we actually need this define. This is ifndef 83 // defined in bt_target.h, but nowhere else, so right now, unless something 84 // overrides this before bt_target.h sets it, it will always be bt_target.h's 85 // version. 86 #ifndef BTUI_OPS_FORMATS 87 #define BTUI_OPS_FORMATS (BTA_OP_VCARD21_MASK \ 88 | BTA_OP_VCARD30_MASK \ 89 | BTA_OP_VCAL_MASK \ 90 | BTA_OP_ICAL_MASK \ 91 | BTA_OP_VNOTE_MASK \ 92 | BTA_OP_VMSG_MASK \ 93 | BTA_OP_ANY_MASK) 94 #endif 95 96 97 98 #define RESERVED_SCN_PBS 19 99 #define RESERVED_SCN_OPS 12 100 101 #define UUID_MAX_LENGTH 16 102 #define UUID_MATCHES(u1, u2) !memcmp(u1, u2, UUID_MAX_LENGTH) 103 104 // Adds a protocol list and service name (if provided) to an SDP record given by 105 // |sdp_handle|, and marks it as browseable. This is a shortcut for defining a 106 // set of protocols that includes L2CAP, RFCOMM, and optionally OBEX. If 107 // |with_obex| is |TRUE|, then an additional OBEX protocol UUID will be included 108 // at the end of the protocol list. 109 // 110 // Returns TRUE if successful, otherwise FALSE. 111 static bool create_base_record(const uint32_t sdp_handle, const char *name, 112 const uint16_t channel, const bool with_obex) { 113 APPL_TRACE_DEBUG("create_base_record: scn: %d, name: %s, with_obex: %d", 114 channel, name, with_obex); 115 116 // Setup the protocol list and add it. 117 tSDP_PROTOCOL_ELEM proto_list[SDP_MAX_LIST_ELEMS]; 118 int num_proto_elements = with_obex ? 3 : 2; 119 120 memset(proto_list, 0, num_proto_elements * sizeof(tSDP_PROTOCOL_ELEM)); 121 122 proto_list[0].protocol_uuid = UUID_PROTOCOL_L2CAP; 123 proto_list[0].num_params = 0; 124 proto_list[1].protocol_uuid = UUID_PROTOCOL_RFCOMM; 125 proto_list[1].num_params = 1; 126 proto_list[1].params[0] = channel; 127 128 if (with_obex == TRUE) { 129 proto_list[2].protocol_uuid = UUID_PROTOCOL_OBEX; 130 proto_list[2].num_params = 0; 131 } 132 133 char *stage = "protocol_list"; 134 if (!SDP_AddProtocolList(sdp_handle, num_proto_elements, proto_list)) 135 goto error; 136 137 // Add the name to the SDP record. 138 if (name[0] != '\0') { 139 stage = "service_name"; 140 if (!SDP_AddAttribute(sdp_handle, ATTR_ID_SERVICE_NAME, 141 TEXT_STR_DESC_TYPE, (uint32_t)(strlen(name) + 1), 142 (uint8_t *)name)) 143 goto error; 144 } 145 146 // Mark the service as browseable. 147 uint16_t list = UUID_SERVCLASS_PUBLIC_BROWSE_GROUP; 148 stage = "browseable"; 149 if (!SDP_AddUuidSequence(sdp_handle, ATTR_ID_BROWSE_GROUP_LIST, 1, &list)) 150 goto error; 151 152 APPL_TRACE_DEBUG("create_base_record: successfully created base service " 153 "record, handle: 0x%08x, scn: %d, name: %s, with_obex: %d", 154 sdp_handle, channel, name, with_obex); 155 return TRUE; 156 157 error: 158 APPL_TRACE_ERROR("create_base_record: failed to create base service " 159 "record, stage: %s, scn: %d, name: %s, with_obex: %d", 160 stage, channel, name, with_obex); 161 return FALSE; 162 } 163 164 // Registers a service with the given |name|, |uuid|, and |channel| in the SDP 165 // database as a generic L2CAP RFCOMM protocol, storing its |uuid| as a service 166 // class sequence. 167 static int add_sdp_by_uuid(const char *name, const uint8_t *uuid, 168 const uint16_t channel) { 169 APPL_TRACE_DEBUG("add_sdp_by_uuid: scn: %d, service_name: %s", channel, name); 170 171 uint32_t handle = SDP_CreateRecord(); 172 if (handle == 0) { 173 APPL_TRACE_ERROR("add_sdp_by_uuid: failed to create sdp record, " 174 "scn: %d, service_name: %s", channel, name); 175 return 0; 176 } 177 178 // Create the base SDP record. 179 char *stage = "create_base_record"; 180 if (!create_base_record(handle, name, channel, FALSE /* with_obex */)) 181 goto error; 182 183 // Convert the |uuid| into a big-endian representation and add it as a 184 // sequence. 185 uint8_t type = UUID_DESC_TYPE; 186 uint8_t type_len = UUID_MAX_LENGTH; 187 uint8_t type_buf[48]; 188 // Store the address of type buf in a pointer on the stack, so we can pass 189 // a double pointer to SDP_AddSequence 190 uint8_t *type_buf_ptr = type_buf; 191 192 // Do the conversion to big-endian -- tmp is only used to iterate through the 193 // UUID array in the macro and serves no other purpose as the conversion 194 // macros are not hygenic. 195 { 196 uint8_t *tmp = type_buf; 197 ARRAY_TO_BE_STREAM(tmp, uuid, UUID_MAX_LENGTH); 198 } 199 200 stage = "service_class_sequence"; 201 if (!SDP_AddSequence(handle, (uint16_t)ATTR_ID_SERVICE_CLASS_ID_LIST, 202 1, &type, &type_len, &type_buf_ptr)) 203 goto error; 204 205 206 APPL_TRACE_DEBUG("add_sdp_by_uuid: service registered successfully, " 207 "service_name: %s, handle: 0x%08x", name, handle); 208 return handle; 209 210 error: 211 SDP_DeleteRecord(handle); 212 APPL_TRACE_ERROR("add_sdp_by_uuid: failed to register service " 213 "stage: %s, service_name: %s", stage, name); 214 return 0; 215 } 216 217 // Registers a service with the given |name| and |channel| in the SDP 218 // database as a PBAP protocol. 219 static int add_pbap_sdp(const char *name, const int channel) { 220 APPL_TRACE_DEBUG("add_pbap_sdp: scn %d, service_name %s", channel, name); 221 222 uint32_t handle = SDP_CreateRecord(); 223 if (handle == 0) { 224 APPL_TRACE_ERROR("add_pbap_sdp: failed to create sdp record, " 225 "service_name: %s", name); 226 return 0; 227 } 228 229 // Create the base SDP record. 230 char *stage = "create_base_record"; 231 if (!create_base_record(handle, name, channel, TRUE /* with_obex */)) 232 goto error; 233 234 // Add service class 235 uint16_t service = UUID_SERVCLASS_PBAP_PSE; 236 stage = "service_class"; 237 if (!SDP_AddServiceClassIdList(handle, 1, &service)) 238 goto error; 239 240 // Add in the phone access descriptor 241 stage = "profile_descriptor_list"; 242 if (!SDP_AddProfileDescriptorList(handle, 243 UUID_SERVCLASS_PHONE_ACCESS, 244 BTA_PBS_DEFAULT_VERSION)) 245 goto error; 246 247 // Set up our supported repositories 248 stage = "supported_repositories"; 249 if (!SDP_AddAttribute(handle, ATTR_ID_SUPPORTED_REPOSITORIES, UINT_DESC_TYPE, 250 1, (uint8_t*)&bta_pbs_cfg.supported_repositories)) 251 goto error; 252 253 // Notify the system that we've got a new service class UUID. 254 bta_sys_add_uuid(UUID_SERVCLASS_PBAP_PSE); 255 APPL_TRACE_DEBUG("add_pbap_sdp: service registered successfully, " 256 "service_name: %s, handle: 0x%08x", name, handle); 257 258 return handle; 259 260 error: 261 SDP_DeleteRecord(handle); 262 APPL_TRACE_ERROR("add_pbap_sdp: failed to register PBAP service, stage: %s, " 263 "service_name: %s", stage, name); 264 return 0; 265 } 266 // Registers a service with the given |name| and |channel| as an OBEX Push 267 // protocol. 268 static int add_ops_sdp(const char *name, const int channel) { 269 APPL_TRACE_DEBUG("add_ops_sdp: scn %d, service_name %s", channel, name); 270 271 uint32_t handle = SDP_CreateRecord(); 272 if (handle == 0) { 273 APPL_TRACE_ERROR("add_ops_sdp: failed to create sdp record, " 274 "service_name: %s", name); 275 return 0; 276 } 277 278 // Create the base SDP record. 279 char *stage = "create_base_record"; 280 if (!create_base_record(handle, name, channel, TRUE /* with_obex */)) 281 goto error; 282 283 // Add service class. 284 stage = "service_class"; 285 uint16_t service = UUID_SERVCLASS_OBEX_OBJECT_PUSH; 286 if (!SDP_AddServiceClassIdList(handle, 1, &service)) 287 goto error; 288 289 // Add the OBEX push profile descriptor. 290 stage = "profile_descriptor_list"; 291 if (!SDP_AddProfileDescriptorList(handle, UUID_SERVCLASS_OBEX_OBJECT_PUSH, 292 0x0100)) 293 goto error; 294 295 // Add sequence for supported types. 296 uint8_t desc_type[OBEX_PUSH_NUM_FORMATS]; 297 uint8_t type_len[OBEX_PUSH_NUM_FORMATS]; 298 uint8_t *type_value[OBEX_PUSH_NUM_FORMATS]; 299 uint8_t j = 0; 300 301 for (int i = 0; i < OBEX_PUSH_NUM_FORMATS; i++) { 302 if ((BTUI_OPS_FORMATS >> i) & 1) { 303 type_value[j] = (uint8_t*)(&bta_ops_obj_fmt[i]); 304 desc_type[j] = UINT_DESC_TYPE; 305 type_len[j++] = 1; 306 } 307 } 308 309 stage = "supported_types"; 310 if (!SDP_AddSequence(handle, (uint16_t)ATTR_ID_SUPPORTED_FORMATS_LIST, 311 j, desc_type, type_len, type_value)) 312 goto error; 313 314 // Set class of device. 315 tBTA_UTL_COD cod; 316 cod.service = BTM_COD_SERVICE_OBJ_TRANSFER; 317 stage = "class_of_device"; 318 if (!utl_set_device_class(&cod, BTA_UTL_SET_COD_SERVICE_CLASS)) 319 goto error; 320 321 // Notify the system that we've got a new service class UUID. 322 bta_sys_add_uuid(UUID_SERVCLASS_OBEX_OBJECT_PUSH); 323 APPL_TRACE_DEBUG("ad_maps_sdp: service registered successfully, " 324 "service_name: %s, handle 0x%08x)", name, handle); 325 326 return handle; 327 328 error: 329 SDP_DeleteRecord(handle); 330 APPL_TRACE_ERROR("add_ops_sdp: failed to register OPS service, " 331 "stage: %s, service_name: %s", stage, name); 332 return 0; 333 } 334 335 // Registers a service with the given |name| and |channel| as a serial port 336 // profile protocol. 337 static int add_spp_sdp(const char *name, const int channel) { 338 APPL_TRACE_DEBUG("add_spp_sdp: scn %d, service_name %s", channel, name); 339 340 int handle = SDP_CreateRecord(); 341 if (handle == 0) { 342 APPL_TRACE_ERROR("add_spp_sdp: failed to create sdp record, " 343 "service_name: %s", name); 344 return 0; 345 } 346 347 // Create the base SDP record. 348 char *stage = "create_base_record"; 349 if (!create_base_record(handle, name, channel, FALSE /* with_obex */)) 350 goto error; 351 352 uint16_t service = UUID_SERVCLASS_SERIAL_PORT; 353 stage = "service_class"; 354 if (!SDP_AddServiceClassIdList(handle, 1, &service)) 355 goto error; 356 357 APPL_TRACE_DEBUG("add_spp_sdp: service registered successfully, " 358 "service_name: %s, handle 0x%08x)", name, handle); 359 360 return handle; 361 362 error: 363 SDP_DeleteRecord(handle); 364 APPL_TRACE_ERROR("add_spp_sdp: failed to register SPP service, " 365 "stage: %s, service_name: %s", stage, name); 366 return 0; 367 } 368 369 // Adds an RFCOMM SDP record for a service with the given |name|, |uuid|, and 370 // |channel|. This function attempts to identify the type of the service based 371 // upon its |uuid|, and will override the |channel| with a reserved channel 372 // number if the |uuid| matches one of the preregistered bluez SDP records. 373 static int add_rfc_sdp_by_uuid(const char *name, const uint8_t *uuid, 374 const int channel) { 375 APPL_TRACE_DEBUG("add_rfc_sdp_by_uuid: service_name: %s, channel: %d", name, 376 channel); 377 378 /* 379 * Bluetooth Socket API relies on having preregistered bluez sdp records for 380 * HSAG, HFAG, OPP & PBAP that are mapped to rc chan 10, 11,12 & 19. Today 381 * HSAG and HFAG is routed to BRCM AG and are not using BT socket API so for 382 * now we will need to support OPP and PBAP to enable 3rd party developer apps 383 * running on BRCM Android. 384 * 385 * To do this we will check the UUID for the requested service and mimic the 386 * SDP records of bluez upon reception. See functions add_opush() and 387 * add_pbap() in sdptool.c for actual records. 388 */ 389 390 int final_channel = get_reserved_rfc_channel(uuid); 391 392 if (final_channel == -1) { 393 final_channel = channel; 394 } 395 396 int handle = 0; 397 398 if (UUID_MATCHES(UUID_OBEX_OBJECT_PUSH, uuid)) { 399 handle = add_ops_sdp(name, final_channel); 400 } else if (UUID_MATCHES(UUID_PBAP_PSE,uuid)) { 401 // PBAP Server is always channel 19 402 handle = add_pbap_sdp(name, final_channel); 403 } else if (UUID_MATCHES(UUID_SPP, uuid)) { 404 handle = add_spp_sdp(name, final_channel); 405 } else if (UUID_MATCHES(UUID_MAP_MAS,uuid)) { 406 // Record created by new SDP create record interface 407 handle = 0xff; 408 } else { 409 handle = add_sdp_by_uuid(name, uuid, final_channel); 410 } 411 412 return handle; 413 } 414 415 bool is_reserved_rfc_channel(const int channel) { 416 switch(channel) { 417 case RESERVED_SCN_PBS: 418 case RESERVED_SCN_OPS: 419 return TRUE; 420 } 421 422 return FALSE; 423 } 424 425 int get_reserved_rfc_channel(const uint8_t *uuid) { 426 if (UUID_MATCHES(UUID_PBAP_PSE, uuid)) { 427 return RESERVED_SCN_PBS; 428 } else if (UUID_MATCHES(UUID_OBEX_OBJECT_PUSH, uuid)) { 429 return RESERVED_SCN_OPS; 430 } 431 432 return -1; 433 } 434 435 // Adds an SDP record to the SDP database using the given |name|, |uuid|, and 436 // |channel|. Note that if the |uuid| is empty, the |uuid| will be set based 437 // upon the |channel| passed in. 438 int add_rfc_sdp_rec(const char *name, const uint8_t *uuid, const int channel) { 439 if (is_uuid_empty(uuid)) { 440 switch(channel) { 441 case RESERVED_SCN_PBS: // PBAP Reserved port 442 uuid = UUID_PBAP_PSE; 443 break; 444 445 case RESERVED_SCN_OPS: 446 uuid = UUID_OBEX_OBJECT_PUSH; 447 break; 448 449 default: 450 uuid = UUID_SPP; 451 break; 452 } 453 } 454 455 return add_rfc_sdp_by_uuid(name, uuid, channel); 456 } 457 458 // Deletes an SDP record with the given |handle|. 459 void del_rfc_sdp_rec(int handle) { 460 APPL_TRACE_DEBUG("del_rfc_sdp_rec: handle:0x%x", handle); 461 462 if ((handle != -1) && (handle != 0)) 463 BTA_JvDeleteRecord(handle); 464 } 465
