1 /* 2 * Copyright (C) 2014 BlueKitchen GmbH 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. Neither the name of the copyright holders nor the names of 14 * contributors may be used to endorse or promote products derived 15 * from this software without specific prior written permission. 16 * 4. Any redistribution, use, or modification is done solely for 17 * personal benefit and not for any commercial purpose or for 18 * monetary gain. 19 * 20 * THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS 21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL MATTHIAS 24 * RINGWALD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 26 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 27 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 28 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 29 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF 30 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 * Please inquire about commercial licensing options at 34 * [email protected] 35 * 36 */ 37 38 // ***************************************************************************** 39 // 40 // test calculation of sdp records created by various profiles 41 // 42 // ***************************************************************************** 43 44 45 #include <stdint.h> 46 #include <stdio.h> 47 #include <stdlib.h> 48 #include <string.h> 49 50 #include "CppUTest/TestHarness.h" 51 #include "CppUTest/CommandLineTestRunner.h" 52 53 #include "classic/avrcp_controller.h" 54 55 #include "btstack_util.h" 56 #include "bluetooth.h" 57 58 #include "classic/device_id_server.h" 59 #include "classic/avrcp_target.h" 60 #include "classic/a2dp_source.h" 61 #include "classic/a2dp_sink.h" 62 #include "classic/hsp_hs.h" 63 #include "classic/hsp_ag.h" 64 #include "classic/hfp_hf.h" 65 #include "classic/hfp_ag.h" 66 #include "classic/hid_device.h" 67 #include "classic/pan.h" 68 #include "classic/spp_server.h" 69 #include "classic/sdp_util.h" 70 71 static uint8_t service_buffer[300]; 72 static const char * test_string = "test"; 73 static const uint16_t uint16_list_empty[] = { 0 }; 74 static const uint16_t uint16_list_single_element[] = { 0x1234, 0 }; 75 76 TEST_GROUP(SDPRecordBuilder){ 77 void setup(void){ 78 memset(service_buffer, 0, sizeof(service_buffer)); 79 } 80 }; 81 82 // a2dp sink 83 84 static const char * default_a2dp_sink_service_name = "BTstack A2DP Sink Service"; 85 static const char * default_a2dp_sink_service_provider_name = "BTstack A2DP Sink Service Provider"; 86 87 #define A2DP_SINK_RECORD_SIZE_MIN 84 88 89 static uint16_t a2dp_sink_record_size(const char * service_name, const char * service_provider_name){ 90 int service_name_len = service_name ? strlen(service_name) : strlen(default_a2dp_sink_service_name); 91 int service_provider_name_len = service_provider_name ? strlen(service_provider_name) : strlen(default_a2dp_sink_service_provider_name); 92 return A2DP_SINK_RECORD_SIZE_MIN + service_name_len + service_provider_name_len; 93 } 94 95 TEST(SDPRecordBuilder, A2DP_SINK){ 96 const char * service_name; 97 const char * service_provider_name; 98 int expected_len; 99 100 service_name = "."; 101 service_provider_name = "."; 102 expected_len = a2dp_sink_record_size(service_name, service_provider_name); 103 a2dp_sink_create_sdp_record(service_buffer, 0, 0, service_name, service_provider_name); 104 CHECK_EQUAL(de_get_len(service_buffer), expected_len); 105 } 106 107 // a2dp source 108 109 static const char * default_a2dp_source_service_name = "BTstack A2DP Source Service"; 110 static const char * default_a2dp_source_service_provider_name = "BTstack A2DP Source Service Provider"; 111 112 #define A2DP_SOURCE_RECORD_SIZE_MIN 84 113 114 static uint16_t a2dp_source_record_size(const char * service_name, const char * service_provider_name){ 115 int service_name_len = service_name ? strlen(service_name) : strlen(default_a2dp_source_service_name); 116 int service_provider_name_len = service_provider_name ? strlen(service_provider_name) : strlen(default_a2dp_source_service_provider_name); 117 return A2DP_SOURCE_RECORD_SIZE_MIN + service_name_len + service_provider_name_len; 118 } 119 120 TEST(SDPRecordBuilder, A2DP_SOURCE){ 121 const char * service_name; 122 const char * service_provider_name; 123 int expected_len; 124 125 service_name = "."; 126 service_provider_name = "."; 127 expected_len = a2dp_source_record_size(service_name, service_provider_name); 128 a2dp_source_create_sdp_record(service_buffer, 0, 0, service_name, service_provider_name); 129 CHECK_EQUAL(de_get_len(service_buffer), expected_len); 130 } 131 132 // 133 // avcrp target 134 // 135 136 static const char * default_avrcp_target_service_name = "BTstack AVRCP Target Service"; 137 static const char * default_avrcp_target_service_provider_name = "BTstack AVRCP Target Service Provider"; 138 139 #define AVRCP_TARGET_RECORD_SIZE_MIN 84 140 141 static uint16_t avrcp_target_record_size(const char * service_name, const char * service_provider_name){ 142 int service_name_len = service_name ? strlen(service_name) : strlen(default_avrcp_target_service_name); 143 int service_provider_name_len = service_provider_name ? strlen(service_provider_name) : strlen(default_avrcp_target_service_provider_name); 144 return AVRCP_TARGET_RECORD_SIZE_MIN + service_name_len + service_provider_name_len; 145 } 146 147 TEST(SDPRecordBuilder, AVRCP_TARGET){ 148 const char * service_name; 149 const char * service_provider_name; 150 int expected_len; 151 int descriptor_size; 152 153 service_name = "."; 154 service_provider_name = "."; 155 descriptor_size = 0; 156 expected_len = avrcp_target_record_size(service_name, service_provider_name); 157 avrcp_target_create_sdp_record(service_buffer, 0, 0, service_name, service_provider_name); 158 CHECK_EQUAL(de_get_len(service_buffer), expected_len); 159 } 160 161 // 162 // avrcp controller 163 // 164 165 static const char * default_avrcp_controller_service_name = "BTstack AVRCP Controller Service"; 166 static const char * default_avrcp_controller_service_provider_name = "BTstack AVRCP Controller Service Provider"; 167 168 #define AVRCP_CONTROLLER_RECORD_SIZE_MIN 87 169 170 static uint16_t avrcp_controller_record_size(const char * service_name, const char * service_provider_name){ 171 int service_name_len = service_name ? strlen(service_name) : strlen(default_avrcp_controller_service_name); 172 int service_provider_name_len = service_provider_name ? strlen(service_provider_name) : strlen(default_avrcp_controller_service_provider_name); 173 return AVRCP_CONTROLLER_RECORD_SIZE_MIN + service_name_len + service_provider_name_len; 174 } 175 176 TEST(SDPRecordBuilder, AVRCP_CONTROLLER){ 177 const char * service_name; 178 const char * service_provider_name; 179 int expected_len; 180 int descriptor_size; 181 182 service_name = "."; 183 service_provider_name = "."; 184 descriptor_size = 0; 185 expected_len = avrcp_controller_record_size(service_name, service_provider_name); 186 avrcp_controller_create_sdp_record(service_buffer, 0, 0, service_name, service_provider_name); 187 CHECK_EQUAL(de_get_len(service_buffer), expected_len); 188 } 189 190 // 191 // hid_device.h 192 // 193 194 #define HID_DEVICE_RECORD_SIZE_MIN 187 195 196 static uint16_t hid_device_record_size(uint16_t descriptor_size, const char * name){ 197 return HID_DEVICE_RECORD_SIZE_MIN + descriptor_size + strlen(name); 198 } 199 200 TEST(SDPRecordBuilder, HID_DEVICE){ 201 const char * name; 202 int expected_len; 203 int descriptor_size; 204 205 name = ""; 206 descriptor_size = 0; 207 expected_len = hid_device_record_size(descriptor_size, name); 208 209 hid_sdp_record_t hid_params = {0, 0, 0, 0, 0, false, false, 0xFFFF, 0xFFFF, 3200, NULL, descriptor_size, name}; 210 hid_create_sdp_record(service_buffer, 0x0001, &hid_params); 211 212 CHECK_EQUAL(de_get_len(service_buffer), expected_len); 213 } 214 215 // 216 // hfp_hf 217 // 218 219 #define HFP_HF_RECORD_SIZE_MIN 78 220 221 static uint16_t hfp_hf_record_size(const char * name){ 222 return HFP_HF_RECORD_SIZE_MIN + strlen(name); 223 } 224 225 TEST(SDPRecordBuilder, HFP_HF){ 226 const char * name; 227 int expected_len; 228 229 name = "."; 230 expected_len = hfp_hf_record_size(name); 231 hfp_hf_create_sdp_record(service_buffer, 0, 0, name, 0, 0); 232 CHECK_EQUAL(de_get_len(service_buffer), expected_len); 233 234 name =test_string; 235 expected_len = hfp_hf_record_size(name); 236 hfp_hf_create_sdp_record(service_buffer, 0, 0, name, 0, 0); 237 CHECK_EQUAL(de_get_len(service_buffer), expected_len); 238 } 239 240 // 241 // hfp_ag 242 // 243 244 #define HFP_AG_RECORD_SIZE_MIN 83 245 246 static uint16_t hfp_ag_record_size(const char * name){ 247 return HFP_AG_RECORD_SIZE_MIN + strlen(name); 248 } 249 250 TEST(SDPRecordBuilder, HFP_AG){ 251 const char * name; 252 int expected_len; 253 254 name = "."; 255 expected_len = hfp_ag_record_size(name); 256 hfp_ag_create_sdp_record(service_buffer, 0, 0, name, 0, 0, 0); 257 CHECK_EQUAL(de_get_len(service_buffer), expected_len); 258 259 name =test_string; 260 expected_len = hfp_ag_record_size(name); 261 hfp_ag_create_sdp_record(service_buffer, 0, 0, name, 0, 0, 0); 262 CHECK_EQUAL(de_get_len(service_buffer), expected_len); 263 } 264 265 266 // 267 // hsp_ag 268 // 269 270 #define HSP_AG_RECORD_SIZE_MIN 72 271 272 static uint16_t hsp_ag_record_size(const char * name){ 273 return HSP_AG_RECORD_SIZE_MIN + strlen(name); 274 } 275 276 TEST(SDPRecordBuilder, HSP_AG){ 277 const char * name; 278 int expected_len; 279 280 name = ""; 281 expected_len = hsp_ag_record_size(name); 282 hsp_ag_create_sdp_record(service_buffer, 0, 0, name); 283 CHECK_EQUAL(de_get_len(service_buffer), expected_len); 284 285 name =test_string; 286 expected_len = hsp_ag_record_size(name); 287 hsp_ag_create_sdp_record(service_buffer, 0, 0, name); 288 CHECK_EQUAL(de_get_len(service_buffer), expected_len); 289 } 290 291 // 292 // hsp_hs 293 // 294 295 #define HSP_HS_RECORD_SIZE_MIN 80 296 297 static uint16_t hsp_hs_record_size(const char * name){ 298 return HSP_HS_RECORD_SIZE_MIN + strlen(name); 299 } 300 301 TEST(SDPRecordBuilder, HSP_HS){ 302 const char * name; 303 int expected_len; 304 305 name = ""; 306 expected_len = hsp_hs_record_size(name); 307 hsp_hs_create_sdp_record(service_buffer, 0, 0, name, 0); 308 CHECK_EQUAL(de_get_len(service_buffer), expected_len); 309 310 name =test_string; 311 expected_len = hsp_hs_record_size(name); 312 hsp_hs_create_sdp_record(service_buffer, 0, 0, name, 0); 313 CHECK_EQUAL(de_get_len(service_buffer), expected_len); 314 } 315 316 // 317 // device id 318 // 319 320 #define DEVICE_ID_RECORD_SIZE 64 321 322 static uint16_t device_id_record_size(void){ 323 return DEVICE_ID_RECORD_SIZE; 324 } 325 326 TEST(SDPRecordBuilder, DeviceID){ 327 int expected_len; 328 expected_len = device_id_record_size(); 329 device_id_create_sdp_record(service_buffer, 0, 0, 0, 0, 0); 330 CHECK_EQUAL(de_get_len(service_buffer), expected_len); 331 } 332 333 334 // 335 // pan 336 // 337 338 #define PAN_RECORD_MIN_LEN 104 339 340 static const char default_panu_service_name[] = "Personal Ad-hoc User Service"; 341 static const char default_panu_service_desc[] = "Personal Ad-hoc User Service"; 342 343 static const char default_nap_service_name[] = "Network Access Point Service"; 344 static const char default_nap_service_desc[] = "Personal Ad-hoc Network Service which provides access to a network"; 345 346 static const char default_gn_service_name[] = "Group Ad-hoc Network Service"; 347 static const char default_gn_service_desc[] = "Personal Group Ad-hoc Network Service"; 348 349 // network_packet_types (X bytes x nr network packet types) 350 // name. default name or name 351 // ipv4 subnet, if yes + x 352 // ipv6 subnet, if yes + x 353 354 static uint16_t pan_sdp_record_size(uint16_t * network_packet_types, const char *name, const char *description, const char *IPv4Subnet, 355 const char *IPv6Subnet, const char * default_name, const char * default_desc){ 356 int num_network_packet_types; 357 for (num_network_packet_types=0; network_packet_types && *network_packet_types; num_network_packet_types++, network_packet_types++); 358 int name_len = name ? strlen(name) : strlen(default_name); 359 int desc_len = description ? strlen(description) : strlen(default_desc); 360 int ipv4_len = IPv4Subnet ? 5 + strlen(IPv4Subnet) : 0; 361 int ipv6_len = IPv6Subnet ? 5 + strlen(IPv6Subnet) : 0; 362 uint16_t res = PAN_RECORD_MIN_LEN + name_len + desc_len + ipv4_len + ipv6_len + num_network_packet_types * 3; // tyoe + uint16_t 363 return res; 364 } 365 366 static uint16_t pan_panu_sdp_record_size(uint16_t * network_packet_types, const char *name, const char *description){ 367 return pan_sdp_record_size(network_packet_types, name, description, NULL, NULL, default_panu_service_name, default_panu_service_desc); 368 } 369 370 static uint16_t pan_gn_sdp_record_size(uint16_t * network_packet_types, const char *name, const char *description, const char *IPv4Subnet, 371 const char *IPv6Subnet){ 372 return pan_sdp_record_size(network_packet_types, name, description, IPv4Subnet, IPv6Subnet, default_gn_service_name, default_gn_service_desc); 373 } 374 375 static uint16_t pan_nap_sdp_record_size(uint16_t * network_packet_types, const char *name, const char *description, const char *IPv4Subnet, 376 const char *IPv6Subnet){ 377 return pan_sdp_record_size(network_packet_types, name, description, IPv4Subnet, IPv6Subnet, default_nap_service_name, default_nap_service_desc) + 14; 378 } 379 380 TEST(SDPRecordBuilder, PANU){ 381 int expected_len; 382 const char * name; 383 const char * desc; 384 uint16_t * network_packet_types; 385 386 // empty name 387 name = ""; 388 desc = ""; 389 network_packet_types = NULL; 390 expected_len = pan_panu_sdp_record_size(network_packet_types, name, desc); 391 pan_create_panu_sdp_record(service_buffer, 0, network_packet_types, name, desc, BNEP_SECURITY_NONE); 392 CHECK_EQUAL(de_get_len(service_buffer), expected_len); 393 394 // default name 395 name = NULL; 396 desc = NULL; 397 network_packet_types = NULL; 398 expected_len = pan_panu_sdp_record_size(network_packet_types, name, desc); 399 pan_create_panu_sdp_record(service_buffer, 0, network_packet_types, name, desc, BNEP_SECURITY_NONE); 400 CHECK_EQUAL(de_get_len(service_buffer), expected_len); 401 402 // empty list 403 name = NULL; 404 desc = NULL; 405 network_packet_types = (uint16_t *) &uint16_list_empty; 406 expected_len = pan_panu_sdp_record_size(network_packet_types, name, desc); 407 pan_create_panu_sdp_record(service_buffer, 0, network_packet_types, name, desc, BNEP_SECURITY_NONE); 408 CHECK_EQUAL(de_get_len(service_buffer), expected_len); 409 410 // single element 411 name = NULL; 412 desc = NULL; 413 network_packet_types = (uint16_t *) &uint16_list_single_element; 414 expected_len = pan_panu_sdp_record_size(network_packet_types, name, desc); 415 pan_create_panu_sdp_record(service_buffer, 0, network_packet_types, name, desc, BNEP_SECURITY_NONE); 416 CHECK_EQUAL(de_get_len(service_buffer), expected_len); 417 } 418 419 TEST(SDPRecordBuilder, GN){ 420 int expected_len; 421 const char * name; 422 const char * desc; 423 uint16_t * network_packet_types; 424 const char *IPv4Subnet; 425 const char *IPv6Subnet; 426 427 // empty name 428 name = ""; 429 desc = ""; 430 network_packet_types = NULL; 431 IPv4Subnet = NULL; 432 IPv6Subnet = NULL; 433 expected_len = pan_gn_sdp_record_size(network_packet_types, name, desc, IPv4Subnet, IPv6Subnet); 434 pan_create_gn_sdp_record(service_buffer, 0, network_packet_types, name, desc, BNEP_SECURITY_NONE, IPv4Subnet, IPv6Subnet); 435 CHECK_EQUAL(de_get_len(service_buffer), expected_len); 436 437 // test ipv4 param 438 name = ""; 439 desc = ""; 440 network_packet_types = NULL; 441 IPv4Subnet = NULL; 442 IPv6Subnet = ""; 443 expected_len = pan_gn_sdp_record_size(network_packet_types, name, desc, IPv4Subnet, IPv6Subnet); 444 pan_create_gn_sdp_record(service_buffer, 0, network_packet_types, name, desc, BNEP_SECURITY_NONE, IPv4Subnet, IPv6Subnet); 445 CHECK_EQUAL(de_get_len(service_buffer), expected_len); 446 447 // test ipv6 param 448 name = ""; 449 desc = ""; 450 network_packet_types = NULL; 451 IPv4Subnet = ""; 452 IPv6Subnet = ""; 453 expected_len = pan_gn_sdp_record_size(network_packet_types, name, desc, IPv4Subnet, IPv6Subnet); 454 pan_create_gn_sdp_record(service_buffer, 0, network_packet_types, name, desc, BNEP_SECURITY_NONE, IPv4Subnet, IPv6Subnet); 455 CHECK_EQUAL(de_get_len(service_buffer), expected_len); 456 } 457 458 TEST(SDPRecordBuilder, NAP){ 459 int expected_len; 460 const char * name; 461 const char * desc; 462 uint16_t * network_packet_types; 463 const char *IPv4Subnet; 464 const char *IPv6Subnet; 465 466 // empty name 467 name = ""; 468 desc = ""; 469 network_packet_types = NULL; 470 IPv4Subnet = NULL; 471 IPv6Subnet = NULL; 472 expected_len = pan_nap_sdp_record_size(network_packet_types, name, desc, IPv4Subnet, IPv6Subnet); 473 pan_create_nap_sdp_record(service_buffer, 0, network_packet_types, name, desc, BNEP_SECURITY_NONE, PAN_NET_ACCESS_TYPE_PSTN, 0, IPv4Subnet, IPv6Subnet); 474 CHECK_EQUAL(de_get_len(service_buffer), expected_len); 475 476 // test ipv4 param 477 name = ""; 478 desc = ""; 479 network_packet_types = NULL; 480 IPv4Subnet = NULL; 481 IPv6Subnet = ""; 482 expected_len = pan_nap_sdp_record_size(network_packet_types, name, desc, IPv4Subnet, IPv6Subnet); 483 pan_create_nap_sdp_record(service_buffer, 0, network_packet_types, name, desc, BNEP_SECURITY_NONE, PAN_NET_ACCESS_TYPE_PSTN, 0, IPv4Subnet, IPv6Subnet); 484 CHECK_EQUAL(de_get_len(service_buffer), expected_len); 485 486 // test ipv6 param 487 name = ""; 488 desc = ""; 489 network_packet_types = NULL; 490 IPv4Subnet = ""; 491 IPv6Subnet = ""; 492 expected_len = pan_nap_sdp_record_size(network_packet_types, name, desc, IPv4Subnet, IPv6Subnet); 493 pan_create_nap_sdp_record(service_buffer, 0, network_packet_types, name, desc, BNEP_SECURITY_NONE, PAN_NET_ACCESS_TYPE_PSTN, 0, IPv4Subnet, IPv6Subnet); 494 CHECK_EQUAL(de_get_len(service_buffer), expected_len); 495 } 496 497 // 498 // SPP: Record + strlen(service_name) 499 // 500 501 #define SPP_RECORD_MIN_LEN 84 502 503 static uint16_t spp_sdp_record_size_for_service_name(const char * service_name){ 504 return SPP_RECORD_MIN_LEN + strlen(service_name); 505 } 506 507 TEST(SDPRecordBuilder, SPP){ 508 int expected_len = spp_sdp_record_size_for_service_name(test_string); 509 spp_create_sdp_record(service_buffer, 0, 0, test_string); 510 CHECK_EQUAL(de_get_len(service_buffer), expected_len); 511 } 512 513 int main (int argc, const char * argv[]){ 514 return CommandLineTestRunner::RunAllTests(argc, argv); 515 } 516