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 BLUEKITCHEN 24 * GMBH 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 #define BTSTACK_FILE__ "daemon.c" 39 40 /* 41 * daemon.c 42 * 43 * Created by Matthias Ringwald on 7/1/09. 44 * 45 * BTstack background daemon 46 * 47 */ 48 49 #include "btstack_config.h" 50 51 #include <pthread.h> 52 #include <signal.h> 53 #include <stdio.h> 54 #include <stdlib.h> 55 #include <strings.h> 56 #include <unistd.h> 57 58 #ifdef _WIN32 59 #include "Winsock2.h" 60 #endif 61 62 #include <getopt.h> 63 64 #include "btstack.h" 65 #include "btstack_client.h" 66 #include "btstack_debug.h" 67 #include "btstack_device_name_db.h" 68 #include "btstack_event.h" 69 #include "btstack_linked_list.h" 70 #include "btstack_run_loop.h" 71 #include "btstack_tlv_posix.h" 72 #include "btstack_util.h" 73 74 #include "btstack_server.h" 75 76 #ifdef _WIN32 77 #include "btstack_run_loop_windows.h" 78 #else 79 #include "btstack_run_loop_posix.h" 80 #endif 81 82 #include "btstack_version.h" 83 #include "classic/btstack_link_key_db.h" 84 #include "classic/btstack_link_key_db_tlv.h" 85 #include "classic/rfcomm.h" 86 #include "classic/sdp_server.h" 87 #include "classic/sdp_client.h" 88 #include "classic/sdp_client_rfcomm.h" 89 #include "hci.h" 90 #include "hci_cmd.h" 91 #include "hci_dump.h" 92 #include "hci_dump_posix_fs.h" 93 #include "hci_dump_posix_stdout.h" 94 #include "hci_transport.h" 95 #include "hci_transport_h4.h" 96 #include "hci_transport_usb.h" 97 #include "l2cap.h" 98 #include "rfcomm_service_db.h" 99 #include "socket_connection.h" 100 101 #ifdef HAVE_INTEL_USB 102 #include "btstack_chipset_intel_firmware.h" 103 #endif 104 105 #ifdef ENABLE_BLE 106 #include "ble/gatt_client.h" 107 #include "ble/att_server.h" 108 #include "ble/att_db.h" 109 #include "ble/le_device_db.h" 110 #include "ble/le_device_db_tlv.h" 111 #include "ble/sm.h" 112 #endif 113 114 // copy of prototypes 115 const btstack_device_name_db_t * btstack_device_name_db_corefoundation_instance(void); 116 const btstack_device_name_db_t * btstack_device_name_db_fs_instance(void); 117 const btstack_link_key_db_t * btstack_link_key_db_corefoundation_instance(void); 118 const btstack_link_key_db_t * btstack_link_key_db_fs_instance(void); 119 120 // use logger: format HCI_DUMP_PACKETLOGGER, HCI_DUMP_BLUEZ or HCI_DUMP_STDOUT 121 #ifndef BTSTACK_LOG_TYPE 122 #define BTSTACK_LOG_TYPE HCI_DUMP_PACKETLOGGER 123 #endif 124 125 #define DAEMON_NO_ACTIVE_CLIENT_TIMEOUT 10000 126 127 #define ATT_MAX_LONG_ATTRIBUTE_SIZE 512 128 129 130 #define SERVICE_LENGTH 20 131 #define CHARACTERISTIC_LENGTH 24 132 #define CHARACTERISTIC_DESCRIPTOR_LENGTH 18 133 134 // ATT_MTU - 1 135 #define ATT_MAX_ATTRIBUTE_SIZE 22 136 137 // HCI CMD OGF/OCF 138 #define READ_CMD_OGF(buffer) (buffer[1] >> 2) 139 #define READ_CMD_OCF(buffer) ((buffer[1] & 0x03) << 8 | buffer[0]) 140 141 typedef struct { 142 // linked list - assert: first field 143 btstack_linked_item_t item; 144 145 // connection 146 connection_t * connection; 147 148 btstack_linked_list_t rfcomm_cids; 149 btstack_linked_list_t rfcomm_services; 150 btstack_linked_list_t l2cap_cids; 151 btstack_linked_list_t l2cap_psms; 152 btstack_linked_list_t sdp_record_handles; 153 btstack_linked_list_t gatt_con_handles; 154 155 // power mode 156 HCI_POWER_MODE power_mode; 157 158 // discoverable 159 uint8_t discoverable; 160 161 } client_state_t; 162 163 typedef struct btstack_linked_list_uint32 { 164 btstack_linked_item_t item; 165 uint32_t value; 166 } btstack_linked_list_uint32_t; 167 168 typedef struct btstack_linked_list_connection { 169 btstack_linked_item_t item; 170 connection_t * connection; 171 } btstack_linked_list_connection_t; 172 173 typedef struct btstack_linked_list_gatt_client_helper{ 174 btstack_linked_item_t item; 175 hci_con_handle_t con_handle; 176 connection_t * active_connection; // the one that started the current query 177 btstack_linked_list_t all_connections; // list of all connections that ever used this helper 178 uint16_t characteristic_length; 179 uint16_t characteristic_handle; 180 uint8_t characteristic_buffer[10 + ATT_MAX_LONG_ATTRIBUTE_SIZE]; // header for sending event right away 181 uint8_t long_query_type; 182 } btstack_linked_list_gatt_client_helper_t; 183 184 // MARK: prototypes 185 static void handle_sdp_rfcomm_service_result(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size); 186 static void handle_sdp_client_query_result(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size); 187 #ifdef ENABLE_BLE 188 static void handle_gatt_client_event(uint8_t packet_type, uint16_t channel, uint8_t * packet, uint16_t size); 189 #endif 190 static void dummy_bluetooth_status_handler(BLUETOOTH_STATE state); 191 static client_state_t * client_for_connection(connection_t *connection); 192 static int clients_require_power_on(void); 193 static int clients_require_discoverable(void); 194 static void clients_clear_power_request(void); 195 static void start_power_off_timer(void); 196 static void stop_power_off_timer(void); 197 static client_state_t * client_for_connection(connection_t *connection); 198 static void hci_emit_system_bluetooth_enabled(uint8_t enabled); 199 static void stack_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t * packet, uint16_t size); 200 static void btstack_server_configure_stack(void); 201 202 // MARK: globals 203 204 #ifdef HAVE_TRANSPORT_H4 205 static hci_transport_config_uart_t hci_transport_config_uart; 206 #endif 207 208 // used for stack configuration 209 static const hci_transport_t * transport; 210 static void * config = NULL; 211 static btstack_control_t * control; 212 213 #ifdef HAVE_INTEL_USB 214 static int intel_firmware_loaded; 215 #endif 216 217 static btstack_timer_source_t timeout; 218 static uint8_t timeout_active = 0; 219 static int power_management_sleep = 0; 220 static btstack_linked_list_t clients = NULL; // list of connected clients ` 221 #ifdef ENABLE_BLE 222 static gatt_client_notification_t daemon_gatt_client_notifications; 223 static btstack_linked_list_t gatt_client_helpers = NULL; // list of used gatt client (helpers) 224 #endif 225 226 static void (*bluetooth_status_handler)(BLUETOOTH_STATE state) = dummy_bluetooth_status_handler; 227 228 static btstack_packet_callback_registration_t hci_event_callback_registration; 229 static btstack_packet_callback_registration_t l2cap_event_callback_registration; 230 static btstack_packet_callback_registration_t sm_event_callback_registration; 231 232 static int global_enable = 0; 233 234 static btstack_link_key_db_t const * btstack_link_key_db = NULL; 235 static btstack_device_name_db_t const * btstack_device_name_db = NULL; 236 // static int rfcomm_channel_generator = 1; 237 238 static uint8_t attribute_value[1000]; 239 static const int attribute_value_buffer_size = sizeof(attribute_value); 240 static uint8_t serviceSearchPattern[200]; 241 static uint8_t attributeIDList[50]; 242 static void * sdp_client_query_connection; 243 244 static char string_buffer[1000]; 245 246 static int loggingEnabled; 247 248 static const char * btstack_server_storage_path; 249 250 // GAP command buffer 251 #ifdef ENABLE_CLASSIC 252 static uint8_t daemon_gap_pin_code[16]; 253 #endif 254 255 // TLV 256 static int tlv_setup_done; 257 static const btstack_tlv_t * tlv_impl; 258 static btstack_tlv_posix_t tlv_context; 259 260 static void dummy_bluetooth_status_handler(BLUETOOTH_STATE state){ 261 log_info("Bluetooth status: %u\n", state); 262 }; 263 264 static void daemon_no_connections_timeout(struct btstack_timer_source *ts){ 265 if (clients_require_power_on()) return; // false alarm :) 266 log_info("No active client connection for %u seconds -> POWER OFF\n", DAEMON_NO_ACTIVE_CLIENT_TIMEOUT/1000); 267 hci_power_control(HCI_POWER_OFF); 268 } 269 270 271 static void add_uint32_to_list(btstack_linked_list_t *list, uint32_t value){ 272 btstack_linked_list_iterator_t it; 273 btstack_linked_list_iterator_init(&it, list); 274 while (btstack_linked_list_iterator_has_next(&it)){ 275 btstack_linked_list_uint32_t * item = (btstack_linked_list_uint32_t*) btstack_linked_list_iterator_next(&it); 276 if ( item->value == value) return; // already in list 277 } 278 279 btstack_linked_list_uint32_t * item = malloc(sizeof(btstack_linked_list_uint32_t)); 280 if (!item) return; 281 memset(item, 0, sizeof(btstack_linked_list_uint32_t)); 282 item->value = value; 283 btstack_linked_list_add(list, (btstack_linked_item_t *) item); 284 } 285 286 static void remove_and_free_uint32_from_list(btstack_linked_list_t *list, uint32_t value){ 287 btstack_linked_list_iterator_t it; 288 btstack_linked_list_iterator_init(&it, list); 289 while (btstack_linked_list_iterator_has_next(&it)){ 290 btstack_linked_list_uint32_t * item = (btstack_linked_list_uint32_t*) btstack_linked_list_iterator_next(&it); 291 if ( item->value != value) continue; 292 btstack_linked_list_remove(list, (btstack_linked_item_t *) item); 293 free(item); 294 } 295 } 296 297 static void daemon_add_client_rfcomm_service(connection_t * connection, uint16_t service_channel){ 298 client_state_t * client_state = client_for_connection(connection); 299 if (!client_state) return; 300 add_uint32_to_list(&client_state->rfcomm_services, service_channel); 301 } 302 303 static void daemon_remove_client_rfcomm_service(connection_t * connection, uint16_t service_channel){ 304 client_state_t * client_state = client_for_connection(connection); 305 if (!client_state) return; 306 remove_and_free_uint32_from_list(&client_state->rfcomm_services, service_channel); 307 } 308 309 static void daemon_add_client_rfcomm_channel(connection_t * connection, uint16_t cid){ 310 client_state_t * client_state = client_for_connection(connection); 311 if (!client_state) return; 312 add_uint32_to_list(&client_state->rfcomm_cids, cid); 313 } 314 315 static void daemon_remove_client_rfcomm_channel(connection_t * connection, uint16_t cid){ 316 client_state_t * client_state = client_for_connection(connection); 317 if (!client_state) return; 318 remove_and_free_uint32_from_list(&client_state->rfcomm_cids, cid); 319 } 320 321 static void daemon_add_client_l2cap_service(connection_t * connection, uint16_t psm){ 322 client_state_t * client_state = client_for_connection(connection); 323 if (!client_state) return; 324 add_uint32_to_list(&client_state->l2cap_psms, psm); 325 } 326 327 static void daemon_remove_client_l2cap_service(connection_t * connection, uint16_t psm){ 328 client_state_t * client_state = client_for_connection(connection); 329 if (!client_state) return; 330 remove_and_free_uint32_from_list(&client_state->l2cap_psms, psm); 331 } 332 333 static void daemon_add_client_l2cap_channel(connection_t * connection, uint16_t cid){ 334 client_state_t * client_state = client_for_connection(connection); 335 if (!client_state) return; 336 add_uint32_to_list(&client_state->l2cap_cids, cid); 337 } 338 339 static void daemon_remove_client_l2cap_channel(connection_t * connection, uint16_t cid){ 340 client_state_t * client_state = client_for_connection(connection); 341 if (!client_state) return; 342 remove_and_free_uint32_from_list(&client_state->l2cap_cids, cid); 343 } 344 345 static void daemon_add_client_sdp_service_record_handle(connection_t * connection, uint32_t handle){ 346 client_state_t * client_state = client_for_connection(connection); 347 if (!client_state) return; 348 add_uint32_to_list(&client_state->sdp_record_handles, handle); 349 } 350 351 static void daemon_remove_client_sdp_service_record_handle(connection_t * connection, uint32_t handle){ 352 client_state_t * client_state = client_for_connection(connection); 353 if (!client_state) return; 354 remove_and_free_uint32_from_list(&client_state->sdp_record_handles, handle); 355 } 356 357 #ifdef ENABLE_BLE 358 static void daemon_add_gatt_client_handle(connection_t * connection, uint32_t handle){ 359 client_state_t * client_state = client_for_connection(connection); 360 if (!client_state) return; 361 362 // check if handle already exists in the gatt_con_handles list 363 btstack_linked_list_iterator_t it; 364 int handle_found = 0; 365 btstack_linked_list_iterator_init(&it, &client_state->gatt_con_handles); 366 while (btstack_linked_list_iterator_has_next(&it)){ 367 btstack_linked_list_uint32_t * item = (btstack_linked_list_uint32_t*) btstack_linked_list_iterator_next(&it); 368 if (item->value == handle){ 369 handle_found = 1; 370 break; 371 } 372 } 373 // if handle doesn't exist add it to gatt_con_handles 374 if (!handle_found){ 375 add_uint32_to_list(&client_state->gatt_con_handles, handle); 376 } 377 378 // check if there is a helper with given handle 379 btstack_linked_list_gatt_client_helper_t * gatt_helper = NULL; 380 btstack_linked_list_iterator_init(&it, &gatt_client_helpers); 381 while (btstack_linked_list_iterator_has_next(&it)){ 382 btstack_linked_list_gatt_client_helper_t * item = (btstack_linked_list_gatt_client_helper_t*) btstack_linked_list_iterator_next(&it); 383 if (item->con_handle == handle){ 384 gatt_helper = item; 385 break; 386 } 387 } 388 389 // if gatt_helper doesn't exist, create it and add it to gatt_client_helpers list 390 if (!gatt_helper){ 391 gatt_helper = calloc(sizeof(btstack_linked_list_gatt_client_helper_t), 1); 392 if (!gatt_helper) return; 393 gatt_helper->con_handle = handle; 394 btstack_linked_list_add(&gatt_client_helpers, (btstack_linked_item_t *) gatt_helper); 395 } 396 397 // check if connection exists 398 int connection_found = 0; 399 btstack_linked_list_iterator_init(&it, &gatt_helper->all_connections); 400 while (btstack_linked_list_iterator_has_next(&it)){ 401 btstack_linked_list_connection_t * item = (btstack_linked_list_connection_t*) btstack_linked_list_iterator_next(&it); 402 if (item->connection == connection){ 403 connection_found = 1; 404 break; 405 } 406 } 407 408 // if connection is not found, add it to the all_connections, and set it as active connection 409 if (!connection_found){ 410 btstack_linked_list_connection_t * con = calloc(sizeof(btstack_linked_list_connection_t), 1); 411 if (!con) return; 412 con->connection = connection; 413 btstack_linked_list_add(&gatt_helper->all_connections, (btstack_linked_item_t *)con); 414 } 415 } 416 417 418 static void daemon_remove_gatt_client_handle(connection_t * connection, uint32_t handle){ 419 // PART 1 - uses connection & handle 420 // might be extracted or vanish totally 421 client_state_t * client_state = client_for_connection(connection); 422 if (!client_state) return; 423 424 btstack_linked_list_iterator_t it; 425 // remove handle from gatt_con_handles list 426 btstack_linked_list_iterator_init(&it, &client_state->gatt_con_handles); 427 while (btstack_linked_list_iterator_has_next(&it)){ 428 btstack_linked_list_uint32_t * item = (btstack_linked_list_uint32_t*) btstack_linked_list_iterator_next(&it); 429 if (item->value == handle){ 430 btstack_linked_list_remove(&client_state->gatt_con_handles, (btstack_linked_item_t *) item); 431 free(item); 432 } 433 } 434 435 // PART 2 - only uses handle 436 437 // find helper with given handle 438 btstack_linked_list_gatt_client_helper_t * helper = NULL; 439 btstack_linked_list_iterator_init(&it, &gatt_client_helpers); 440 while (btstack_linked_list_iterator_has_next(&it)){ 441 btstack_linked_list_gatt_client_helper_t * item = (btstack_linked_list_gatt_client_helper_t*) btstack_linked_list_iterator_next(&it); 442 if (item->con_handle == handle){ 443 helper = item; 444 break; 445 } 446 } 447 448 if (!helper) return; 449 // remove connection from helper 450 btstack_linked_list_iterator_init(&it, &helper->all_connections); 451 while (btstack_linked_list_iterator_has_next(&it)){ 452 btstack_linked_list_connection_t * item = (btstack_linked_list_connection_t*) btstack_linked_list_iterator_next(&it); 453 if (item->connection == connection){ 454 btstack_linked_list_remove(&helper->all_connections, (btstack_linked_item_t *) item); 455 free(item); 456 break; 457 } 458 } 459 460 if (helper->active_connection == connection){ 461 helper->active_connection = NULL; 462 } 463 // if helper has no more connections, call disconnect 464 if (helper->all_connections == NULL){ 465 gap_disconnect((hci_con_handle_t) helper->con_handle); 466 } 467 } 468 469 470 static void daemon_remove_gatt_client_helper(uint32_t con_handle){ 471 log_info("daemon_remove_gatt_client_helper for con_handle 0x%04x", con_handle); 472 473 btstack_linked_list_iterator_t it, cl; 474 // find helper with given handle 475 btstack_linked_list_gatt_client_helper_t * helper = NULL; 476 btstack_linked_list_iterator_init(&it, &gatt_client_helpers); 477 while (btstack_linked_list_iterator_has_next(&it)){ 478 btstack_linked_list_gatt_client_helper_t * item = (btstack_linked_list_gatt_client_helper_t*) btstack_linked_list_iterator_next(&it); 479 if (item->con_handle == con_handle){ 480 helper = item; 481 break; 482 } 483 } 484 485 if (!helper) return; 486 487 // remove all connection from helper 488 btstack_linked_list_iterator_init(&it, &helper->all_connections); 489 while (btstack_linked_list_iterator_has_next(&it)){ 490 btstack_linked_list_connection_t * item = (btstack_linked_list_connection_t*) btstack_linked_list_iterator_next(&it); 491 btstack_linked_list_remove(&helper->all_connections, (btstack_linked_item_t *) item); 492 free(item); 493 } 494 495 btstack_linked_list_remove(&gatt_client_helpers, (btstack_linked_item_t *) helper); 496 free(helper); 497 498 btstack_linked_list_iterator_init(&cl, &clients); 499 while (btstack_linked_list_iterator_has_next(&cl)){ 500 client_state_t * client_state = (client_state_t *) btstack_linked_list_iterator_next(&cl); 501 btstack_linked_list_iterator_init(&it, &client_state->gatt_con_handles); 502 while (btstack_linked_list_iterator_has_next(&it)){ 503 btstack_linked_list_uint32_t * item = (btstack_linked_list_uint32_t*) btstack_linked_list_iterator_next(&it); 504 if (item->value == con_handle){ 505 btstack_linked_list_remove(&client_state->gatt_con_handles, (btstack_linked_item_t *) item); 506 free(item); 507 } 508 } 509 } 510 } 511 #endif 512 513 static void daemon_rfcomm_close_connection(client_state_t * daemon_client){ 514 btstack_linked_list_iterator_t it; 515 btstack_linked_list_t *rfcomm_services = &daemon_client->rfcomm_services; 516 btstack_linked_list_t *rfcomm_cids = &daemon_client->rfcomm_cids; 517 518 btstack_linked_list_iterator_init(&it, rfcomm_services); 519 while (btstack_linked_list_iterator_has_next(&it)){ 520 btstack_linked_list_uint32_t * item = (btstack_linked_list_uint32_t*) btstack_linked_list_iterator_next(&it); 521 rfcomm_unregister_service(item->value); 522 btstack_linked_list_remove(rfcomm_services, (btstack_linked_item_t *) item); 523 free(item); 524 } 525 526 btstack_linked_list_iterator_init(&it, rfcomm_cids); 527 while (btstack_linked_list_iterator_has_next(&it)){ 528 btstack_linked_list_uint32_t * item = (btstack_linked_list_uint32_t*) btstack_linked_list_iterator_next(&it); 529 rfcomm_disconnect(item->value); 530 btstack_linked_list_remove(rfcomm_cids, (btstack_linked_item_t *) item); 531 free(item); 532 } 533 } 534 535 536 static void daemon_l2cap_close_connection(client_state_t * daemon_client){ 537 btstack_linked_list_iterator_t it; 538 btstack_linked_list_t *l2cap_psms = &daemon_client->l2cap_psms; 539 btstack_linked_list_t *l2cap_cids = &daemon_client->l2cap_cids; 540 541 btstack_linked_list_iterator_init(&it, l2cap_psms); 542 while (btstack_linked_list_iterator_has_next(&it)){ 543 btstack_linked_list_uint32_t * item = (btstack_linked_list_uint32_t*) btstack_linked_list_iterator_next(&it); 544 l2cap_unregister_service(item->value); 545 btstack_linked_list_remove(l2cap_psms, (btstack_linked_item_t *) item); 546 free(item); 547 } 548 549 btstack_linked_list_iterator_init(&it, l2cap_cids); 550 while (btstack_linked_list_iterator_has_next(&it)){ 551 btstack_linked_list_uint32_t * item = (btstack_linked_list_uint32_t*) btstack_linked_list_iterator_next(&it); 552 l2cap_disconnect(item->value); 553 btstack_linked_list_remove(l2cap_cids, (btstack_linked_item_t *) item); 554 free(item); 555 } 556 } 557 558 static void daemon_sdp_close_connection(client_state_t * daemon_client){ 559 btstack_linked_list_t * list = &daemon_client->sdp_record_handles; 560 btstack_linked_list_iterator_t it; 561 btstack_linked_list_iterator_init(&it, list); 562 while (btstack_linked_list_iterator_has_next(&it)){ 563 btstack_linked_list_uint32_t * item = (btstack_linked_list_uint32_t*) btstack_linked_list_iterator_next(&it); 564 sdp_unregister_service(item->value); 565 btstack_linked_list_remove(list, (btstack_linked_item_t *) item); 566 free(item); 567 } 568 } 569 570 static connection_t * connection_for_l2cap_cid(uint16_t cid){ 571 btstack_linked_list_iterator_t cl; 572 btstack_linked_list_iterator_init(&cl, &clients); 573 while (btstack_linked_list_iterator_has_next(&cl)){ 574 client_state_t * client_state = (client_state_t *) btstack_linked_list_iterator_next(&cl); 575 btstack_linked_list_iterator_t it; 576 btstack_linked_list_iterator_init(&it, &client_state->l2cap_cids); 577 while (btstack_linked_list_iterator_has_next(&it)){ 578 btstack_linked_list_uint32_t * item = (btstack_linked_list_uint32_t*) btstack_linked_list_iterator_next(&it); 579 if (item->value == cid){ 580 return client_state->connection; 581 } 582 } 583 } 584 return NULL; 585 } 586 587 static const uint8_t removeServiceRecordHandleAttributeIDList[] = { 0x36, 0x00, 0x05, 0x0A, 0x00, 0x01, 0xFF, 0xFF }; 588 589 // register a service record 590 // pre: AttributeIDs are in ascending order 591 // pre: ServiceRecordHandle is first attribute and is not already registered in database 592 // @returns status 593 static uint32_t daemon_sdp_create_and_register_service(uint8_t * record){ 594 595 // create new handle 596 uint32_t record_handle = sdp_create_service_record_handle(); 597 598 // calculate size of new service record: DES (2 byte len) 599 // + ServiceRecordHandle attribute (UINT16 UINT32) + size of existing attributes 600 uint16_t recordSize = 3 + (3 + 5) + de_get_data_size(record); 601 602 // alloc memory for new service record 603 uint8_t * newRecord = malloc(recordSize); 604 if (!newRecord) return 0; 605 606 // create DES for new record 607 de_create_sequence(newRecord); 608 609 // set service record handle 610 de_add_number(newRecord, DE_UINT, DE_SIZE_16, 0); 611 de_add_number(newRecord, DE_UINT, DE_SIZE_32, record_handle); 612 613 // add other attributes 614 sdp_append_attributes_in_attributeIDList(record, (uint8_t *) removeServiceRecordHandleAttributeIDList, 0, recordSize, newRecord); 615 616 uint8_t status = sdp_register_service(newRecord); 617 618 if (status) { 619 free(newRecord); 620 return 0; 621 } 622 623 return record_handle; 624 } 625 626 static connection_t * connection_for_rfcomm_cid(uint16_t cid){ 627 btstack_linked_list_iterator_t cl; 628 btstack_linked_list_iterator_init(&cl, &clients); 629 while (btstack_linked_list_iterator_has_next(&cl)){ 630 client_state_t * client_state = (client_state_t *) btstack_linked_list_iterator_next(&cl); 631 btstack_linked_list_iterator_t it; 632 btstack_linked_list_iterator_init(&it, &client_state->rfcomm_cids); 633 while (btstack_linked_list_iterator_has_next(&it)){ 634 btstack_linked_list_uint32_t * item = (btstack_linked_list_uint32_t*) btstack_linked_list_iterator_next(&it); 635 if (item->value == cid){ 636 return client_state->connection; 637 } 638 } 639 } 640 return NULL; 641 } 642 643 #ifdef ENABLE_BLE 644 static void daemon_gatt_client_close_connection(connection_t * connection){ 645 client_state_t * client = client_for_connection(connection); 646 if (!client) return; 647 648 btstack_linked_list_iterator_t it; 649 650 btstack_linked_list_iterator_init(&it, &client->gatt_con_handles); 651 while (btstack_linked_list_iterator_has_next(&it)){ 652 btstack_linked_list_uint32_t * item = (btstack_linked_list_uint32_t*) btstack_linked_list_iterator_next(&it); 653 daemon_remove_gatt_client_handle(connection, item->value); 654 } 655 } 656 #endif 657 658 static void daemon_disconnect_client(connection_t * connection){ 659 log_info("Daemon disconnect client %p\n",connection); 660 661 client_state_t * client = client_for_connection(connection); 662 if (!client) return; 663 664 daemon_sdp_close_connection(client); 665 daemon_rfcomm_close_connection(client); 666 daemon_l2cap_close_connection(client); 667 #ifdef ENABLE_BLE 668 // NOTE: experimental - disconnect all LE connections where GATT Client was used 669 // gatt_client_disconnect_connection(connection); 670 daemon_gatt_client_close_connection(connection); 671 #endif 672 673 btstack_linked_list_remove(&clients, (btstack_linked_item_t *) client); 674 free(client); 675 } 676 677 static void hci_emit_btstack_version(void){ 678 log_info("DAEMON_EVENT_VERSION %u.%u", BTSTACK_MAJOR, BTSTACK_MINOR); 679 uint8_t event[6]; 680 event[0] = DAEMON_EVENT_VERSION; 681 event[1] = sizeof(event) - 2; 682 event[2] = BTSTACK_MAJOR; 683 event[3] = BTSTACK_MINOR; 684 little_endian_store_16(event, 4, 3257); // last SVN commit on Google Code + 1 685 socket_connection_send_packet_all(HCI_EVENT_PACKET, 0, event, sizeof(event)); 686 } 687 688 static void hci_emit_system_bluetooth_enabled(uint8_t enabled){ 689 log_info("DAEMON_EVENT_SYSTEM_BLUETOOTH_ENABLED %u", enabled); 690 uint8_t event[3]; 691 event[0] = DAEMON_EVENT_SYSTEM_BLUETOOTH_ENABLED; 692 event[1] = sizeof(event) - 2; 693 event[2] = enabled; 694 hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event)); 695 socket_connection_send_packet_all(HCI_EVENT_PACKET, 0, event, sizeof(event)); 696 } 697 698 static void send_l2cap_connection_open_failed(connection_t * connection, bd_addr_t address, uint16_t psm, uint8_t status){ 699 // emit error - see l2cap.c:l2cap_emit_channel_opened(..) 700 uint8_t event[23]; 701 memset(event, 0, sizeof(event)); 702 event[0] = L2CAP_EVENT_CHANNEL_OPENED; 703 event[1] = sizeof(event) - 2; 704 event[2] = status; 705 reverse_bd_addr(address, &event[3]); 706 // little_endian_store_16(event, 9, channel->handle); 707 little_endian_store_16(event, 11, psm); 708 // little_endian_store_16(event, 13, channel->local_cid); 709 // little_endian_store_16(event, 15, channel->remote_cid); 710 // little_endian_store_16(event, 17, channel->local_mtu); 711 // little_endian_store_16(event, 19, channel->remote_mtu); 712 // little_endian_store_16(event, 21, channel->flush_timeout); 713 hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event)); 714 socket_connection_send_packet(connection, HCI_EVENT_PACKET, 0, event, sizeof(event)); 715 } 716 717 static void l2cap_emit_service_registered(void *connection, uint8_t status, uint16_t psm){ 718 uint8_t event[5]; 719 event[0] = DAEMON_EVENT_L2CAP_SERVICE_REGISTERED; 720 event[1] = sizeof(event) - 2; 721 event[2] = status; 722 little_endian_store_16(event, 3, psm); 723 hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event)); 724 socket_connection_send_packet(connection, HCI_EVENT_PACKET, 0, event, sizeof(event)); 725 } 726 727 static void rfcomm_emit_service_registered(void *connection, uint8_t status, uint8_t channel){ 728 uint8_t event[4]; 729 event[0] = DAEMON_EVENT_RFCOMM_SERVICE_REGISTERED; 730 event[1] = sizeof(event) - 2; 731 event[2] = status; 732 event[3] = channel; 733 hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event)); 734 socket_connection_send_packet(connection, HCI_EVENT_PACKET, 0, event, sizeof(event)); 735 } 736 737 static void send_rfcomm_create_channel_failed(void * connection, bd_addr_t addr, uint8_t server_channel, uint8_t status){ 738 // emit error - see rfcom.c:rfcomm_emit_channel_open_failed_outgoing_memory(..) 739 uint8_t event[16]; 740 memset(event, 0, sizeof(event)); 741 uint8_t pos = 0; 742 event[pos++] = RFCOMM_EVENT_CHANNEL_OPENED; 743 event[pos++] = sizeof(event) - 2; 744 event[pos++] = status; 745 reverse_bd_addr(addr, &event[pos]); pos += 6; 746 little_endian_store_16(event, pos, 0); pos += 2; 747 event[pos++] = server_channel; 748 little_endian_store_16(event, pos, 0); pos += 2; // channel ID 749 little_endian_store_16(event, pos, 0); pos += 2; // max frame size 750 hci_dump_packet(HCI_EVENT_PACKET, 0, event, sizeof(event)); 751 socket_connection_send_packet(connection, HCI_EVENT_PACKET, 0, event, sizeof(event)); 752 } 753 754 // data: event(8), len(8), status(8), service_record_handle(32) 755 static void sdp_emit_service_registered(void *connection, uint32_t handle, uint8_t status) { 756 uint8_t event[7]; 757 event[0] = DAEMON_EVENT_SDP_SERVICE_REGISTERED; 758 event[1] = sizeof(event) - 2; 759 event[2] = status; 760 little_endian_store_32(event, 3, handle); 761 hci_dump_packet(HCI_EVENT_PACKET, 0, event, sizeof(event)); 762 socket_connection_send_packet(connection, HCI_EVENT_PACKET, 0, event, sizeof(event)); 763 } 764 765 #ifdef ENABLE_BLE 766 767 btstack_linked_list_gatt_client_helper_t * daemon_get_gatt_client_helper(hci_con_handle_t con_handle) { 768 btstack_linked_list_iterator_t it; 769 if (!gatt_client_helpers) return NULL; 770 log_debug("daemon_get_gatt_client_helper for handle 0x%02x", con_handle); 771 772 btstack_linked_list_iterator_init(&it, &gatt_client_helpers); 773 while (btstack_linked_list_iterator_has_next(&it)){ 774 btstack_linked_list_gatt_client_helper_t * item = (btstack_linked_list_gatt_client_helper_t*) btstack_linked_list_iterator_next(&it); 775 if (item->con_handle == con_handle){ 776 return item; 777 } 778 } 779 log_info("no gatt_client_helper for handle 0x%02x yet", con_handle); 780 return NULL; 781 } 782 783 static void send_gatt_query_complete(connection_t * connection, hci_con_handle_t con_handle, uint8_t status){ 784 // @format H1 785 uint8_t event[5]; 786 event[0] = GATT_EVENT_QUERY_COMPLETE; 787 event[1] = 3; 788 little_endian_store_16(event, 2, con_handle); 789 event[4] = status; 790 hci_dump_packet(HCI_EVENT_PACKET, 0, event, sizeof(event)); 791 socket_connection_send_packet(connection, HCI_EVENT_PACKET, 0, event, sizeof(event)); 792 } 793 794 static void send_gatt_mtu_event(connection_t * connection, hci_con_handle_t con_handle, uint16_t mtu){ 795 uint8_t event[6]; 796 int pos = 0; 797 event[pos++] = GATT_EVENT_MTU; 798 event[pos++] = sizeof(event) - 2; 799 little_endian_store_16(event, pos, con_handle); 800 pos += 2; 801 little_endian_store_16(event, pos, mtu); 802 pos += 2; 803 hci_dump_packet(HCI_EVENT_PACKET, 0, event, sizeof(event)); 804 socket_connection_send_packet(connection, HCI_EVENT_PACKET, 0, event, sizeof(event)); 805 } 806 807 btstack_linked_list_gatt_client_helper_t * daemon_setup_gatt_client_request(connection_t *connection, uint8_t *packet, int track_active_connection) { 808 hci_con_handle_t con_handle = little_endian_read_16(packet, 3); 809 log_info("daemon_setup_gatt_client_request for handle 0x%02x", con_handle); 810 hci_connection_t * hci_con = hci_connection_for_handle(con_handle); 811 if ((hci_con == NULL) || (hci_con->state != OPEN)){ 812 send_gatt_query_complete(connection, con_handle, GATT_CLIENT_NOT_CONNECTED); 813 return NULL; 814 } 815 816 btstack_linked_list_gatt_client_helper_t * helper = daemon_get_gatt_client_helper(con_handle); 817 818 if (!helper){ 819 log_info("helper does not exist"); 820 helper = calloc(sizeof(btstack_linked_list_gatt_client_helper_t), 1); 821 if (!helper) return NULL; 822 helper->con_handle = con_handle; 823 btstack_linked_list_add(&gatt_client_helpers, (btstack_linked_item_t *) helper); 824 } 825 826 if (track_active_connection && helper->active_connection){ 827 send_gatt_query_complete(connection, con_handle, GATT_CLIENT_BUSY); 828 return NULL; 829 } 830 831 daemon_add_gatt_client_handle(connection, con_handle); 832 833 if (track_active_connection){ 834 // remember connection responsible for this request 835 helper->active_connection = connection; 836 } 837 838 return helper; 839 } 840 841 // (de)serialize structs from/to HCI commands/events 842 843 void daemon_gatt_serialize_service(gatt_client_service_t * service, uint8_t * event, int offset){ 844 little_endian_store_16(event, offset, service->start_group_handle); 845 little_endian_store_16(event, offset+2, service->end_group_handle); 846 reverse_128(service->uuid128, &event[offset + 4]); 847 } 848 849 void daemon_gatt_serialize_characteristic(gatt_client_characteristic_t * characteristic, uint8_t * event, int offset){ 850 little_endian_store_16(event, offset, characteristic->start_handle); 851 little_endian_store_16(event, offset+2, characteristic->value_handle); 852 little_endian_store_16(event, offset+4, characteristic->end_handle); 853 little_endian_store_16(event, offset+6, characteristic->properties); 854 reverse_128(characteristic->uuid128, &event[offset+8]); 855 } 856 857 void daemon_gatt_serialize_characteristic_descriptor(gatt_client_characteristic_descriptor_t * characteristic_descriptor, uint8_t * event, int offset){ 858 little_endian_store_16(event, offset, characteristic_descriptor->handle); 859 reverse_128(characteristic_descriptor->uuid128, &event[offset+2]); 860 } 861 862 #endif 863 864 #ifdef HAVE_INTEL_USB 865 static void btstack_server_intel_firmware_done(int result){ 866 intel_firmware_loaded = 1; 867 // setup stack 868 btstack_server_configure_stack(); 869 // start power up 870 hci_power_control(HCI_POWER_ON); 871 } 872 #endif 873 874 static int btstack_command_handler(connection_t *connection, uint8_t *packet, uint16_t size){ 875 876 bd_addr_t addr; 877 #ifdef ENABLE_BLE 878 bd_addr_type_t addr_type; 879 hci_con_handle_t handle; 880 #endif 881 #ifdef ENABLE_CLASSIC 882 uint8_t reason; 883 uint8_t rfcomm_channel; 884 uint8_t rfcomm_credits; 885 uint16_t mtu; 886 uint32_t service_record_handle; 887 uint16_t cid; 888 uint16_t service_channel; 889 uint16_t serviceSearchPatternLen; 890 uint16_t attributeIDListLen; 891 uint16_t psm; 892 #endif 893 client_state_t *client; 894 uint8_t status; 895 uint8_t * data; 896 #if defined(HAVE_MALLOC) && defined(ENABLE_BLE) 897 uint8_t uuid128[16]; 898 gatt_client_service_t service; 899 gatt_client_characteristic_t characteristic; 900 gatt_client_characteristic_descriptor_t descriptor; 901 uint16_t data_length; 902 btstack_linked_list_gatt_client_helper_t * gatt_helper; 903 #endif 904 905 906 // verbose log info before other info to allow for better tracking 907 hci_dump_packet( HCI_COMMAND_DATA_PACKET, 1, packet, size); 908 909 // BTstack internal commands - 16 Bit OpCode, 8 Bit ParamLen, Params... 910 switch (READ_CMD_OCF(packet)){ 911 case BTSTACK_GET_STATE: 912 log_info("BTSTACK_GET_STATE"); 913 hci_emit_state(); 914 break; 915 case BTSTACK_SET_POWER_MODE: 916 log_info("BTSTACK_SET_POWER_MODE %u", packet[3]); 917 // track client power requests 918 client = client_for_connection(connection); 919 if (!client) break; 920 client->power_mode = packet[3]; 921 // handle merged state 922 if (!clients_require_power_on()){ 923 start_power_off_timer(); 924 } else if (!power_management_sleep) { 925 stop_power_off_timer(); 926 #ifdef HAVE_INTEL_USB 927 if (!intel_firmware_loaded){ 928 // before staring up the stack, load intel firmware 929 btstack_chipset_intel_download_firmware(transport, &btstack_server_intel_firmware_done); 930 break; 931 } 932 #endif 933 hci_power_control(HCI_POWER_ON); 934 } 935 break; 936 case BTSTACK_GET_VERSION: 937 log_info("BTSTACK_GET_VERSION"); 938 hci_emit_btstack_version(); 939 break; 940 case BTSTACK_SET_SYSTEM_BLUETOOTH_ENABLED: 941 case BTSTACK_GET_SYSTEM_BLUETOOTH_ENABLED: 942 hci_emit_system_bluetooth_enabled(0); 943 break; 944 case BTSTACK_SET_DISCOVERABLE: 945 log_info("BTSTACK_SET_DISCOVERABLE discoverable %u)", packet[3]); 946 // track client discoverable requests 947 client = client_for_connection(connection); 948 if (!client) break; 949 client->discoverable = packet[3]; 950 // merge state 951 gap_discoverable_control(clients_require_discoverable()); 952 break; 953 case BTSTACK_SET_BLUETOOTH_ENABLED: 954 log_info("BTSTACK_SET_BLUETOOTH_ENABLED: %u\n", packet[3]); 955 if (packet[3]) { 956 // global enable 957 global_enable = 1; 958 hci_power_control(HCI_POWER_ON); 959 } else { 960 global_enable = 0; 961 clients_clear_power_request(); 962 hci_power_control(HCI_POWER_OFF); 963 } 964 break; 965 #ifdef ENABLE_CLASSIC 966 case L2CAP_CREATE_CHANNEL_MTU: 967 reverse_bd_addr(&packet[3], addr); 968 psm = little_endian_read_16(packet, 9); 969 mtu = little_endian_read_16(packet, 11); 970 status = l2cap_create_channel(NULL, addr, psm, mtu, &cid); 971 if (status){ 972 send_l2cap_connection_open_failed(connection, addr, psm, status); 973 } else { 974 daemon_add_client_l2cap_channel(connection, cid); 975 } 976 break; 977 case L2CAP_CREATE_CHANNEL: 978 reverse_bd_addr(&packet[3], addr); 979 psm = little_endian_read_16(packet, 9); 980 mtu = 150; // until r865 981 status = l2cap_create_channel(NULL, addr, psm, mtu, &cid); 982 if (status){ 983 send_l2cap_connection_open_failed(connection, addr, psm, status); 984 } else { 985 daemon_add_client_l2cap_channel(connection, cid); 986 } 987 break; 988 case L2CAP_DISCONNECT: 989 cid = little_endian_read_16(packet, 3); 990 l2cap_disconnect(cid); 991 break; 992 case L2CAP_REGISTER_SERVICE: 993 psm = little_endian_read_16(packet, 3); 994 mtu = little_endian_read_16(packet, 5); 995 status = l2cap_register_service(NULL, psm, mtu, LEVEL_0); 996 daemon_add_client_l2cap_service(connection, little_endian_read_16(packet, 3)); 997 l2cap_emit_service_registered(connection, status, psm); 998 break; 999 case L2CAP_UNREGISTER_SERVICE: 1000 psm = little_endian_read_16(packet, 3); 1001 daemon_remove_client_l2cap_service(connection, psm); 1002 l2cap_unregister_service(psm); 1003 break; 1004 case L2CAP_ACCEPT_CONNECTION: 1005 cid = little_endian_read_16(packet, 3); 1006 l2cap_accept_connection(cid); 1007 break; 1008 case L2CAP_DECLINE_CONNECTION: 1009 cid = little_endian_read_16(packet, 3); 1010 reason = packet[7]; 1011 l2cap_decline_connection(cid); 1012 break; 1013 case RFCOMM_CREATE_CHANNEL: 1014 reverse_bd_addr(&packet[3], addr); 1015 rfcomm_channel = packet[9]; 1016 status = rfcomm_create_channel(&stack_packet_handler, addr, rfcomm_channel, &cid); 1017 if (status){ 1018 send_rfcomm_create_channel_failed(connection, addr, rfcomm_channel, status); 1019 } else { 1020 daemon_add_client_rfcomm_channel(connection, cid); 1021 } 1022 break; 1023 case RFCOMM_CREATE_CHANNEL_WITH_CREDITS: 1024 reverse_bd_addr(&packet[3], addr); 1025 rfcomm_channel = packet[9]; 1026 rfcomm_credits = packet[10]; 1027 status = rfcomm_create_channel_with_initial_credits(&stack_packet_handler, addr, rfcomm_channel, rfcomm_credits, &cid ); 1028 if (status){ 1029 send_rfcomm_create_channel_failed(connection, addr, rfcomm_channel, status); 1030 } else { 1031 daemon_add_client_rfcomm_channel(connection, cid); 1032 } 1033 break; 1034 case RFCOMM_DISCONNECT: 1035 cid = little_endian_read_16(packet, 3); 1036 reason = packet[5]; 1037 rfcomm_disconnect(cid); 1038 break; 1039 case RFCOMM_REGISTER_SERVICE: 1040 rfcomm_channel = packet[3]; 1041 mtu = little_endian_read_16(packet, 4); 1042 status = rfcomm_register_service(&stack_packet_handler, rfcomm_channel, mtu); 1043 rfcomm_emit_service_registered(connection, status, rfcomm_channel); 1044 break; 1045 case RFCOMM_REGISTER_SERVICE_WITH_CREDITS: 1046 rfcomm_channel = packet[3]; 1047 mtu = little_endian_read_16(packet, 4); 1048 rfcomm_credits = packet[6]; 1049 status = rfcomm_register_service_with_initial_credits(&stack_packet_handler, rfcomm_channel, mtu, rfcomm_credits); 1050 rfcomm_emit_service_registered(connection, status, rfcomm_channel); 1051 break; 1052 case RFCOMM_UNREGISTER_SERVICE: 1053 service_channel = little_endian_read_16(packet, 3); 1054 daemon_remove_client_rfcomm_service(connection, service_channel); 1055 rfcomm_unregister_service(service_channel); 1056 break; 1057 case RFCOMM_ACCEPT_CONNECTION: 1058 cid = little_endian_read_16(packet, 3); 1059 rfcomm_accept_connection(cid); 1060 break; 1061 case RFCOMM_DECLINE_CONNECTION: 1062 cid = little_endian_read_16(packet, 3); 1063 reason = packet[7]; 1064 rfcomm_decline_connection(cid); 1065 break; 1066 case RFCOMM_GRANT_CREDITS: 1067 cid = little_endian_read_16(packet, 3); 1068 rfcomm_credits = packet[5]; 1069 rfcomm_grant_credits(cid, rfcomm_credits); 1070 break; 1071 case RFCOMM_PERSISTENT_CHANNEL: { 1072 // enforce \0 1073 packet[3+248] = 0; 1074 rfcomm_channel = rfcomm_service_db_channel_for_service((char*)&packet[3]); 1075 log_info("DAEMON_EVENT_RFCOMM_PERSISTENT_CHANNEL %u", rfcomm_channel); 1076 uint8_t event[4]; 1077 event[0] = DAEMON_EVENT_RFCOMM_PERSISTENT_CHANNEL; 1078 event[1] = sizeof(event) - 2; 1079 event[2] = 0; 1080 event[3] = rfcomm_channel; 1081 hci_dump_packet(HCI_EVENT_PACKET, 0, event, sizeof(event)); 1082 socket_connection_send_packet(connection, HCI_EVENT_PACKET, 0, (uint8_t *) event, sizeof(event)); 1083 break; 1084 } 1085 case SDP_REGISTER_SERVICE_RECORD: 1086 log_info("SDP_REGISTER_SERVICE_RECORD size %u\n", size); 1087 service_record_handle = daemon_sdp_create_and_register_service(&packet[3]); 1088 if (service_record_handle){ 1089 daemon_add_client_sdp_service_record_handle(connection, service_record_handle); 1090 sdp_emit_service_registered(connection, service_record_handle, 0); 1091 } else { 1092 sdp_emit_service_registered(connection, 0, BTSTACK_MEMORY_ALLOC_FAILED); 1093 } 1094 break; 1095 case SDP_UNREGISTER_SERVICE_RECORD: 1096 service_record_handle = little_endian_read_32(packet, 3); 1097 log_info("SDP_UNREGISTER_SERVICE_RECORD handle 0x%x ", service_record_handle); 1098 data = sdp_get_record_for_handle(service_record_handle); 1099 sdp_unregister_service(service_record_handle); 1100 daemon_remove_client_sdp_service_record_handle(connection, service_record_handle); 1101 if (data){ 1102 free(data); 1103 } 1104 break; 1105 case SDP_CLIENT_QUERY_RFCOMM_SERVICES: 1106 reverse_bd_addr(&packet[3], addr); 1107 1108 serviceSearchPatternLen = de_get_len(&packet[9]); 1109 memcpy(serviceSearchPattern, &packet[9], serviceSearchPatternLen); 1110 1111 sdp_client_query_connection = connection; 1112 sdp_client_query_rfcomm_channel_and_name_for_search_pattern(&handle_sdp_rfcomm_service_result, addr, serviceSearchPattern); 1113 1114 break; 1115 case SDP_CLIENT_QUERY_SERVICES: 1116 reverse_bd_addr(&packet[3], addr); 1117 sdp_client_query_connection = connection; 1118 1119 serviceSearchPatternLen = de_get_len(&packet[9]); 1120 memcpy(serviceSearchPattern, &packet[9], serviceSearchPatternLen); 1121 1122 attributeIDListLen = de_get_len(&packet[9+serviceSearchPatternLen]); 1123 memcpy(attributeIDList, &packet[9+serviceSearchPatternLen], attributeIDListLen); 1124 1125 sdp_client_query(&handle_sdp_client_query_result, addr, (uint8_t*)&serviceSearchPattern[0], (uint8_t*)&attributeIDList[0]); 1126 break; 1127 #endif 1128 case GAP_DISCONNECT: 1129 handle = little_endian_read_16(packet, 3); 1130 gap_disconnect(handle); 1131 break; 1132 #ifdef ENABLE_CLASSIC 1133 case GAP_INQUIRY_START: 1134 gap_inquiry_start(packet[3]); 1135 break; 1136 case GAP_INQUIRY_STOP: 1137 gap_inquiry_stop(); 1138 break; 1139 case GAP_REMOTE_NAME_REQUEST: 1140 reverse_bd_addr(&packet[3], addr); 1141 gap_remote_name_request(addr, packet[9], little_endian_read_16(packet, 10)); 1142 break; 1143 case GAP_DROP_LINK_KEY_FOR_BD_ADDR: 1144 reverse_bd_addr(&packet[3], addr); 1145 gap_drop_link_key_for_bd_addr(addr); 1146 break; 1147 case GAP_DELETE_ALL_LINK_KEYS: 1148 gap_delete_all_link_keys(); 1149 break; 1150 case GAP_PIN_CODE_RESPONSE: 1151 reverse_bd_addr(&packet[3], addr); 1152 memcpy(daemon_gap_pin_code, &packet[10], 16); 1153 gap_pin_code_response_binary(addr, daemon_gap_pin_code, packet[9]); 1154 break; 1155 case GAP_PIN_CODE_NEGATIVE: 1156 reverse_bd_addr(&packet[3], addr); 1157 gap_pin_code_negative(addr); 1158 break; 1159 #endif 1160 #ifdef ENABLE_BLE 1161 case GAP_LE_SCAN_START: 1162 gap_start_scan(); 1163 break; 1164 case GAP_LE_SCAN_STOP: 1165 gap_stop_scan(); 1166 break; 1167 case GAP_LE_SET_SCAN_PARAMETERS: 1168 gap_set_scan_parameters(packet[3], little_endian_read_16(packet, 4), little_endian_read_16(packet, 6)); 1169 break; 1170 case GAP_LE_CONNECT: 1171 reverse_bd_addr(&packet[4], addr); 1172 addr_type = packet[3]; 1173 gap_connect(addr, addr_type); 1174 break; 1175 case GAP_LE_CONNECT_CANCEL: 1176 gap_connect_cancel(); 1177 break; 1178 #endif 1179 #if defined(HAVE_MALLOC) && defined(ENABLE_BLE) 1180 case GATT_DISCOVER_ALL_PRIMARY_SERVICES: 1181 gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1); 1182 if (!gatt_helper) break; 1183 gatt_client_discover_primary_services(&handle_gatt_client_event, gatt_helper->con_handle); 1184 break; 1185 case GATT_DISCOVER_PRIMARY_SERVICES_BY_UUID16: 1186 gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1); 1187 if (!gatt_helper) break; 1188 gatt_client_discover_primary_services_by_uuid16(&handle_gatt_client_event, gatt_helper->con_handle, little_endian_read_16(packet, 5)); 1189 break; 1190 case GATT_DISCOVER_PRIMARY_SERVICES_BY_UUID128: 1191 gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1); 1192 if (!gatt_helper) break; 1193 reverse_128(&packet[5], uuid128); 1194 gatt_client_discover_primary_services_by_uuid128(&handle_gatt_client_event, gatt_helper->con_handle, uuid128); 1195 break; 1196 case GATT_FIND_INCLUDED_SERVICES_FOR_SERVICE: 1197 gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1); 1198 if (!gatt_helper) break; 1199 gatt_client_deserialize_service(packet, 5, &service); 1200 gatt_client_find_included_services_for_service(&handle_gatt_client_event, gatt_helper->con_handle, &service); 1201 break; 1202 1203 case GATT_DISCOVER_CHARACTERISTICS_FOR_SERVICE: 1204 gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1); 1205 if (!gatt_helper) break; 1206 gatt_client_deserialize_service(packet, 5, &service); 1207 gatt_client_discover_characteristics_for_service(&handle_gatt_client_event, gatt_helper->con_handle, &service); 1208 break; 1209 case GATT_DISCOVER_CHARACTERISTICS_FOR_SERVICE_BY_UUID128: 1210 gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1); 1211 if (!gatt_helper) break; 1212 gatt_client_deserialize_service(packet, 5, &service); 1213 reverse_128(&packet[5 + SERVICE_LENGTH], uuid128); 1214 gatt_client_discover_characteristics_for_service_by_uuid128(&handle_gatt_client_event, gatt_helper->con_handle, &service, uuid128); 1215 break; 1216 case GATT_DISCOVER_CHARACTERISTIC_DESCRIPTORS: 1217 gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1); 1218 if (!gatt_helper) break; 1219 gatt_client_deserialize_characteristic(packet, 5, &characteristic); 1220 gatt_client_discover_characteristic_descriptors(&handle_gatt_client_event, gatt_helper->con_handle, &characteristic); 1221 break; 1222 1223 case GATT_READ_VALUE_OF_CHARACTERISTIC: 1224 gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1); 1225 if (!gatt_helper) break; 1226 gatt_client_deserialize_characteristic(packet, 5, &characteristic); 1227 gatt_client_read_value_of_characteristic(&handle_gatt_client_event, gatt_helper->con_handle, &characteristic); 1228 break; 1229 case GATT_READ_LONG_VALUE_OF_CHARACTERISTIC: 1230 gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1); 1231 if (!gatt_helper) break; 1232 gatt_client_deserialize_characteristic(packet, 5, &characteristic); 1233 gatt_client_read_long_value_of_characteristic(&handle_gatt_client_event, gatt_helper->con_handle, &characteristic); 1234 break; 1235 1236 case GATT_WRITE_VALUE_OF_CHARACTERISTIC_WITHOUT_RESPONSE: 1237 gatt_helper = daemon_setup_gatt_client_request(connection, packet, 0); // note: don't track active connection 1238 if (!gatt_helper) break; 1239 gatt_client_deserialize_characteristic(packet, 5, &characteristic); 1240 data_length = little_endian_read_16(packet, 5 + CHARACTERISTIC_LENGTH); 1241 data = gatt_helper->characteristic_buffer; 1242 memcpy(data, &packet[7 + CHARACTERISTIC_LENGTH], data_length); 1243 gatt_client_write_value_of_characteristic_without_response(gatt_helper->con_handle, characteristic.value_handle, data_length, data); 1244 break; 1245 case GATT_WRITE_VALUE_OF_CHARACTERISTIC: 1246 gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1); 1247 if (!gatt_helper) break; 1248 gatt_client_deserialize_characteristic(packet, 5, &characteristic); 1249 data_length = little_endian_read_16(packet, 5 + CHARACTERISTIC_LENGTH); 1250 data = gatt_helper->characteristic_buffer; 1251 memcpy(data, &packet[7 + CHARACTERISTIC_LENGTH], data_length); 1252 gatt_client_write_value_of_characteristic(&handle_gatt_client_event, gatt_helper->con_handle, characteristic.value_handle, data_length, data); 1253 break; 1254 case GATT_WRITE_LONG_VALUE_OF_CHARACTERISTIC: 1255 gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1); 1256 if (!gatt_helper) break; 1257 gatt_client_deserialize_characteristic(packet, 5, &characteristic); 1258 data_length = little_endian_read_16(packet, 5 + CHARACTERISTIC_LENGTH); 1259 data = gatt_helper->characteristic_buffer; 1260 memcpy(data, &packet[7 + CHARACTERISTIC_LENGTH], data_length); 1261 gatt_client_write_long_value_of_characteristic(&handle_gatt_client_event, gatt_helper->con_handle, characteristic.value_handle, data_length, data); 1262 break; 1263 case GATT_RELIABLE_WRITE_LONG_VALUE_OF_CHARACTERISTIC: 1264 gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1); 1265 if (!gatt_helper) break; 1266 gatt_client_deserialize_characteristic(packet, 5, &characteristic); 1267 data_length = little_endian_read_16(packet, 5 + CHARACTERISTIC_LENGTH); 1268 data = gatt_helper->characteristic_buffer; 1269 memcpy(data, &packet[7 + CHARACTERISTIC_LENGTH], data_length); 1270 gatt_client_write_long_value_of_characteristic(&handle_gatt_client_event, gatt_helper->con_handle, characteristic.value_handle, data_length, data); 1271 break; 1272 case GATT_READ_CHARACTERISTIC_DESCRIPTOR: 1273 gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1); 1274 if (!gatt_helper) break; 1275 handle = little_endian_read_16(packet, 3); 1276 gatt_client_deserialize_characteristic_descriptor(packet, 5, &descriptor); 1277 gatt_client_read_characteristic_descriptor(&handle_gatt_client_event, gatt_helper->con_handle, &descriptor); 1278 break; 1279 case GATT_READ_LONG_CHARACTERISTIC_DESCRIPTOR: 1280 gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1); 1281 if (!gatt_helper) break; 1282 gatt_client_deserialize_characteristic_descriptor(packet, 5, &descriptor); 1283 gatt_client_read_long_characteristic_descriptor(&handle_gatt_client_event, gatt_helper->con_handle, &descriptor); 1284 break; 1285 case GATT_WRITE_CHARACTERISTIC_DESCRIPTOR: 1286 gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1); 1287 if (!gatt_helper) break; 1288 gatt_client_deserialize_characteristic_descriptor(packet, 5, &descriptor); 1289 data = gatt_helper->characteristic_buffer; 1290 data_length = little_endian_read_16(packet, 5 + CHARACTERISTIC_DESCRIPTOR_LENGTH); 1291 gatt_client_write_characteristic_descriptor(&handle_gatt_client_event, gatt_helper->con_handle, &descriptor, data_length, data); 1292 break; 1293 case GATT_WRITE_LONG_CHARACTERISTIC_DESCRIPTOR: 1294 gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1); 1295 if (!gatt_helper) break; 1296 gatt_client_deserialize_characteristic_descriptor(packet, 5, &descriptor); 1297 data = gatt_helper->characteristic_buffer; 1298 data_length = little_endian_read_16(packet, 5 + CHARACTERISTIC_DESCRIPTOR_LENGTH); 1299 gatt_client_write_long_characteristic_descriptor(&handle_gatt_client_event, gatt_helper->con_handle, &descriptor, data_length, data); 1300 break; 1301 case GATT_WRITE_CLIENT_CHARACTERISTIC_CONFIGURATION:{ 1302 uint16_t configuration = little_endian_read_16(packet, 5 + CHARACTERISTIC_LENGTH); 1303 gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1); 1304 if (!gatt_helper) break; 1305 data = gatt_helper->characteristic_buffer; 1306 gatt_client_deserialize_characteristic(packet, 5, &characteristic); 1307 status = gatt_client_write_client_characteristic_configuration(&handle_gatt_client_event, gatt_helper->con_handle, &characteristic, configuration); 1308 if (status){ 1309 send_gatt_query_complete(connection, gatt_helper->con_handle, status); 1310 } 1311 break; 1312 } 1313 case GATT_GET_MTU: 1314 handle = little_endian_read_16(packet, 3); 1315 gatt_client_get_mtu(handle, &mtu); 1316 send_gatt_mtu_event(connection, handle, mtu); 1317 break; 1318 #endif 1319 #ifdef ENABLE_BLE 1320 case SM_SET_AUTHENTICATION_REQUIREMENTS: 1321 log_info("set auth %x", packet[3]); 1322 sm_set_authentication_requirements(packet[3]); 1323 break; 1324 case SM_SET_IO_CAPABILITIES: 1325 log_info("set io %x", packet[3]); 1326 sm_set_io_capabilities(packet[3]); 1327 break; 1328 case SM_BONDING_DECLINE: 1329 sm_bonding_decline(little_endian_read_16(packet, 3)); 1330 break; 1331 case SM_JUST_WORKS_CONFIRM: 1332 sm_just_works_confirm(little_endian_read_16(packet, 3)); 1333 break; 1334 case SM_NUMERIC_COMPARISON_CONFIRM: 1335 sm_numeric_comparison_confirm(little_endian_read_16(packet, 3)); 1336 break; 1337 case SM_PASSKEY_INPUT: 1338 sm_passkey_input(little_endian_read_16(packet, 3), little_endian_read_32(packet, 5)); 1339 break; 1340 #endif 1341 default: 1342 log_error("Error: command %u not implemented:", READ_CMD_OCF(packet)); 1343 break; 1344 } 1345 1346 return 0; 1347 } 1348 1349 static int daemon_client_handler(connection_t *connection, uint16_t packet_type, uint16_t channel, uint8_t *data, uint16_t length){ 1350 1351 int err = 0; 1352 client_state_t * client; 1353 1354 switch (packet_type){ 1355 case HCI_COMMAND_DATA_PACKET: 1356 if (READ_CMD_OGF(data) != OGF_BTSTACK) { 1357 // HCI Command 1358 hci_send_cmd_packet(data, length); 1359 } else { 1360 // BTstack command 1361 btstack_command_handler(connection, data, length); 1362 } 1363 break; 1364 case L2CAP_DATA_PACKET: 1365 // process l2cap packet... 1366 err = l2cap_send(channel, data, length); 1367 break; 1368 case RFCOMM_DATA_PACKET: 1369 // process rfcomm packet... 1370 err = rfcomm_send(channel, data, length); 1371 break; 1372 case DAEMON_EVENT_PACKET: 1373 switch (data[0]) { 1374 case DAEMON_EVENT_CONNECTION_OPENED: 1375 log_info("DAEMON_EVENT_CONNECTION_OPENED %p\n",connection); 1376 1377 client = calloc(sizeof(client_state_t), 1); 1378 if (!client) break; // fail 1379 client->connection = connection; 1380 client->power_mode = HCI_POWER_OFF; 1381 client->discoverable = 0; 1382 btstack_linked_list_add(&clients, (btstack_linked_item_t *) client); 1383 break; 1384 case DAEMON_EVENT_CONNECTION_CLOSED: 1385 log_info("DAEMON_EVENT_CONNECTION_CLOSED %p\n",connection); 1386 daemon_disconnect_client(connection); 1387 // no clients -> no HCI connections 1388 if (!clients){ 1389 hci_disconnect_all(); 1390 } 1391 1392 // update discoverable mode 1393 gap_discoverable_control(clients_require_discoverable()); 1394 // start power off, if last active client 1395 if (!clients_require_power_on()){ 1396 start_power_off_timer(); 1397 } 1398 break; 1399 default: 1400 break; 1401 } 1402 break; 1403 } 1404 if (err) { 1405 log_info("Daemon Handler: err %d\n", err); 1406 } 1407 return err; 1408 } 1409 1410 1411 static void daemon_set_logging_enabled(int enabled){ 1412 if (enabled && !loggingEnabled){ 1413 // construct path to log file 1414 const hci_dump_t * hci_dump_impl; 1415 switch (BTSTACK_LOG_TYPE){ 1416 case HCI_DUMP_PACKETLOGGER: 1417 hci_dump_impl = hci_dump_posix_fs_get_instance(); 1418 snprintf(string_buffer, sizeof(string_buffer), "%s/hci_dump.pklg", btstack_server_storage_path); 1419 hci_dump_posix_fs_open(string_buffer, HCI_DUMP_PACKETLOGGER); 1420 break; 1421 case HCI_DUMP_BLUEZ: 1422 hci_dump_impl = hci_dump_posix_fs_get_instance(); 1423 snprintf(string_buffer, sizeof(string_buffer), "%s/hci_dump.snoop", btstack_server_storage_path); 1424 hci_dump_posix_fs_open(string_buffer, HCI_DUMP_BLUEZ); 1425 break; 1426 default: 1427 break; 1428 } 1429 hci_dump_init(hci_dump_impl); 1430 printf("Logging to %s\n", string_buffer); 1431 } 1432 if (!enabled && loggingEnabled){ 1433 hci_dump_posix_fs_close(); 1434 hci_dump_init(NULL); 1435 } 1436 loggingEnabled = enabled; 1437 } 1438 1439 // local cache used to manage UI status 1440 static HCI_STATE hci_state = HCI_STATE_OFF; 1441 static int num_connections = 0; 1442 static void update_ui_status(void){ 1443 if (hci_state != HCI_STATE_WORKING) { 1444 bluetooth_status_handler(BLUETOOTH_OFF); 1445 } else { 1446 if (num_connections) { 1447 bluetooth_status_handler(BLUETOOTH_ACTIVE); 1448 } else { 1449 bluetooth_status_handler(BLUETOOTH_ON); 1450 } 1451 } 1452 } 1453 1454 #ifdef USE_SPRINGBOARD 1455 static void preferences_changed_callback(void){ 1456 int logging = platform_iphone_logging_enabled(); 1457 log_info("Logging enabled: %u\n", logging); 1458 daemon_set_logging_enabled(logging); 1459 } 1460 #endif 1461 1462 static void deamon_status_event_handler(uint8_t *packet, uint16_t size){ 1463 1464 uint8_t update_status = 0; 1465 1466 // handle state event 1467 switch (hci_event_packet_get_type(packet)) { 1468 case BTSTACK_EVENT_STATE: 1469 hci_state = packet[2]; 1470 log_info("New state: %u\n", hci_state); 1471 update_status = 1; 1472 break; 1473 case BTSTACK_EVENT_NR_CONNECTIONS_CHANGED: 1474 num_connections = packet[2]; 1475 log_info("New nr connections: %u\n", num_connections); 1476 update_status = 1; 1477 break; 1478 default: 1479 break; 1480 } 1481 1482 // choose full bluetooth state 1483 if (update_status) { 1484 update_ui_status(); 1485 } 1486 } 1487 1488 static void daemon_retry_parked(void){ 1489 1490 // socket_connection_retry_parked is not reentrant 1491 static int retry_mutex = 0; 1492 1493 // lock mutex 1494 if (retry_mutex) return; 1495 retry_mutex = 1; 1496 1497 // ... try sending again 1498 socket_connection_retry_parked(); 1499 1500 // unlock mutex 1501 retry_mutex = 0; 1502 } 1503 1504 static void daemon_emit_packet(void * connection, uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 1505 if (connection) { 1506 socket_connection_send_packet(connection, packet_type, channel, packet, size); 1507 } else { 1508 socket_connection_send_packet_all(packet_type, channel, packet, size); 1509 } 1510 } 1511 1512 // copy from btstack_util, just using a '-' 1513 static char bd_addr_to_str_buffer[6*3]; // 12:45:78:01:34:67\0 1514 char * bd_addr_to_str_dashed(const bd_addr_t addr){ 1515 // orig code 1516 // sprintf(bd_addr_to_str_buffer, "%02x:%02x:%02x:%02x:%02x:%02x", addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]); 1517 // sprintf-free code 1518 char * p = bd_addr_to_str_buffer; 1519 int i; 1520 for (i = 0; i < 6 ; i++) { 1521 uint8_t byte = addr[i]; 1522 *p++ = char_for_nibble(byte >> 4); 1523 *p++ = char_for_nibble(byte & 0x0f); 1524 *p++ = '-'; 1525 } 1526 *--p = 0; 1527 return (char *) bd_addr_to_str_buffer; 1528 } 1529 1530 static uint8_t remote_name_event[2+1+6+DEVICE_NAME_LEN+1]; // +1 for \0 in log_info 1531 static void daemon_packet_handler(void * connection, uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 1532 uint16_t cid; 1533 int i; 1534 bd_addr_t addr; 1535 switch (packet_type) { 1536 case HCI_EVENT_PACKET: 1537 deamon_status_event_handler(packet, size); 1538 switch (hci_event_packet_get_type(packet)){ 1539 1540 case BTSTACK_EVENT_STATE: 1541 if (btstack_event_state_get_state(packet) != HCI_STATE_WORKING) break; 1542 if (tlv_setup_done) break; 1543 1544 // setup TLV using local address as part of the name 1545 gap_local_bd_addr(addr); 1546 log_info("BTstack up and running at %s", bd_addr_to_str(addr)); 1547 snprintf(string_buffer, sizeof(string_buffer), "%s/btstack_%s.tlv", btstack_server_storage_path, bd_addr_to_str_dashed(addr)); 1548 tlv_impl = btstack_tlv_posix_init_instance(&tlv_context, string_buffer); 1549 btstack_tlv_set_instance(tlv_impl, &tlv_context); 1550 1551 // setup link key db 1552 hci_set_link_key_db(btstack_link_key_db_tlv_get_instance(tlv_impl, &tlv_context)); 1553 1554 // init le device db to use TLV 1555 le_device_db_tlv_configure(tlv_impl, &tlv_context); 1556 le_device_db_init(); 1557 le_device_db_set_local_bd_addr(addr); 1558 1559 tlv_setup_done = 1; 1560 break; 1561 1562 case HCI_EVENT_NUMBER_OF_COMPLETED_PACKETS: 1563 // ACL buffer freed... 1564 daemon_retry_parked(); 1565 // no need to tell clients 1566 return; 1567 1568 case HCI_EVENT_REMOTE_NAME_REQUEST_COMPLETE: 1569 if (!btstack_device_name_db) break; 1570 if (packet[2]) break; // status not ok 1571 1572 reverse_bd_addr(&packet[3], addr); 1573 // fix for invalid remote names - terminate on 0xff 1574 for (i=0; i<248;i++){ 1575 if (packet[9+i] == 0xff){ 1576 packet[9+i] = 0; 1577 break; 1578 } 1579 } 1580 packet[9+248] = 0; 1581 btstack_device_name_db->put_name(addr, (device_name_t *)&packet[9]); 1582 break; 1583 1584 case HCI_EVENT_INQUIRY_RESULT: 1585 case HCI_EVENT_INQUIRY_RESULT_WITH_RSSI:{ 1586 if (!btstack_device_name_db) break; 1587 1588 // first send inq result packet 1589 daemon_emit_packet(connection, packet_type, channel, packet, size); 1590 1591 // then send cached remote names 1592 int offset = 3; 1593 for (i=0; i<packet[2];i++){ 1594 reverse_bd_addr(&packet[offset], addr); 1595 if (btstack_device_name_db->get_name(addr, (device_name_t *) &remote_name_event[9])){ 1596 remote_name_event[0] = DAEMON_EVENT_REMOTE_NAME_CACHED; 1597 remote_name_event[1] = sizeof(remote_name_event) - 2 - 1; 1598 remote_name_event[2] = 0; // just to be compatible with HCI_EVENT_REMOTE_NAME_REQUEST_COMPLETE 1599 reverse_bd_addr(addr, &remote_name_event[3]); 1600 1601 remote_name_event[9+248] = 0; // assert \0 for log_info 1602 log_info("DAEMON_EVENT_REMOTE_NAME_CACHED %s = '%s'", bd_addr_to_str(addr), &remote_name_event[9]); 1603 hci_dump_packet(HCI_EVENT_PACKET, 0, remote_name_event, sizeof(remote_name_event)-1); 1604 daemon_emit_packet(connection, HCI_EVENT_PACKET, channel, remote_name_event, sizeof(remote_name_event) -1); 1605 } 1606 offset += 14; // 6 + 1 + 1 + 1 + 3 + 2; 1607 } 1608 return; 1609 } 1610 1611 case DAEMON_EVENT_RFCOMM_CREDITS: 1612 // RFCOMM CREDITS received... 1613 daemon_retry_parked(); 1614 break; 1615 1616 case RFCOMM_EVENT_CHANNEL_OPENED: 1617 cid = little_endian_read_16(packet, 13); 1618 connection = connection_for_rfcomm_cid(cid); 1619 if (!connection) break; 1620 if (packet[2]) { 1621 daemon_remove_client_rfcomm_channel(connection, cid); 1622 } else { 1623 daemon_add_client_rfcomm_channel(connection, cid); 1624 } 1625 break; 1626 case RFCOMM_EVENT_CHANNEL_CLOSED: 1627 cid = little_endian_read_16(packet, 2); 1628 connection = connection_for_rfcomm_cid(cid); 1629 if (!connection) break; 1630 daemon_remove_client_rfcomm_channel(connection, cid); 1631 break; 1632 case DAEMON_EVENT_RFCOMM_SERVICE_REGISTERED: 1633 if (packet[2]) break; 1634 daemon_add_client_rfcomm_service(connection, packet[3]); 1635 break; 1636 case L2CAP_EVENT_CHANNEL_OPENED: 1637 cid = little_endian_read_16(packet, 13); 1638 connection = connection_for_l2cap_cid(cid); 1639 if (!connection) break; 1640 if (packet[2]) { 1641 daemon_remove_client_l2cap_channel(connection, cid); 1642 } else { 1643 daemon_add_client_l2cap_channel(connection, cid); 1644 } 1645 break; 1646 case L2CAP_EVENT_CHANNEL_CLOSED: 1647 cid = little_endian_read_16(packet, 2); 1648 connection = connection_for_l2cap_cid(cid); 1649 if (!connection) break; 1650 daemon_remove_client_l2cap_channel(connection, cid); 1651 break; 1652 #if defined(ENABLE_BLE) && defined(HAVE_MALLOC) 1653 case HCI_EVENT_DISCONNECTION_COMPLETE: 1654 daemon_remove_gatt_client_helper(little_endian_read_16(packet, 3)); 1655 break; 1656 #endif 1657 default: 1658 break; 1659 } 1660 break; 1661 case L2CAP_DATA_PACKET: 1662 connection = connection_for_l2cap_cid(channel); 1663 if (!connection) return; 1664 break; 1665 case RFCOMM_DATA_PACKET: 1666 connection = connection_for_rfcomm_cid(channel); 1667 if (!connection) return; 1668 break; 1669 default: 1670 break; 1671 } 1672 1673 daemon_emit_packet(connection, packet_type, channel, packet, size); 1674 } 1675 1676 static void stack_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t * packet, uint16_t size){ 1677 daemon_packet_handler(NULL, packet_type, channel, packet, size); 1678 } 1679 1680 static void handle_sdp_rfcomm_service_result(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 1681 switch (hci_event_packet_get_type(packet)){ 1682 case SDP_EVENT_QUERY_RFCOMM_SERVICE: 1683 case SDP_EVENT_QUERY_COMPLETE: 1684 // already HCI Events, just forward them 1685 hci_dump_packet(HCI_EVENT_PACKET, 0, packet, size); 1686 socket_connection_send_packet(sdp_client_query_connection, HCI_EVENT_PACKET, 0, packet, size); 1687 break; 1688 default: 1689 break; 1690 } 1691 } 1692 1693 static void sdp_client_assert_buffer(int size){ 1694 if (size > attribute_value_buffer_size){ 1695 log_error("SDP attribute value buffer size exceeded: available %d, required %d", attribute_value_buffer_size, size); 1696 } 1697 } 1698 1699 // define new packet type SDP_CLIENT_PACKET 1700 static void handle_sdp_client_query_result(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 1701 int event_len; 1702 1703 switch (hci_event_packet_get_type(packet)){ 1704 case SDP_EVENT_QUERY_ATTRIBUTE_BYTE: 1705 sdp_client_assert_buffer(sdp_event_query_attribute_byte_get_attribute_length(packet)); 1706 attribute_value[sdp_event_query_attribute_byte_get_data_offset(packet)] = sdp_event_query_attribute_byte_get_data(packet); 1707 if ((uint16_t)(sdp_event_query_attribute_byte_get_data_offset(packet)+1) == sdp_event_query_attribute_byte_get_attribute_length(packet)){ 1708 log_info_hexdump(attribute_value, sdp_event_query_attribute_byte_get_attribute_length(packet)); 1709 1710 int event_len = 1 + 3 * 2 + sdp_event_query_attribute_byte_get_attribute_length(packet); 1711 uint8_t event[event_len]; 1712 event[0] = SDP_EVENT_QUERY_ATTRIBUTE_VALUE; 1713 little_endian_store_16(event, 1, sdp_event_query_attribute_byte_get_record_id(packet)); 1714 little_endian_store_16(event, 3, sdp_event_query_attribute_byte_get_attribute_id(packet)); 1715 little_endian_store_16(event, 5, (uint16_t)sdp_event_query_attribute_byte_get_attribute_length(packet)); 1716 memcpy(&event[7], attribute_value, sdp_event_query_attribute_byte_get_attribute_length(packet)); 1717 hci_dump_packet(SDP_CLIENT_PACKET, 0, event, event_len); 1718 socket_connection_send_packet(sdp_client_query_connection, SDP_CLIENT_PACKET, 0, event, event_len); 1719 } 1720 break; 1721 case SDP_EVENT_QUERY_COMPLETE: 1722 event_len = packet[1] + 2; 1723 hci_dump_packet(HCI_EVENT_PACKET, 0, packet, event_len); 1724 socket_connection_send_packet(sdp_client_query_connection, HCI_EVENT_PACKET, 0, packet, event_len); 1725 break; 1726 } 1727 } 1728 1729 static void power_notification_callback(POWER_NOTIFICATION_t notification){ 1730 switch (notification) { 1731 case POWER_WILL_SLEEP: 1732 // let's sleep 1733 power_management_sleep = 1; 1734 hci_power_control(HCI_POWER_SLEEP); 1735 break; 1736 case POWER_WILL_WAKE_UP: 1737 // assume that all clients use Bluetooth -> if connection, start Bluetooth 1738 power_management_sleep = 0; 1739 if (clients_require_power_on()) { 1740 hci_power_control(HCI_POWER_ON); 1741 } 1742 break; 1743 default: 1744 break; 1745 } 1746 } 1747 1748 static void daemon_sigint_handler(int param){ 1749 1750 log_info(" <= SIGINT received, shutting down..\n"); 1751 1752 int send_power_off = 1; 1753 #ifdef HAVE_INTEL_USB 1754 // power off and close only if hci was initialized before 1755 send_power_off = intel_firmware_loaded; 1756 #endif 1757 1758 if (send_power_off){ 1759 hci_power_control( HCI_POWER_OFF); 1760 hci_close(); 1761 } 1762 1763 log_info("Good bye, see you.\n"); 1764 1765 exit(0); 1766 } 1767 1768 // MARK: manage power off timer 1769 1770 #define USE_POWER_OFF_TIMER 1771 1772 static void stop_power_off_timer(void){ 1773 #ifdef USE_POWER_OFF_TIMER 1774 if (timeout_active) { 1775 btstack_run_loop_remove_timer(&timeout); 1776 timeout_active = 0; 1777 } 1778 #endif 1779 } 1780 1781 static void start_power_off_timer(void){ 1782 #ifdef USE_POWER_OFF_TIMER 1783 stop_power_off_timer(); 1784 btstack_run_loop_set_timer(&timeout, DAEMON_NO_ACTIVE_CLIENT_TIMEOUT); 1785 btstack_run_loop_add_timer(&timeout); 1786 timeout_active = 1; 1787 #else 1788 hci_power_control(HCI_POWER_OFF); 1789 #endif 1790 } 1791 1792 // MARK: manage list of clients 1793 1794 1795 static client_state_t * client_for_connection(connection_t *connection) { 1796 btstack_linked_item_t *it; 1797 for (it = (btstack_linked_item_t *) clients; it ; it = it->next){ 1798 client_state_t * client_state = (client_state_t *) it; 1799 if (client_state->connection == connection) { 1800 return client_state; 1801 } 1802 } 1803 return NULL; 1804 } 1805 1806 static void clients_clear_power_request(void){ 1807 btstack_linked_item_t *it; 1808 for (it = (btstack_linked_item_t *) clients; it ; it = it->next){ 1809 client_state_t * client_state = (client_state_t *) it; 1810 client_state->power_mode = HCI_POWER_OFF; 1811 } 1812 } 1813 1814 static int clients_require_power_on(void){ 1815 1816 if (global_enable) return 1; 1817 1818 btstack_linked_item_t *it; 1819 for (it = (btstack_linked_item_t *) clients; it ; it = it->next){ 1820 client_state_t * client_state = (client_state_t *) it; 1821 if (client_state->power_mode == HCI_POWER_ON) { 1822 return 1; 1823 } 1824 } 1825 return 0; 1826 } 1827 1828 static int clients_require_discoverable(void){ 1829 btstack_linked_item_t *it; 1830 for (it = (btstack_linked_item_t *) clients; it ; it = it->next){ 1831 client_state_t * client_state = (client_state_t *) it; 1832 if (client_state->discoverable) { 1833 return 1; 1834 } 1835 } 1836 return 0; 1837 } 1838 1839 static void usage(const char * name) { 1840 printf("%s, BTstack background daemon\n", name); 1841 printf("usage: %s [--help] [--tcp]\n", name); 1842 printf(" --help display this usage\n"); 1843 printf(" --tcp use TCP server on port %u\n", BTSTACK_PORT); 1844 printf("Without the --tcp option, BTstack Server is listening on unix domain socket %s\n\n", BTSTACK_UNIX); 1845 } 1846 1847 #ifdef ENABLE_BLE 1848 1849 static void handle_gatt_client_event(uint8_t packet_type, uint16_t channel, uint8_t * packet, uint16_t size){ 1850 1851 // only handle GATT Events 1852 switch(hci_event_packet_get_type(packet)){ 1853 case GATT_EVENT_SERVICE_QUERY_RESULT: 1854 case GATT_EVENT_INCLUDED_SERVICE_QUERY_RESULT: 1855 case GATT_EVENT_NOTIFICATION: 1856 case GATT_EVENT_INDICATION: 1857 case GATT_EVENT_CHARACTERISTIC_QUERY_RESULT: 1858 case GATT_EVENT_ALL_CHARACTERISTIC_DESCRIPTORS_QUERY_RESULT: 1859 case GATT_EVENT_CHARACTERISTIC_DESCRIPTOR_QUERY_RESULT: 1860 case GATT_EVENT_LONG_CHARACTERISTIC_DESCRIPTOR_QUERY_RESULT: 1861 case GATT_EVENT_CHARACTERISTIC_VALUE_QUERY_RESULT: 1862 case GATT_EVENT_LONG_CHARACTERISTIC_VALUE_QUERY_RESULT: 1863 case GATT_EVENT_QUERY_COMPLETE: 1864 break; 1865 default: 1866 return; 1867 } 1868 1869 hci_con_handle_t con_handle = little_endian_read_16(packet, 2); 1870 btstack_linked_list_gatt_client_helper_t * gatt_client_helper = daemon_get_gatt_client_helper(con_handle); 1871 if (!gatt_client_helper){ 1872 log_info("daemon handle_gatt_client_event: gc helper for handle 0x%2x is NULL.", con_handle); 1873 return; 1874 } 1875 1876 connection_t *connection = NULL; 1877 1878 // daemon doesn't track which connection subscribed to this particular handle, so we just notify all connections 1879 switch(hci_event_packet_get_type(packet)){ 1880 case GATT_EVENT_NOTIFICATION: 1881 case GATT_EVENT_INDICATION:{ 1882 hci_dump_packet(HCI_EVENT_PACKET, 0, packet, size); 1883 1884 btstack_linked_item_t *it; 1885 for (it = (btstack_linked_item_t *) clients; it ; it = it->next){ 1886 client_state_t * client_state = (client_state_t *) it; 1887 socket_connection_send_packet(client_state->connection, HCI_EVENT_PACKET, 0, packet, size); 1888 } 1889 return; 1890 } 1891 default: 1892 break; 1893 } 1894 1895 // otherwise, we have to have an active connection 1896 connection = gatt_client_helper->active_connection; 1897 uint16_t offset; 1898 uint16_t length; 1899 1900 if (!connection) return; 1901 1902 switch(hci_event_packet_get_type(packet)){ 1903 1904 case GATT_EVENT_SERVICE_QUERY_RESULT: 1905 case GATT_EVENT_INCLUDED_SERVICE_QUERY_RESULT: 1906 case GATT_EVENT_CHARACTERISTIC_QUERY_RESULT: 1907 case GATT_EVENT_CHARACTERISTIC_VALUE_QUERY_RESULT: 1908 case GATT_EVENT_CHARACTERISTIC_DESCRIPTOR_QUERY_RESULT: 1909 case GATT_EVENT_ALL_CHARACTERISTIC_DESCRIPTORS_QUERY_RESULT: 1910 hci_dump_packet(HCI_EVENT_PACKET, 0, packet, size); 1911 socket_connection_send_packet(connection, HCI_EVENT_PACKET, 0, packet, size); 1912 break; 1913 1914 case GATT_EVENT_LONG_CHARACTERISTIC_VALUE_QUERY_RESULT: 1915 case GATT_EVENT_LONG_CHARACTERISTIC_DESCRIPTOR_QUERY_RESULT: 1916 offset = little_endian_read_16(packet, 6); 1917 length = little_endian_read_16(packet, 8); 1918 gatt_client_helper->characteristic_buffer[0] = hci_event_packet_get_type(packet); // store type (characteristic/descriptor) 1919 gatt_client_helper->characteristic_handle = little_endian_read_16(packet, 4); // store attribute handle 1920 gatt_client_helper->characteristic_length = offset + length; // update length 1921 memcpy(&gatt_client_helper->characteristic_buffer[10 + offset], &packet[10], length); 1922 break; 1923 1924 case GATT_EVENT_QUERY_COMPLETE:{ 1925 gatt_client_helper->active_connection = NULL; 1926 if (gatt_client_helper->characteristic_length){ 1927 // send re-combined long characteristic value or long characteristic descriptor value 1928 uint8_t * event = gatt_client_helper->characteristic_buffer; 1929 uint16_t event_size = 10 + gatt_client_helper->characteristic_length; 1930 // event[0] == already set by previsous case 1931 event[1] = 8 + gatt_client_helper->characteristic_length; 1932 little_endian_store_16(event, 2, little_endian_read_16(packet, 2)); 1933 little_endian_store_16(event, 4, gatt_client_helper->characteristic_handle); 1934 little_endian_store_16(event, 6, 0); // offset 1935 little_endian_store_16(event, 8, gatt_client_helper->characteristic_length); 1936 hci_dump_packet(HCI_EVENT_PACKET, 0, event, event_size); 1937 socket_connection_send_packet(connection, HCI_EVENT_PACKET, 0, event, event_size); 1938 gatt_client_helper->characteristic_length = 0; 1939 } 1940 hci_dump_packet(HCI_EVENT_PACKET, 0, packet, size); 1941 socket_connection_send_packet(connection, HCI_EVENT_PACKET, 0, packet, size); 1942 break; 1943 } 1944 default: 1945 break; 1946 } 1947 } 1948 #endif 1949 1950 static char hostname[30]; 1951 1952 static void btstack_server_configure_stack(void){ 1953 // init HCI 1954 hci_init(transport, config); 1955 if (btstack_link_key_db){ 1956 hci_set_link_key_db(btstack_link_key_db); 1957 } 1958 if (control){ 1959 hci_set_control(control); 1960 } 1961 1962 // hostname for POSIX systems 1963 gethostname(hostname, 30); 1964 hostname[29] = '\0'; 1965 gap_set_local_name(hostname); 1966 1967 // enabled EIR 1968 hci_set_inquiry_mode(INQUIRY_MODE_RSSI_AND_EIR); 1969 1970 // register for HCI events 1971 hci_event_callback_registration.callback = &stack_packet_handler; 1972 hci_add_event_handler(&hci_event_callback_registration); 1973 1974 // init L2CAP 1975 l2cap_init(); 1976 l2cap_event_callback_registration.callback = &stack_packet_handler; 1977 l2cap_add_event_handler(&l2cap_event_callback_registration); 1978 timeout.process = daemon_no_connections_timeout; 1979 1980 #ifdef ENABLE_RFCOMM 1981 log_info("config.h: ENABLE_RFCOMM\n"); 1982 rfcomm_init(); 1983 #endif 1984 1985 #ifdef ENABLE_SDP 1986 sdp_init(); 1987 #endif 1988 1989 #ifdef ENABLE_BLE 1990 sm_init(); 1991 sm_event_callback_registration.callback = &stack_packet_handler; 1992 sm_add_event_handler(&sm_event_callback_registration); 1993 // sm_set_io_capabilities(IO_CAPABILITY_DISPLAY_ONLY); 1994 // sm_set_authentication_requirements( SM_AUTHREQ_BONDING | SM_AUTHREQ_MITM_PROTECTION); 1995 1996 // GATT Client 1997 gatt_client_init(); 1998 gatt_client_listen_for_characteristic_value_updates(&daemon_gatt_client_notifications, &handle_gatt_client_event, GATT_CLIENT_ANY_CONNECTION, GATT_CLIENT_ANY_VALUE_HANDLE); 1999 2000 // GATT Server - empty attribute database 2001 att_server_init(NULL, NULL, NULL); 2002 2003 #endif 2004 } 2005 2006 int btstack_server_run(int tcp_flag){ 2007 2008 if (tcp_flag){ 2009 printf("BTstack Server started on port %u\n", BTSTACK_PORT); 2010 } else { 2011 printf("BTstack Server started on socket %s\n", BTSTACK_UNIX); 2012 } 2013 2014 // handle default init 2015 if (!btstack_server_storage_path){ 2016 #ifdef _WIN32 2017 btstack_server_storage_path = strdup("."); 2018 #else 2019 btstack_server_storage_path = strdup("/tmp"); 2020 #endif 2021 } 2022 2023 // make stdout unbuffered 2024 setbuf(stdout, NULL); 2025 2026 // handle CTRL-c 2027 signal(SIGINT, daemon_sigint_handler); 2028 // handle SIGTERM - suggested for launchd 2029 signal(SIGTERM, daemon_sigint_handler); 2030 2031 socket_connection_init(); 2032 2033 btstack_control_t * control = NULL; 2034 const btstack_uart_t * uart_implementation = NULL; 2035 (void) uart_implementation; 2036 2037 #ifdef HAVE_TRANSPORT_H4 2038 hci_transport_config_uart.type = HCI_TRANSPORT_CONFIG_UART; 2039 hci_transport_config_uart.baudrate_init = UART_SPEED; 2040 hci_transport_config_uart.baudrate_main = 0; 2041 hci_transport_config_uart.flowcontrol = 1; 2042 hci_transport_config_uart.device_name = UART_DEVICE; 2043 2044 #ifdef _WIN32 2045 uart_implementation = (const btstack_uart_t *) btstack_uart_block_windows_instance(); 2046 #else 2047 uart_implementation = btstack_uart_posix_instance(); 2048 #endif 2049 2050 config = &hci_transport_config_uart; 2051 transport = hci_transport_h4_instance_for_uart(uart_implementation); 2052 #endif 2053 2054 #ifdef HAVE_TRANSPORT_USB 2055 transport = hci_transport_usb_instance(); 2056 #endif 2057 2058 #ifdef BTSTACK_DEVICE_NAME_DB_INSTANCE 2059 btstack_device_name_db = BTSTACK_DEVICE_NAME_DB_INSTANCE(); 2060 #endif 2061 2062 #ifdef _WIN32 2063 btstack_run_loop_init(btstack_run_loop_windows_get_instance()); 2064 #else 2065 btstack_run_loop_init(btstack_run_loop_posix_get_instance()); 2066 #endif 2067 2068 // init power management notifications 2069 if (control && control->register_for_power_notifications){ 2070 control->register_for_power_notifications(power_notification_callback); 2071 } 2072 2073 // logging 2074 loggingEnabled = 0; 2075 int newLoggingEnabled = 1; 2076 daemon_set_logging_enabled(newLoggingEnabled); 2077 2078 // dump version 2079 log_info("BTStack Server started\n"); 2080 log_info("version %s, build %s", BTSTACK_VERSION, BTSTACK_DATE); 2081 2082 #ifndef HAVE_INTEL_USB 2083 btstack_server_configure_stack(); 2084 #endif 2085 2086 #ifdef USE_LAUNCHD 2087 socket_connection_create_launchd(); 2088 #else 2089 // create server 2090 if (tcp_flag) { 2091 socket_connection_create_tcp(BTSTACK_PORT); 2092 } else { 2093 #ifdef HAVE_UNIX_SOCKETS 2094 socket_connection_create_unix(BTSTACK_UNIX); 2095 #endif 2096 } 2097 #endif 2098 socket_connection_register_packet_callback(&daemon_client_handler); 2099 2100 // go! 2101 btstack_run_loop_execute(); 2102 return 0; 2103 } 2104 2105 int btstack_server_run_tcp(void){ 2106 return btstack_server_run(1); 2107 } 2108 2109 int main (int argc, char * const * argv){ 2110 2111 int tcp_flag = 0; 2112 struct option long_options[] = { 2113 { "tcp", no_argument, &tcp_flag, 1 }, 2114 { "help", no_argument, 0, 0 }, 2115 { 0,0,0,0 } // This is a filler for -1 2116 }; 2117 2118 while (true) { 2119 int c; 2120 int option_index = -1; 2121 c = getopt_long(argc, argv, "h", long_options, &option_index); 2122 if (c == -1) break; // no more option 2123 2124 // treat long parameter first 2125 if (option_index == -1) { 2126 switch (c) { 2127 case '?': 2128 case 'h': 2129 usage(argv[0]); 2130 return 0; 2131 break; 2132 } 2133 } else { 2134 switch (option_index) { 2135 case 1: 2136 usage(argv[0]); 2137 return 0; 2138 break; 2139 } 2140 } 2141 } 2142 2143 #ifndef HAVE_UNIX_SOCKETS 2144 // TCP is default if there are no unix sockets 2145 tcp_flag = 1; 2146 #endif 2147 2148 btstack_server_run(tcp_flag); 2149 2150 return 0; 2151 } 2152 2153 void btstack_server_set_storage_path(const char * path){ 2154 if (btstack_server_storage_path){ 2155 free((void*)btstack_server_storage_path); 2156 btstack_server_storage_path = NULL; 2157 } 2158 btstack_server_storage_path = strdup(path); 2159 log_info("Storage path %s", btstack_server_storage_path); 2160 } 2161