1 2 // hal_cpu 3 #include "hal_cpu.h" 4 void hal_cpu_disable_irqs(void){} 5 void hal_cpu_enable_irqs(void){} 6 void hal_cpu_enable_irqs_and_sleep(void){} 7 8 // mock_sm.c 9 #include "ble/sm.h" 10 void sm_add_event_handler(btstack_packet_callback_registration_t * callback_handler){} 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); 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 } 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 } 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 } 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 569 int main (int argc, const char * argv[]){ 570 return CommandLineTestRunner::RunAllTests(argc, argv); 571 } 572