1
2 // hal_cpu
3 #include "hal_cpu.h"
hal_cpu_disable_irqs(void)4 void hal_cpu_disable_irqs(void){}
hal_cpu_enable_irqs(void)5 void hal_cpu_enable_irqs(void){}
hal_cpu_enable_irqs_and_sleep(void)6 void hal_cpu_enable_irqs_and_sleep(void){}
7
8 // mock_sm.c
9 #include "ble/sm.h"
sm_add_event_handler(btstack_packet_callback_registration_t * callback_handler)10 void sm_add_event_handler(btstack_packet_callback_registration_t * callback_handler){}
sm_request_pairing(hci_con_handle_t con_handle)11 void sm_request_pairing(hci_con_handle_t con_handle){}
12
13 // mock_hci_transport.h
14 #include "hci_transport.h"
15 void mock_hci_transport_receive_packet(uint8_t packet_type, uint8_t * packet, uint16_t size);
16 const hci_transport_t * mock_hci_transport_mock_get_instance(void);
17
18 // mock_hci_transport.c
19 #include <stddef.h>
20 static uint8_t mock_hci_transport_outgoing_packet_buffer[HCI_ACL_PAYLOAD_SIZE];
21 static uint16_t mock_hci_transport_outgoing_packet_size;
22 static uint8_t mock_hci_transport_outgoing_packet_type;
23
24 static void (*mock_hci_transport_packet_handler)(uint8_t packet_type, uint8_t * packet, uint16_t size);
mock_hci_transport_register_packet_handler(void (* packet_handler)(uint8_t packet_type,uint8_t * packet,uint16_t size))25 static void mock_hci_transport_register_packet_handler(void (*packet_handler)(uint8_t packet_type, uint8_t * packet, uint16_t size)){
26 mock_hci_transport_packet_handler = packet_handler;
27 }
mock_hci_transport_send_packet(uint8_t packet_type,uint8_t * packet,int size)28 static int mock_hci_transport_send_packet(uint8_t packet_type, uint8_t *packet, int size){
29 mock_hci_transport_outgoing_packet_type = packet_type;
30 mock_hci_transport_outgoing_packet_size = size;
31 memcpy(mock_hci_transport_outgoing_packet_buffer, packet, size);
32 return 0;
33 }
mock_hci_transport_mock_get_instance(void)34 const hci_transport_t * mock_hci_transport_mock_get_instance(void){
35 static hci_transport_t mock_hci_transport = {
36 /* .transport.name = */ "mock",
37 /* .transport.init = */ NULL,
38 /* .transport.open = */ NULL,
39 /* .transport.close = */ NULL,
40 /* .transport.register_packet_handler = */ &mock_hci_transport_register_packet_handler,
41 /* .transport.can_send_packet_now = */ NULL,
42 /* .transport.send_packet = */ &mock_hci_transport_send_packet,
43 /* .transport.set_baudrate = */ NULL,
44 };
45 return &mock_hci_transport;
46 }
mock_hci_transport_receive_packet(uint8_t packet_type,const uint8_t * packet,uint16_t size)47 void mock_hci_transport_receive_packet(uint8_t packet_type, const uint8_t * packet, uint16_t size){
48 (*mock_hci_transport_packet_handler)(packet_type, (uint8_t *) packet, size);
49 }
50
51 // copy from hci.c
mock_hci_emit_disconnection_complete(hci_con_handle_t con_handle,uint8_t reason)52 static void mock_hci_emit_disconnection_complete(hci_con_handle_t con_handle, uint8_t reason){
53 uint8_t event[6];
54 event[0] = HCI_EVENT_DISCONNECTION_COMPLETE;
55 event[1] = sizeof(event) - 2u;
56 event[2] = 0; // status = OK
57 little_endian_store_16(event, 3, con_handle);
58 event[5] = reason;
59 (*mock_hci_transport_packet_handler)(HCI_EVENT_PACKET, event, sizeof(event));
60 }
61
62 //
63
64 #include <stdint.h>
65 #include <stdio.h>
66 #include <stdlib.h>
67 #include <string.h>
68
69 #include "CppUTest/TestHarness.h"
70 #include "CppUTest/CommandLineTestRunner.h"
71 #include "CppUTestExt/MockSupport.h"
72
73 #include "hci_dump.h"
74 #include "btstack_debug.h"
75 #include "l2cap.h"
76 #include "btstack_memory.h"
77 #include "btstack_run_loop_embedded.h"
78 #include "hci_dump_posix_stdout.h"
79 #include "btstack_event.h"
80
81 #define TEST_PACKET_SIZE 100
82 #define HCI_CON_HANDLE_TEST_LE 0x0005
83 #define HCI_CON_HANDLE_TEST_CLASSIC 0x0003
84 #define TEST_PSM 0x1001
85
86 static bool l2cap_channel_accept_incoming;
87 static uint16_t initial_credits = L2CAP_LE_AUTOMATIC_CREDITS;
88 static uint8_t data_channel_buffer_1[TEST_PACKET_SIZE];
89 static uint8_t data_channel_buffer_2[TEST_PACKET_SIZE];
90 static uint16_t l2cap_cids[10];
91 static uint16_t num_l2cap_channel_opened;
92 static uint16_t num_l2cap_channel_closed;
93 static uint8_t * receive_buffers_2[] = { data_channel_buffer_1, data_channel_buffer_2 };
94 static uint8_t * reconfigure_buffers_2[] = {data_channel_buffer_1, data_channel_buffer_2 };
95 static uint8_t received_packet[TEST_PACKET_SIZE];
96 static uint16_t reconfigure_result;
97 static btstack_packet_callback_registration_t l2cap_event_callback_registration;
98
99 // two channels with cids 0x041 and 0x042
100 const uint8_t l2cap_enhanced_data_channel_le_conn_request_1[] = {
101 0x05, 0x20, 0x14, 0x00, 0x10, 0x00, 0x05, 0x00, 0x17, 0x01, 0x0c, 0x00, 0x01, 0x10, 0x64, 0x00,
102 0x30, 0x00, 0xff, 0xff, 0x41, 0x00, 0x42, 0x00
103 };
104
105 const uint8_t l2cap_enhanced_data_channel_classic_conn_request_1[] = {
106 0x03, 0x20, 0x14, 0x00, 0x10, 0x00, 0x01, 0x00, 0x17, 0x01, 0x0c, 0x00, 0x01, 0x10, 0x64, 0x00,
107 0x30, 0x00, 0xff, 0xff, 0x41, 0x00, 0x42, 0x00
108 };
109
110 const uint8_t l2cap_enhanced_data_channel_le_conn_response_2_failed[] = {
111 0x05, 0x20, 0x14, 0x00, 0x10, 0x00, 0x05, 0x00, 0x18, 0x01, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00,
112 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00
113 };
114
115 const uint8_t l2cap_enhanced_data_channel_le_conn_response_2_success[] = {
116 0x05, 0x20, 0x14, 0x00, 0x10, 0x00, 0x05, 0x00, 0x18, 0x01, 0x0c, 0x00, 0x64, 0x00, 0x30, 0x00,
117 0xff, 0xff, 0x00, 0x00, 0x41, 0x00, 0x42, 0x00
118 };
119
120 const uint8_t l2cap_enhanced_data_channel_classic_conn_response_2_success[] = {
121 0x03, 0x20, 0x14, 0x00, 0x10, 0x00, 0x01, 0x00, 0x18, 0x01, 0x0c, 0x00, 0x64, 0x00, 0x30, 0x00,
122 0xff, 0xff, 0x00, 0x00, 0x41, 0x00, 0x42, 0x00
123 };
124
125 const uint8_t l2cap_enhanced_data_channel_le_credits[] = {
126 0x05, 0x20, 0x0c, 0x00, 0x08, 0x00, 0x05, 0x00, 0x16, 0x02, 0x04, 0x00, 0x41, 0x00, 0x05, 0x00,
127 };
128
129 const uint8_t l2cap_enhanced_data_channel_classic_credits[] = {
130 0x03, 0x20, 0x0c, 0x00, 0x08, 0x00, 0x01, 0x00, 0x16, 0x02, 0x04, 0x00, 0x41, 0x00, 0x05, 0x00,
131 };
132
133 const uint8_t l2cap_enhanced_data_channel_le_single_packet[] = {
134 0x05, 0x20, 0x0b, 0x00, 0x07, 0x00, 0x41, 0x00, 0x05, 0x00, 0x68, 0x65, 0x6c, 0x6c, 0x6f
135 };
136
137 const uint8_t l2cap_enhanced_data_channel_classic_single_packet[] = {
138 0x03, 0x20, 0x0b, 0x00, 0x07, 0x00, 0x41, 0x00, 0x05, 0x00, 0x68, 0x65, 0x6c, 0x6c, 0x6f
139 };
140
141 const uint8_t l2cap_enhanced_data_channel_le_disconnect_request_1[] = {
142 0x05, 0x20, 0x0c, 0x00, 0x08, 0x00, 0x05, 0x00, 0x06, 0x02, 0x04, 0x00, 0x41, 0x00, 0x41, 0x00
143 };
144
145 const uint8_t l2cap_enhanced_data_channel_le_disconnect_response_1[] = {
146 0x05, 0x20, 0x0c, 0x00, 0x08, 0x00, 0x05, 0x00, 0x07, 0x02, 0x04, 0x00, 0x41, 0x00, 0x41, 0x00
147 };
148
149 const uint8_t l2cap_enhanced_data_channel_le_disconnect_request_2[] = {
150 0x05, 0x20, 0x0c, 0x00, 0x08, 0x00, 0x05, 0x00, 0x06, 0x03, 0x04, 0x00, 0x42, 0x00, 0x42, 0x00
151 };
152
153 const uint8_t l2cap_enhanced_data_channel_le_disconnect_response_2[] = {
154 0x05, 0x20, 0x0c, 0x00, 0x08, 0x00, 0x05, 0x00, 0x07, 0x03, 0x04, 0x00, 0x42, 0x00, 0x42, 0x00
155 };
156
157 const uint8_t l2cap_enhanced_data_channel_classic_disconnect_request_1[] = {
158 0x03, 0x20, 0x0c, 0x00, 0x08, 0x00, 0x01, 0x00, 0x06, 0x02, 0x04, 0x00, 0x41, 0x00, 0x41, 0x00
159 };
160
161 const uint8_t l2cap_enhanced_data_channel_classic_disconnect_response_1[] = {
162 0x03, 0x20, 0x0c, 0x00, 0x08, 0x00, 0x01, 0x00, 0x07, 0x02, 0x04, 0x00, 0x41, 0x00, 0x41, 0x00
163 };
164
165 const uint8_t l2cap_enhanced_data_channel_classic_disconnect_request_2[] = {
166 0x03, 0x20, 0x0c, 0x00, 0x08, 0x00, 0x01, 0x00, 0x06, 0x03, 0x04, 0x00, 0x42, 0x00, 0x42, 0x00
167 };
168
169 const uint8_t l2cap_enhanced_data_channel_classic_disconnect_response_2[] = {
170 0x03, 0x20, 0x0c, 0x00, 0x08, 0x00, 0x01, 0x00, 0x07, 0x03, 0x04, 0x00, 0x42, 0x00, 0x42, 0x00
171 };
172
173 const uint8_t l2cap_enhanced_data_channel_le_renegotiate_request[] = {
174 0x05, 0x20, 0x10, 0x00, 0x0c, 0x00, 0x05, 0x00, 0x19, 0x02, 0x08, 0x00, 0x64, 0x00, 0x30, 0x00,
175 0x41, 0x00, 0x42, 0x00
176 };
177
178 const uint8_t l2cap_enhanced_data_channel_classic_renegotiate_request[] = {
179 0x03, 0x20, 0x10, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x19, 0x02, 0x08, 0x00, 0x64, 0x00, 0x30, 0x00,
180 0x41, 0x00, 0x42, 0x00
181 };
182
183 const uint8_t l2cap_enhanced_data_channel_le_renegotiate_response[] = {
184 0x05, 0x20, 0x0a, 0x00, 0x06, 0x00, 0x05, 0x00, 0x1a, 0x02, 0x02, 0x00, 0x00, 0x00
185 };
186
187 const uint8_t l2cap_enhanced_data_channel_classic_renegotiate_response[] = {
188 0x03, 0x20, 0x0a, 0x00, 0x06, 0x00, 0x01, 0x00, 0x1a, 0x02, 0x02, 0x00, 0x00, 0x00
189 };
190
fix_boundary_flags(uint8_t * packet,uint16_t size)191 static void fix_boundary_flags(uint8_t * packet, uint16_t size){
192 uint8_t acl_flags = packet[1] >> 4;
193 if (acl_flags == 0){
194 acl_flags = 2; // first fragment
195 }
196 packet[1] = (packet[1] & 0x0f) | (acl_flags << 4);
197 }
198
print_acl(const char * name,const uint8_t * packet,uint16_t size)199 static void print_acl(const char * name, const uint8_t * packet, uint16_t size){
200 printf("const uint8_t %s[] = {", name);
201 uint16_t i;
202 for (i=0;i<size;i++){
203 if (i != 0){
204 printf(", ");
205 }
206 if ((i % 16) == 0){
207 printf("\n ");
208 }
209 printf("0x%02x", packet[i]);
210 }
211 printf("\n};\n");
212 }
213
214 // print packet for test inclusion
215 // fix_boundary_flags(mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size);
216 // print_acl("l2cap_enhanced_data_channel_le_single_packet", mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size);
217
l2cap_channel_packet_handler(uint8_t packet_type,uint16_t channel,uint8_t * packet,uint16_t size)218 static void l2cap_channel_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
219 UNUSED(channel);
220 UNUSED(size);
221 uint16_t psm;
222 uint16_t cid;
223 uint16_t cids[5];
224 switch (packet_type) {
225 case HCI_EVENT_PACKET:
226 switch (hci_event_packet_get_type(packet)) {
227 case L2CAP_EVENT_ECBM_INCOMING_CONNECTION:
228 printf("L2CAP_EVENT_DATA_CHANNEL_INCOMING\n");
229 cid = l2cap_event_ecbm_incoming_connection_get_local_cid(packet);
230 if (l2cap_channel_accept_incoming){
231 l2cap_ecbm_accept_channels(cid, 2, initial_credits, TEST_PACKET_SIZE, receive_buffers_2, cids);
232 } else {
233 // reject request by providing zero buffers
234 l2cap_ecbm_accept_channels(cid, 0, 0, 0,NULL, NULL);
235 }
236 break;
237 case L2CAP_EVENT_ECBM_CHANNEL_OPENED:
238 l2cap_cids[num_l2cap_channel_opened] = l2cap_event_ecbm_channel_opened_get_local_cid(packet);
239 printf("L2CAP_EVENT_DATA_CHANNEL_OPENED - cid 0x%04x\n", l2cap_cids[num_l2cap_channel_opened] );
240 num_l2cap_channel_opened++;
241 break;
242 case L2CAP_EVENT_ECBM_RECONFIGURATION_COMPLETE:
243 reconfigure_result = l2cap_event_ecbm_reconfiguration_complete_get_reconfigure_result(packet);
244 break;
245 case L2CAP_EVENT_CHANNEL_CLOSED:
246 num_l2cap_channel_closed++;
247 break;
248 default:
249 break;
250 }
251 break;
252 case L2CAP_DATA_PACKET:
253 printf("Pacekt received (%u bytes): ", size);
254 printf_hexdump(packet, size);
255 memcpy(received_packet, packet, size);
256 break;
257 default:
258 break;
259 }
260 }
261
TEST_GROUP(L2CAP_CHANNELS)262 TEST_GROUP(L2CAP_CHANNELS){
263 const hci_transport_t * hci_transport;
264 void setup(void){
265 btstack_memory_init();
266 btstack_run_loop_init(btstack_run_loop_embedded_get_instance());
267 hci_transport = mock_hci_transport_mock_get_instance();
268 hci_init(hci_transport, NULL);
269 l2cap_init();
270 l2cap_event_callback_registration.callback = &l2cap_channel_packet_handler;
271 l2cap_add_event_handler(&l2cap_event_callback_registration);
272 l2cap_register_fixed_channel(&l2cap_channel_packet_handler, L2CAP_CID_ATTRIBUTE_PROTOCOL);
273 hci_dump_init(hci_dump_posix_stdout_get_instance());
274 num_l2cap_channel_opened = 0;
275 num_l2cap_channel_closed = 0;
276 memset(received_packet, 0, sizeof(received_packet));
277 }
278 void teardown(void){
279 l2cap_deinit();
280 hci_deinit();
281 btstack_memory_deinit();
282 btstack_run_loop_deinit();
283 }
284 };
285
TEST(L2CAP_CHANNELS,no_connection)286 TEST(L2CAP_CHANNELS, no_connection){
287 uint16_t cids[2];
288 uint8_t status = l2cap_ecbm_create_channels(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_LE, LEVEL_0, TEST_PSM,
289 2, initial_credits, TEST_PACKET_SIZE, receive_buffers_2, cids);
290 CHECK_EQUAL(ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER, status);
291 }
292
TEST(L2CAP_CHANNELS,outgoing_le_2_success)293 TEST(L2CAP_CHANNELS, outgoing_le_2_success){
294 hci_setup_test_connections_fuzz();
295 uint16_t cids[2];
296 uint8_t status = l2cap_ecbm_create_channels(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_LE, LEVEL_0, TEST_PSM,
297 2, initial_credits, TEST_PACKET_SIZE, receive_buffers_2, cids);
298 CHECK_EQUAL(ERROR_CODE_SUCCESS, status);
299 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_le_conn_response_2_success, sizeof(l2cap_enhanced_data_channel_le_conn_response_2_success));
300 CHECK_EQUAL(2, num_l2cap_channel_opened);
301 }
302
TEST(L2CAP_CHANNELS,outgoing_classic_2_success)303 TEST(L2CAP_CHANNELS, outgoing_classic_2_success){
304 hci_setup_test_connections_fuzz();
305 uint16_t cids[2];
306 uint8_t status = l2cap_ecbm_create_channels(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_CLASSIC, LEVEL_0, TEST_PSM,
307 2, initial_credits, TEST_PACKET_SIZE, receive_buffers_2, cids);
308 CHECK_EQUAL(ERROR_CODE_SUCCESS, status);
309 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_classic_conn_response_2_success, sizeof(l2cap_enhanced_data_channel_classic_conn_response_2_success));
310 CHECK_EQUAL(2, num_l2cap_channel_opened);
311 }
312
TEST(L2CAP_CHANNELS,incoming_no_service)313 TEST(L2CAP_CHANNELS, incoming_no_service){
314 hci_setup_test_connections_fuzz();
315 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_le_conn_request_1, sizeof(l2cap_enhanced_data_channel_le_conn_request_1));
316 }
317
TEST(L2CAP_CHANNELS,incoming_classic_no_service)318 TEST(L2CAP_CHANNELS, incoming_classic_no_service){
319 hci_setup_test_connections_fuzz();
320 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_classic_conn_request_1, sizeof(l2cap_enhanced_data_channel_classic_conn_request_1));
321 }
322
TEST(L2CAP_CHANNELS,incoming_1)323 TEST(L2CAP_CHANNELS, incoming_1){
324 hci_setup_test_connections_fuzz();
325 l2cap_ecbm_register_service(&l2cap_channel_packet_handler, TEST_PSM, TEST_PACKET_SIZE, LEVEL_0, false);
326 l2cap_channel_accept_incoming = false;
327 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_le_conn_request_1, sizeof(l2cap_enhanced_data_channel_le_conn_request_1));
328 CHECK_EQUAL(0, num_l2cap_channel_opened);
329 }
330
TEST(L2CAP_CHANNELS,incoming_2)331 TEST(L2CAP_CHANNELS, incoming_2){
332 hci_setup_test_connections_fuzz();
333 l2cap_ecbm_register_service(&l2cap_channel_packet_handler, TEST_PSM, TEST_PACKET_SIZE, LEVEL_0, false);
334 l2cap_channel_accept_incoming = true;
335 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_le_conn_request_1, sizeof(l2cap_enhanced_data_channel_le_conn_request_1));
336 CHECK_EQUAL(2, num_l2cap_channel_opened);
337 }
338
TEST(L2CAP_CHANNELS,outgoing_le_receive_credits)339 TEST(L2CAP_CHANNELS, outgoing_le_receive_credits){
340 hci_setup_test_connections_fuzz();
341 uint16_t cids[2];
342 uint8_t status = l2cap_ecbm_create_channels(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_LE, LEVEL_0, TEST_PSM,
343 2, initial_credits, TEST_PACKET_SIZE, receive_buffers_2, cids);
344 CHECK_EQUAL(ERROR_CODE_SUCCESS, status);
345 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_le_conn_response_2_success, sizeof(l2cap_enhanced_data_channel_le_conn_response_2_success));
346 CHECK_EQUAL(2, num_l2cap_channel_opened);
347 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_le_credits, sizeof(l2cap_enhanced_data_channel_le_credits));
348 }
349
TEST(L2CAP_CHANNELS,outgoing_classic_receive_credits)350 TEST(L2CAP_CHANNELS, outgoing_classic_receive_credits){
351 hci_setup_test_connections_fuzz();
352 uint16_t cids[2];
353 uint8_t status = l2cap_ecbm_create_channels(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_CLASSIC, LEVEL_0, TEST_PSM,
354 2, initial_credits, TEST_PACKET_SIZE, receive_buffers_2, cids);
355 CHECK_EQUAL(ERROR_CODE_SUCCESS, status);
356 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_classic_conn_response_2_success, sizeof(l2cap_enhanced_data_channel_classic_conn_response_2_success));
357 CHECK_EQUAL(2, num_l2cap_channel_opened);
358 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_classic_credits, sizeof(l2cap_enhanced_data_channel_classic_credits));
359 }
360
TEST(L2CAP_CHANNELS,outgoing_le_send_packet)361 TEST(L2CAP_CHANNELS, outgoing_le_send_packet){
362 hci_setup_test_connections_fuzz();
363 uint16_t cids[2];
364 uint8_t status = l2cap_ecbm_create_channels(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_LE, LEVEL_0, TEST_PSM,
365 2, initial_credits, TEST_PACKET_SIZE, receive_buffers_2, cids);
366 CHECK_EQUAL(ERROR_CODE_SUCCESS, status);
367 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_le_conn_response_2_success, sizeof(l2cap_enhanced_data_channel_le_conn_response_2_success));
368 CHECK_EQUAL(2, num_l2cap_channel_opened);
369 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_le_credits, sizeof(l2cap_enhanced_data_channel_le_credits));
370 status = l2cap_send(l2cap_cids[0], (const uint8_t *) "hello", 5);
371 }
372
TEST(L2CAP_CHANNELS,outgoing_classic_send_packet)373 TEST(L2CAP_CHANNELS, outgoing_classic_send_packet){
374 hci_setup_test_connections_fuzz();
375 uint16_t cids[2];
376 uint8_t status = l2cap_ecbm_create_channels(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_CLASSIC, LEVEL_0, TEST_PSM,
377 2, initial_credits, TEST_PACKET_SIZE, receive_buffers_2, cids);
378 CHECK_EQUAL(ERROR_CODE_SUCCESS, status);
379 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_classic_conn_response_2_success, sizeof(l2cap_enhanced_data_channel_classic_conn_response_2_success));
380 CHECK_EQUAL(2, num_l2cap_channel_opened);
381 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_classic_credits, sizeof(l2cap_enhanced_data_channel_classic_credits));
382 status = l2cap_send(l2cap_cids[0], (const uint8_t *) "hello", 5);
383 }
384
TEST(L2CAP_CHANNELS,outgoing_le_receive_packet)385 TEST(L2CAP_CHANNELS, outgoing_le_receive_packet){
386 hci_setup_test_connections_fuzz();
387 uint16_t cids[2];
388 uint8_t status = l2cap_ecbm_create_channels(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_LE, LEVEL_0, TEST_PSM,
389 2, initial_credits, TEST_PACKET_SIZE, receive_buffers_2, cids);
390 CHECK_EQUAL(ERROR_CODE_SUCCESS, status);
391 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_le_conn_response_2_success, sizeof(l2cap_enhanced_data_channel_le_conn_response_2_success));
392 CHECK_EQUAL(2, num_l2cap_channel_opened);
393 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_le_single_packet, sizeof(l2cap_enhanced_data_channel_le_single_packet));
394 MEMCMP_EQUAL("hello", received_packet, 5);
395 }
396
TEST(L2CAP_CHANNELS,outgoing_classic_receive_packet)397 TEST(L2CAP_CHANNELS, outgoing_classic_receive_packet){
398 hci_setup_test_connections_fuzz();
399 uint16_t cids[2];
400 uint8_t status = l2cap_ecbm_create_channels(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_CLASSIC, LEVEL_0, TEST_PSM,
401 2, initial_credits, TEST_PACKET_SIZE, receive_buffers_2, cids);
402 CHECK_EQUAL(ERROR_CODE_SUCCESS, status);
403 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_classic_conn_response_2_success, sizeof(l2cap_enhanced_data_channel_classic_conn_response_2_success));
404 CHECK_EQUAL(2, num_l2cap_channel_opened);
405 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_classic_single_packet, sizeof(l2cap_enhanced_data_channel_classic_single_packet));
406 MEMCMP_EQUAL("hello", received_packet, 5);
407 }
408
TEST(L2CAP_CHANNELS,outgoing_le_provide_credits)409 TEST(L2CAP_CHANNELS, outgoing_le_provide_credits){
410 hci_setup_test_connections_fuzz();
411 uint16_t cids[2];
412 uint8_t status = l2cap_ecbm_create_channels(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_LE, LEVEL_0, TEST_PSM,
413 2, 0, TEST_PACKET_SIZE, receive_buffers_2, cids);
414 CHECK_EQUAL(ERROR_CODE_SUCCESS, status);
415 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_le_conn_response_2_success, sizeof(l2cap_enhanced_data_channel_le_conn_response_2_success));
416 CHECK_EQUAL(2, num_l2cap_channel_opened);
417 status = l2cap_ecbm_provide_credits(l2cap_cids[0], 5);
418 CHECK_EQUAL(ERROR_CODE_SUCCESS, status);
419 }
420
TEST(L2CAP_CHANNELS,outgoing_classic_provide_credits)421 TEST(L2CAP_CHANNELS, outgoing_classic_provide_credits){
422 hci_setup_test_connections_fuzz();
423 uint16_t cids[2];
424 uint8_t status = l2cap_ecbm_create_channels(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_CLASSIC, LEVEL_0, TEST_PSM,
425 2, 0, TEST_PACKET_SIZE, receive_buffers_2, cids);
426 CHECK_EQUAL(ERROR_CODE_SUCCESS, status);
427 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_classic_conn_response_2_success, sizeof(l2cap_enhanced_data_channel_classic_conn_response_2_success));
428 CHECK_EQUAL(2, num_l2cap_channel_opened);
429 status = l2cap_ecbm_provide_credits(l2cap_cids[0], 5);
430 CHECK_EQUAL(ERROR_CODE_SUCCESS, status);
431 }
432
TEST(L2CAP_CHANNELS,outgoing_le_renegotiate_initiator)433 TEST(L2CAP_CHANNELS, outgoing_le_renegotiate_initiator){
434 hci_setup_test_connections_fuzz();
435 reconfigure_result = 0xffff;
436 uint16_t cids[2];
437 uint8_t status = l2cap_ecbm_create_channels(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_LE, LEVEL_0, TEST_PSM,
438 2, 0, TEST_PACKET_SIZE, receive_buffers_2, cids);
439 CHECK_EQUAL(ERROR_CODE_SUCCESS, status);
440 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_le_conn_response_2_success, sizeof(l2cap_enhanced_data_channel_le_conn_response_2_success));
441 CHECK_EQUAL(2, num_l2cap_channel_opened);
442 status = l2cap_ecbm_reconfigure_channels(2, l2cap_cids, TEST_PACKET_SIZE/2, reconfigure_buffers_2);
443 CHECK_EQUAL(ERROR_CODE_SUCCESS, status);
444 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_le_renegotiate_response, sizeof(l2cap_enhanced_data_channel_le_renegotiate_response));
445 CHECK_EQUAL(0, reconfigure_result);
446 }
447
TEST(L2CAP_CHANNELS,outgoing_classic_renegotiate_initiator)448 TEST(L2CAP_CHANNELS, outgoing_classic_renegotiate_initiator){
449 hci_setup_test_connections_fuzz();
450 reconfigure_result = 0xffff;
451 uint16_t cids[2];
452 uint8_t status = l2cap_ecbm_create_channels(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_CLASSIC, LEVEL_0, TEST_PSM,
453 2, 0, TEST_PACKET_SIZE, receive_buffers_2, cids);
454 CHECK_EQUAL(ERROR_CODE_SUCCESS, status);
455 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_classic_conn_response_2_success, sizeof(l2cap_enhanced_data_channel_classic_conn_response_2_success));
456 CHECK_EQUAL(2, num_l2cap_channel_opened);
457 status = l2cap_ecbm_reconfigure_channels(2, l2cap_cids, TEST_PACKET_SIZE/2, reconfigure_buffers_2);
458 CHECK_EQUAL(ERROR_CODE_SUCCESS, status);
459 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_classic_renegotiate_response, sizeof(l2cap_enhanced_data_channel_classic_renegotiate_response));
460 CHECK_EQUAL(0, reconfigure_result);
461 }
462
TEST(L2CAP_CHANNELS,outgoing_le_renegotiate_responder)463 TEST(L2CAP_CHANNELS, outgoing_le_renegotiate_responder){
464 hci_setup_test_connections_fuzz();
465 uint16_t cids[2];
466 uint8_t status = l2cap_ecbm_create_channels(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_LE, LEVEL_0, TEST_PSM,
467 2, 0, TEST_PACKET_SIZE, receive_buffers_2, cids);
468 CHECK_EQUAL(ERROR_CODE_SUCCESS, status);
469 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_le_conn_response_2_success, sizeof(l2cap_enhanced_data_channel_le_conn_response_2_success));
470 CHECK_EQUAL(2, num_l2cap_channel_opened);
471 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_le_renegotiate_request, sizeof(l2cap_enhanced_data_channel_le_renegotiate_request));
472 fix_boundary_flags(mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size);
473 print_acl("l2cap_enhanced_data_channel_le_renegotiate_response", mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size);
474 }
475
TEST(L2CAP_CHANNELS,outgoing_classic_renegotiate_responder)476 TEST(L2CAP_CHANNELS, outgoing_classic_renegotiate_responder){
477 hci_setup_test_connections_fuzz();
478 uint16_t cids[2];
479 uint8_t status = l2cap_ecbm_create_channels(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_CLASSIC, LEVEL_0, TEST_PSM,
480 2, 0, TEST_PACKET_SIZE, receive_buffers_2, cids);
481 CHECK_EQUAL(ERROR_CODE_SUCCESS, status);
482 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_classic_conn_response_2_success, sizeof(l2cap_enhanced_data_channel_classic_conn_response_2_success));
483 CHECK_EQUAL(2, num_l2cap_channel_opened);
484 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_classic_renegotiate_request, sizeof(l2cap_enhanced_data_channel_classic_renegotiate_request));
485 fix_boundary_flags(mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size);
486 print_acl("l2cap_enhanced_data_channel_classic_renegotiate_response", mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size);
487 }
488
TEST(L2CAP_CHANNELS,outgoing_le_disconnect_initiator)489 TEST(L2CAP_CHANNELS, outgoing_le_disconnect_initiator){
490 hci_setup_test_connections_fuzz();
491 uint16_t cids[2];
492 uint8_t status = l2cap_ecbm_create_channels(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_LE, LEVEL_0, TEST_PSM,
493 2, 0, TEST_PACKET_SIZE, receive_buffers_2, cids);
494 CHECK_EQUAL(ERROR_CODE_SUCCESS, status);
495 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_le_conn_response_2_success, sizeof(l2cap_enhanced_data_channel_le_conn_response_2_success));
496 CHECK_EQUAL(2, num_l2cap_channel_opened);
497 l2cap_disconnect(l2cap_cids[0]);
498 l2cap_disconnect(l2cap_cids[1]);
499 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_le_disconnect_response_1, sizeof(l2cap_enhanced_data_channel_le_disconnect_response_1));
500 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_le_disconnect_response_2, sizeof(l2cap_enhanced_data_channel_le_disconnect_response_2));
501 CHECK_EQUAL(2, num_l2cap_channel_closed);
502 }
503
TEST(L2CAP_CHANNELS,outgoing_le_disconnect_responder)504 TEST(L2CAP_CHANNELS, outgoing_le_disconnect_responder){
505 hci_setup_test_connections_fuzz();
506 uint16_t cids[2];
507 uint8_t status = l2cap_ecbm_create_channels(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_LE, LEVEL_0, TEST_PSM,
508 2, 0, TEST_PACKET_SIZE, receive_buffers_2, cids);
509 CHECK_EQUAL(ERROR_CODE_SUCCESS, status);
510 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_le_conn_response_2_success, sizeof(l2cap_enhanced_data_channel_le_conn_response_2_success));
511 CHECK_EQUAL(2, num_l2cap_channel_opened);
512 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_le_disconnect_request_1, sizeof(l2cap_enhanced_data_channel_le_disconnect_request_1));
513 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_le_disconnect_request_2, sizeof(l2cap_enhanced_data_channel_le_disconnect_request_2));
514 CHECK_EQUAL(2, num_l2cap_channel_closed);
515 }
516
TEST(L2CAP_CHANNELS,outgoing_classic_disconnect_initiator)517 TEST(L2CAP_CHANNELS, outgoing_classic_disconnect_initiator){
518 hci_setup_test_connections_fuzz();
519 uint16_t cids[2];
520 uint8_t status = l2cap_ecbm_create_channels(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_CLASSIC, LEVEL_0, TEST_PSM,
521 2, 0, TEST_PACKET_SIZE, receive_buffers_2, cids);
522 CHECK_EQUAL(ERROR_CODE_SUCCESS, status);
523 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_classic_conn_response_2_success, sizeof(l2cap_enhanced_data_channel_classic_conn_response_2_success));
524 CHECK_EQUAL(2, num_l2cap_channel_opened);
525 l2cap_disconnect(l2cap_cids[0]);
526 l2cap_disconnect(l2cap_cids[1]);
527 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_classic_disconnect_response_1, sizeof(l2cap_enhanced_data_channel_classic_disconnect_response_1));
528 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_classic_disconnect_response_2, sizeof(l2cap_enhanced_data_channel_classic_disconnect_response_2));
529 CHECK_EQUAL(2, num_l2cap_channel_closed);
530 }
531
TEST(L2CAP_CHANNELS,outgoing_classic_disconnect_responder)532 TEST(L2CAP_CHANNELS, outgoing_classic_disconnect_responder){
533 hci_setup_test_connections_fuzz();
534 uint16_t cids[2];
535 uint8_t status = l2cap_ecbm_create_channels(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_CLASSIC, LEVEL_0, TEST_PSM,
536 2, 0, TEST_PACKET_SIZE, receive_buffers_2, cids);
537 CHECK_EQUAL(ERROR_CODE_SUCCESS, status);
538 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_classic_conn_response_2_success, sizeof(l2cap_enhanced_data_channel_classic_conn_response_2_success));
539 CHECK_EQUAL(2, num_l2cap_channel_opened);
540 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_classic_disconnect_request_1, sizeof(l2cap_enhanced_data_channel_classic_disconnect_request_1));
541 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_classic_disconnect_request_2, sizeof(l2cap_enhanced_data_channel_classic_disconnect_request_2));
542 CHECK_EQUAL(2, num_l2cap_channel_closed);
543 }
544
TEST(L2CAP_CHANNELS,outgoing_le_hci_disconnect)545 TEST(L2CAP_CHANNELS, outgoing_le_hci_disconnect){
546 hci_setup_test_connections_fuzz();
547 uint16_t cids[2];
548 uint8_t status = l2cap_ecbm_create_channels(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_LE, LEVEL_0, TEST_PSM,
549 2, 0, TEST_PACKET_SIZE, receive_buffers_2, cids);
550 CHECK_EQUAL(ERROR_CODE_SUCCESS, status);
551 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_le_conn_response_2_success, sizeof(l2cap_enhanced_data_channel_le_conn_response_2_success));
552 CHECK_EQUAL(2, num_l2cap_channel_opened);
553 mock_hci_emit_disconnection_complete(HCI_CON_HANDLE_TEST_LE, 0x13);
554 CHECK_EQUAL(2, num_l2cap_channel_closed);
555 }
556
TEST(L2CAP_CHANNELS,outgoing_classic_hci_disconnect)557 TEST(L2CAP_CHANNELS, outgoing_classic_hci_disconnect){
558 hci_setup_test_connections_fuzz();
559 uint16_t cids[2];
560 uint8_t status = l2cap_ecbm_create_channels(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_CLASSIC, LEVEL_0, TEST_PSM,
561 2, 0, TEST_PACKET_SIZE, receive_buffers_2, cids);
562 CHECK_EQUAL(ERROR_CODE_SUCCESS, status);
563 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, l2cap_enhanced_data_channel_classic_conn_response_2_success, sizeof(l2cap_enhanced_data_channel_classic_conn_response_2_success));
564 CHECK_EQUAL(2, num_l2cap_channel_opened);
565 mock_hci_emit_disconnection_complete(HCI_CON_HANDLE_TEST_CLASSIC, 0x13);
566 CHECK_EQUAL(2, num_l2cap_channel_closed);
567 }
568
main(int argc,const char * argv[])569 int main (int argc, const char * argv[]){
570 return CommandLineTestRunner::RunAllTests(argc, argv);
571 }
572