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 = 0; 65 66 static uint8_t outgoing_rfcomm_payload[200]; 67 static uint16_t outgoing_rfcomm_payload_len = 0; 68 69 static uint8_t rfcomm_reserved_buffer[1000]; 70 71 void * active_connection; 72 hfp_connection_t * hfp_context; 73 74 void (*registered_rfcomm_packet_handler)(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size); 75 void (*registered_sdp_app_callback)(sdp_query_event_t * event, void * context); 76 77 uint8_t * get_rfcomm_payload(){ 78 return &rfcomm_payload[0]; 79 } 80 81 uint16_t get_rfcomm_payload_len(){ 82 return rfcomm_payload_len; 83 } 84 85 static int hfp_command_start_index = 0; 86 87 88 int has_more_hfp_commands(int start_command_offset, int end_command_offset){ 89 int has_cmd = get_rfcomm_payload_len() - hfp_command_start_index >= 2 + start_command_offset + end_command_offset; 90 //printf("has more: payload len %d, start %d, has more %d\n", get_rfcomm_payload_len(), hfp_command_start_index, has_cmd); 91 return has_cmd; 92 } 93 94 char * get_next_hfp_command(int start_command_offset, int end_command_offset){ 95 //printf("get next: payload len %d, start %d\n", get_rfcomm_payload_len(), hfp_command_start_index); 96 char * data = (char *)(&get_rfcomm_payload()[hfp_command_start_index + start_command_offset]); 97 int data_len = get_rfcomm_payload_len() - hfp_command_start_index - start_command_offset; 98 99 int i; 100 101 for (i = 0; i < data_len; i++){ 102 if ( *(data+i) == '\r' || *(data+i) == '\n' ) { 103 data[i]=0; 104 // update state 105 //printf("!!! command %s\n", data); 106 hfp_command_start_index = hfp_command_start_index + i + start_command_offset + end_command_offset; 107 return data; 108 } 109 } 110 printf("should not got here\n"); 111 return NULL; 112 } 113 114 void print_without_newlines(uint8_t *data, uint16_t len); 115 void print_without_newlines(uint8_t *data, uint16_t len){ 116 int found_newline = 0; 117 int found_item = 0; 118 119 for (int i=0; i<len; i++){ 120 if (data[i] == '\r' || data[i] == '\n'){ 121 if (!found_newline && found_item) printf("\n"); 122 found_newline = 1; 123 } else { 124 printf("%c", data[i]); 125 found_newline = 0; 126 found_item = 1; 127 } 128 } 129 printf("\n"); 130 } 131 132 extern "C" void l2cap_init(void){} 133 134 extern "C" void l2cap_register_packet_handler(void (*handler)(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size)){ 135 } 136 137 int rfcomm_send_internal(uint16_t rfcomm_cid, uint8_t *data, uint16_t len){ 138 int start_command_offset = 2; 139 int end_command_offset = 2; 140 141 if (strncmp((char*)data, "AT", 2) == 0){ 142 start_command_offset = 0; 143 } 144 145 if (has_more_hfp_commands(start_command_offset, end_command_offset)){ 146 //printf("Buffer response: "); 147 strncpy((char*)&rfcomm_payload[rfcomm_payload_len], (char*)data, len); 148 rfcomm_payload_len += len; 149 } else { 150 hfp_command_start_index = 0; 151 //printf("Copy response: "); 152 strncpy((char*)&rfcomm_payload[0], (char*)data, len); 153 rfcomm_payload_len = len; 154 } 155 156 //print_without_newlines(rfcomm_payload,rfcomm_payload_len); 157 return 0; 158 } 159 160 int rfcomm_reserve_packet_buffer(void){ 161 return 1; 162 }; 163 void rfcomm_release_packet_buffer(void){}; 164 uint8_t * rfcomm_get_outgoing_buffer(void) { 165 return rfcomm_reserved_buffer; 166 } 167 uint16_t rfcomm_get_max_frame_size(uint16_t rfcomm_cid){ 168 return sizeof(rfcomm_reserved_buffer); 169 } 170 int rfcomm_send_prepared(uint16_t rfcomm_cid, uint16_t len){ 171 printf("--- rfcomm_send_prepared with len %u ---\n", len); 172 return rfcomm_send_internal(rfcomm_cid, rfcomm_reserved_buffer, len); 173 } 174 175 static void hci_event_sco_complete(){ 176 uint8_t event[19]; 177 uint8_t pos = 0; 178 event[pos++] = HCI_EVENT_SYNCHRONOUS_CONNECTION_COMPLETE; 179 event[pos++] = sizeof(event) - 2; 180 181 event[pos++] = 0; //status 182 bt_store_16(event, pos, sco_handle); pos += 2; // sco handle 183 bt_flip_addr(&event[pos], dev_addr); pos += 6; 184 185 event[pos++] = 0; // link_type 186 event[pos++] = 0; // transmission_interval 187 event[pos++] = 0; // retransmission_interval 188 189 bt_store_16(event, pos, 0); pos += 2; // rx_packet_length 190 bt_store_16(event, pos, 0); pos += 2; // tx_packet_length 191 192 event[pos++] = 0; // air_mode 193 (*registered_rfcomm_packet_handler)(HCI_EVENT_PACKET, 0, event, sizeof(event)); 194 } 195 196 int hci_send_cmd(const hci_cmd_t *cmd, ...){ 197 //printf("hci_send_cmd opcode 0x%02x\n", cmd->opcode); 198 if (cmd->opcode == 0x428){ 199 hci_event_sco_complete(); 200 } 201 return 0; 202 } 203 204 205 void sdp_query_rfcomm_register_callback(void(*sdp_app_callback)(sdp_query_event_t * event, void * context), void * context){ 206 registered_sdp_app_callback = sdp_app_callback; 207 registered_sdp_app_context = context; 208 } 209 210 static void sdp_query_complete_response(uint8_t status){ 211 sdp_query_complete_event_t complete_event = { 212 SDP_QUERY_COMPLETE, 213 status 214 }; 215 (*registered_sdp_app_callback)((sdp_query_event_t*)&complete_event, registered_sdp_app_context); 216 } 217 218 static void sdp_query_rfcomm_service_response(uint8_t status){ 219 sdp_query_rfcomm_service_event_t service_event = { 220 SDP_QUERY_RFCOMM_SERVICE, 221 sdp_rfcomm_channel_nr, 222 (uint8_t *)sdp_rfcomm_service_name 223 }; 224 (*registered_sdp_app_callback)((sdp_query_event_t*)&service_event, registered_sdp_app_context); 225 } 226 227 void sdp_query_rfcomm_channel_and_name_for_uuid(bd_addr_t remote, uint16_t uuid){ 228 // printf("sdp_query_rfcomm_channel_and_name_for_uuid %p\n", registered_sdp_app_callback); 229 sdp_query_rfcomm_service_response(0); 230 sdp_query_complete_response(0); 231 } 232 233 234 uint8_t rfcomm_create_channel(bd_addr_t addr, uint8_t channel, uint16_t * out_cid){ 235 // RFCOMM_EVENT_OPEN_CHANNEL_COMPLETE 236 uint8_t event[16]; 237 uint8_t pos = 0; 238 event[pos++] = RFCOMM_EVENT_OPEN_CHANNEL_COMPLETE; 239 event[pos++] = sizeof(event) - 2; 240 event[pos++] = 0; 241 242 bt_flip_addr(&event[pos], addr); 243 memcpy(dev_addr, addr, 6); 244 pos += 6; 245 246 bt_store_16(event, pos, 1); pos += 2; 247 event[pos++] = 0; 248 249 bt_store_16(event, pos, rfcomm_cid); pos += 2; // channel ID 250 bt_store_16(event, pos, 200); pos += 2; // max frame size 251 (*registered_rfcomm_packet_handler)(HCI_EVENT_PACKET, 0, (uint8_t *) event, pos); 252 253 if (out_cid){ 254 *out_cid = rfcomm_cid; 255 } 256 return 0; 257 } 258 259 int rfcomm_can_send_packet_now(uint16_t rfcomm_cid){ 260 return 1; 261 } 262 263 void rfcomm_disconnect_internal(uint16_t rfcomm_cid){ 264 uint8_t event[4]; 265 event[0] = RFCOMM_EVENT_CHANNEL_CLOSED; 266 event[1] = sizeof(event) - 2; 267 bt_store_16(event, 2, rfcomm_cid); 268 (*registered_rfcomm_packet_handler)(HCI_EVENT_PACKET, 0, (uint8_t *) event, sizeof(event)); 269 } 270 271 void rfcomm_register_packet_handler(void (*handler)(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size)){ 272 registered_rfcomm_packet_handler = handler; 273 } 274 275 uint8_t rfcomm_register_service(uint8_t channel, uint16_t max_frame_size){ 276 printf("rfcomm_register_service\n"); 277 return 0; 278 } 279 280 281 void sdp_query_rfcomm_channel_and_name_for_search_pattern(bd_addr_t remote, uint8_t * des_serviceSearchPattern){ 282 printf("sdp_query_rfcomm_channel_and_name_for_search_pattern\n"); 283 } 284 285 286 void rfcomm_accept_connection_internal(uint16_t rfcomm_cid){ 287 printf("rfcomm_accept_connection_internal \n"); 288 } 289 290 void run_loop_add_timer(timer_source_t *timer){ 291 } 292 293 int run_loop_remove_timer(timer_source_t *timer){ 294 return 0; 295 } 296 void run_loop_set_timer_handler(timer_source_t *ts, void (*process)(timer_source_t *_ts)){ 297 } 298 299 void run_loop_set_timer(timer_source_t *a, uint32_t timeout_in_ms){ 300 } 301 302 303 void hci_emit_disconnection_complete(uint16_t handle, uint8_t reason){ 304 uint8_t event[6]; 305 event[0] = HCI_EVENT_DISCONNECTION_COMPLETE; 306 event[1] = sizeof(event) - 2; 307 event[2] = 0; // status = OK 308 bt_store_16(event, 3, handle); 309 event[5] = reason; 310 (*registered_rfcomm_packet_handler)(HCI_EVENT_PACKET, 0, event, sizeof(event)); 311 } 312 313 uint8_t gap_disconnect(hci_con_handle_t handle){ 314 hci_emit_disconnection_complete(handle, 0); 315 return 0; 316 } 317 318 uint16_t hci_get_sco_voice_setting(){ 319 return 0x40; 320 } 321 322 int hci_remote_eSCO_supported(hci_con_handle_t handle){ 323 return 0; 324 } 325 326 static void add_new_lines_to_hfp_command(uint8_t * data, int len){ 327 if (len <= 0) return; 328 memset(&outgoing_rfcomm_payload, 0, 200); 329 int pos = 0; 330 331 if (strncmp((char*)data, "AT", 2) == 0){ 332 strncpy((char*)&outgoing_rfcomm_payload[pos], (char*)data, len); 333 pos += len; 334 } else { 335 outgoing_rfcomm_payload[pos++] = '\r'; 336 outgoing_rfcomm_payload[pos++] = '\n'; 337 strncpy((char*)&outgoing_rfcomm_payload[pos], (char*)data, len); 338 pos += len; 339 } 340 outgoing_rfcomm_payload[pos++] = '\r'; 341 outgoing_rfcomm_payload[pos++] = '\n'; 342 outgoing_rfcomm_payload[pos] = 0; 343 outgoing_rfcomm_payload_len = pos; 344 } 345 346 void inject_hfp_command_to_hf(uint8_t * data, int len){ 347 if (memcmp((char*)data, "AT", 2) == 0) return; 348 add_new_lines_to_hfp_command(data, len); 349 // printf("inject_hfp_command_to_hf to HF: "); 350 // print_without_newlines(outgoing_rfcomm_payload,outgoing_rfcomm_payload_len); 351 (*registered_rfcomm_packet_handler)(active_connection, RFCOMM_DATA_PACKET, rfcomm_cid, (uint8_t *) &outgoing_rfcomm_payload[0], outgoing_rfcomm_payload_len); 352 353 } 354 355 void inject_hfp_command_to_ag(uint8_t * data, int len){ 356 if (data[0] == '+') return; 357 358 add_new_lines_to_hfp_command(data, len); 359 (*registered_rfcomm_packet_handler)(active_connection, RFCOMM_DATA_PACKET, rfcomm_cid, (uint8_t *) &outgoing_rfcomm_payload[0], outgoing_rfcomm_payload_len); 360 } 361 362 363 364