1 #include <stdint.h> 2 #include <stdio.h> 3 #include <stdlib.h> 4 #include <string.h> 5 6 #include "hci.h" 7 #include "gap.h" 8 #include "hci_dump.h" 9 #include "l2cap.h" 10 11 #include "ble/att_db.h" 12 #include "ble/att_dispatch.h" 13 #include "ble/sm.h" 14 15 #include "btstack_debug.h" 16 17 static btstack_packet_handler_t att_server_packet_handler; 18 static void (*registered_hci_event_handler) (uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size) = NULL; 19 20 static btstack_linked_list_t connections; 21 static const uint16_t max_mtu = 23; 22 static uint8_t l2cap_stack_buffer[HCI_INCOMING_PRE_BUFFER_SIZE + 8 + max_mtu]; // pre buffer + HCI Header + L2CAP header 23 static uint16_t gatt_client_handle = 0x40; 24 static hci_connection_t hci_connection; 25 26 uint16_t get_gatt_client_handle(void){ 27 return gatt_client_handle; 28 } 29 30 void mock_simulate_command_complete(const hci_cmd_t *cmd){ 31 uint8_t packet[] = {HCI_EVENT_COMMAND_COMPLETE, 4, 1, (uint8_t) (cmd->opcode & 0xff), (uint8_t) (cmd->opcode >> 8), 0}; 32 registered_hci_event_handler(HCI_EVENT_PACKET, 0, (uint8_t *)&packet, sizeof(packet)); 33 } 34 35 void mock_simulate_hci_state_working(void){ 36 uint8_t packet[3] = {BTSTACK_EVENT_STATE, 0, HCI_STATE_WORKING}; 37 registered_hci_event_handler(HCI_EVENT_PACKET, 0, (uint8_t *)&packet, 3); 38 } 39 40 void mock_simulate_connected(void){ 41 uint8_t packet[] = {0x3E, 0x13, 0x01, 0x00, 0x40, 0x00, 0x00, 0x00, 0x9B, 0x77, 0xD1, 0xF7, 0xB1, 0x34, 0x50, 0x00, 0x00, 0x00, 0xD0, 0x07, 0x05}; 42 registered_hci_event_handler(HCI_EVENT_PACKET, 0, (uint8_t *)&packet, sizeof(packet)); 43 } 44 45 void mock_simulate_scan_response(void){ 46 uint8_t packet[] = {0xE2, 0x13, 0xE2, 0x01, 0x34, 0xB1, 0xF7, 0xD1, 0x77, 0x9B, 0xCC, 0x09, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}; 47 registered_hci_event_handler(HCI_EVENT_PACKET, 0, (uint8_t *)&packet, sizeof(packet)); 48 } 49 50 void gap_start_scan(void){ 51 } 52 void gap_stop_scan(void){ 53 } 54 uint8_t gap_connect(const bd_addr_t addr, bd_addr_type_t addr_type){ 55 return 0; 56 } 57 void gap_set_scan_parameters(uint8_t scan_type, uint16_t scan_interval, uint16_t scan_window){ 58 } 59 60 int gap_reconnect_security_setup_active(hci_con_handle_t con_handle){ 61 UNUSED(con_handle); 62 return 0; 63 } 64 65 void att_init_connection(uint16_t con_handle){ 66 hci_connection.att_connection.mtu = 23; 67 hci_connection.att_connection.con_handle = con_handle; 68 hci_connection.att_connection.max_mtu = 23; 69 hci_connection.att_connection.encryption_key_size = 0; 70 hci_connection.att_connection.authenticated = 0; 71 hci_connection.att_connection.authorized = 0; 72 73 hci_connection.att_server.ir_le_device_db_index = 0; 74 75 if (btstack_linked_list_empty(&connections)){ 76 btstack_linked_list_add(&connections, (btstack_linked_item_t *)&hci_connection); 77 } 78 } 79 80 void hci_add_event_handler(btstack_packet_callback_registration_t * callback_handler){ 81 registered_hci_event_handler = callback_handler->callback; 82 } 83 84 bool hci_can_send_acl_le_packet_now(void){ 85 return true; 86 } 87 88 bool hci_can_send_command_packet_now(void){ 89 return true; 90 } 91 92 HCI_STATE hci_get_state(void){ 93 return HCI_STATE_WORKING; 94 } 95 96 uint8_t hci_send_cmd(const hci_cmd_t *cmd, ...){ 97 btstack_assert(false); 98 return ERROR_CODE_SUCCESS; 99 } 100 101 void hci_halting_defer(void){ 102 } 103 104 bool l2cap_can_send_connectionless_packet_now(void){ 105 return 1; 106 } 107 108 void l2cap_add_event_handler(btstack_packet_callback_registration_t * callback_handler){ 109 UNUSED(callback_handler); 110 } 111 112 uint8_t *l2cap_get_outgoing_buffer(void){ 113 // printf("l2cap_get_outgoing_buffer\n"); 114 return (uint8_t *)&l2cap_stack_buffer; // 8 bytes 115 } 116 117 uint16_t l2cap_max_mtu(void){ 118 // printf("l2cap_max_mtu\n"); 119 return max_mtu; 120 } 121 122 uint16_t l2cap_max_le_mtu(void){ 123 // printf("l2cap_max_mtu\n"); 124 return max_mtu; 125 } 126 127 void l2cap_init(void){} 128 129 bool l2cap_reserve_packet_buffer(void){ 130 return true; 131 } 132 133 void l2cap_release_packet_buffer(void){ 134 } 135 136 static uint8_t l2cap_can_send_fixed_channel_packet_now_status = 1; 137 138 void l2cap_can_send_fixed_channel_packet_now_set_status(uint8_t status){ 139 l2cap_can_send_fixed_channel_packet_now_status = status; 140 } 141 142 bool l2cap_can_send_fixed_channel_packet_now(uint16_t handle, uint16_t channel_id){ 143 return l2cap_can_send_fixed_channel_packet_now_status; 144 } 145 146 void l2cap_request_can_send_fix_channel_now_event(uint16_t handle, uint16_t channel_id){ 147 uint8_t event[] = { L2CAP_EVENT_CAN_SEND_NOW, 2, 1, 0}; 148 att_server_packet_handler(HCI_EVENT_PACKET, 0, (uint8_t*)event, sizeof(event)); 149 } 150 151 uint8_t l2cap_send_prepared_connectionless(uint16_t handle, uint16_t cid, uint16_t len){ 152 att_connection_t att_connection; 153 att_init_connection(handle); 154 uint8_t response[max_mtu]; 155 uint16_t response_len = att_handle_request(&att_connection, l2cap_get_outgoing_buffer(), len, &response[0]); 156 if (response_len){ 157 att_server_packet_handler(ATT_DATA_PACKET, gatt_client_handle, &response[0], response_len); 158 } 159 return ERROR_CODE_SUCCESS; 160 } 161 162 void sm_add_event_handler(btstack_packet_callback_registration_t * callback_handler){ 163 } 164 165 int sm_cmac_ready(void){ 166 return 1; 167 } 168 void sm_cmac_signed_write_start(const sm_key_t key, uint8_t opcode, uint16_t attribute_handle, uint16_t message_len, const uint8_t * message, uint32_t sign_counter, void (*done_callback)(uint8_t * hash)){ 169 //sm_notify_client(SM_EVENT_IDENTITY_RESOLVING_SUCCEEDED, sm_central_device_addr_type, sm_central_device_address, 0, sm_central_device_matched); 170 } 171 int sm_le_device_index(uint16_t handle ){ 172 return -1; 173 } 174 175 irk_lookup_state_t sm_identity_resolving_state(hci_con_handle_t con_handle){ 176 return IRK_LOOKUP_SUCCEEDED; 177 } 178 179 void sm_request_pairing(hci_con_handle_t con_handle){ 180 } 181 182 void btstack_run_loop_set_timer(btstack_timer_source_t *a, uint32_t timeout_in_ms){ 183 } 184 185 // Set callback that will be executed when timer expires. 186 void btstack_run_loop_set_timer_handler(btstack_timer_source_t *ts, void (*process)(btstack_timer_source_t *_ts)){ 187 } 188 189 // Add/Remove timer source. 190 void btstack_run_loop_add_timer(btstack_timer_source_t *timer){ 191 } 192 193 int btstack_run_loop_remove_timer(btstack_timer_source_t *timer){ 194 return 1; 195 } 196 197 void * btstack_run_loop_get_timer_context(btstack_timer_source_t *ts){ 198 return ts->context; 199 } 200 201 // todo: 202 hci_connection_t * hci_connection_for_bd_addr_and_type(const bd_addr_t addr, bd_addr_type_t addr_type){ 203 printf("hci_connection_for_bd_addr_and_type not implemented in mock backend\n"); 204 return NULL; 205 } 206 hci_connection_t * hci_connection_for_handle(hci_con_handle_t con_handle){ 207 if (con_handle != hci_connection.con_handle) return NULL; 208 return &hci_connection; 209 } 210 void hci_connections_get_iterator(btstack_linked_list_iterator_t *it){ 211 // printf("hci_connections_get_iterator not implemented in mock backend\n"); 212 btstack_linked_list_iterator_init(it, &connections); 213 } 214 215 // int hci_send_cmd(const hci_cmd_t *cmd, ...){ 216 // // printf("hci_send_cmd opcode 0x%02x\n", cmd->opcode); 217 // return 0; 218 // } 219 220 // int hci_can_send_packet_now_using_packet_buffer(uint8_t packet_type){ 221 // return 1; 222 // } 223 224 // void hci_disconnect_security_block(hci_con_handle_t con_handle){ 225 // printf("hci_disconnect_security_block \n"); 226 // } 227 228 // void hci_dump_log(const char * format, ...){ 229 // printf("hci_disconnect_security_block \n"); 230 // } 231 232 void l2cap_run(void){ 233 } 234 235 void l2cap_register_packet_handler(void (*handler)(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size)){ 236 } 237 238 bool gap_authenticated(hci_con_handle_t con_handle){ 239 return false; 240 } 241 authorization_state_t gap_authorization_state(hci_con_handle_t con_handle){ 242 return AUTHORIZATION_UNKNOWN; 243 } 244 uint8_t gap_encryption_key_size(hci_con_handle_t con_handle){ 245 return 0; 246 } 247 bool gap_secure_connection(hci_con_handle_t con_handle){ 248 return false; 249 } 250 gap_connection_type_t gap_get_connection_type(hci_con_handle_t connection_handle){ 251 return GAP_CONNECTION_INVALID; 252 } 253 int gap_request_connection_parameter_update(hci_con_handle_t con_handle, uint16_t conn_interval_min, 254 uint16_t conn_interval_max, uint16_t conn_latency, uint16_t supervision_timeout){ 255 return 0; 256 } 257 258 void mock_call_att_server_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 259 (*att_server_packet_handler)(packet_type, channel, packet, size); 260 } 261 262 void att_dispatch_register_server(btstack_packet_handler_t packet_handler){ 263 att_server_packet_handler = packet_handler; 264 } 265 266 int att_dispatch_server_can_send_now(hci_con_handle_t con_handle){ 267 UNUSED(con_handle); 268 return l2cap_can_send_fixed_channel_packet_now_status; 269 } 270 271 void att_dispatch_server_mtu_exchanged(hci_con_handle_t con_handle, uint16_t new_mtu){ 272 UNUSED(con_handle); 273 UNUSED(new_mtu); 274 } 275 276 void att_dispatch_server_request_can_send_now_event(hci_con_handle_t con_handle){ 277 if (l2cap_can_send_fixed_channel_packet_now_status){ 278 uint8_t event[] = { L2CAP_EVENT_CAN_SEND_NOW, 2, 1, 0}; 279 att_server_packet_handler(HCI_EVENT_PACKET, 0, (uint8_t*)event, sizeof(event)); 280 } 281 } 282