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 // 52 53 #include <stdint.h> 54 #include <stdio.h> 55 #include <stdlib.h> 56 #include <string.h> 57 58 #include "CppUTest/TestHarness.h" 59 #include "CppUTest/CommandLineTestRunner.h" 60 #include "CppUTestExt/MockSupport.h" 61 62 #include "hci_dump.h" 63 #include "btstack_debug.h" 64 #include "l2cap.h" 65 #include "btstack_memory.h" 66 #include "btstack_run_loop_embedded.h" 67 #include "hci_dump_posix_stdout.h" 68 #include "btstack_event.h" 69 70 #define TEST_PACKET_SIZE 100 71 #define HCI_CON_HANDLE_TEST_LE 0x0005 72 #define TEST_PSM 0x1001 73 74 static bool l2cap_channel_accept_incoming; 75 static uint16_t initial_credits = L2CAP_LE_AUTOMATIC_CREDITS; 76 static uint8_t data_channel_buffer[TEST_PACKET_SIZE]; 77 static uint16_t l2cap_cid; 78 static bool l2cap_channel_opened; 79 static btstack_packet_callback_registration_t l2cap_event_callback_registration; 80 81 const uint8_t le_data_channel_conn_request_1[] = { 82 0x05, 0x20, 0x12, 0x00, 0x0e, 0x00, 0x05, 0x00, 0x14, 0x01, 0x0a, 0x00, 0x01, 0x10, 0x41, 0x00, 83 0x64, 0x00, 0x30, 0x00, 0xff, 0xff 84 }; 85 86 const uint8_t le_data_channel_invalid_pdu[] = { 87 0x05, 0x20, 0x12, 0x00, 0x0e, 0x00, 0x05, 0x00, 0x11, 0x01, 0x0a, 0x00, 0x01, 0x10, 0x41, 0x00, 88 0x64, 0x00, 0x30, 0x00, 0xff, 0xff 89 }; 90 91 const uint8_t le_data_channel_conn_response_1[] = { 92 0x05, 0x20, 0x12, 0x00, 0x0e, 0x00, 0x05, 0x00, 0x15, 0x01, 0x0a, 0x00, 0x41, 0x00, 0x64, 0x00, 93 0x30, 0x00, 0xff, 0xff, 0x00, 0x00 94 }; 95 96 const uint8_t le_data_channel_data_1[] = { 97 0x05, 0x20, 0x04, 0x00, 0x00, 0x00, 0x41, 0x00 98 }; 99 100 static void fix_boundary_flags(uint8_t * packet, uint16_t size){ 101 uint8_t acl_flags = packet[1] >> 4; 102 if (acl_flags == 0){ 103 acl_flags = 2; // first fragment 104 } 105 packet[1] = (packet[1] & 0x0f) | (acl_flags << 4); 106 } 107 108 static void print_acl(const char * name, const uint8_t * packet, uint16_t size){ 109 printf("const uint8_t %s[] = {", name); 110 uint16_t i; 111 for (i=0;i<size;i++){ 112 if (i != 0){ 113 printf(", "); 114 } 115 if ((i % 16) == 0){ 116 printf("\n "); 117 } 118 printf("0x%02x", packet[i]); 119 } 120 printf("\n};\n"); 121 } 122 123 static void l2cap_channel_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 124 UNUSED(channel); 125 UNUSED(size); 126 uint16_t cid; 127 switch (packet_type) { 128 case HCI_EVENT_PACKET: 129 switch (hci_event_packet_get_type(packet)) { 130 case L2CAP_EVENT_CBM_INCOMING_CONNECTION: 131 cid = l2cap_event_cbm_incoming_connection_get_local_cid(packet); 132 if (l2cap_channel_accept_incoming){ 133 l2cap_cbm_accept_connection(cid, data_channel_buffer, sizeof(data_channel_buffer), initial_credits); 134 } else { 135 l2cap_cbm_decline_connection(cid, L2CAP_CBM_CONNECTION_RESULT_NO_RESOURCES_AVAILABLE); 136 } 137 break; 138 case L2CAP_EVENT_CBM_CHANNEL_OPENED: 139 l2cap_channel_opened = true; 140 break; 141 default: 142 break; 143 } 144 break; 145 default: 146 break; 147 } 148 } 149 150 TEST_GROUP(L2CAP_CHANNELS){ 151 const hci_transport_t * hci_transport; 152 void setup(void){ 153 btstack_memory_init(); 154 btstack_run_loop_init(btstack_run_loop_embedded_get_instance()); 155 hci_transport = mock_hci_transport_mock_get_instance(); 156 hci_init(hci_transport, NULL); 157 l2cap_init(); 158 l2cap_event_callback_registration.callback = &l2cap_channel_packet_handler; 159 l2cap_add_event_handler(&l2cap_event_callback_registration); 160 l2cap_register_fixed_channel(&l2cap_channel_packet_handler, L2CAP_CID_ATTRIBUTE_PROTOCOL); 161 hci_dump_init(hci_dump_posix_stdout_get_instance()); 162 l2cap_channel_opened = false; 163 } 164 void teardown(void){ 165 l2cap_remove_event_handler(&l2cap_event_callback_registration); 166 l2cap_finalize_channel_close(); 167 l2cap_deinit(); 168 hci_deinit(); 169 btstack_memory_deinit(); 170 btstack_run_loop_deinit(); 171 } 172 }; 173 174 TEST(L2CAP_CHANNELS, fixed_channel){ 175 hci_setup_test_connections_fuzz(); 176 // channel does not exist 177 l2cap_request_can_send_fix_channel_now_event(HCI_CON_HANDLE_TEST_LE, 0x003f); 178 // att 179 l2cap_request_can_send_fix_channel_now_event(HCI_CON_HANDLE_TEST_LE, L2CAP_CID_ATTRIBUTE_PROTOCOL); 180 // 181 (void) l2cap_can_send_fixed_channel_packet_now(HCI_CON_HANDLE_TEST_LE, L2CAP_CID_ATTRIBUTE_PROTOCOL); 182 // packet buffer not reserved 183 log_info("ignore error in next line (calling .. without reserving buffer first"); 184 l2cap_send_prepared_connectionless(HCI_CON_HANDLE_TEST_LE, L2CAP_CID_ATTRIBUTE_PROTOCOL, 5); 185 // packet buffer reserved 186 l2cap_reserve_packet_buffer(); 187 l2cap_send_prepared_connectionless(HCI_CON_HANDLE_TEST_LE, L2CAP_CID_ATTRIBUTE_PROTOCOL, 5); 188 // 189 l2cap_send_connectionless(HCI_CON_HANDLE_TEST_LE, L2CAP_CID_ATTRIBUTE_PROTOCOL, (uint8_t *) "hallo", 5); 190 } 191 192 TEST(L2CAP_CHANNELS, some_functions){ 193 hci_setup_test_connections_fuzz(); 194 l2cap_reserve_packet_buffer(); 195 (void) l2cap_get_outgoing_buffer(); 196 l2cap_release_packet_buffer(); 197 l2cap_set_max_le_mtu(30); 198 l2cap_set_max_le_mtu(30); 199 l2cap_cbm_unregister_service(TEST_PSM); 200 l2cap_cbm_accept_connection(0X01, NULL, 0, 0); 201 l2cap_cbm_decline_connection(0x01, L2CAP_CBM_CONNECTION_RESULT_NO_RESOURCES_AVAILABLE); 202 l2cap_disconnect(0x01); 203 204 uint16_t credits = 10; 205 uint16_t mtu = 23; 206 uint8_t buffer[10]; 207 uint16_t out_local_cid; 208 209 l2cap_le_register_service(&l2cap_channel_packet_handler, TEST_PSM, LEVEL_2); 210 l2cap_le_unregister_service(TEST_PSM); 211 l2cap_le_accept_connection(0X01, buffer, mtu, credits); 212 l2cap_le_decline_connection(0X01); 213 l2cap_le_create_channel(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_LE, TEST_PSM, buffer, mtu, credits, LEVEL_2, &out_local_cid); 214 l2cap_le_provide_credits(0X01, credits); 215 l2cap_le_can_send_now(0X01); 216 l2cap_le_request_can_send_now_event(0X01); 217 l2cap_le_send_data(0X01, (const uint8_t * )buffer, sizeof(buffer)); 218 l2cap_le_disconnect(0X01); 219 } 220 221 TEST(L2CAP_CHANNELS, outgoing_no_connection){ 222 l2cap_cbm_create_channel(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_LE, TEST_PSM, data_channel_buffer, 223 sizeof(data_channel_buffer), L2CAP_LE_AUTOMATIC_CREDITS, LEVEL_0, &l2cap_cid); 224 } 225 226 TEST(L2CAP_CHANNELS, outgoing_security_1){ 227 hci_setup_test_connections_fuzz(); 228 l2cap_cbm_create_channel(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_LE, TEST_PSM, data_channel_buffer, 229 sizeof(data_channel_buffer), L2CAP_LE_AUTOMATIC_CREDITS, LEVEL_2, NULL); 230 l2cap_cbm_create_channel(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_LE, TEST_PSM, data_channel_buffer, 231 sizeof(data_channel_buffer), L2CAP_LE_AUTOMATIC_CREDITS, LEVEL_2, &l2cap_cid); 232 } 233 234 TEST(L2CAP_CHANNELS, outgoing_1){ 235 hci_setup_test_connections_fuzz(); 236 l2cap_cbm_create_channel(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_LE, TEST_PSM, data_channel_buffer, 237 sizeof(data_channel_buffer), L2CAP_LE_AUTOMATIC_CREDITS, LEVEL_0, &l2cap_cid); 238 // fix_boundary_flags(mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size); 239 // print_acl("le_data_channel_conn_request_1", mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size); 240 // simulate conn response 241 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, le_data_channel_conn_response_1, sizeof(le_data_channel_conn_response_1)); 242 CHECK(l2cap_channel_opened); 243 CHECK(hci_number_free_acl_slots_for_handle(HCI_CON_HANDLE_TEST_LE) > 0); 244 bool can_send_now = l2cap_can_send_packet_now(l2cap_cid); 245 CHECK(can_send_now); 246 l2cap_request_can_send_now_event(l2cap_cid); 247 CHECK(hci_number_free_acl_slots_for_handle(HCI_CON_HANDLE_TEST_LE) > 0); 248 l2cap_send(l2cap_cid, (uint8_t *) "hallo", 5); 249 // CHECK(hci_number_free_acl_slots_for_handle(HCI_CON_HANDLE_TEST) > 0); 250 // fix_boundary_flags(mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size); 251 // print_acl("le_data_channel_data_1", mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size); 252 // simulate data 253 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, le_data_channel_data_1, sizeof(le_data_channel_data_1)); 254 l2cap_disconnect(l2cap_cid); 255 } 256 257 TEST(L2CAP_CHANNELS, incoming_1){ 258 hci_setup_test_connections_fuzz(); 259 l2cap_cbm_register_service(&l2cap_channel_packet_handler, TEST_PSM, LEVEL_0); 260 // simulate conn request 261 l2cap_channel_accept_incoming = true; 262 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, le_data_channel_conn_request_1, sizeof(le_data_channel_conn_request_1)); 263 // fix_boundary_flags(mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size); 264 // print_acl("le_data_channel_conn_response_1", mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size); 265 // TODO: verify data 266 l2cap_cbm_unregister_service(TEST_PSM); 267 } 268 269 TEST(L2CAP_CHANNELS, incoming_2){ 270 hci_setup_test_connections_fuzz(); 271 l2cap_cbm_register_service(&l2cap_channel_packet_handler, TEST_PSM, LEVEL_2); 272 // simulate conn request 273 l2cap_channel_accept_incoming = true; 274 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, le_data_channel_conn_request_1, sizeof(le_data_channel_conn_request_1)); 275 } 276 277 TEST(L2CAP_CHANNELS, incoming_3){ 278 hci_setup_test_connections_fuzz(); 279 l2cap_cbm_register_service(&l2cap_channel_packet_handler, TEST_PSM, LEVEL_0); 280 // simulate conn request 281 l2cap_channel_accept_incoming = true; 282 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, le_data_channel_invalid_pdu, sizeof(le_data_channel_invalid_pdu)); 283 } 284 285 TEST(L2CAP_CHANNELS, incoming_decline){ 286 hci_setup_test_connections_fuzz(); 287 l2cap_cbm_register_service(&l2cap_channel_packet_handler, TEST_PSM, LEVEL_0); 288 // simulate conn request 289 l2cap_channel_accept_incoming = false; 290 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, le_data_channel_conn_request_1, sizeof(le_data_channel_conn_request_1)); 291 // fix_boundary_flags(mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size); 292 // print_acl("le_data_channel_conn_response_1", mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size); 293 // TODO: verify data 294 } 295 296 int main (int argc, const char * argv[]){ 297 return CommandLineTestRunner::RunAllTests(argc, argv); 298 } 299