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
TEST_GROUP(SDPRecordBuilder)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
a2dp_sink_record_size(const char * service_name,const char * service_provider_name)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
TEST(SDPRecordBuilder,A2DP_SINK)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
a2dp_source_record_size(const char * service_name,const char * service_provider_name)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
TEST(SDPRecordBuilder,A2DP_SOURCE)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
avrcp_target_record_size(const char * service_name,const char * service_provider_name)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
TEST(SDPRecordBuilder,AVRCP_TARGET)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
avrcp_controller_record_size(const char * service_name,const char * service_provider_name)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
TEST(SDPRecordBuilder,AVRCP_CONTROLLER)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
hid_device_record_size(uint16_t descriptor_size,const char * name)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
TEST(SDPRecordBuilder,HID_DEVICE)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
hfp_hf_record_size(const char * name)221 static uint16_t hfp_hf_record_size(const char * name){
222 return HFP_HF_RECORD_SIZE_MIN + strlen(name);
223 }
224
TEST(SDPRecordBuilder,HFP_HF)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
hfp_ag_record_size(const char * name)246 static uint16_t hfp_ag_record_size(const char * name){
247 return HFP_AG_RECORD_SIZE_MIN + strlen(name);
248 }
249
TEST(SDPRecordBuilder,HFP_AG)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
hsp_ag_record_size(const char * name)272 static uint16_t hsp_ag_record_size(const char * name){
273 return HSP_AG_RECORD_SIZE_MIN + strlen(name);
274 }
275
TEST(SDPRecordBuilder,HSP_AG)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
hsp_hs_record_size(const char * name)297 static uint16_t hsp_hs_record_size(const char * name){
298 return HSP_HS_RECORD_SIZE_MIN + strlen(name);
299 }
300
TEST(SDPRecordBuilder,HSP_HS)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
device_id_record_size(void)322 static uint16_t device_id_record_size(void){
323 return DEVICE_ID_RECORD_SIZE;
324 }
325
TEST(SDPRecordBuilder,DeviceID)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
pan_sdp_record_size(uint16_t * network_packet_types,const char * name,const char * description,const char * IPv4Subnet,const char * IPv6Subnet,const char * default_name,const char * default_desc)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
pan_panu_sdp_record_size(uint16_t * network_packet_types,const char * name,const char * description)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
pan_gn_sdp_record_size(uint16_t * network_packet_types,const char * name,const char * description,const char * IPv4Subnet,const char * IPv6Subnet)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
pan_nap_sdp_record_size(uint16_t * network_packet_types,const char * name,const char * description,const char * IPv4Subnet,const char * IPv6Subnet)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
TEST(SDPRecordBuilder,PANU)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
TEST(SDPRecordBuilder,GN)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
TEST(SDPRecordBuilder,NAP)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
spp_sdp_record_size_for_service_name(const char * service_name)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
TEST(SDPRecordBuilder,SPP)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
main(int argc,const char * argv[])513 int main (int argc, const char * argv[]){
514 return CommandLineTestRunner::RunAllTests(argc, argv);
515 }
516