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_deinit(); 167 hci_deinit(); 168 btstack_memory_deinit(); 169 btstack_run_loop_deinit(); 170 } 171 }; 172 173 TEST(L2CAP_CHANNELS, fixed_channel){ 174 hci_setup_test_connections_fuzz(); 175 // channel does not exist 176 l2cap_request_can_send_fix_channel_now_event(HCI_CON_HANDLE_TEST_LE, 0x003f); 177 // att 178 l2cap_request_can_send_fix_channel_now_event(HCI_CON_HANDLE_TEST_LE, L2CAP_CID_ATTRIBUTE_PROTOCOL); 179 // 180 (void) l2cap_can_send_fixed_channel_packet_now(HCI_CON_HANDLE_TEST_LE, L2CAP_CID_ATTRIBUTE_PROTOCOL); 181 // packet buffer not reserved 182 log_info("ignore error in next line (calling .. without reserving buffer first"); 183 l2cap_send_prepared_connectionless(HCI_CON_HANDLE_TEST_LE, L2CAP_CID_ATTRIBUTE_PROTOCOL, 5); 184 // packet buffer reserved 185 l2cap_reserve_packet_buffer(); 186 l2cap_send_prepared_connectionless(HCI_CON_HANDLE_TEST_LE, L2CAP_CID_ATTRIBUTE_PROTOCOL, 5); 187 // 188 l2cap_send_connectionless(HCI_CON_HANDLE_TEST_LE, L2CAP_CID_ATTRIBUTE_PROTOCOL, (uint8_t *) "hallo", 5); 189 } 190 191 TEST(L2CAP_CHANNELS, some_functions){ 192 hci_setup_test_connections_fuzz(); 193 l2cap_reserve_packet_buffer(); 194 (void) l2cap_get_outgoing_buffer(); 195 l2cap_release_packet_buffer(); 196 l2cap_set_max_le_mtu(30); 197 l2cap_set_max_le_mtu(30); 198 l2cap_cbm_unregister_service(TEST_PSM); 199 l2cap_cbm_accept_connection(0X01, NULL, 0, 0); 200 l2cap_cbm_decline_connection(0x01, L2CAP_CBM_CONNECTION_RESULT_NO_RESOURCES_AVAILABLE); 201 l2cap_disconnect(0x01); 202 203 uint16_t credits = 10; 204 uint16_t mtu = 23; 205 uint8_t buffer[10]; 206 uint16_t out_local_cid; 207 208 l2cap_le_register_service(&l2cap_channel_packet_handler, TEST_PSM, LEVEL_2); 209 l2cap_le_unregister_service(TEST_PSM); 210 l2cap_le_accept_connection(0X01, buffer, mtu, credits); 211 l2cap_le_decline_connection(0X01); 212 l2cap_le_create_channel(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_LE, TEST_PSM, buffer, mtu, credits, LEVEL_2, &out_local_cid); 213 l2cap_le_provide_credits(0X01, credits); 214 l2cap_le_can_send_now(0X01); 215 l2cap_le_request_can_send_now_event(0X01); 216 l2cap_le_send_data(0X01, (const uint8_t * )buffer, sizeof(buffer)); 217 l2cap_le_disconnect(0X01); 218 } 219 220 TEST(L2CAP_CHANNELS, outgoing_no_connection){ 221 l2cap_cbm_create_channel(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_LE, TEST_PSM, data_channel_buffer, 222 sizeof(data_channel_buffer), L2CAP_LE_AUTOMATIC_CREDITS, LEVEL_0, &l2cap_cid); 223 } 224 225 TEST(L2CAP_CHANNELS, outgoing_security_1){ 226 hci_setup_test_connections_fuzz(); 227 l2cap_cbm_create_channel(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_LE, TEST_PSM, data_channel_buffer, 228 sizeof(data_channel_buffer), L2CAP_LE_AUTOMATIC_CREDITS, LEVEL_2, NULL); 229 l2cap_cbm_create_channel(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_LE, TEST_PSM, data_channel_buffer, 230 sizeof(data_channel_buffer), L2CAP_LE_AUTOMATIC_CREDITS, LEVEL_2, &l2cap_cid); 231 } 232 233 TEST(L2CAP_CHANNELS, outgoing_1){ 234 hci_setup_test_connections_fuzz(); 235 l2cap_cbm_create_channel(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_LE, TEST_PSM, data_channel_buffer, 236 sizeof(data_channel_buffer), L2CAP_LE_AUTOMATIC_CREDITS, LEVEL_0, &l2cap_cid); 237 // fix_boundary_flags(mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size); 238 // print_acl("le_data_channel_conn_request_1", mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size); 239 // simulate conn response 240 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, le_data_channel_conn_response_1, sizeof(le_data_channel_conn_response_1)); 241 CHECK(l2cap_channel_opened); 242 CHECK(hci_number_free_acl_slots_for_handle(HCI_CON_HANDLE_TEST_LE) > 0); 243 bool can_send_now = l2cap_can_send_packet_now(l2cap_cid); 244 CHECK(can_send_now); 245 l2cap_request_can_send_now_event(l2cap_cid); 246 CHECK(hci_number_free_acl_slots_for_handle(HCI_CON_HANDLE_TEST_LE) > 0); 247 l2cap_send(l2cap_cid, (uint8_t *) "hallo", 5); 248 // CHECK(hci_number_free_acl_slots_for_handle(HCI_CON_HANDLE_TEST) > 0); 249 // fix_boundary_flags(mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size); 250 // print_acl("le_data_channel_data_1", mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size); 251 // simulate data 252 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, le_data_channel_data_1, sizeof(le_data_channel_data_1)); 253 l2cap_disconnect(l2cap_cid); 254 } 255 256 TEST(L2CAP_CHANNELS, incoming_1){ 257 hci_setup_test_connections_fuzz(); 258 l2cap_cbm_register_service(&l2cap_channel_packet_handler, TEST_PSM, LEVEL_0); 259 // simulate conn request 260 l2cap_channel_accept_incoming = true; 261 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, le_data_channel_conn_request_1, sizeof(le_data_channel_conn_request_1)); 262 // fix_boundary_flags(mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size); 263 // print_acl("le_data_channel_conn_response_1", mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size); 264 // TODO: verify data 265 l2cap_cbm_unregister_service(TEST_PSM); 266 } 267 268 TEST(L2CAP_CHANNELS, incoming_2){ 269 hci_setup_test_connections_fuzz(); 270 l2cap_cbm_register_service(&l2cap_channel_packet_handler, TEST_PSM, LEVEL_2); 271 // simulate conn request 272 l2cap_channel_accept_incoming = true; 273 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, le_data_channel_conn_request_1, sizeof(le_data_channel_conn_request_1)); 274 } 275 276 TEST(L2CAP_CHANNELS, incoming_3){ 277 hci_setup_test_connections_fuzz(); 278 l2cap_cbm_register_service(&l2cap_channel_packet_handler, TEST_PSM, LEVEL_0); 279 // simulate conn request 280 l2cap_channel_accept_incoming = true; 281 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, le_data_channel_invalid_pdu, sizeof(le_data_channel_invalid_pdu)); 282 } 283 284 TEST(L2CAP_CHANNELS, incoming_decline){ 285 hci_setup_test_connections_fuzz(); 286 l2cap_cbm_register_service(&l2cap_channel_packet_handler, TEST_PSM, LEVEL_0); 287 // simulate conn request 288 l2cap_channel_accept_incoming = false; 289 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, le_data_channel_conn_request_1, sizeof(le_data_channel_conn_request_1)); 290 // fix_boundary_flags(mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size); 291 // print_acl("le_data_channel_conn_response_1", mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size); 292 // TODO: verify data 293 } 294 295 int main (int argc, const char * argv[]){ 296 return CommandLineTestRunner::RunAllTests(argc, argv); 297 } 298