1 /* 2 * Copyright (C) 2014 BlueKitchen GmbH 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. Neither the name of the copyright holders nor the names of 14 * contributors may be used to endorse or promote products derived 15 * from this software without specific prior written permission. 16 * 4. Any redistribution, use, or modification is done solely for 17 * personal benefit and not for any commercial purpose or for 18 * monetary gain. 19 * 20 * THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS 21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL MATTHIAS 24 * RINGWALD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 26 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 27 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 28 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 29 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF 30 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 * Please inquire about commercial licensing options at 34 * [email protected] 35 * 36 */ 37 38 // ***************************************************************************** 39 // 40 // HFP BTstack Mocks 41 // 42 // ***************************************************************************** 43 44 #include <stdint.h> 45 #include <stdio.h> 46 #include <stdlib.h> 47 #include <string.h> 48 49 #include "hci.h" 50 #include "hci_dump.h" 51 #include "classic/sdp_query_rfcomm.h" 52 #include "classic/rfcomm.h" 53 #include "classic/hfp_hf.h" 54 55 #include "mock.h" 56 57 static void *registered_sdp_app_context; 58 static uint8_t sdp_rfcomm_channel_nr = 1; 59 const char sdp_rfcomm_service_name[] = "BTstackMock"; 60 static uint16_t rfcomm_cid = 1; 61 static bd_addr_t dev_addr; 62 static uint16_t sco_handle = 10; 63 static uint8_t rfcomm_payload[200]; 64 static uint16_t rfcomm_payload_len; 65 void * active_connection; 66 hfp_connection_t * hfp_context; 67 68 void (*registered_rfcomm_packet_handler)(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size); 69 void (*registered_sdp_app_callback)(sdp_query_event_t * event, void * context); 70 71 uint8_t * get_rfcomm_payload(){ 72 return &rfcomm_payload[0]; 73 } 74 75 uint16_t get_rfcomm_payload_len(){ 76 return rfcomm_payload_len; 77 } 78 79 static void prepare_rfcomm_buffer(uint8_t * data, int len){ 80 if (len <= 0) return; 81 memset(&rfcomm_payload, 0, 200); 82 int pos = 0; 83 84 if (strncmp((char*)data, "AT", 2) == 0){ 85 strncpy((char*)&rfcomm_payload[pos], (char*)data, len); 86 pos += len; 87 } else { 88 rfcomm_payload[pos++] = '\r'; 89 rfcomm_payload[pos++] = '\n'; 90 strncpy((char*)&rfcomm_payload[pos], (char*)data, len); 91 pos += len; 92 93 if (memcmp((char*)data, "+BAC", 4) != 0 && 94 memcmp((char*)data, "+BCS", 4) != 0){ 95 rfcomm_payload[pos++] = '\r'; 96 rfcomm_payload[pos++] = '\n'; 97 rfcomm_payload[pos++] = 'O'; 98 rfcomm_payload[pos++] = 'K'; 99 } 100 101 } 102 rfcomm_payload[pos++] = '\r'; 103 rfcomm_payload[pos++] = '\n'; 104 rfcomm_payload[pos] = 0; 105 rfcomm_payload_len = pos; 106 } 107 108 static void print_without_newlines(uint8_t *data, uint16_t len){ 109 int found_newline = 0; 110 int found_item = 0; 111 112 for (int i=0; i<len; i++){ 113 if (data[i] == '\r' || data[i] == '\n'){ 114 if (!found_newline && found_item) printf("\n"); 115 found_newline = 1; 116 } else { 117 printf("%c", data[i]); 118 found_newline = 0; 119 found_item = 1; 120 } 121 } 122 printf("\n"); 123 } 124 125 extern "C" void l2cap_init(void){} 126 127 extern "C" void l2cap_register_packet_handler(void (*handler)(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size)){ 128 } 129 130 131 int rfcomm_send_internal(uint16_t rfcomm_cid, uint8_t *data, uint16_t len){ 132 if (strncmp((char*)data, "AT", 2) == 0){ 133 printf("Verify HF state machine response: "); 134 print_without_newlines(data,len); 135 } else { 136 printf("Verify AG state machine response: "); 137 print_without_newlines(data,len); 138 } 139 strncpy((char*)&rfcomm_payload[0], (char*)data, len); 140 rfcomm_payload_len = len; 141 return 0; 142 } 143 144 static void hci_event_sco_complete(){ 145 uint8_t event[19]; 146 uint8_t pos = 0; 147 event[pos++] = HCI_EVENT_SYNCHRONOUS_CONNECTION_COMPLETE; 148 event[pos++] = sizeof(event) - 2; 149 150 event[pos++] = 0; //status 151 bt_store_16(event, pos, sco_handle); pos += 2; // sco handle 152 bt_flip_addr(&event[pos], dev_addr); pos += 6; 153 154 event[pos++] = 0; // link_type 155 event[pos++] = 0; // transmission_interval 156 event[pos++] = 0; // retransmission_interval 157 158 bt_store_16(event, pos, 0); pos += 2; // rx_packet_length 159 bt_store_16(event, pos, 0); pos += 2; // tx_packet_length 160 161 event[pos++] = 0; // air_mode 162 (*registered_rfcomm_packet_handler)(HCI_EVENT_PACKET, 0, event, sizeof(event)); 163 } 164 165 int hci_send_cmd(const hci_cmd_t *cmd, ...){ 166 printf("hci_send_cmd opcode 0x%02x\n", cmd->opcode); 167 if (cmd->opcode == 0x428){ 168 hci_event_sco_complete(); 169 } 170 return 0; 171 } 172 173 174 void sdp_query_rfcomm_register_callback(void(*sdp_app_callback)(sdp_query_event_t * event, void * context), void * context){ 175 registered_sdp_app_callback = sdp_app_callback; 176 registered_sdp_app_context = context; 177 } 178 179 static void sdp_query_complete_response(uint8_t status){ 180 sdp_query_complete_event_t complete_event = { 181 SDP_QUERY_COMPLETE, 182 status 183 }; 184 (*registered_sdp_app_callback)((sdp_query_event_t*)&complete_event, registered_sdp_app_context); 185 } 186 187 static void sdp_query_rfcomm_service_response(uint8_t status){ 188 sdp_query_rfcomm_service_event_t service_event = { 189 SDP_QUERY_RFCOMM_SERVICE, 190 sdp_rfcomm_channel_nr, 191 (uint8_t *)sdp_rfcomm_service_name 192 }; 193 (*registered_sdp_app_callback)((sdp_query_event_t*)&service_event, registered_sdp_app_context); 194 } 195 196 void sdp_query_rfcomm_channel_and_name_for_uuid(bd_addr_t remote, uint16_t uuid){ 197 // printf("sdp_query_rfcomm_channel_and_name_for_uuid %p\n", registered_sdp_app_callback); 198 sdp_query_rfcomm_service_response(0); 199 sdp_query_complete_response(0); 200 } 201 202 203 uint8_t rfcomm_create_channel(bd_addr_t addr, uint8_t channel, uint16_t * out_cid){ 204 // RFCOMM_EVENT_OPEN_CHANNEL_COMPLETE 205 uint8_t event[16]; 206 uint8_t pos = 0; 207 event[pos++] = RFCOMM_EVENT_OPEN_CHANNEL_COMPLETE; 208 event[pos++] = sizeof(event) - 2; 209 event[pos++] = 0; 210 211 bt_flip_addr(&event[pos], addr); 212 memcpy(dev_addr, addr, 6); 213 pos += 6; 214 215 bt_store_16(event, pos, 1); pos += 2; 216 event[pos++] = 0; 217 218 bt_store_16(event, pos, rfcomm_cid); pos += 2; // channel ID 219 bt_store_16(event, pos, 200); pos += 2; // max frame size 220 (*registered_rfcomm_packet_handler)(HCI_EVENT_PACKET, 0, (uint8_t *) event, pos); 221 222 if (out_cid){ 223 *out_cid = rfcomm_cid; 224 } 225 return 0; 226 } 227 228 int rfcomm_can_send_packet_now(uint16_t rfcomm_cid){ 229 return 1; 230 } 231 232 void rfcomm_disconnect_internal(uint16_t rfcomm_cid){ 233 uint8_t event[4]; 234 event[0] = RFCOMM_EVENT_CHANNEL_CLOSED; 235 event[1] = sizeof(event) - 2; 236 bt_store_16(event, 2, rfcomm_cid); 237 (*registered_rfcomm_packet_handler)(HCI_EVENT_PACKET, 0, (uint8_t *) event, sizeof(event)); 238 } 239 240 void rfcomm_register_packet_handler(void (*handler)(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size)){ 241 registered_rfcomm_packet_handler = handler; 242 } 243 244 uint8_t rfcomm_register_service(uint8_t channel, uint16_t max_frame_size){ 245 printf("rfcomm_register_service\n"); 246 return 0; 247 } 248 249 250 void sdp_query_rfcomm_channel_and_name_for_search_pattern(bd_addr_t remote, uint8_t * des_serviceSearchPattern){ 251 printf("sdp_query_rfcomm_channel_and_name_for_search_pattern\n"); 252 } 253 254 255 void rfcomm_accept_connection_internal(uint16_t rfcomm_cid){ 256 printf("rfcomm_accept_connection_internal \n"); 257 } 258 259 void run_loop_add_timer(timer_source_t *timer){ 260 } 261 262 int run_loop_remove_timer(timer_source_t *timer){ 263 return 0; 264 } 265 void run_loop_set_timer_handler(timer_source_t *ts, void (*process)(timer_source_t *_ts)){ 266 } 267 268 void run_loop_set_timer(timer_source_t *a, uint32_t timeout_in_ms){ 269 } 270 271 272 void hci_emit_disconnection_complete(uint16_t handle, uint8_t reason){ 273 uint8_t event[6]; 274 event[0] = HCI_EVENT_DISCONNECTION_COMPLETE; 275 event[1] = sizeof(event) - 2; 276 event[2] = 0; // status = OK 277 bt_store_16(event, 3, handle); 278 event[5] = reason; 279 (*registered_rfcomm_packet_handler)(HCI_EVENT_PACKET, 0, event, sizeof(event)); 280 } 281 282 uint8_t gap_disconnect(hci_con_handle_t handle){ 283 hci_emit_disconnection_complete(handle, 0); 284 return 0; 285 } 286 287 uint16_t hci_get_sco_voice_setting(){ 288 return 0x40; 289 } 290 291 void inject_rfcomm_command_to_hf(uint8_t * data, int len){ 292 if (memcmp((char*)data, "AT", 2) == 0) return; 293 294 prepare_rfcomm_buffer(data, len); 295 if (data[0] == '+' || (data[0] == 'O' && data[1] == 'K')){ 296 printf("Send cmd to HF state machine: %s\n", data); 297 } else { 298 printf("Trigger HF state machine - %s", data); 299 } 300 (*registered_rfcomm_packet_handler)(RFCOMM_DATA_PACKET, rfcomm_cid, (uint8_t *) &rfcomm_payload[0], rfcomm_payload_len); 301 } 302 303 void inject_rfcomm_command_to_ag(uint8_t * data, int len){ 304 if (data[0] == '+') return; 305 306 prepare_rfcomm_buffer(data, len); 307 if (memcmp((char*)data, "AT", 2) == 0){ 308 printf("Send cmd to AG state machine: %s\n", data); 309 } else { 310 printf("Trigger AG state machine - %s", data); 311 } 312 (*registered_rfcomm_packet_handler)( RFCOMM_DATA_PACKET, rfcomm_cid, (uint8_t *) &rfcomm_payload[0], rfcomm_payload_len); 313 } 314 315 316 317