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 psm; 127 uint16_t cid; 128 switch (packet_type) { 129 case HCI_EVENT_PACKET: 130 switch (hci_event_packet_get_type(packet)) { 131 case L2CAP_EVENT_CBM_INCOMING_CONNECTION: 132 psm = l2cap_event_cbm_incoming_connection_get_psm(packet); 133 cid = l2cap_event_cbm_incoming_connection_get_local_cid(packet); 134 if (l2cap_channel_accept_incoming){ 135 l2cap_cbm_accept_connection(cid, data_channel_buffer, sizeof(data_channel_buffer), initial_credits); 136 } else { 137 l2cap_cbm_decline_connection(cid, L2CAP_CBM_CONNECTION_RESULT_NO_RESOURCES_AVAILABLE); 138 } 139 break; 140 case L2CAP_EVENT_CBM_CHANNEL_OPENED: 141 l2cap_channel_opened = true; 142 break; 143 default: 144 break; 145 } 146 break; 147 default: 148 break; 149 } 150 } 151 152 TEST_GROUP(L2CAP_CHANNELS){ 153 const hci_transport_t * hci_transport; 154 void setup(void){ 155 btstack_memory_init(); 156 btstack_run_loop_init(btstack_run_loop_embedded_get_instance()); 157 hci_transport = mock_hci_transport_mock_get_instance(); 158 hci_init(hci_transport, NULL); 159 l2cap_init(); 160 l2cap_event_callback_registration.callback = &l2cap_channel_packet_handler; 161 l2cap_add_event_handler(&l2cap_event_callback_registration); 162 l2cap_register_fixed_channel(&l2cap_channel_packet_handler, L2CAP_CID_ATTRIBUTE_PROTOCOL); 163 hci_dump_init(hci_dump_posix_stdout_get_instance()); 164 l2cap_channel_opened = false; 165 } 166 void teardown(void){ 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 205 TEST(L2CAP_CHANNELS, outgoing_no_connection){ 206 l2cap_cbm_create_channel(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_LE, TEST_PSM, data_channel_buffer, 207 sizeof(data_channel_buffer), L2CAP_LE_AUTOMATIC_CREDITS, LEVEL_0, &l2cap_cid); 208 } 209 210 TEST(L2CAP_CHANNELS, outgoing_security_1){ 211 hci_setup_test_connections_fuzz(); 212 l2cap_cbm_create_channel(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_LE, TEST_PSM, data_channel_buffer, 213 sizeof(data_channel_buffer), L2CAP_LE_AUTOMATIC_CREDITS, LEVEL_2, NULL); 214 l2cap_cbm_create_channel(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_LE, TEST_PSM, data_channel_buffer, 215 sizeof(data_channel_buffer), L2CAP_LE_AUTOMATIC_CREDITS, LEVEL_2, &l2cap_cid); 216 } 217 218 TEST(L2CAP_CHANNELS, outgoing_1){ 219 hci_setup_test_connections_fuzz(); 220 l2cap_cbm_create_channel(&l2cap_channel_packet_handler, HCI_CON_HANDLE_TEST_LE, TEST_PSM, data_channel_buffer, 221 sizeof(data_channel_buffer), L2CAP_LE_AUTOMATIC_CREDITS, LEVEL_0, &l2cap_cid); 222 // fix_boundary_flags(mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size); 223 // print_acl("le_data_channel_conn_request_1", mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size); 224 // simulate conn response 225 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, le_data_channel_conn_response_1, sizeof(le_data_channel_conn_response_1)); 226 CHECK(l2cap_channel_opened); 227 CHECK(hci_number_free_acl_slots_for_handle(HCI_CON_HANDLE_TEST_LE) > 0); 228 bool can_send_now = l2cap_can_send_packet_now(l2cap_cid); 229 CHECK(can_send_now); 230 l2cap_request_can_send_now_event(l2cap_cid); 231 CHECK(hci_number_free_acl_slots_for_handle(HCI_CON_HANDLE_TEST_LE) > 0); 232 l2cap_send(l2cap_cid, (uint8_t *) "hallo", 5); 233 // CHECK(hci_number_free_acl_slots_for_handle(HCI_CON_HANDLE_TEST) > 0); 234 // fix_boundary_flags(mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size); 235 // print_acl("le_data_channel_data_1", mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size); 236 // simulate data 237 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, le_data_channel_data_1, sizeof(le_data_channel_data_1)); 238 l2cap_disconnect(l2cap_cid); 239 } 240 241 TEST(L2CAP_CHANNELS, incoming_1){ 242 hci_setup_test_connections_fuzz(); 243 l2cap_cbm_register_service(&l2cap_channel_packet_handler, TEST_PSM, LEVEL_0); 244 // simulate conn request 245 l2cap_channel_accept_incoming = true; 246 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, le_data_channel_conn_request_1, sizeof(le_data_channel_conn_request_1)); 247 // fix_boundary_flags(mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size); 248 // print_acl("le_data_channel_conn_response_1", mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size); 249 // TODO: verify data 250 l2cap_cbm_unregister_service(TEST_PSM); 251 } 252 253 TEST(L2CAP_CHANNELS, incoming_2){ 254 hci_setup_test_connections_fuzz(); 255 l2cap_cbm_register_service(&l2cap_channel_packet_handler, TEST_PSM, LEVEL_2); 256 // simulate conn request 257 l2cap_channel_accept_incoming = true; 258 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, le_data_channel_conn_request_1, sizeof(le_data_channel_conn_request_1)); 259 } 260 261 TEST(L2CAP_CHANNELS, incoming_3){ 262 hci_setup_test_connections_fuzz(); 263 l2cap_cbm_register_service(&l2cap_channel_packet_handler, TEST_PSM, LEVEL_0); 264 // simulate conn request 265 l2cap_channel_accept_incoming = true; 266 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, le_data_channel_invalid_pdu, sizeof(le_data_channel_invalid_pdu)); 267 } 268 269 TEST(L2CAP_CHANNELS, incoming_decline){ 270 hci_setup_test_connections_fuzz(); 271 l2cap_cbm_register_service(&l2cap_channel_packet_handler, TEST_PSM, LEVEL_0); 272 // simulate conn request 273 l2cap_channel_accept_incoming = false; 274 mock_hci_transport_receive_packet(HCI_ACL_DATA_PACKET, le_data_channel_conn_request_1, sizeof(le_data_channel_conn_request_1)); 275 // fix_boundary_flags(mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size); 276 // print_acl("le_data_channel_conn_response_1", mock_hci_transport_outgoing_packet_buffer, mock_hci_transport_outgoing_packet_size); 277 // TODO: verify data 278 } 279 280 int main (int argc, const char * argv[]){ 281 return CommandLineTestRunner::RunAllTests(argc, argv); 282 } 283