xref: /btstack/platform/daemon/src/daemon.c (revision 24047dd67dcfd3f5488fcaeab728aa4f6acfbafb)
12531c97eSMatthias Ringwald /*
22531c97eSMatthias Ringwald  * Copyright (C) 2014 BlueKitchen GmbH
32531c97eSMatthias Ringwald  *
42531c97eSMatthias Ringwald  * Redistribution and use in source and binary forms, with or without
52531c97eSMatthias Ringwald  * modification, are permitted provided that the following conditions
62531c97eSMatthias Ringwald  * are met:
72531c97eSMatthias Ringwald  *
82531c97eSMatthias Ringwald  * 1. Redistributions of source code must retain the above copyright
92531c97eSMatthias Ringwald  *    notice, this list of conditions and the following disclaimer.
102531c97eSMatthias Ringwald  * 2. Redistributions in binary form must reproduce the above copyright
112531c97eSMatthias Ringwald  *    notice, this list of conditions and the following disclaimer in the
122531c97eSMatthias Ringwald  *    documentation and/or other materials provided with the distribution.
132531c97eSMatthias Ringwald  * 3. Neither the name of the copyright holders nor the names of
142531c97eSMatthias Ringwald  *    contributors may be used to endorse or promote products derived
152531c97eSMatthias Ringwald  *    from this software without specific prior written permission.
162531c97eSMatthias Ringwald  * 4. Any redistribution, use, or modification is done solely for
172531c97eSMatthias Ringwald  *    personal benefit and not for any commercial purpose or for
182531c97eSMatthias Ringwald  *    monetary gain.
192531c97eSMatthias Ringwald  *
202531c97eSMatthias Ringwald  * THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS
212531c97eSMatthias Ringwald  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
222531c97eSMatthias Ringwald  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
232531c97eSMatthias Ringwald  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL MATTHIAS
242531c97eSMatthias Ringwald  * RINGWALD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
252531c97eSMatthias Ringwald  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
262531c97eSMatthias Ringwald  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
272531c97eSMatthias Ringwald  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
282531c97eSMatthias Ringwald  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
292531c97eSMatthias Ringwald  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
302531c97eSMatthias Ringwald  * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
312531c97eSMatthias Ringwald  * SUCH DAMAGE.
322531c97eSMatthias Ringwald  *
332531c97eSMatthias Ringwald  * Please inquire about commercial licensing options at
342531c97eSMatthias Ringwald  * [email protected]
352531c97eSMatthias Ringwald  *
362531c97eSMatthias Ringwald  */
372531c97eSMatthias Ringwald 
38ab2c6ae4SMatthias Ringwald #define __BTSTACK_FILE__ "daemon.c"
39ab2c6ae4SMatthias Ringwald 
402531c97eSMatthias Ringwald /*
412531c97eSMatthias Ringwald  *  daemon.c
422531c97eSMatthias Ringwald  *
432531c97eSMatthias Ringwald  *  Created by Matthias Ringwald on 7/1/09.
442531c97eSMatthias Ringwald  *
452531c97eSMatthias Ringwald  *  BTstack background daemon
462531c97eSMatthias Ringwald  *
472531c97eSMatthias Ringwald  */
482531c97eSMatthias Ringwald 
492531c97eSMatthias Ringwald #include "btstack_config.h"
502531c97eSMatthias Ringwald 
512531c97eSMatthias Ringwald #include <pthread.h>
522531c97eSMatthias Ringwald #include <signal.h>
532531c97eSMatthias Ringwald #include <stdio.h>
542531c97eSMatthias Ringwald #include <stdlib.h>
552531c97eSMatthias Ringwald #include <strings.h>
562531c97eSMatthias Ringwald #include <unistd.h>
572531c97eSMatthias Ringwald 
58092bd57eSMatthias Ringwald #ifdef _WIN32
59092bd57eSMatthias Ringwald #include "Winsock2.h"
60092bd57eSMatthias Ringwald #endif
61092bd57eSMatthias Ringwald 
62b9dcd1ccSMatthias Ringwald #include <getopt.h>
63b9dcd1ccSMatthias Ringwald 
642531c97eSMatthias Ringwald #include "btstack.h"
652531c97eSMatthias Ringwald #include "btstack_client.h"
662531c97eSMatthias Ringwald #include "btstack_debug.h"
672531c97eSMatthias Ringwald #include "btstack_device_name_db.h"
682531c97eSMatthias Ringwald #include "btstack_event.h"
692531c97eSMatthias Ringwald #include "btstack_linked_list.h"
702531c97eSMatthias Ringwald #include "btstack_run_loop.h"
71a05b2457SMatthias Ringwald #include "btstack_tlv_posix.h"
722370d9c1SMatthias Ringwald #include "btstack_util.h"
73a05b2457SMatthias Ringwald 
74ee252d54SMatthias Ringwald #include "btstack_server.h"
75b9dcd1ccSMatthias Ringwald 
76b9dcd1ccSMatthias Ringwald #ifdef _WIN32
77b9dcd1ccSMatthias Ringwald #include "btstack_run_loop_windows.h"
78b9dcd1ccSMatthias Ringwald #else
792531c97eSMatthias Ringwald #include "btstack_run_loop_posix.h"
80b9dcd1ccSMatthias Ringwald #endif
81e9b53984SMatthias Ringwald 
822531c97eSMatthias Ringwald #include "btstack_version.h"
832531c97eSMatthias Ringwald #include "classic/btstack_link_key_db.h"
84a05b2457SMatthias Ringwald #include "classic/btstack_link_key_db_tlv.h"
852531c97eSMatthias Ringwald #include "classic/rfcomm.h"
862531c97eSMatthias Ringwald #include "classic/sdp_server.h"
872531c97eSMatthias Ringwald #include "classic/sdp_client.h"
88efda0b48SMatthias Ringwald #include "classic/sdp_client_rfcomm.h"
892531c97eSMatthias Ringwald #include "hci.h"
902531c97eSMatthias Ringwald #include "hci_cmd.h"
912531c97eSMatthias Ringwald #include "hci_dump.h"
922531c97eSMatthias Ringwald #include "hci_transport.h"
932531c97eSMatthias Ringwald #include "l2cap.h"
942531c97eSMatthias Ringwald #include "rfcomm_service_db.h"
952531c97eSMatthias Ringwald #include "socket_connection.h"
962531c97eSMatthias Ringwald 
972531c97eSMatthias Ringwald #ifdef ENABLE_BLE
982531c97eSMatthias Ringwald #include "ble/gatt_client.h"
992531c97eSMatthias Ringwald #include "ble/att_server.h"
1002531c97eSMatthias Ringwald #include "ble/att_db.h"
1012531c97eSMatthias Ringwald #include "ble/le_device_db.h"
102a05b2457SMatthias Ringwald #include "ble/le_device_db_tlv.h"
1032531c97eSMatthias Ringwald #include "ble/sm.h"
1042531c97eSMatthias Ringwald #endif
1052531c97eSMatthias Ringwald 
1062531c97eSMatthias Ringwald #ifdef HAVE_PLATFORM_IPHONE_OS
1072531c97eSMatthias Ringwald #include <CoreFoundation/CoreFoundation.h>
1082531c97eSMatthias Ringwald #include <notify.h>
1092531c97eSMatthias Ringwald #include "../port/ios/src/btstack_control_iphone.h"
1102531c97eSMatthias Ringwald #include "../port/ios/src/platform_iphone.h"
1112531c97eSMatthias Ringwald // support for "enforece wake device" in h4 - used by iOS power management
1122531c97eSMatthias Ringwald extern void hci_transport_h4_iphone_set_enforce_wake_device(char *path);
1132531c97eSMatthias Ringwald #endif
1142531c97eSMatthias Ringwald 
1152531c97eSMatthias Ringwald // copy of prototypes
116f8d88472SMatthias Ringwald const btstack_device_name_db_t * btstack_device_name_db_corefoundation_instance(void);
1172531c97eSMatthias Ringwald const btstack_device_name_db_t * btstack_device_name_db_fs_instance(void);
118f8d88472SMatthias Ringwald const btstack_link_key_db_t * btstack_link_key_db_corefoundation_instance(void);
1192531c97eSMatthias Ringwald const btstack_link_key_db_t * btstack_link_key_db_fs_instance(void);
1202531c97eSMatthias Ringwald 
1212531c97eSMatthias Ringwald // use logger: format HCI_DUMP_PACKETLOGGER, HCI_DUMP_BLUEZ or HCI_DUMP_STDOUT
1222531c97eSMatthias Ringwald #ifndef BTSTACK_LOG_TYPE
1232531c97eSMatthias Ringwald #define BTSTACK_LOG_TYPE HCI_DUMP_PACKETLOGGER
1242531c97eSMatthias Ringwald #endif
1252531c97eSMatthias Ringwald 
1262531c97eSMatthias Ringwald #define DAEMON_NO_ACTIVE_CLIENT_TIMEOUT 10000
1272531c97eSMatthias Ringwald 
1282531c97eSMatthias Ringwald #define ATT_MAX_LONG_ATTRIBUTE_SIZE 512
1292531c97eSMatthias Ringwald 
1302531c97eSMatthias Ringwald 
1312531c97eSMatthias Ringwald #define SERVICE_LENGTH                      20
1322531c97eSMatthias Ringwald #define CHARACTERISTIC_LENGTH               24
1332531c97eSMatthias Ringwald #define CHARACTERISTIC_DESCRIPTOR_LENGTH    18
1342531c97eSMatthias Ringwald 
1352531c97eSMatthias Ringwald // ATT_MTU - 1
1362531c97eSMatthias Ringwald #define ATT_MAX_ATTRIBUTE_SIZE 22
1372531c97eSMatthias Ringwald 
1382531c97eSMatthias Ringwald // HCI CMD OGF/OCF
1392531c97eSMatthias Ringwald #define READ_CMD_OGF(buffer) (buffer[1] >> 2)
1402531c97eSMatthias Ringwald #define READ_CMD_OCF(buffer) ((buffer[1] & 0x03) << 8 | buffer[0])
1412531c97eSMatthias Ringwald 
1422531c97eSMatthias Ringwald typedef struct {
1432531c97eSMatthias Ringwald     // linked list - assert: first field
1442531c97eSMatthias Ringwald     btstack_linked_item_t    item;
1452531c97eSMatthias Ringwald 
1462531c97eSMatthias Ringwald     // connection
1472531c97eSMatthias Ringwald     connection_t * connection;
1482531c97eSMatthias Ringwald 
1492531c97eSMatthias Ringwald     btstack_linked_list_t rfcomm_cids;
1502531c97eSMatthias Ringwald     btstack_linked_list_t rfcomm_services;
1512531c97eSMatthias Ringwald     btstack_linked_list_t l2cap_cids;
1522531c97eSMatthias Ringwald     btstack_linked_list_t l2cap_psms;
1532531c97eSMatthias Ringwald     btstack_linked_list_t sdp_record_handles;
1542531c97eSMatthias Ringwald     btstack_linked_list_t gatt_con_handles;
155*24047dd6SMatthias Ringwald 
1562531c97eSMatthias Ringwald     // power mode
1572531c97eSMatthias Ringwald     HCI_POWER_MODE power_mode;
1582531c97eSMatthias Ringwald 
1592531c97eSMatthias Ringwald     // discoverable
1602531c97eSMatthias Ringwald     uint8_t        discoverable;
1612531c97eSMatthias Ringwald 
1622531c97eSMatthias Ringwald } client_state_t;
1632531c97eSMatthias Ringwald 
1642531c97eSMatthias Ringwald typedef struct btstack_linked_list_uint32 {
1652531c97eSMatthias Ringwald     btstack_linked_item_t   item;
1662531c97eSMatthias Ringwald     uint32_t        value;
1672531c97eSMatthias Ringwald } btstack_linked_list_uint32_t;
1682531c97eSMatthias Ringwald 
1692531c97eSMatthias Ringwald typedef struct btstack_linked_list_connection {
1702531c97eSMatthias Ringwald     btstack_linked_item_t   item;
1712531c97eSMatthias Ringwald     connection_t  * connection;
1722531c97eSMatthias Ringwald } btstack_linked_list_connection_t;
1732531c97eSMatthias Ringwald 
1742531c97eSMatthias Ringwald typedef struct btstack_linked_list_gatt_client_helper{
1752531c97eSMatthias Ringwald     btstack_linked_item_t item;
176711e6c80SMatthias Ringwald     hci_con_handle_t con_handle;
1772531c97eSMatthias Ringwald     connection_t * active_connection;   // the one that started the current query
1782531c97eSMatthias Ringwald     btstack_linked_list_t  all_connections;     // list of all connections that ever used this helper
179*24047dd6SMatthias Ringwald     btstack_linked_list_t gatt_client_notifications;    // could be in client_state_t as well
1802531c97eSMatthias Ringwald     uint16_t characteristic_length;
1812531c97eSMatthias Ringwald     uint16_t characteristic_handle;
1822531c97eSMatthias Ringwald     uint8_t  characteristic_buffer[10 + ATT_MAX_LONG_ATTRIBUTE_SIZE];   // header for sending event right away
1832531c97eSMatthias Ringwald     uint8_t  long_query_type;
1842531c97eSMatthias Ringwald } btstack_linked_list_gatt_client_helper_t;
1852531c97eSMatthias Ringwald 
186*24047dd6SMatthias Ringwald typedef struct {
187*24047dd6SMatthias Ringwald     btstack_linked_item_t       item;
188*24047dd6SMatthias Ringwald     gatt_client_notification_t  notification_listener;
189*24047dd6SMatthias Ringwald } btstack_linked_list_gatt_client_notification_t;
190*24047dd6SMatthias Ringwald 
1912531c97eSMatthias Ringwald // MARK: prototypes
1922531c97eSMatthias Ringwald static void handle_sdp_rfcomm_service_result(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size);
1932531c97eSMatthias Ringwald static void handle_sdp_client_query_result(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size);
1942531c97eSMatthias Ringwald #ifdef ENABLE_BLE
1952531c97eSMatthias Ringwald static void handle_gatt_client_event(uint8_t packet_type, uint16_t channel, uint8_t * packet, uint16_t size);
1962531c97eSMatthias Ringwald #endif
1972531c97eSMatthias Ringwald static void dummy_bluetooth_status_handler(BLUETOOTH_STATE state);
1982531c97eSMatthias Ringwald static client_state_t * client_for_connection(connection_t *connection);
1992531c97eSMatthias Ringwald static int              clients_require_power_on(void);
2002531c97eSMatthias Ringwald static int              clients_require_discoverable(void);
2012531c97eSMatthias Ringwald static void              clients_clear_power_request(void);
2022531c97eSMatthias Ringwald static void start_power_off_timer(void);
2032531c97eSMatthias Ringwald static void stop_power_off_timer(void);
2042531c97eSMatthias Ringwald static client_state_t * client_for_connection(connection_t *connection);
2052531c97eSMatthias Ringwald static void hci_emit_system_bluetooth_enabled(uint8_t enabled);
2061edc4fc7SMatthias Ringwald static void stack_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t * packet, uint16_t size);
2072531c97eSMatthias Ringwald 
2082531c97eSMatthias Ringwald 
2092531c97eSMatthias Ringwald // MARK: globals
2108c9f78e5SMatthias Ringwald 
2118c9f78e5SMatthias Ringwald #ifdef HAVE_TRANSPORT_H4
2122531c97eSMatthias Ringwald static hci_transport_config_uart_t hci_transport_config_uart;
2138c9f78e5SMatthias Ringwald #endif
2148c9f78e5SMatthias Ringwald 
2158c9f78e5SMatthias Ringwald static const hci_transport_t * transport;
2162531c97eSMatthias Ringwald static btstack_timer_source_t timeout;
2172531c97eSMatthias Ringwald static uint8_t timeout_active = 0;
2182531c97eSMatthias Ringwald static int power_management_sleep = 0;
2192531c97eSMatthias Ringwald static btstack_linked_list_t clients = NULL;        // list of connected clients `
2202531c97eSMatthias Ringwald #ifdef ENABLE_BLE
2212531c97eSMatthias Ringwald static btstack_linked_list_t gatt_client_helpers = NULL;   // list of used gatt client (helpers)
2222531c97eSMatthias Ringwald #endif
2232531c97eSMatthias Ringwald 
2242531c97eSMatthias Ringwald static void (*bluetooth_status_handler)(BLUETOOTH_STATE state) = dummy_bluetooth_status_handler;
2252531c97eSMatthias Ringwald 
2262531c97eSMatthias Ringwald static btstack_packet_callback_registration_t hci_event_callback_registration;
2271edc4fc7SMatthias Ringwald static btstack_packet_callback_registration_t sm_event_callback_registration;
2282531c97eSMatthias Ringwald 
2292531c97eSMatthias Ringwald static int global_enable = 0;
2302531c97eSMatthias Ringwald 
2312531c97eSMatthias Ringwald static btstack_link_key_db_t    const * btstack_link_key_db = NULL;
2322531c97eSMatthias Ringwald static btstack_device_name_db_t const * btstack_device_name_db = NULL;
2332531c97eSMatthias Ringwald // static int rfcomm_channel_generator = 1;
2342531c97eSMatthias Ringwald 
2352531c97eSMatthias Ringwald static uint8_t   attribute_value[1000];
2362531c97eSMatthias Ringwald static const int attribute_value_buffer_size = sizeof(attribute_value);
2372531c97eSMatthias Ringwald static uint8_t serviceSearchPattern[200];
2382531c97eSMatthias Ringwald static uint8_t attributeIDList[50];
2392531c97eSMatthias Ringwald static void * sdp_client_query_connection;
2402531c97eSMatthias Ringwald 
2416cf7652eSMatthias Ringwald static char string_buffer[1000];
2426cf7652eSMatthias Ringwald 
2432531c97eSMatthias Ringwald static int loggingEnabled;
2442531c97eSMatthias Ringwald 
2456cf7652eSMatthias Ringwald static const char * btstack_server_storage_path;
2462531c97eSMatthias Ringwald 
247a05b2457SMatthias Ringwald // TLV
248a05b2457SMatthias Ringwald static int                   tlv_setup_done;
249a05b2457SMatthias Ringwald static const btstack_tlv_t * tlv_impl;
250a05b2457SMatthias Ringwald static btstack_tlv_posix_t   tlv_context;
251a05b2457SMatthias Ringwald 
2522531c97eSMatthias Ringwald static void dummy_bluetooth_status_handler(BLUETOOTH_STATE state){
2532531c97eSMatthias Ringwald     log_info("Bluetooth status: %u\n", state);
2542531c97eSMatthias Ringwald };
2552531c97eSMatthias Ringwald 
2562531c97eSMatthias Ringwald static void daemon_no_connections_timeout(struct btstack_timer_source *ts){
2572531c97eSMatthias Ringwald     if (clients_require_power_on()) return;    // false alarm :)
2582531c97eSMatthias Ringwald     log_info("No active client connection for %u seconds -> POWER OFF\n", DAEMON_NO_ACTIVE_CLIENT_TIMEOUT/1000);
2592531c97eSMatthias Ringwald     hci_power_control(HCI_POWER_OFF);
2602531c97eSMatthias Ringwald }
2612531c97eSMatthias Ringwald 
2622531c97eSMatthias Ringwald 
2632531c97eSMatthias Ringwald static void add_uint32_to_list(btstack_linked_list_t *list, uint32_t value){
2642531c97eSMatthias Ringwald     btstack_linked_list_iterator_t it;
2652531c97eSMatthias Ringwald     btstack_linked_list_iterator_init(&it, list);
2662531c97eSMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
2672531c97eSMatthias Ringwald         btstack_linked_list_uint32_t * item = (btstack_linked_list_uint32_t*) btstack_linked_list_iterator_next(&it);
2682531c97eSMatthias Ringwald         if ( item->value == value) return; // already in list
2692531c97eSMatthias Ringwald     }
2702531c97eSMatthias Ringwald 
2712531c97eSMatthias Ringwald     btstack_linked_list_uint32_t * item = malloc(sizeof(btstack_linked_list_uint32_t));
2722531c97eSMatthias Ringwald     if (!item) return;
2732531c97eSMatthias Ringwald     item->value = value;
2742531c97eSMatthias Ringwald     btstack_linked_list_add(list, (btstack_linked_item_t *) item);
2752531c97eSMatthias Ringwald }
2762531c97eSMatthias Ringwald 
2772531c97eSMatthias Ringwald static void remove_and_free_uint32_from_list(btstack_linked_list_t *list, uint32_t value){
2782531c97eSMatthias Ringwald     btstack_linked_list_iterator_t it;
2792531c97eSMatthias Ringwald     btstack_linked_list_iterator_init(&it, list);
2802531c97eSMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
2812531c97eSMatthias Ringwald         btstack_linked_list_uint32_t * item = (btstack_linked_list_uint32_t*) btstack_linked_list_iterator_next(&it);
2822531c97eSMatthias Ringwald         if ( item->value != value) continue;
2832531c97eSMatthias Ringwald         btstack_linked_list_remove(list, (btstack_linked_item_t *) item);
2842531c97eSMatthias Ringwald         free(item);
2852531c97eSMatthias Ringwald     }
2862531c97eSMatthias Ringwald }
2872531c97eSMatthias Ringwald 
2882531c97eSMatthias Ringwald static void daemon_add_client_rfcomm_service(connection_t * connection, uint16_t service_channel){
2892531c97eSMatthias Ringwald     client_state_t * client_state = client_for_connection(connection);
2902531c97eSMatthias Ringwald     if (!client_state) return;
2912531c97eSMatthias Ringwald     add_uint32_to_list(&client_state->rfcomm_services, service_channel);
2922531c97eSMatthias Ringwald }
2932531c97eSMatthias Ringwald 
2942531c97eSMatthias Ringwald static void daemon_remove_client_rfcomm_service(connection_t * connection, uint16_t service_channel){
2952531c97eSMatthias Ringwald     client_state_t * client_state = client_for_connection(connection);
2962531c97eSMatthias Ringwald     if (!client_state) return;
2972531c97eSMatthias Ringwald     remove_and_free_uint32_from_list(&client_state->rfcomm_services, service_channel);
2982531c97eSMatthias Ringwald }
2992531c97eSMatthias Ringwald 
3002531c97eSMatthias Ringwald static void daemon_add_client_rfcomm_channel(connection_t * connection, uint16_t cid){
3012531c97eSMatthias Ringwald     client_state_t * client_state = client_for_connection(connection);
3022531c97eSMatthias Ringwald     if (!client_state) return;
3032531c97eSMatthias Ringwald     add_uint32_to_list(&client_state->rfcomm_cids, cid);
3042531c97eSMatthias Ringwald }
3052531c97eSMatthias Ringwald 
3062531c97eSMatthias Ringwald static void daemon_remove_client_rfcomm_channel(connection_t * connection, uint16_t cid){
3072531c97eSMatthias Ringwald     client_state_t * client_state = client_for_connection(connection);
3082531c97eSMatthias Ringwald     if (!client_state) return;
3092531c97eSMatthias Ringwald     remove_and_free_uint32_from_list(&client_state->rfcomm_cids, cid);
3102531c97eSMatthias Ringwald }
3112531c97eSMatthias Ringwald 
3122531c97eSMatthias Ringwald static void daemon_add_client_l2cap_service(connection_t * connection, uint16_t psm){
3132531c97eSMatthias Ringwald     client_state_t * client_state = client_for_connection(connection);
3142531c97eSMatthias Ringwald     if (!client_state) return;
3152531c97eSMatthias Ringwald     add_uint32_to_list(&client_state->l2cap_psms, psm);
3162531c97eSMatthias Ringwald }
3172531c97eSMatthias Ringwald 
3182531c97eSMatthias Ringwald static void daemon_remove_client_l2cap_service(connection_t * connection, uint16_t psm){
3192531c97eSMatthias Ringwald     client_state_t * client_state = client_for_connection(connection);
3202531c97eSMatthias Ringwald     if (!client_state) return;
3212531c97eSMatthias Ringwald     remove_and_free_uint32_from_list(&client_state->l2cap_psms, psm);
3222531c97eSMatthias Ringwald }
3232531c97eSMatthias Ringwald 
3242531c97eSMatthias Ringwald static void daemon_add_client_l2cap_channel(connection_t * connection, uint16_t cid){
3252531c97eSMatthias Ringwald     client_state_t * client_state = client_for_connection(connection);
3262531c97eSMatthias Ringwald     if (!client_state) return;
3272531c97eSMatthias Ringwald     add_uint32_to_list(&client_state->l2cap_cids, cid);
3282531c97eSMatthias Ringwald }
3292531c97eSMatthias Ringwald 
3302531c97eSMatthias Ringwald static void daemon_remove_client_l2cap_channel(connection_t * connection, uint16_t cid){
3312531c97eSMatthias Ringwald     client_state_t * client_state = client_for_connection(connection);
3322531c97eSMatthias Ringwald     if (!client_state) return;
3332531c97eSMatthias Ringwald     remove_and_free_uint32_from_list(&client_state->l2cap_cids, cid);
3342531c97eSMatthias Ringwald }
3352531c97eSMatthias Ringwald 
3362531c97eSMatthias Ringwald static void daemon_add_client_sdp_service_record_handle(connection_t * connection, uint32_t handle){
3372531c97eSMatthias Ringwald     client_state_t * client_state = client_for_connection(connection);
3382531c97eSMatthias Ringwald     if (!client_state) return;
3392531c97eSMatthias Ringwald     add_uint32_to_list(&client_state->sdp_record_handles, handle);
3402531c97eSMatthias Ringwald }
3412531c97eSMatthias Ringwald 
3422531c97eSMatthias Ringwald static void daemon_remove_client_sdp_service_record_handle(connection_t * connection, uint32_t handle){
3432531c97eSMatthias Ringwald     client_state_t * client_state = client_for_connection(connection);
3442531c97eSMatthias Ringwald     if (!client_state) return;
3452531c97eSMatthias Ringwald     remove_and_free_uint32_from_list(&client_state->sdp_record_handles, handle);
3462531c97eSMatthias Ringwald }
3472531c97eSMatthias Ringwald 
3482531c97eSMatthias Ringwald #ifdef ENABLE_BLE
3492531c97eSMatthias Ringwald static void daemon_add_gatt_client_handle(connection_t * connection, uint32_t handle){
3502531c97eSMatthias Ringwald     client_state_t * client_state = client_for_connection(connection);
3512531c97eSMatthias Ringwald     if (!client_state) return;
3522531c97eSMatthias Ringwald 
3532531c97eSMatthias Ringwald     // check if handle already exists in the gatt_con_handles list
3542531c97eSMatthias Ringwald     btstack_linked_list_iterator_t it;
3552531c97eSMatthias Ringwald     int handle_found = 0;
3562531c97eSMatthias Ringwald     btstack_linked_list_iterator_init(&it, &client_state->gatt_con_handles);
3572531c97eSMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
3582531c97eSMatthias Ringwald         btstack_linked_list_uint32_t * item = (btstack_linked_list_uint32_t*) btstack_linked_list_iterator_next(&it);
3592531c97eSMatthias Ringwald         if (item->value == handle){
3602531c97eSMatthias Ringwald             handle_found = 1;
3612531c97eSMatthias Ringwald             break;
3622531c97eSMatthias Ringwald         }
3632531c97eSMatthias Ringwald     }
3642531c97eSMatthias Ringwald     // if handle doesn't exist add it to gatt_con_handles
3652531c97eSMatthias Ringwald     if (!handle_found){
3662531c97eSMatthias Ringwald         add_uint32_to_list(&client_state->gatt_con_handles, handle);
3672531c97eSMatthias Ringwald     }
3682531c97eSMatthias Ringwald 
3692531c97eSMatthias Ringwald     // check if there is a helper with given handle
3702531c97eSMatthias Ringwald     btstack_linked_list_gatt_client_helper_t * gatt_helper = NULL;
3712531c97eSMatthias Ringwald     btstack_linked_list_iterator_init(&it, &gatt_client_helpers);
3722531c97eSMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
3732531c97eSMatthias Ringwald         btstack_linked_list_gatt_client_helper_t * item = (btstack_linked_list_gatt_client_helper_t*) btstack_linked_list_iterator_next(&it);
3742531c97eSMatthias Ringwald         if (item->con_handle == handle){
3752531c97eSMatthias Ringwald             gatt_helper = item;
3762531c97eSMatthias Ringwald             break;
3772531c97eSMatthias Ringwald         }
3782531c97eSMatthias Ringwald     }
3792531c97eSMatthias Ringwald 
3802531c97eSMatthias Ringwald     // if gatt_helper doesn't exist, create it and add it to gatt_client_helpers list
3812531c97eSMatthias Ringwald     if (!gatt_helper){
382af0d0df5SMatthias Ringwald         gatt_helper = calloc(sizeof(btstack_linked_list_gatt_client_helper_t), 1);
3832531c97eSMatthias Ringwald         if (!gatt_helper) return;
3842531c97eSMatthias Ringwald         gatt_helper->con_handle = handle;
3852531c97eSMatthias Ringwald         btstack_linked_list_add(&gatt_client_helpers, (btstack_linked_item_t *) gatt_helper);
3862531c97eSMatthias Ringwald     }
3872531c97eSMatthias Ringwald 
3882531c97eSMatthias Ringwald     // check if connection exists
3892531c97eSMatthias Ringwald     int connection_found = 0;
3902531c97eSMatthias Ringwald     btstack_linked_list_iterator_init(&it, &gatt_helper->all_connections);
3912531c97eSMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
3922531c97eSMatthias Ringwald         btstack_linked_list_connection_t * item = (btstack_linked_list_connection_t*) btstack_linked_list_iterator_next(&it);
3932531c97eSMatthias Ringwald         if (item->connection == connection){
3942531c97eSMatthias Ringwald             connection_found = 1;
3952531c97eSMatthias Ringwald             break;
3962531c97eSMatthias Ringwald         }
3972531c97eSMatthias Ringwald     }
3982531c97eSMatthias Ringwald 
3992531c97eSMatthias Ringwald     // if connection is not found, add it to the all_connections, and set it as active connection
4002531c97eSMatthias Ringwald     if (!connection_found){
401af0d0df5SMatthias Ringwald         btstack_linked_list_connection_t * con = calloc(sizeof(btstack_linked_list_connection_t), 1);
4022531c97eSMatthias Ringwald         if (!con) return;
4032531c97eSMatthias Ringwald         con->connection = connection;
4042531c97eSMatthias Ringwald         btstack_linked_list_add(&gatt_helper->all_connections, (btstack_linked_item_t *)con);
4052531c97eSMatthias Ringwald     }
4062531c97eSMatthias Ringwald }
4072531c97eSMatthias Ringwald 
4082531c97eSMatthias Ringwald 
4092531c97eSMatthias Ringwald static void daemon_remove_gatt_client_handle(connection_t * connection, uint32_t handle){
4102531c97eSMatthias Ringwald     // PART 1 - uses connection & handle
4112531c97eSMatthias Ringwald     // might be extracted or vanish totally
4122531c97eSMatthias Ringwald     client_state_t * client_state = client_for_connection(connection);
4132531c97eSMatthias Ringwald     if (!client_state) return;
4142531c97eSMatthias Ringwald 
4152531c97eSMatthias Ringwald     btstack_linked_list_iterator_t it;
4162531c97eSMatthias Ringwald     // remove handle from gatt_con_handles list
4172531c97eSMatthias Ringwald     btstack_linked_list_iterator_init(&it, &client_state->gatt_con_handles);
4182531c97eSMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
4192531c97eSMatthias Ringwald         btstack_linked_list_uint32_t * item = (btstack_linked_list_uint32_t*) btstack_linked_list_iterator_next(&it);
4202531c97eSMatthias Ringwald         if (item->value == handle){
4212531c97eSMatthias Ringwald             btstack_linked_list_remove(&client_state->gatt_con_handles, (btstack_linked_item_t *) item);
4222531c97eSMatthias Ringwald             free(item);
4232531c97eSMatthias Ringwald         }
4242531c97eSMatthias Ringwald     }
4252531c97eSMatthias Ringwald 
4262531c97eSMatthias Ringwald     // PART 2 - only uses handle
4272531c97eSMatthias Ringwald 
4282531c97eSMatthias Ringwald     // find helper with given handle
4292531c97eSMatthias Ringwald     btstack_linked_list_gatt_client_helper_t * helper = NULL;
4302531c97eSMatthias Ringwald     btstack_linked_list_iterator_init(&it, &gatt_client_helpers);
4312531c97eSMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
4322531c97eSMatthias Ringwald         btstack_linked_list_gatt_client_helper_t * item = (btstack_linked_list_gatt_client_helper_t*) btstack_linked_list_iterator_next(&it);
4332531c97eSMatthias Ringwald         if (item->con_handle == handle){
4342531c97eSMatthias Ringwald             helper = item;
4352531c97eSMatthias Ringwald             break;
4362531c97eSMatthias Ringwald         }
4372531c97eSMatthias Ringwald     }
4382531c97eSMatthias Ringwald 
4392531c97eSMatthias Ringwald     if (!helper) return;
4402531c97eSMatthias Ringwald     // remove connection from helper
4412531c97eSMatthias Ringwald     btstack_linked_list_iterator_init(&it, &helper->all_connections);
4422531c97eSMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
4432531c97eSMatthias Ringwald         btstack_linked_list_connection_t * item = (btstack_linked_list_connection_t*) btstack_linked_list_iterator_next(&it);
4442531c97eSMatthias Ringwald         if (item->connection == connection){
4452531c97eSMatthias Ringwald             btstack_linked_list_remove(&helper->all_connections, (btstack_linked_item_t *) item);
4462531c97eSMatthias Ringwald             free(item);
4472531c97eSMatthias Ringwald             break;
4482531c97eSMatthias Ringwald         }
4492531c97eSMatthias Ringwald     }
4502531c97eSMatthias Ringwald 
4512531c97eSMatthias Ringwald     if (helper->active_connection == connection){
4522531c97eSMatthias Ringwald         helper->active_connection = NULL;
4532531c97eSMatthias Ringwald     }
4542531c97eSMatthias Ringwald     // if helper has no more connections, call disconnect
4552531c97eSMatthias Ringwald     if (helper->all_connections == NULL){
4562531c97eSMatthias Ringwald         gap_disconnect((hci_con_handle_t) helper->con_handle);
4572531c97eSMatthias Ringwald     }
4582531c97eSMatthias Ringwald }
4592531c97eSMatthias Ringwald 
4602531c97eSMatthias Ringwald 
4612531c97eSMatthias Ringwald static void daemon_remove_gatt_client_helper(uint32_t con_handle){
4622531c97eSMatthias Ringwald     btstack_linked_list_iterator_t it, cl;
4632531c97eSMatthias Ringwald     // find helper with given handle
4642531c97eSMatthias Ringwald     btstack_linked_list_gatt_client_helper_t * helper = NULL;
4652531c97eSMatthias Ringwald     btstack_linked_list_iterator_init(&it, &gatt_client_helpers);
4662531c97eSMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
4672531c97eSMatthias Ringwald         btstack_linked_list_gatt_client_helper_t * item = (btstack_linked_list_gatt_client_helper_t*) btstack_linked_list_iterator_next(&it);
4682531c97eSMatthias Ringwald         if (item->con_handle == con_handle){
4692531c97eSMatthias Ringwald             helper = item;
4702531c97eSMatthias Ringwald             break;
4712531c97eSMatthias Ringwald         }
4722531c97eSMatthias Ringwald     }
4732531c97eSMatthias Ringwald 
4742531c97eSMatthias Ringwald     if (!helper) return;
4752531c97eSMatthias Ringwald 
476*24047dd6SMatthias Ringwald     // stop listening
477*24047dd6SMatthias Ringwald     btstack_linked_list_iterator_init(&it, &helper->gatt_client_notifications);
478*24047dd6SMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
479*24047dd6SMatthias Ringwald         btstack_linked_list_gatt_client_notification_t * item = (btstack_linked_list_gatt_client_notification_t*) btstack_linked_list_iterator_next(&it);
480*24047dd6SMatthias Ringwald         log_info("Stop gatt notification listener %p", item);
481*24047dd6SMatthias Ringwald         gatt_client_stop_listening_for_characteristic_value_updates(&item->notification_listener);
482*24047dd6SMatthias Ringwald         btstack_linked_list_remove(&helper->gatt_client_notifications, (btstack_linked_item_t *) item);
483*24047dd6SMatthias Ringwald         free(item);
484*24047dd6SMatthias Ringwald     }
485*24047dd6SMatthias Ringwald 
4862531c97eSMatthias Ringwald     // remove all connection from helper
4872531c97eSMatthias Ringwald     btstack_linked_list_iterator_init(&it, &helper->all_connections);
4882531c97eSMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
4892531c97eSMatthias Ringwald         btstack_linked_list_connection_t * item = (btstack_linked_list_connection_t*) btstack_linked_list_iterator_next(&it);
4902531c97eSMatthias Ringwald         btstack_linked_list_remove(&helper->all_connections, (btstack_linked_item_t *) item);
4912531c97eSMatthias Ringwald         free(item);
4922531c97eSMatthias Ringwald     }
4932531c97eSMatthias Ringwald 
4942531c97eSMatthias Ringwald     btstack_linked_list_remove(&gatt_client_helpers, (btstack_linked_item_t *) helper);
4952531c97eSMatthias Ringwald     free(helper);
4962531c97eSMatthias Ringwald 
4972531c97eSMatthias Ringwald     btstack_linked_list_iterator_init(&cl, &clients);
4982531c97eSMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&cl)){
4992531c97eSMatthias Ringwald         client_state_t * client_state = (client_state_t *) btstack_linked_list_iterator_next(&cl);
5002531c97eSMatthias Ringwald         btstack_linked_list_iterator_init(&it, &client_state->gatt_con_handles);
5012531c97eSMatthias Ringwald         while (btstack_linked_list_iterator_has_next(&it)){
5022531c97eSMatthias Ringwald             btstack_linked_list_uint32_t * item = (btstack_linked_list_uint32_t*) btstack_linked_list_iterator_next(&it);
5032531c97eSMatthias Ringwald             if (item->value == con_handle){
5042531c97eSMatthias Ringwald                 btstack_linked_list_remove(&client_state->gatt_con_handles, (btstack_linked_item_t *) item);
5052531c97eSMatthias Ringwald                 free(item);
5062531c97eSMatthias Ringwald             }
5072531c97eSMatthias Ringwald         }
5082531c97eSMatthias Ringwald     }
5092531c97eSMatthias Ringwald }
5102531c97eSMatthias Ringwald #endif
5112531c97eSMatthias Ringwald 
5122531c97eSMatthias Ringwald static void daemon_rfcomm_close_connection(client_state_t * daemon_client){
5132531c97eSMatthias Ringwald     btstack_linked_list_iterator_t it;
5142531c97eSMatthias Ringwald     btstack_linked_list_t *rfcomm_services = &daemon_client->rfcomm_services;
5152531c97eSMatthias Ringwald     btstack_linked_list_t *rfcomm_cids = &daemon_client->rfcomm_cids;
5162531c97eSMatthias Ringwald 
5172531c97eSMatthias Ringwald     btstack_linked_list_iterator_init(&it, rfcomm_services);
5182531c97eSMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
5192531c97eSMatthias Ringwald         btstack_linked_list_uint32_t * item = (btstack_linked_list_uint32_t*) btstack_linked_list_iterator_next(&it);
5202531c97eSMatthias Ringwald         rfcomm_unregister_service(item->value);
5212531c97eSMatthias Ringwald         btstack_linked_list_remove(rfcomm_services, (btstack_linked_item_t *) item);
5222531c97eSMatthias Ringwald         free(item);
5232531c97eSMatthias Ringwald     }
5242531c97eSMatthias Ringwald 
5252531c97eSMatthias Ringwald     btstack_linked_list_iterator_init(&it, rfcomm_cids);
5262531c97eSMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
5272531c97eSMatthias Ringwald         btstack_linked_list_uint32_t * item = (btstack_linked_list_uint32_t*) btstack_linked_list_iterator_next(&it);
5282531c97eSMatthias Ringwald         rfcomm_disconnect(item->value);
5292531c97eSMatthias Ringwald         btstack_linked_list_remove(rfcomm_cids, (btstack_linked_item_t *) item);
5302531c97eSMatthias Ringwald         free(item);
5312531c97eSMatthias Ringwald     }
5322531c97eSMatthias Ringwald }
5332531c97eSMatthias Ringwald 
5342531c97eSMatthias Ringwald 
5352531c97eSMatthias Ringwald static void daemon_l2cap_close_connection(client_state_t * daemon_client){
5362531c97eSMatthias Ringwald     btstack_linked_list_iterator_t it;
5372531c97eSMatthias Ringwald     btstack_linked_list_t *l2cap_psms = &daemon_client->l2cap_psms;
5382531c97eSMatthias Ringwald     btstack_linked_list_t *l2cap_cids = &daemon_client->l2cap_cids;
5392531c97eSMatthias Ringwald 
5402531c97eSMatthias Ringwald     btstack_linked_list_iterator_init(&it, l2cap_psms);
5412531c97eSMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
5422531c97eSMatthias Ringwald         btstack_linked_list_uint32_t * item = (btstack_linked_list_uint32_t*) btstack_linked_list_iterator_next(&it);
5432531c97eSMatthias Ringwald         l2cap_unregister_service(item->value);
5442531c97eSMatthias Ringwald         btstack_linked_list_remove(l2cap_psms, (btstack_linked_item_t *) item);
5452531c97eSMatthias Ringwald         free(item);
5462531c97eSMatthias Ringwald     }
5472531c97eSMatthias Ringwald 
5482531c97eSMatthias Ringwald     btstack_linked_list_iterator_init(&it, l2cap_cids);
5492531c97eSMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
5502531c97eSMatthias Ringwald         btstack_linked_list_uint32_t * item = (btstack_linked_list_uint32_t*) btstack_linked_list_iterator_next(&it);
5512531c97eSMatthias Ringwald         l2cap_disconnect(item->value, 0); // note: reason isn't used
5522531c97eSMatthias Ringwald         btstack_linked_list_remove(l2cap_cids, (btstack_linked_item_t *) item);
5532531c97eSMatthias Ringwald         free(item);
5542531c97eSMatthias Ringwald     }
5552531c97eSMatthias Ringwald }
5562531c97eSMatthias Ringwald 
5572531c97eSMatthias Ringwald static void daemon_sdp_close_connection(client_state_t * daemon_client){
5582531c97eSMatthias Ringwald     btstack_linked_list_t * list = &daemon_client->sdp_record_handles;
5592531c97eSMatthias Ringwald     btstack_linked_list_iterator_t it;
5602531c97eSMatthias Ringwald     btstack_linked_list_iterator_init(&it, list);
5612531c97eSMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
5622531c97eSMatthias Ringwald         btstack_linked_list_uint32_t * item = (btstack_linked_list_uint32_t*) btstack_linked_list_iterator_next(&it);
5632531c97eSMatthias Ringwald         sdp_unregister_service(item->value);
5642531c97eSMatthias Ringwald         btstack_linked_list_remove(list, (btstack_linked_item_t *) item);
5652531c97eSMatthias Ringwald         free(item);
5662531c97eSMatthias Ringwald     }
5672531c97eSMatthias Ringwald }
5682531c97eSMatthias Ringwald 
5692531c97eSMatthias Ringwald static connection_t * connection_for_l2cap_cid(uint16_t cid){
5702531c97eSMatthias Ringwald     btstack_linked_list_iterator_t cl;
5712531c97eSMatthias Ringwald     btstack_linked_list_iterator_init(&cl, &clients);
5722531c97eSMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&cl)){
5732531c97eSMatthias Ringwald         client_state_t * client_state = (client_state_t *) btstack_linked_list_iterator_next(&cl);
5742531c97eSMatthias Ringwald         btstack_linked_list_iterator_t it;
5752531c97eSMatthias Ringwald         btstack_linked_list_iterator_init(&it, &client_state->l2cap_cids);
5762531c97eSMatthias Ringwald         while (btstack_linked_list_iterator_has_next(&it)){
5772531c97eSMatthias Ringwald             btstack_linked_list_uint32_t * item = (btstack_linked_list_uint32_t*) btstack_linked_list_iterator_next(&it);
5782531c97eSMatthias Ringwald             if (item->value == cid){
5792531c97eSMatthias Ringwald                 return client_state->connection;
5802531c97eSMatthias Ringwald             }
5812531c97eSMatthias Ringwald         }
5822531c97eSMatthias Ringwald     }
5832531c97eSMatthias Ringwald     return NULL;
5842531c97eSMatthias Ringwald }
5852531c97eSMatthias Ringwald 
5862531c97eSMatthias Ringwald static const uint8_t removeServiceRecordHandleAttributeIDList[] = { 0x36, 0x00, 0x05, 0x0A, 0x00, 0x01, 0xFF, 0xFF };
5872531c97eSMatthias Ringwald 
5882531c97eSMatthias Ringwald // register a service record
5892531c97eSMatthias Ringwald // pre: AttributeIDs are in ascending order
5902531c97eSMatthias Ringwald // pre: ServiceRecordHandle is first attribute and is not already registered in database
5912531c97eSMatthias Ringwald // @returns status
5922531c97eSMatthias Ringwald static uint32_t daemon_sdp_create_and_register_service(uint8_t * record){
5932531c97eSMatthias Ringwald 
5942531c97eSMatthias Ringwald     // create new handle
5952531c97eSMatthias Ringwald     uint32_t record_handle = sdp_create_service_record_handle();
5962531c97eSMatthias Ringwald 
5972531c97eSMatthias Ringwald     // calculate size of new service record: DES (2 byte len)
5982531c97eSMatthias Ringwald     // + ServiceRecordHandle attribute (UINT16 UINT32) + size of existing attributes
5992531c97eSMatthias Ringwald     uint16_t recordSize =  3 + (3 + 5) + de_get_data_size(record);
6002531c97eSMatthias Ringwald 
6012531c97eSMatthias Ringwald     // alloc memory for new service record
6022531c97eSMatthias Ringwald     uint8_t * newRecord = malloc(recordSize);
6032531c97eSMatthias Ringwald     if (!newRecord) return 0;
6042531c97eSMatthias Ringwald 
6052531c97eSMatthias Ringwald     // create DES for new record
6062531c97eSMatthias Ringwald     de_create_sequence(newRecord);
6072531c97eSMatthias Ringwald 
6082531c97eSMatthias Ringwald     // set service record handle
6092531c97eSMatthias Ringwald     de_add_number(newRecord, DE_UINT, DE_SIZE_16, 0);
6102531c97eSMatthias Ringwald     de_add_number(newRecord, DE_UINT, DE_SIZE_32, record_handle);
6112531c97eSMatthias Ringwald 
6122531c97eSMatthias Ringwald     // add other attributes
6132531c97eSMatthias Ringwald     sdp_append_attributes_in_attributeIDList(record, (uint8_t *) removeServiceRecordHandleAttributeIDList, 0, recordSize, newRecord);
6142531c97eSMatthias Ringwald 
6152531c97eSMatthias Ringwald     uint8_t status = sdp_register_service(newRecord);
6162531c97eSMatthias Ringwald 
6172531c97eSMatthias Ringwald     if (status) {
6182531c97eSMatthias Ringwald         free(newRecord);
6192531c97eSMatthias Ringwald         return 0;
6202531c97eSMatthias Ringwald     }
6212531c97eSMatthias Ringwald 
6222531c97eSMatthias Ringwald     return record_handle;
6232531c97eSMatthias Ringwald }
6242531c97eSMatthias Ringwald 
6252531c97eSMatthias Ringwald static connection_t * connection_for_rfcomm_cid(uint16_t cid){
6262531c97eSMatthias Ringwald     btstack_linked_list_iterator_t cl;
6272531c97eSMatthias Ringwald     btstack_linked_list_iterator_init(&cl, &clients);
6282531c97eSMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&cl)){
6292531c97eSMatthias Ringwald         client_state_t * client_state = (client_state_t *) btstack_linked_list_iterator_next(&cl);
6302531c97eSMatthias Ringwald         btstack_linked_list_iterator_t it;
6312531c97eSMatthias Ringwald         btstack_linked_list_iterator_init(&it, &client_state->rfcomm_cids);
6322531c97eSMatthias Ringwald         while (btstack_linked_list_iterator_has_next(&it)){
6332531c97eSMatthias Ringwald             btstack_linked_list_uint32_t * item = (btstack_linked_list_uint32_t*) btstack_linked_list_iterator_next(&it);
6342531c97eSMatthias Ringwald             if (item->value == cid){
6352531c97eSMatthias Ringwald                 return client_state->connection;
6362531c97eSMatthias Ringwald             }
6372531c97eSMatthias Ringwald         }
6382531c97eSMatthias Ringwald     }
6392531c97eSMatthias Ringwald     return NULL;
6402531c97eSMatthias Ringwald }
6412531c97eSMatthias Ringwald 
6422531c97eSMatthias Ringwald #ifdef ENABLE_BLE
6432531c97eSMatthias Ringwald static void daemon_gatt_client_close_connection(connection_t * connection){
6442531c97eSMatthias Ringwald     client_state_t * client = client_for_connection(connection);
6452531c97eSMatthias Ringwald     if (!client) return;
6462531c97eSMatthias Ringwald 
6472531c97eSMatthias Ringwald     btstack_linked_list_iterator_t it;
648*24047dd6SMatthias Ringwald 
6492531c97eSMatthias Ringwald     btstack_linked_list_iterator_init(&it, &client->gatt_con_handles);
6502531c97eSMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
6512531c97eSMatthias Ringwald         btstack_linked_list_uint32_t * item = (btstack_linked_list_uint32_t*) btstack_linked_list_iterator_next(&it);
6522531c97eSMatthias Ringwald         daemon_remove_gatt_client_handle(connection, item->value);
6532531c97eSMatthias Ringwald     }
6542531c97eSMatthias Ringwald }
6552531c97eSMatthias Ringwald #endif
6562531c97eSMatthias Ringwald 
6572531c97eSMatthias Ringwald static void daemon_disconnect_client(connection_t * connection){
6582531c97eSMatthias Ringwald     log_info("Daemon disconnect client %p\n",connection);
6592531c97eSMatthias Ringwald 
6602531c97eSMatthias Ringwald     client_state_t * client = client_for_connection(connection);
6612531c97eSMatthias Ringwald     if (!client) return;
6622531c97eSMatthias Ringwald 
6632531c97eSMatthias Ringwald     daemon_sdp_close_connection(client);
6642531c97eSMatthias Ringwald     daemon_rfcomm_close_connection(client);
6652531c97eSMatthias Ringwald     daemon_l2cap_close_connection(client);
6662531c97eSMatthias Ringwald #ifdef ENABLE_BLE
6672531c97eSMatthias Ringwald     // NOTE: experimental - disconnect all LE connections where GATT Client was used
6682531c97eSMatthias Ringwald     // gatt_client_disconnect_connection(connection);
6692531c97eSMatthias Ringwald     daemon_gatt_client_close_connection(connection);
6702531c97eSMatthias Ringwald #endif
6712531c97eSMatthias Ringwald 
6722531c97eSMatthias Ringwald     btstack_linked_list_remove(&clients, (btstack_linked_item_t *) client);
6732531c97eSMatthias Ringwald     free(client);
6742531c97eSMatthias Ringwald }
6752531c97eSMatthias Ringwald 
6762531c97eSMatthias Ringwald static void hci_emit_btstack_version(void){
6772531c97eSMatthias Ringwald     log_info("DAEMON_EVENT_VERSION %u.%u", BTSTACK_MAJOR, BTSTACK_MINOR);
6782531c97eSMatthias Ringwald     uint8_t event[6];
6792531c97eSMatthias Ringwald     event[0] = DAEMON_EVENT_VERSION;
6802531c97eSMatthias Ringwald     event[1] = sizeof(event) - 2;
6812531c97eSMatthias Ringwald     event[2] = BTSTACK_MAJOR;
6822531c97eSMatthias Ringwald     event[3] = BTSTACK_MINOR;
6832531c97eSMatthias Ringwald     little_endian_store_16(event, 4, 3257);    // last SVN commit on Google Code + 1
6842531c97eSMatthias Ringwald     socket_connection_send_packet_all(HCI_EVENT_PACKET, 0, event, sizeof(event));
6852531c97eSMatthias Ringwald }
6862531c97eSMatthias Ringwald 
6872531c97eSMatthias Ringwald static void hci_emit_system_bluetooth_enabled(uint8_t enabled){
6882531c97eSMatthias Ringwald     log_info("DAEMON_EVENT_SYSTEM_BLUETOOTH_ENABLED %u", enabled);
6892531c97eSMatthias Ringwald     uint8_t event[3];
6902531c97eSMatthias Ringwald     event[0] = DAEMON_EVENT_SYSTEM_BLUETOOTH_ENABLED;
6912531c97eSMatthias Ringwald     event[1] = sizeof(event) - 2;
6922531c97eSMatthias Ringwald     event[2] = enabled;
6932531c97eSMatthias Ringwald     hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event));
6942531c97eSMatthias Ringwald     socket_connection_send_packet_all(HCI_EVENT_PACKET, 0, event, sizeof(event));
6952531c97eSMatthias Ringwald }
6962531c97eSMatthias Ringwald 
6972531c97eSMatthias Ringwald static void send_l2cap_connection_open_failed(connection_t * connection, bd_addr_t address, uint16_t psm, uint8_t status){
6982531c97eSMatthias Ringwald     // emit error - see l2cap.c:l2cap_emit_channel_opened(..)
6992531c97eSMatthias Ringwald     uint8_t event[23];
7002531c97eSMatthias Ringwald     memset(event, 0, sizeof(event));
7012531c97eSMatthias Ringwald     event[0] = L2CAP_EVENT_CHANNEL_OPENED;
7022531c97eSMatthias Ringwald     event[1] = sizeof(event) - 2;
7032531c97eSMatthias Ringwald     event[2] = status;
7042531c97eSMatthias Ringwald     reverse_bd_addr(address, &event[3]);
7052531c97eSMatthias Ringwald     // little_endian_store_16(event,  9, channel->handle);
7062531c97eSMatthias Ringwald     little_endian_store_16(event, 11, psm);
7072531c97eSMatthias Ringwald     // little_endian_store_16(event, 13, channel->local_cid);
7082531c97eSMatthias Ringwald     // little_endian_store_16(event, 15, channel->remote_cid);
7092531c97eSMatthias Ringwald     // little_endian_store_16(event, 17, channel->local_mtu);
7102531c97eSMatthias Ringwald     // little_endian_store_16(event, 19, channel->remote_mtu);
7112531c97eSMatthias Ringwald     // little_endian_store_16(event, 21, channel->flush_timeout);
7122531c97eSMatthias Ringwald     hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event));
7132531c97eSMatthias Ringwald     socket_connection_send_packet(connection, HCI_EVENT_PACKET, 0, event, sizeof(event));
7142531c97eSMatthias Ringwald }
7152531c97eSMatthias Ringwald 
7162531c97eSMatthias Ringwald static void l2cap_emit_service_registered(void *connection, uint8_t status, uint16_t psm){
7172531c97eSMatthias Ringwald     uint8_t event[5];
71862c64df1SMatthias Ringwald     event[0] = DAEMON_EVENT_L2CAP_SERVICE_REGISTERED;
7192531c97eSMatthias Ringwald     event[1] = sizeof(event) - 2;
7202531c97eSMatthias Ringwald     event[2] = status;
7212531c97eSMatthias Ringwald     little_endian_store_16(event, 3, psm);
7222531c97eSMatthias Ringwald     hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event));
7232531c97eSMatthias Ringwald     socket_connection_send_packet(connection, HCI_EVENT_PACKET, 0, event, sizeof(event));
7242531c97eSMatthias Ringwald }
7252531c97eSMatthias Ringwald 
7262531c97eSMatthias Ringwald static void rfcomm_emit_service_registered(void *connection, uint8_t status, uint8_t channel){
7272531c97eSMatthias Ringwald     uint8_t event[4];
72862c64df1SMatthias Ringwald     event[0] = DAEMON_EVENT_RFCOMM_SERVICE_REGISTERED;
7292531c97eSMatthias Ringwald     event[1] = sizeof(event) - 2;
7302531c97eSMatthias Ringwald     event[2] = status;
7312531c97eSMatthias Ringwald     event[3] = channel;
7322531c97eSMatthias Ringwald     hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event));
7332531c97eSMatthias Ringwald     socket_connection_send_packet(connection, HCI_EVENT_PACKET, 0, event, sizeof(event));
7342531c97eSMatthias Ringwald }
7352531c97eSMatthias Ringwald 
7362531c97eSMatthias Ringwald static void send_rfcomm_create_channel_failed(void * connection, bd_addr_t addr, uint8_t server_channel, uint8_t status){
7372531c97eSMatthias Ringwald     // emit error - see rfcom.c:rfcomm_emit_channel_open_failed_outgoing_memory(..)
7382531c97eSMatthias Ringwald     uint8_t event[16];
7392531c97eSMatthias Ringwald     memset(event, 0, sizeof(event));
7402531c97eSMatthias Ringwald     uint8_t pos = 0;
741f8f6a918SMatthias Ringwald     event[pos++] = RFCOMM_EVENT_CHANNEL_OPENED;
7422531c97eSMatthias Ringwald     event[pos++] = sizeof(event) - 2;
7432531c97eSMatthias Ringwald     event[pos++] = status;
7442531c97eSMatthias Ringwald     reverse_bd_addr(addr, &event[pos]); pos += 6;
7452531c97eSMatthias Ringwald     little_endian_store_16(event,  pos, 0);   pos += 2;
7462531c97eSMatthias Ringwald     event[pos++] = server_channel;
7472531c97eSMatthias Ringwald     little_endian_store_16(event, pos, 0); pos += 2;   // channel ID
7482531c97eSMatthias Ringwald     little_endian_store_16(event, pos, 0); pos += 2;   // max frame size
7492531c97eSMatthias Ringwald     hci_dump_packet(HCI_EVENT_PACKET, 0, event, sizeof(event));
7502531c97eSMatthias Ringwald     socket_connection_send_packet(connection, HCI_EVENT_PACKET, 0, event, sizeof(event));
7512531c97eSMatthias Ringwald }
7522531c97eSMatthias Ringwald 
7532531c97eSMatthias Ringwald // data: event(8), len(8), status(8), service_record_handle(32)
7542531c97eSMatthias Ringwald static void sdp_emit_service_registered(void *connection, uint32_t handle, uint8_t status) {
7552531c97eSMatthias Ringwald     uint8_t event[7];
75662c64df1SMatthias Ringwald     event[0] = DAEMON_EVENT_SDP_SERVICE_REGISTERED;
7572531c97eSMatthias Ringwald     event[1] = sizeof(event) - 2;
7582531c97eSMatthias Ringwald     event[2] = status;
7592531c97eSMatthias Ringwald     little_endian_store_32(event, 3, handle);
7602531c97eSMatthias Ringwald     hci_dump_packet(HCI_EVENT_PACKET, 0, event, sizeof(event));
7612531c97eSMatthias Ringwald     socket_connection_send_packet(connection, HCI_EVENT_PACKET, 0, event, sizeof(event));
7622531c97eSMatthias Ringwald }
7632531c97eSMatthias Ringwald 
7642531c97eSMatthias Ringwald #ifdef ENABLE_BLE
7652531c97eSMatthias Ringwald 
766fc64f94aSMatthias Ringwald btstack_linked_list_gatt_client_helper_t * daemon_get_gatt_client_helper(hci_con_handle_t con_handle) {
7672531c97eSMatthias Ringwald     btstack_linked_list_iterator_t it;
7682531c97eSMatthias Ringwald     if (!gatt_client_helpers) return NULL;
769fc64f94aSMatthias Ringwald     log_info("daemon_get_gatt_client_helper for handle 0x%02x", con_handle);
7702531c97eSMatthias Ringwald 
7712531c97eSMatthias Ringwald     btstack_linked_list_iterator_init(&it, &gatt_client_helpers);
7722531c97eSMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
7732531c97eSMatthias Ringwald         btstack_linked_list_gatt_client_helper_t * item = (btstack_linked_list_gatt_client_helper_t*) btstack_linked_list_iterator_next(&it);
7742531c97eSMatthias Ringwald         if (!item ) {
7752531c97eSMatthias Ringwald             log_info("daemon_get_gatt_client_helper gatt_client_helpers null item");
7762531c97eSMatthias Ringwald             break;
7772531c97eSMatthias Ringwald         }
778fc64f94aSMatthias Ringwald         if (item->con_handle == con_handle){
7792531c97eSMatthias Ringwald             return item;
7802531c97eSMatthias Ringwald         }
7812531c97eSMatthias Ringwald     }
782fc64f94aSMatthias Ringwald     log_info("daemon_get_gatt_client_helper for handle 0x%02x is NULL.", con_handle);
7832531c97eSMatthias Ringwald     return NULL;
7842531c97eSMatthias Ringwald }
7852531c97eSMatthias Ringwald 
786fc64f94aSMatthias Ringwald static void send_gatt_query_complete(connection_t * connection, hci_con_handle_t con_handle, uint8_t status){
7872531c97eSMatthias Ringwald     // @format H1
7882531c97eSMatthias Ringwald     uint8_t event[5];
7892531c97eSMatthias Ringwald     event[0] = GATT_EVENT_QUERY_COMPLETE;
7902531c97eSMatthias Ringwald     event[1] = 3;
791fc64f94aSMatthias Ringwald     little_endian_store_16(event, 2, con_handle);
7922531c97eSMatthias Ringwald     event[4] = status;
7932531c97eSMatthias Ringwald     hci_dump_packet(HCI_EVENT_PACKET, 0, event, sizeof(event));
7942531c97eSMatthias Ringwald     socket_connection_send_packet(connection, HCI_EVENT_PACKET, 0, event, sizeof(event));
7952531c97eSMatthias Ringwald }
7962531c97eSMatthias Ringwald 
797fc64f94aSMatthias Ringwald static void send_gatt_mtu_event(connection_t * connection, hci_con_handle_t con_handle, uint16_t mtu){
7982531c97eSMatthias Ringwald     uint8_t event[6];
7992531c97eSMatthias Ringwald     int pos = 0;
8002531c97eSMatthias Ringwald     event[pos++] = GATT_EVENT_MTU;
8012531c97eSMatthias Ringwald     event[pos++] = sizeof(event) - 2;
802fc64f94aSMatthias Ringwald     little_endian_store_16(event, pos, con_handle);
8032531c97eSMatthias Ringwald     pos += 2;
8042531c97eSMatthias Ringwald     little_endian_store_16(event, pos, mtu);
8052531c97eSMatthias Ringwald     pos += 2;
8062531c97eSMatthias Ringwald     hci_dump_packet(HCI_EVENT_PACKET, 0, event, sizeof(event));
8072531c97eSMatthias Ringwald     socket_connection_send_packet(connection, HCI_EVENT_PACKET, 0, event, sizeof(event));
8082531c97eSMatthias Ringwald }
8092531c97eSMatthias Ringwald 
8102531c97eSMatthias Ringwald btstack_linked_list_gatt_client_helper_t * daemon_setup_gatt_client_request(connection_t *connection, uint8_t *packet, int track_active_connection) {
811fc64f94aSMatthias Ringwald     hci_con_handle_t con_handle = little_endian_read_16(packet, 3);
812fc64f94aSMatthias Ringwald     log_info("daemon_setup_gatt_client_request for handle 0x%02x", con_handle);
813fc64f94aSMatthias Ringwald     hci_connection_t * hci_con = hci_connection_for_handle(con_handle);
8142531c97eSMatthias Ringwald     if ((hci_con == NULL) || (hci_con->state != OPEN)){
815fc64f94aSMatthias Ringwald         send_gatt_query_complete(connection, con_handle, GATT_CLIENT_NOT_CONNECTED);
8162531c97eSMatthias Ringwald         return NULL;
8172531c97eSMatthias Ringwald     }
8182531c97eSMatthias Ringwald 
819fc64f94aSMatthias Ringwald     btstack_linked_list_gatt_client_helper_t * helper = daemon_get_gatt_client_helper(con_handle);
8202531c97eSMatthias Ringwald 
8212531c97eSMatthias Ringwald     if (!helper){
8222531c97eSMatthias Ringwald         log_info("helper does not exist");
823af0d0df5SMatthias Ringwald         helper = calloc(sizeof(btstack_linked_list_gatt_client_helper_t), 1);
8242531c97eSMatthias Ringwald         if (!helper) return NULL;
825fc64f94aSMatthias Ringwald         helper->con_handle = con_handle;
8262531c97eSMatthias Ringwald         btstack_linked_list_add(&gatt_client_helpers, (btstack_linked_item_t *) helper);
8272531c97eSMatthias Ringwald     }
8282531c97eSMatthias Ringwald 
8292531c97eSMatthias Ringwald     if (track_active_connection && helper->active_connection){
830fc64f94aSMatthias Ringwald         send_gatt_query_complete(connection, con_handle, GATT_CLIENT_BUSY);
8312531c97eSMatthias Ringwald         return NULL;
8322531c97eSMatthias Ringwald     }
8332531c97eSMatthias Ringwald 
834fc64f94aSMatthias Ringwald     daemon_add_gatt_client_handle(connection, con_handle);
8352531c97eSMatthias Ringwald 
8362531c97eSMatthias Ringwald     if (track_active_connection){
8372531c97eSMatthias Ringwald         // remember connection responsible for this request
8382531c97eSMatthias Ringwald         helper->active_connection = connection;
8392531c97eSMatthias Ringwald     }
8402531c97eSMatthias Ringwald 
8412531c97eSMatthias Ringwald     return helper;
8422531c97eSMatthias Ringwald }
8432531c97eSMatthias Ringwald 
8442531c97eSMatthias Ringwald // (de)serialize structs from/to HCI commands/events
8452531c97eSMatthias Ringwald 
8462531c97eSMatthias Ringwald void daemon_gatt_serialize_service(gatt_client_service_t * service, uint8_t * event, int offset){
8472531c97eSMatthias Ringwald     little_endian_store_16(event, offset, service->start_group_handle);
8482531c97eSMatthias Ringwald     little_endian_store_16(event, offset+2, service->end_group_handle);
8492531c97eSMatthias Ringwald     reverse_128(service->uuid128, &event[offset + 4]);
8502531c97eSMatthias Ringwald }
8512531c97eSMatthias Ringwald 
8522531c97eSMatthias Ringwald void daemon_gatt_serialize_characteristic(gatt_client_characteristic_t * characteristic, uint8_t * event, int offset){
8532531c97eSMatthias Ringwald     little_endian_store_16(event, offset, characteristic->start_handle);
8542531c97eSMatthias Ringwald     little_endian_store_16(event, offset+2, characteristic->value_handle);
8552531c97eSMatthias Ringwald     little_endian_store_16(event, offset+4, characteristic->end_handle);
8562531c97eSMatthias Ringwald     little_endian_store_16(event, offset+6, characteristic->properties);
8572531c97eSMatthias Ringwald     reverse_128(characteristic->uuid128, &event[offset+8]);
8582531c97eSMatthias Ringwald }
8592531c97eSMatthias Ringwald 
8602531c97eSMatthias Ringwald void daemon_gatt_serialize_characteristic_descriptor(gatt_client_characteristic_descriptor_t * characteristic_descriptor, uint8_t * event, int offset){
8612531c97eSMatthias Ringwald     little_endian_store_16(event, offset, characteristic_descriptor->handle);
8622531c97eSMatthias Ringwald     reverse_128(characteristic_descriptor->uuid128, &event[offset+2]);
8632531c97eSMatthias Ringwald }
8642531c97eSMatthias Ringwald 
8652531c97eSMatthias Ringwald #endif
8662531c97eSMatthias Ringwald 
8672531c97eSMatthias Ringwald static int btstack_command_handler(connection_t *connection, uint8_t *packet, uint16_t size){
8682531c97eSMatthias Ringwald 
8692531c97eSMatthias Ringwald     bd_addr_t addr;
870a046efa6SMatthias Ringwald #ifdef ENABLE_BLE
8712531c97eSMatthias Ringwald     bd_addr_type_t addr_type;
8722531c97eSMatthias Ringwald     hci_con_handle_t handle;
873a046efa6SMatthias Ringwald #endif
8742531c97eSMatthias Ringwald     uint16_t cid;
8752531c97eSMatthias Ringwald     uint16_t psm;
8762531c97eSMatthias Ringwald     uint16_t service_channel;
8772531c97eSMatthias Ringwald     uint16_t mtu;
8782531c97eSMatthias Ringwald     uint8_t  reason;
8792531c97eSMatthias Ringwald     uint8_t  rfcomm_channel;
8802531c97eSMatthias Ringwald     uint8_t  rfcomm_credits;
8812531c97eSMatthias Ringwald     uint32_t service_record_handle;
8822531c97eSMatthias Ringwald     client_state_t *client;
8832531c97eSMatthias Ringwald     uint8_t status;
8842531c97eSMatthias Ringwald     uint8_t  * data;
8852531c97eSMatthias Ringwald #if defined(HAVE_MALLOC) && defined(ENABLE_BLE)
8862531c97eSMatthias Ringwald     uint8_t uuid128[16];
8872531c97eSMatthias Ringwald     gatt_client_service_t service;
8882531c97eSMatthias Ringwald     gatt_client_characteristic_t characteristic;
8892531c97eSMatthias Ringwald     gatt_client_characteristic_descriptor_t descriptor;
8902531c97eSMatthias Ringwald     uint16_t data_length;
8912531c97eSMatthias Ringwald     btstack_linked_list_gatt_client_helper_t * gatt_helper;
8922531c97eSMatthias Ringwald #endif
8932531c97eSMatthias Ringwald 
8942531c97eSMatthias Ringwald     uint16_t serviceSearchPatternLen;
8952531c97eSMatthias Ringwald     uint16_t attributeIDListLen;
8962531c97eSMatthias Ringwald 
8972531c97eSMatthias Ringwald     // verbose log info before other info to allow for better tracking
8982531c97eSMatthias Ringwald     hci_dump_packet( HCI_COMMAND_DATA_PACKET, 1, packet, size);
8992531c97eSMatthias Ringwald 
9002531c97eSMatthias Ringwald     // BTstack internal commands - 16 Bit OpCode, 8 Bit ParamLen, Params...
9012531c97eSMatthias Ringwald     switch (READ_CMD_OCF(packet)){
9022531c97eSMatthias Ringwald         case BTSTACK_GET_STATE:
9032531c97eSMatthias Ringwald             log_info("BTSTACK_GET_STATE");
9042531c97eSMatthias Ringwald             hci_emit_state();
9052531c97eSMatthias Ringwald             break;
9062531c97eSMatthias Ringwald         case BTSTACK_SET_POWER_MODE:
9072531c97eSMatthias Ringwald             log_info("BTSTACK_SET_POWER_MODE %u", packet[3]);
9082531c97eSMatthias Ringwald             // track client power requests
9092531c97eSMatthias Ringwald             client = client_for_connection(connection);
9102531c97eSMatthias Ringwald             if (!client) break;
9112531c97eSMatthias Ringwald             client->power_mode = packet[3];
9122531c97eSMatthias Ringwald             // handle merged state
9132531c97eSMatthias Ringwald             if (!clients_require_power_on()){
9142531c97eSMatthias Ringwald                 start_power_off_timer();
9152531c97eSMatthias Ringwald             } else if (!power_management_sleep) {
9162531c97eSMatthias Ringwald                 stop_power_off_timer();
9172531c97eSMatthias Ringwald                 hci_power_control(HCI_POWER_ON);
9182531c97eSMatthias Ringwald             }
9192531c97eSMatthias Ringwald             break;
9202531c97eSMatthias Ringwald         case BTSTACK_GET_VERSION:
9212531c97eSMatthias Ringwald             log_info("BTSTACK_GET_VERSION");
9222531c97eSMatthias Ringwald             hci_emit_btstack_version();
9232531c97eSMatthias Ringwald             break;
9242531c97eSMatthias Ringwald #ifdef HAVE_PLATFORM_IPHONE_OS
9252531c97eSMatthias Ringwald         case BTSTACK_SET_SYSTEM_BLUETOOTH_ENABLED:
9262531c97eSMatthias Ringwald             log_info("BTSTACK_SET_SYSTEM_BLUETOOTH_ENABLED %u", packet[3]);
9272531c97eSMatthias Ringwald             btstack_control_iphone_bt_set_enabled(packet[3]);
9282531c97eSMatthias Ringwald             hci_emit_system_bluetooth_enabled(btstack_control_iphone_bt_enabled());
9292531c97eSMatthias Ringwald             break;
9302531c97eSMatthias Ringwald 
9312531c97eSMatthias Ringwald         case BTSTACK_GET_SYSTEM_BLUETOOTH_ENABLED:
9322531c97eSMatthias Ringwald             log_info("BTSTACK_GET_SYSTEM_BLUETOOTH_ENABLED");
9332531c97eSMatthias Ringwald             hci_emit_system_bluetooth_enabled(btstack_control_iphone_bt_enabled());
9342531c97eSMatthias Ringwald             break;
9352531c97eSMatthias Ringwald #else
9362531c97eSMatthias Ringwald         case BTSTACK_SET_SYSTEM_BLUETOOTH_ENABLED:
9372531c97eSMatthias Ringwald         case BTSTACK_GET_SYSTEM_BLUETOOTH_ENABLED:
9382531c97eSMatthias Ringwald             hci_emit_system_bluetooth_enabled(0);
9392531c97eSMatthias Ringwald             break;
9402531c97eSMatthias Ringwald #endif
9412531c97eSMatthias Ringwald         case BTSTACK_SET_DISCOVERABLE:
9422531c97eSMatthias Ringwald             log_info("BTSTACK_SET_DISCOVERABLE discoverable %u)", packet[3]);
9432531c97eSMatthias Ringwald             // track client discoverable requests
9442531c97eSMatthias Ringwald             client = client_for_connection(connection);
9452531c97eSMatthias Ringwald             if (!client) break;
9462531c97eSMatthias Ringwald             client->discoverable = packet[3];
9472531c97eSMatthias Ringwald             // merge state
9482531c97eSMatthias Ringwald             gap_discoverable_control(clients_require_discoverable());
9492531c97eSMatthias Ringwald             break;
9502531c97eSMatthias Ringwald         case BTSTACK_SET_BLUETOOTH_ENABLED:
9512531c97eSMatthias Ringwald             log_info("BTSTACK_SET_BLUETOOTH_ENABLED: %u\n", packet[3]);
9522531c97eSMatthias Ringwald             if (packet[3]) {
9532531c97eSMatthias Ringwald                 // global enable
9542531c97eSMatthias Ringwald                 global_enable = 1;
9552531c97eSMatthias Ringwald                 hci_power_control(HCI_POWER_ON);
9562531c97eSMatthias Ringwald             } else {
9572531c97eSMatthias Ringwald                 global_enable = 0;
9582531c97eSMatthias Ringwald                 clients_clear_power_request();
9592531c97eSMatthias Ringwald                 hci_power_control(HCI_POWER_OFF);
9602531c97eSMatthias Ringwald             }
9612531c97eSMatthias Ringwald             break;
9622531c97eSMatthias Ringwald         case L2CAP_CREATE_CHANNEL_MTU:
9632531c97eSMatthias Ringwald             reverse_bd_addr(&packet[3], addr);
9642531c97eSMatthias Ringwald             psm = little_endian_read_16(packet, 9);
9652531c97eSMatthias Ringwald             mtu = little_endian_read_16(packet, 11);
9662531c97eSMatthias Ringwald             status = l2cap_create_channel(NULL, addr, psm, mtu, &cid);
9672531c97eSMatthias Ringwald             if (status){
9682531c97eSMatthias Ringwald                 send_l2cap_connection_open_failed(connection, addr, psm, status);
9692531c97eSMatthias Ringwald             } else {
9702531c97eSMatthias Ringwald                 daemon_add_client_l2cap_channel(connection, cid);
9712531c97eSMatthias Ringwald             }
9722531c97eSMatthias Ringwald             break;
9732531c97eSMatthias Ringwald         case L2CAP_CREATE_CHANNEL:
9742531c97eSMatthias Ringwald             reverse_bd_addr(&packet[3], addr);
9752531c97eSMatthias Ringwald             psm = little_endian_read_16(packet, 9);
9762531c97eSMatthias Ringwald             mtu = 150; // until r865
9772531c97eSMatthias Ringwald             status = l2cap_create_channel(NULL, addr, psm, mtu, &cid);
9782531c97eSMatthias Ringwald             if (status){
9792531c97eSMatthias Ringwald                 send_l2cap_connection_open_failed(connection, addr, psm, status);
9802531c97eSMatthias Ringwald             } else {
9812531c97eSMatthias Ringwald                 daemon_add_client_l2cap_channel(connection, cid);
9822531c97eSMatthias Ringwald             }
9832531c97eSMatthias Ringwald             break;
9842531c97eSMatthias Ringwald         case L2CAP_DISCONNECT:
9852531c97eSMatthias Ringwald             cid = little_endian_read_16(packet, 3);
9862531c97eSMatthias Ringwald             reason = packet[5];
9872531c97eSMatthias Ringwald             l2cap_disconnect(cid, reason);
9882531c97eSMatthias Ringwald             break;
9892531c97eSMatthias Ringwald         case L2CAP_REGISTER_SERVICE:
9902531c97eSMatthias Ringwald             psm = little_endian_read_16(packet, 3);
9912531c97eSMatthias Ringwald             mtu = little_endian_read_16(packet, 5);
9922531c97eSMatthias Ringwald             status = l2cap_register_service(NULL, psm, mtu, LEVEL_0);
9932531c97eSMatthias Ringwald             daemon_add_client_l2cap_service(connection, little_endian_read_16(packet, 3));
9942531c97eSMatthias Ringwald             l2cap_emit_service_registered(connection, status, psm);
9952531c97eSMatthias Ringwald             break;
9962531c97eSMatthias Ringwald         case L2CAP_UNREGISTER_SERVICE:
9972531c97eSMatthias Ringwald             psm = little_endian_read_16(packet, 3);
9982531c97eSMatthias Ringwald             daemon_remove_client_l2cap_service(connection, psm);
9992531c97eSMatthias Ringwald             l2cap_unregister_service(psm);
10002531c97eSMatthias Ringwald             break;
10012531c97eSMatthias Ringwald         case L2CAP_ACCEPT_CONNECTION:
10022531c97eSMatthias Ringwald             cid    = little_endian_read_16(packet, 3);
10032531c97eSMatthias Ringwald             l2cap_accept_connection(cid);
10042531c97eSMatthias Ringwald             break;
10052531c97eSMatthias Ringwald         case L2CAP_DECLINE_CONNECTION:
10062531c97eSMatthias Ringwald             cid    = little_endian_read_16(packet, 3);
10072531c97eSMatthias Ringwald             reason = packet[7];
10087ef6a7bbSMatthias Ringwald             l2cap_decline_connection(cid);
10092531c97eSMatthias Ringwald             break;
10102531c97eSMatthias Ringwald         case RFCOMM_CREATE_CHANNEL:
10112531c97eSMatthias Ringwald             reverse_bd_addr(&packet[3], addr);
10122531c97eSMatthias Ringwald             rfcomm_channel = packet[9];
10131edc4fc7SMatthias Ringwald             status = rfcomm_create_channel(&stack_packet_handler, addr, rfcomm_channel, &cid);
10142531c97eSMatthias Ringwald             if (status){
10152531c97eSMatthias Ringwald                 send_rfcomm_create_channel_failed(connection, addr, rfcomm_channel, status);
10162531c97eSMatthias Ringwald             } else {
10172531c97eSMatthias Ringwald                 daemon_add_client_rfcomm_channel(connection, cid);
10182531c97eSMatthias Ringwald             }
10192531c97eSMatthias Ringwald             break;
10202531c97eSMatthias Ringwald         case RFCOMM_CREATE_CHANNEL_WITH_CREDITS:
10212531c97eSMatthias Ringwald             reverse_bd_addr(&packet[3], addr);
10222531c97eSMatthias Ringwald             rfcomm_channel = packet[9];
10232531c97eSMatthias Ringwald             rfcomm_credits = packet[10];
10241edc4fc7SMatthias Ringwald             status = rfcomm_create_channel_with_initial_credits(&stack_packet_handler, addr, rfcomm_channel, rfcomm_credits, &cid );
10252531c97eSMatthias Ringwald             if (status){
10262531c97eSMatthias Ringwald                 send_rfcomm_create_channel_failed(connection, addr, rfcomm_channel, status);
10272531c97eSMatthias Ringwald             } else {
10282531c97eSMatthias Ringwald                 daemon_add_client_rfcomm_channel(connection, cid);
10292531c97eSMatthias Ringwald             }
10302531c97eSMatthias Ringwald             break;
10312531c97eSMatthias Ringwald         case RFCOMM_DISCONNECT:
10322531c97eSMatthias Ringwald             cid = little_endian_read_16(packet, 3);
10332531c97eSMatthias Ringwald             reason = packet[5];
10342531c97eSMatthias Ringwald             rfcomm_disconnect(cid);
10352531c97eSMatthias Ringwald             break;
10362531c97eSMatthias Ringwald         case RFCOMM_REGISTER_SERVICE:
10372531c97eSMatthias Ringwald             rfcomm_channel = packet[3];
10382531c97eSMatthias Ringwald             mtu = little_endian_read_16(packet, 4);
10391edc4fc7SMatthias Ringwald             status = rfcomm_register_service(&stack_packet_handler, rfcomm_channel, mtu);
10402531c97eSMatthias Ringwald             rfcomm_emit_service_registered(connection, status, rfcomm_channel);
10412531c97eSMatthias Ringwald             break;
10422531c97eSMatthias Ringwald         case RFCOMM_REGISTER_SERVICE_WITH_CREDITS:
10432531c97eSMatthias Ringwald             rfcomm_channel = packet[3];
10442531c97eSMatthias Ringwald             mtu = little_endian_read_16(packet, 4);
10452531c97eSMatthias Ringwald             rfcomm_credits = packet[6];
10461edc4fc7SMatthias Ringwald             status = rfcomm_register_service_with_initial_credits(&stack_packet_handler, rfcomm_channel, mtu, rfcomm_credits);
10472531c97eSMatthias Ringwald             rfcomm_emit_service_registered(connection, status, rfcomm_channel);
10482531c97eSMatthias Ringwald             break;
10492531c97eSMatthias Ringwald         case RFCOMM_UNREGISTER_SERVICE:
10502531c97eSMatthias Ringwald             service_channel = little_endian_read_16(packet, 3);
10512531c97eSMatthias Ringwald             daemon_remove_client_rfcomm_service(connection, service_channel);
10522531c97eSMatthias Ringwald             rfcomm_unregister_service(service_channel);
10532531c97eSMatthias Ringwald             break;
10542531c97eSMatthias Ringwald         case RFCOMM_ACCEPT_CONNECTION:
10552531c97eSMatthias Ringwald             cid    = little_endian_read_16(packet, 3);
10562531c97eSMatthias Ringwald             rfcomm_accept_connection(cid);
10572531c97eSMatthias Ringwald             break;
10582531c97eSMatthias Ringwald         case RFCOMM_DECLINE_CONNECTION:
10592531c97eSMatthias Ringwald             cid    = little_endian_read_16(packet, 3);
10602531c97eSMatthias Ringwald             reason = packet[7];
10612531c97eSMatthias Ringwald             rfcomm_decline_connection(cid);
10622531c97eSMatthias Ringwald             break;
10632531c97eSMatthias Ringwald         case RFCOMM_GRANT_CREDITS:
10642531c97eSMatthias Ringwald             cid    = little_endian_read_16(packet, 3);
10652531c97eSMatthias Ringwald             rfcomm_credits = packet[5];
10662531c97eSMatthias Ringwald             rfcomm_grant_credits(cid, rfcomm_credits);
10672531c97eSMatthias Ringwald             break;
10682531c97eSMatthias Ringwald         case RFCOMM_PERSISTENT_CHANNEL: {
10692531c97eSMatthias Ringwald             // enforce \0
10702531c97eSMatthias Ringwald             packet[3+248] = 0;
10712531c97eSMatthias Ringwald             rfcomm_channel = rfcomm_service_db_channel_for_service((char*)&packet[3]);
10721bb145c9SMatthias Ringwald             log_info("DAEMON_EVENT_RFCOMM_PERSISTENT_CHANNEL %u", rfcomm_channel);
10732531c97eSMatthias Ringwald             uint8_t event[4];
10741bb145c9SMatthias Ringwald             event[0] = DAEMON_EVENT_RFCOMM_PERSISTENT_CHANNEL;
10752531c97eSMatthias Ringwald             event[1] = sizeof(event) - 2;
10762531c97eSMatthias Ringwald             event[2] = 0;
10772531c97eSMatthias Ringwald             event[3] = rfcomm_channel;
10782531c97eSMatthias Ringwald             hci_dump_packet(HCI_EVENT_PACKET, 0, event, sizeof(event));
10792531c97eSMatthias Ringwald             socket_connection_send_packet(connection, HCI_EVENT_PACKET, 0, (uint8_t *) event, sizeof(event));
10802531c97eSMatthias Ringwald             break;
10812531c97eSMatthias Ringwald         }
10822531c97eSMatthias Ringwald         case SDP_REGISTER_SERVICE_RECORD:
10832531c97eSMatthias Ringwald             log_info("SDP_REGISTER_SERVICE_RECORD size %u\n", size);
10842531c97eSMatthias Ringwald             service_record_handle = daemon_sdp_create_and_register_service(&packet[3]);
10852531c97eSMatthias Ringwald             if (service_record_handle){
10862531c97eSMatthias Ringwald                 daemon_add_client_sdp_service_record_handle(connection, service_record_handle);
10872531c97eSMatthias Ringwald                 sdp_emit_service_registered(connection, service_record_handle, 0);
10882531c97eSMatthias Ringwald             } else {
10892531c97eSMatthias Ringwald                sdp_emit_service_registered(connection, 0, BTSTACK_MEMORY_ALLOC_FAILED);
10902531c97eSMatthias Ringwald             }
10912531c97eSMatthias Ringwald             break;
10922531c97eSMatthias Ringwald         case SDP_UNREGISTER_SERVICE_RECORD:
10932531c97eSMatthias Ringwald             service_record_handle = little_endian_read_32(packet, 3);
10942531c97eSMatthias Ringwald             log_info("SDP_UNREGISTER_SERVICE_RECORD handle 0x%x ", service_record_handle);
10952531c97eSMatthias Ringwald             data = sdp_get_record_for_handle(service_record_handle);
10962531c97eSMatthias Ringwald             sdp_unregister_service(service_record_handle);
10972531c97eSMatthias Ringwald             daemon_remove_client_sdp_service_record_handle(connection, service_record_handle);
10982531c97eSMatthias Ringwald             if (data){
10992531c97eSMatthias Ringwald                 free(data);
11002531c97eSMatthias Ringwald             }
11012531c97eSMatthias Ringwald             break;
11022531c97eSMatthias Ringwald         case SDP_CLIENT_QUERY_RFCOMM_SERVICES:
11032531c97eSMatthias Ringwald             reverse_bd_addr(&packet[3], addr);
11042531c97eSMatthias Ringwald 
11052531c97eSMatthias Ringwald             serviceSearchPatternLen = de_get_len(&packet[9]);
11062531c97eSMatthias Ringwald             memcpy(serviceSearchPattern, &packet[9], serviceSearchPatternLen);
11072531c97eSMatthias Ringwald 
11082531c97eSMatthias Ringwald             sdp_client_query_connection = connection;
11097fbb5f59SMatthias Ringwald             sdp_client_query_rfcomm_channel_and_name_for_search_pattern(&handle_sdp_rfcomm_service_result, addr, serviceSearchPattern);
11102531c97eSMatthias Ringwald 
11112531c97eSMatthias Ringwald             break;
11122531c97eSMatthias Ringwald         case SDP_CLIENT_QUERY_SERVICES:
11132531c97eSMatthias Ringwald             reverse_bd_addr(&packet[3], addr);
11142531c97eSMatthias Ringwald             sdp_client_query_connection = connection;
11152531c97eSMatthias Ringwald 
11162531c97eSMatthias Ringwald             serviceSearchPatternLen = de_get_len(&packet[9]);
11172531c97eSMatthias Ringwald             memcpy(serviceSearchPattern, &packet[9], serviceSearchPatternLen);
11182531c97eSMatthias Ringwald 
11192531c97eSMatthias Ringwald             attributeIDListLen = de_get_len(&packet[9+serviceSearchPatternLen]);
11202531c97eSMatthias Ringwald             memcpy(attributeIDList, &packet[9+serviceSearchPatternLen], attributeIDListLen);
11212531c97eSMatthias Ringwald 
11222531c97eSMatthias Ringwald             sdp_client_query(&handle_sdp_client_query_result, addr, (uint8_t*)&serviceSearchPattern[0], (uint8_t*)&attributeIDList[0]);
11232531c97eSMatthias Ringwald             break;
1124a046efa6SMatthias Ringwald #ifdef ENABLE_BLE
11252531c97eSMatthias Ringwald         case GAP_LE_SCAN_START:
11262531c97eSMatthias Ringwald             gap_start_scan();
11272531c97eSMatthias Ringwald             break;
11282531c97eSMatthias Ringwald         case GAP_LE_SCAN_STOP:
11292531c97eSMatthias Ringwald             gap_stop_scan();
11302531c97eSMatthias Ringwald             break;
11312531c97eSMatthias Ringwald         case GAP_LE_SET_SCAN_PARAMETERS:
11322531c97eSMatthias Ringwald             gap_set_scan_parameters(packet[3], little_endian_read_16(packet, 4), little_endian_read_16(packet, 6));
11332531c97eSMatthias Ringwald             break;
11342531c97eSMatthias Ringwald         case GAP_LE_CONNECT:
11352531c97eSMatthias Ringwald             reverse_bd_addr(&packet[4], addr);
11362531c97eSMatthias Ringwald             addr_type = packet[3];
11372531c97eSMatthias Ringwald             gap_connect(addr, addr_type);
11382531c97eSMatthias Ringwald             break;
11392531c97eSMatthias Ringwald         case GAP_LE_CONNECT_CANCEL:
11402531c97eSMatthias Ringwald             gap_connect_cancel();
11412531c97eSMatthias Ringwald             break;
11422531c97eSMatthias Ringwald         case GAP_DISCONNECT:
11432531c97eSMatthias Ringwald             handle = little_endian_read_16(packet, 3);
11442531c97eSMatthias Ringwald             gap_disconnect(handle);
11452531c97eSMatthias Ringwald             break;
1146a046efa6SMatthias Ringwald #endif
11472531c97eSMatthias Ringwald #if defined(HAVE_MALLOC) && defined(ENABLE_BLE)
11482531c97eSMatthias Ringwald         case GATT_DISCOVER_ALL_PRIMARY_SERVICES:
11492531c97eSMatthias Ringwald             gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1);
11502531c97eSMatthias Ringwald             if (!gatt_helper) break;
11512531c97eSMatthias Ringwald             gatt_client_discover_primary_services(&handle_gatt_client_event, gatt_helper->con_handle);
11522531c97eSMatthias Ringwald             break;
11532531c97eSMatthias Ringwald         case GATT_DISCOVER_PRIMARY_SERVICES_BY_UUID16:
11542531c97eSMatthias Ringwald             gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1);
11552531c97eSMatthias Ringwald             if (!gatt_helper) break;
11562531c97eSMatthias Ringwald             gatt_client_discover_primary_services_by_uuid16(&handle_gatt_client_event, gatt_helper->con_handle, little_endian_read_16(packet, 5));
11572531c97eSMatthias Ringwald             break;
11582531c97eSMatthias Ringwald         case GATT_DISCOVER_PRIMARY_SERVICES_BY_UUID128:
11592531c97eSMatthias Ringwald             gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1);
11602531c97eSMatthias Ringwald             if (!gatt_helper) break;
11612531c97eSMatthias Ringwald             reverse_128(&packet[5], uuid128);
11622531c97eSMatthias Ringwald             gatt_client_discover_primary_services_by_uuid128(&handle_gatt_client_event, gatt_helper->con_handle, uuid128);
11632531c97eSMatthias Ringwald             break;
11642531c97eSMatthias Ringwald         case GATT_FIND_INCLUDED_SERVICES_FOR_SERVICE:
11652531c97eSMatthias Ringwald             gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1);
11662531c97eSMatthias Ringwald             if (!gatt_helper) break;
11672531c97eSMatthias Ringwald             gatt_client_deserialize_service(packet, 5, &service);
11682531c97eSMatthias Ringwald             gatt_client_find_included_services_for_service(&handle_gatt_client_event, gatt_helper->con_handle, &service);
11692531c97eSMatthias Ringwald             break;
11702531c97eSMatthias Ringwald 
11712531c97eSMatthias Ringwald         case GATT_DISCOVER_CHARACTERISTICS_FOR_SERVICE:
11722531c97eSMatthias Ringwald             gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1);
11732531c97eSMatthias Ringwald             if (!gatt_helper) break;
11742531c97eSMatthias Ringwald             gatt_client_deserialize_service(packet, 5, &service);
11752531c97eSMatthias Ringwald             gatt_client_discover_characteristics_for_service(&handle_gatt_client_event, gatt_helper->con_handle, &service);
11762531c97eSMatthias Ringwald             break;
11772531c97eSMatthias Ringwald         case GATT_DISCOVER_CHARACTERISTICS_FOR_SERVICE_BY_UUID128:
11782531c97eSMatthias Ringwald             gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1);
11792531c97eSMatthias Ringwald             if (!gatt_helper) break;
11802531c97eSMatthias Ringwald             gatt_client_deserialize_service(packet, 5, &service);
11812531c97eSMatthias Ringwald             reverse_128(&packet[5 + SERVICE_LENGTH], uuid128);
11822531c97eSMatthias Ringwald             gatt_client_discover_characteristics_for_service_by_uuid128(&handle_gatt_client_event, gatt_helper->con_handle, &service, uuid128);
11832531c97eSMatthias Ringwald             break;
11842531c97eSMatthias Ringwald         case GATT_DISCOVER_CHARACTERISTIC_DESCRIPTORS:
11852531c97eSMatthias Ringwald             gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1);
11862531c97eSMatthias Ringwald             if (!gatt_helper) break;
11872531c97eSMatthias Ringwald             gatt_client_deserialize_characteristic(packet, 5, &characteristic);
11882531c97eSMatthias Ringwald             gatt_client_discover_characteristic_descriptors(&handle_gatt_client_event, gatt_helper->con_handle, &characteristic);
11892531c97eSMatthias Ringwald             break;
11902531c97eSMatthias Ringwald 
11912531c97eSMatthias Ringwald         case GATT_READ_VALUE_OF_CHARACTERISTIC:
11922531c97eSMatthias Ringwald             gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1);
11932531c97eSMatthias Ringwald             if (!gatt_helper) break;
11942531c97eSMatthias Ringwald             gatt_client_deserialize_characteristic(packet, 5, &characteristic);
11952531c97eSMatthias Ringwald             gatt_client_read_value_of_characteristic(&handle_gatt_client_event, gatt_helper->con_handle, &characteristic);
11962531c97eSMatthias Ringwald             break;
11972531c97eSMatthias Ringwald         case GATT_READ_LONG_VALUE_OF_CHARACTERISTIC:
11982531c97eSMatthias Ringwald             gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1);
11992531c97eSMatthias Ringwald             if (!gatt_helper) break;
12002531c97eSMatthias Ringwald             gatt_client_deserialize_characteristic(packet, 5, &characteristic);
12012531c97eSMatthias Ringwald             gatt_client_read_long_value_of_characteristic(&handle_gatt_client_event, gatt_helper->con_handle, &characteristic);
12022531c97eSMatthias Ringwald             break;
12032531c97eSMatthias Ringwald 
12042531c97eSMatthias Ringwald         case GATT_WRITE_VALUE_OF_CHARACTERISTIC_WITHOUT_RESPONSE:
12052531c97eSMatthias Ringwald             gatt_helper = daemon_setup_gatt_client_request(connection, packet, 0);  // note: don't track active connection
12062531c97eSMatthias Ringwald             if (!gatt_helper) break;
12072531c97eSMatthias Ringwald             gatt_client_deserialize_characteristic(packet, 5, &characteristic);
12082531c97eSMatthias Ringwald             data_length = little_endian_read_16(packet, 5 + CHARACTERISTIC_LENGTH);
12092531c97eSMatthias Ringwald             data = gatt_helper->characteristic_buffer;
12102531c97eSMatthias Ringwald             memcpy(data, &packet[7 + CHARACTERISTIC_LENGTH], data_length);
12110ce46700SMatthias Ringwald             gatt_client_write_value_of_characteristic_without_response(gatt_helper->con_handle, characteristic.value_handle, data_length, data);
12122531c97eSMatthias Ringwald             break;
12132531c97eSMatthias Ringwald         case GATT_WRITE_VALUE_OF_CHARACTERISTIC:
12142531c97eSMatthias Ringwald             gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1);
12152531c97eSMatthias Ringwald             if (!gatt_helper) break;
12162531c97eSMatthias Ringwald             gatt_client_deserialize_characteristic(packet, 5, &characteristic);
12172531c97eSMatthias Ringwald             data_length = little_endian_read_16(packet, 5 + CHARACTERISTIC_LENGTH);
12182531c97eSMatthias Ringwald             data = gatt_helper->characteristic_buffer;
12192531c97eSMatthias Ringwald             memcpy(data, &packet[7 + CHARACTERISTIC_LENGTH], data_length);
12202531c97eSMatthias Ringwald             gatt_client_write_value_of_characteristic(&handle_gatt_client_event, gatt_helper->con_handle, characteristic.value_handle, data_length, data);
12212531c97eSMatthias Ringwald             break;
12222531c97eSMatthias Ringwald         case GATT_WRITE_LONG_VALUE_OF_CHARACTERISTIC:
12232531c97eSMatthias Ringwald             gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1);
12242531c97eSMatthias Ringwald             if (!gatt_helper) break;
12252531c97eSMatthias Ringwald             gatt_client_deserialize_characteristic(packet, 5, &characteristic);
12262531c97eSMatthias Ringwald             data_length = little_endian_read_16(packet, 5 + CHARACTERISTIC_LENGTH);
12272531c97eSMatthias Ringwald             data = gatt_helper->characteristic_buffer;
12282531c97eSMatthias Ringwald             memcpy(data, &packet[7 + CHARACTERISTIC_LENGTH], data_length);
12292531c97eSMatthias Ringwald             gatt_client_write_long_value_of_characteristic(&handle_gatt_client_event, gatt_helper->con_handle, characteristic.value_handle, data_length, data);
12302531c97eSMatthias Ringwald             break;
12312531c97eSMatthias Ringwald         case GATT_RELIABLE_WRITE_LONG_VALUE_OF_CHARACTERISTIC:
12322531c97eSMatthias Ringwald             gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1);
12332531c97eSMatthias Ringwald             if (!gatt_helper) break;
12342531c97eSMatthias Ringwald             gatt_client_deserialize_characteristic(packet, 5, &characteristic);
12352531c97eSMatthias Ringwald             data_length = little_endian_read_16(packet, 5 + CHARACTERISTIC_LENGTH);
12362531c97eSMatthias Ringwald             data = gatt_helper->characteristic_buffer;
12372531c97eSMatthias Ringwald             memcpy(data, &packet[7 + CHARACTERISTIC_LENGTH], data_length);
12382531c97eSMatthias Ringwald             gatt_client_write_long_value_of_characteristic(&handle_gatt_client_event, gatt_helper->con_handle, characteristic.value_handle, data_length, data);
12392531c97eSMatthias Ringwald             break;
12402531c97eSMatthias Ringwald         case GATT_READ_CHARACTERISTIC_DESCRIPTOR:
12412531c97eSMatthias Ringwald             gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1);
12422531c97eSMatthias Ringwald             if (!gatt_helper) break;
12432531c97eSMatthias Ringwald             handle = little_endian_read_16(packet, 3);
12442531c97eSMatthias Ringwald             gatt_client_deserialize_characteristic_descriptor(packet, 5, &descriptor);
12452531c97eSMatthias Ringwald             gatt_client_read_characteristic_descriptor(&handle_gatt_client_event, gatt_helper->con_handle, &descriptor);
12462531c97eSMatthias Ringwald             break;
12472531c97eSMatthias Ringwald         case GATT_READ_LONG_CHARACTERISTIC_DESCRIPTOR:
12482531c97eSMatthias Ringwald             gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1);
12492531c97eSMatthias Ringwald             if (!gatt_helper) break;
12502531c97eSMatthias Ringwald             gatt_client_deserialize_characteristic_descriptor(packet, 5, &descriptor);
12512531c97eSMatthias Ringwald             gatt_client_read_long_characteristic_descriptor(&handle_gatt_client_event, gatt_helper->con_handle, &descriptor);
12522531c97eSMatthias Ringwald             break;
12532531c97eSMatthias Ringwald 
12542531c97eSMatthias Ringwald         case GATT_WRITE_CHARACTERISTIC_DESCRIPTOR:
12552531c97eSMatthias Ringwald             gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1);
12562531c97eSMatthias Ringwald             if (!gatt_helper) break;
12572531c97eSMatthias Ringwald             gatt_client_deserialize_characteristic_descriptor(packet, 5, &descriptor);
12582531c97eSMatthias Ringwald             data = gatt_helper->characteristic_buffer;
12592531c97eSMatthias Ringwald             data_length = little_endian_read_16(packet, 5 + CHARACTERISTIC_DESCRIPTOR_LENGTH);
12602531c97eSMatthias Ringwald             gatt_client_write_characteristic_descriptor(&handle_gatt_client_event, gatt_helper->con_handle, &descriptor, data_length, data);
12612531c97eSMatthias Ringwald             break;
12622531c97eSMatthias Ringwald         case GATT_WRITE_LONG_CHARACTERISTIC_DESCRIPTOR:
12632531c97eSMatthias Ringwald             gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1);
12642531c97eSMatthias Ringwald             if (!gatt_helper) break;
12652531c97eSMatthias Ringwald             gatt_client_deserialize_characteristic_descriptor(packet, 5, &descriptor);
12662531c97eSMatthias Ringwald             data = gatt_helper->characteristic_buffer;
12672531c97eSMatthias Ringwald             data_length = little_endian_read_16(packet, 5 + CHARACTERISTIC_DESCRIPTOR_LENGTH);
12682531c97eSMatthias Ringwald             gatt_client_write_long_characteristic_descriptor(&handle_gatt_client_event, gatt_helper->con_handle, &descriptor, data_length, data);
12692531c97eSMatthias Ringwald             break;
12702531c97eSMatthias Ringwald         case GATT_WRITE_CLIENT_CHARACTERISTIC_CONFIGURATION:{
12712531c97eSMatthias Ringwald             uint16_t configuration = little_endian_read_16(packet, 5 + CHARACTERISTIC_LENGTH);
12722531c97eSMatthias Ringwald             gatt_helper = daemon_setup_gatt_client_request(connection, packet, 1);
12732531c97eSMatthias Ringwald             if (!gatt_helper) break;
12742531c97eSMatthias Ringwald             data = gatt_helper->characteristic_buffer;
12752531c97eSMatthias Ringwald             gatt_client_deserialize_characteristic(packet, 5, &characteristic);
12768d2f5935SMatthias Ringwald             status = gatt_client_write_client_characteristic_configuration(&handle_gatt_client_event, gatt_helper->con_handle, &characteristic, configuration);
12778d2f5935SMatthias Ringwald             if (status){
12788d2f5935SMatthias Ringwald                 send_gatt_query_complete(connection, gatt_helper->con_handle, status);
1279*24047dd6SMatthias Ringwald                 break;
12808d2f5935SMatthias Ringwald             }
1281*24047dd6SMatthias Ringwald             // ignore notification off
1282*24047dd6SMatthias Ringwald             if (configuration == 0) break;
1283*24047dd6SMatthias Ringwald 
1284*24047dd6SMatthias Ringwald             // TODO: we assume it works
1285*24047dd6SMatthias Ringwald 
1286*24047dd6SMatthias Ringwald             // start listening
1287*24047dd6SMatthias Ringwald             btstack_linked_list_gatt_client_notification_t * linked_notification = malloc(sizeof(btstack_linked_list_gatt_client_notification_t));
1288*24047dd6SMatthias Ringwald             if (!linked_notification) break;
1289*24047dd6SMatthias Ringwald             log_info("Start gatt notification listener %p", linked_notification);
1290*24047dd6SMatthias Ringwald             gatt_client_listen_for_characteristic_value_updates(&linked_notification->notification_listener, &handle_gatt_client_event, gatt_helper->con_handle, &characteristic);
1291*24047dd6SMatthias Ringwald             btstack_linked_list_add(&gatt_helper->gatt_client_notifications, (btstack_linked_item_t *) linked_notification);
12922531c97eSMatthias Ringwald             break;
12938d2f5935SMatthias Ringwald         }
12942531c97eSMatthias Ringwald         case GATT_GET_MTU:
12952531c97eSMatthias Ringwald             handle = little_endian_read_16(packet, 3);
12962531c97eSMatthias Ringwald             gatt_client_get_mtu(handle, &mtu);
12972531c97eSMatthias Ringwald             send_gatt_mtu_event(connection, handle, mtu);
12982531c97eSMatthias Ringwald             break;
12992531c97eSMatthias Ringwald #endif
13001edc4fc7SMatthias Ringwald #ifdef ENABLE_BLE
13011edc4fc7SMatthias Ringwald         case SM_SET_AUTHENTICATION_REQUIREMENTS:
1302fb4ddcf3SMatthias Ringwald             log_info("set auth %x", packet[3]);
13031edc4fc7SMatthias Ringwald             sm_set_authentication_requirements(packet[3]);
13041edc4fc7SMatthias Ringwald             break;
13051edc4fc7SMatthias Ringwald         case SM_SET_IO_CAPABILITIES:
1306fb4ddcf3SMatthias Ringwald             log_info("set io %x", packet[3]);
13071edc4fc7SMatthias Ringwald             sm_set_io_capabilities(packet[3]);
13081edc4fc7SMatthias Ringwald             break;
13091edc4fc7SMatthias Ringwald         case SM_BONDING_DECLINE:
13101edc4fc7SMatthias Ringwald             sm_bonding_decline(little_endian_read_16(packet, 3));
13111edc4fc7SMatthias Ringwald             break;
13121edc4fc7SMatthias Ringwald         case SM_JUST_WORKS_CONFIRM:
13131edc4fc7SMatthias Ringwald             sm_just_works_confirm(little_endian_read_16(packet, 3));
13141edc4fc7SMatthias Ringwald             break;
13151edc4fc7SMatthias Ringwald         case SM_NUMERIC_COMPARISON_CONFIRM:
13161edc4fc7SMatthias Ringwald             sm_numeric_comparison_confirm(little_endian_read_16(packet, 3));
13171edc4fc7SMatthias Ringwald             break;
13181edc4fc7SMatthias Ringwald         case SM_PASSKEY_INPUT:
13191edc4fc7SMatthias Ringwald             sm_passkey_input(little_endian_read_16(packet, 3), little_endian_read_32(packet, 5));
13201edc4fc7SMatthias Ringwald             break;
13211edc4fc7SMatthias Ringwald #endif
13222531c97eSMatthias Ringwald     default:
13232531c97eSMatthias Ringwald             log_error("Error: command %u not implemented:", READ_CMD_OCF(packet));
13242531c97eSMatthias Ringwald             break;
13252531c97eSMatthias Ringwald     }
13262531c97eSMatthias Ringwald 
13272531c97eSMatthias Ringwald     return 0;
13282531c97eSMatthias Ringwald }
13292531c97eSMatthias Ringwald 
13302531c97eSMatthias Ringwald static int daemon_client_handler(connection_t *connection, uint16_t packet_type, uint16_t channel, uint8_t *data, uint16_t length){
13312531c97eSMatthias Ringwald 
13322531c97eSMatthias Ringwald     int err = 0;
13332531c97eSMatthias Ringwald     client_state_t * client;
13342531c97eSMatthias Ringwald 
13352531c97eSMatthias Ringwald     switch (packet_type){
13362531c97eSMatthias Ringwald         case HCI_COMMAND_DATA_PACKET:
13372531c97eSMatthias Ringwald             if (READ_CMD_OGF(data) != OGF_BTSTACK) {
13382531c97eSMatthias Ringwald                 // HCI Command
13392531c97eSMatthias Ringwald                 hci_send_cmd_packet(data, length);
13402531c97eSMatthias Ringwald             } else {
13412531c97eSMatthias Ringwald                 // BTstack command
13422531c97eSMatthias Ringwald                 btstack_command_handler(connection, data, length);
13432531c97eSMatthias Ringwald             }
13442531c97eSMatthias Ringwald             break;
13452531c97eSMatthias Ringwald         case L2CAP_DATA_PACKET:
13462531c97eSMatthias Ringwald             // process l2cap packet...
13472531c97eSMatthias Ringwald             err = l2cap_send(channel, data, length);
13482531c97eSMatthias Ringwald             break;
13492531c97eSMatthias Ringwald         case RFCOMM_DATA_PACKET:
13502531c97eSMatthias Ringwald             // process l2cap packet...
13512531c97eSMatthias Ringwald             err = rfcomm_send(channel, data, length);
13522531c97eSMatthias Ringwald             break;
13532531c97eSMatthias Ringwald         case DAEMON_EVENT_PACKET:
13542531c97eSMatthias Ringwald             switch (data[0]) {
13552531c97eSMatthias Ringwald                 case DAEMON_EVENT_CONNECTION_OPENED:
13562531c97eSMatthias Ringwald                     log_info("DAEMON_EVENT_CONNECTION_OPENED %p\n",connection);
13572531c97eSMatthias Ringwald 
1358af0d0df5SMatthias Ringwald                     client = calloc(sizeof(client_state_t), 1);
13592531c97eSMatthias Ringwald                     if (!client) break; // fail
13602531c97eSMatthias Ringwald                     client->connection   = connection;
13612531c97eSMatthias Ringwald                     client->power_mode   = HCI_POWER_OFF;
13622531c97eSMatthias Ringwald                     client->discoverable = 0;
13632531c97eSMatthias Ringwald                     btstack_linked_list_add(&clients, (btstack_linked_item_t *) client);
13642531c97eSMatthias Ringwald                     break;
13652531c97eSMatthias Ringwald                 case DAEMON_EVENT_CONNECTION_CLOSED:
13662531c97eSMatthias Ringwald                     log_info("DAEMON_EVENT_CONNECTION_CLOSED %p\n",connection);
13672531c97eSMatthias Ringwald                     daemon_disconnect_client(connection);
13682531c97eSMatthias Ringwald                     // no clients -> no HCI connections
13692531c97eSMatthias Ringwald                     if (!clients){
13702531c97eSMatthias Ringwald                         hci_disconnect_all();
13712531c97eSMatthias Ringwald                     }
13722531c97eSMatthias Ringwald 
13732531c97eSMatthias Ringwald                     // update discoverable mode
13742531c97eSMatthias Ringwald                     gap_discoverable_control(clients_require_discoverable());
13752531c97eSMatthias Ringwald                     // start power off, if last active client
13762531c97eSMatthias Ringwald                     if (!clients_require_power_on()){
13772531c97eSMatthias Ringwald                         start_power_off_timer();
13782531c97eSMatthias Ringwald                     }
13792531c97eSMatthias Ringwald                     break;
13802531c97eSMatthias Ringwald                 default:
13812531c97eSMatthias Ringwald                     break;
13822531c97eSMatthias Ringwald             }
13832531c97eSMatthias Ringwald             break;
13842531c97eSMatthias Ringwald     }
13852531c97eSMatthias Ringwald     if (err) {
13862531c97eSMatthias Ringwald         log_info("Daemon Handler: err %d\n", err);
13872531c97eSMatthias Ringwald     }
13882531c97eSMatthias Ringwald     return err;
13892531c97eSMatthias Ringwald }
13902531c97eSMatthias Ringwald 
13912531c97eSMatthias Ringwald 
13922531c97eSMatthias Ringwald static void daemon_set_logging_enabled(int enabled){
13932531c97eSMatthias Ringwald     if (enabled && !loggingEnabled){
13946cf7652eSMatthias Ringwald         // construct path to log file
13956cf7652eSMatthias Ringwald         switch (BTSTACK_LOG_TYPE){
13966cf7652eSMatthias Ringwald             case HCI_DUMP_STDOUT:
13976cf7652eSMatthias Ringwald                 snprintf(string_buffer, sizeof(string_buffer), "stdout");
13986cf7652eSMatthias Ringwald                 break;
13996cf7652eSMatthias Ringwald             case HCI_DUMP_PACKETLOGGER:
14006cf7652eSMatthias Ringwald                 snprintf(string_buffer, sizeof(string_buffer), "%s/hci_dump.pklg", btstack_server_storage_path);
14016cf7652eSMatthias Ringwald                 break;
14026cf7652eSMatthias Ringwald             case HCI_DUMP_BLUEZ:
14036cf7652eSMatthias Ringwald                 snprintf(string_buffer, sizeof(string_buffer), "%s/hci_dump.snoop", btstack_server_storage_path);
14046cf7652eSMatthias Ringwald                 break;
14056cf7652eSMatthias Ringwald             default:
14066cf7652eSMatthias Ringwald                 break;
14076cf7652eSMatthias Ringwald         }
14086cf7652eSMatthias Ringwald         hci_dump_open(string_buffer, BTSTACK_LOG_TYPE);
14096cf7652eSMatthias Ringwald         printf("Logging to %s\n", string_buffer);
14102531c97eSMatthias Ringwald     }
14112531c97eSMatthias Ringwald     if (!enabled && loggingEnabled){
14122531c97eSMatthias Ringwald         hci_dump_close();
14132531c97eSMatthias Ringwald     }
14142531c97eSMatthias Ringwald     loggingEnabled = enabled;
14152531c97eSMatthias Ringwald }
14162531c97eSMatthias Ringwald 
14172531c97eSMatthias Ringwald // local cache used to manage UI status
14182531c97eSMatthias Ringwald static HCI_STATE hci_state = HCI_STATE_OFF;
14192531c97eSMatthias Ringwald static int num_connections = 0;
14202531c97eSMatthias Ringwald static void update_ui_status(void){
14212531c97eSMatthias Ringwald     if (hci_state != HCI_STATE_WORKING) {
14222531c97eSMatthias Ringwald         bluetooth_status_handler(BLUETOOTH_OFF);
14232531c97eSMatthias Ringwald     } else {
14242531c97eSMatthias Ringwald         if (num_connections) {
14252531c97eSMatthias Ringwald             bluetooth_status_handler(BLUETOOTH_ACTIVE);
14262531c97eSMatthias Ringwald         } else {
14272531c97eSMatthias Ringwald             bluetooth_status_handler(BLUETOOTH_ON);
14282531c97eSMatthias Ringwald         }
14292531c97eSMatthias Ringwald     }
14302531c97eSMatthias Ringwald }
14312531c97eSMatthias Ringwald 
14322531c97eSMatthias Ringwald #ifdef USE_SPRINGBOARD
14332531c97eSMatthias Ringwald static void preferences_changed_callback(void){
14342531c97eSMatthias Ringwald     int logging = platform_iphone_logging_enabled();
14352531c97eSMatthias Ringwald     log_info("Logging enabled: %u\n", logging);
14362531c97eSMatthias Ringwald     daemon_set_logging_enabled(logging);
14372531c97eSMatthias Ringwald }
14382531c97eSMatthias Ringwald #endif
14392531c97eSMatthias Ringwald 
14402531c97eSMatthias Ringwald static void deamon_status_event_handler(uint8_t *packet, uint16_t size){
14412531c97eSMatthias Ringwald 
14422531c97eSMatthias Ringwald     uint8_t update_status = 0;
14432531c97eSMatthias Ringwald 
14442531c97eSMatthias Ringwald     // handle state event
14450e2df43fSMatthias Ringwald     switch (hci_event_packet_get_type(packet)) {
14462531c97eSMatthias Ringwald         case BTSTACK_EVENT_STATE:
14472531c97eSMatthias Ringwald             hci_state = packet[2];
14482531c97eSMatthias Ringwald             log_info("New state: %u\n", hci_state);
14492531c97eSMatthias Ringwald             update_status = 1;
14502531c97eSMatthias Ringwald             break;
14512531c97eSMatthias Ringwald         case BTSTACK_EVENT_NR_CONNECTIONS_CHANGED:
14522531c97eSMatthias Ringwald             num_connections = packet[2];
14532531c97eSMatthias Ringwald             log_info("New nr connections: %u\n", num_connections);
14542531c97eSMatthias Ringwald             update_status = 1;
14552531c97eSMatthias Ringwald             break;
14562531c97eSMatthias Ringwald         default:
14572531c97eSMatthias Ringwald             break;
14582531c97eSMatthias Ringwald     }
14592531c97eSMatthias Ringwald 
14602531c97eSMatthias Ringwald     // choose full bluetooth state
14612531c97eSMatthias Ringwald     if (update_status) {
14622531c97eSMatthias Ringwald         update_ui_status();
14632531c97eSMatthias Ringwald     }
14642531c97eSMatthias Ringwald }
14652531c97eSMatthias Ringwald 
14662531c97eSMatthias Ringwald static void daemon_retry_parked(void){
14672531c97eSMatthias Ringwald 
14682531c97eSMatthias Ringwald     // socket_connection_retry_parked is not reentrant
14692531c97eSMatthias Ringwald     static int retry_mutex = 0;
14702531c97eSMatthias Ringwald 
14712531c97eSMatthias Ringwald     // lock mutex
14722531c97eSMatthias Ringwald     if (retry_mutex) return;
14732531c97eSMatthias Ringwald     retry_mutex = 1;
14742531c97eSMatthias Ringwald 
14752531c97eSMatthias Ringwald     // ... try sending again
14762531c97eSMatthias Ringwald     socket_connection_retry_parked();
14772531c97eSMatthias Ringwald 
14782531c97eSMatthias Ringwald     // unlock mutex
14792531c97eSMatthias Ringwald     retry_mutex = 0;
14802531c97eSMatthias Ringwald }
14812531c97eSMatthias Ringwald 
14822531c97eSMatthias Ringwald static void daemon_emit_packet(void * connection, uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
14832531c97eSMatthias Ringwald     if (connection) {
14842531c97eSMatthias Ringwald         socket_connection_send_packet(connection, packet_type, channel, packet, size);
14852531c97eSMatthias Ringwald     } else {
14862531c97eSMatthias Ringwald         socket_connection_send_packet_all(packet_type, channel, packet, size);
14872531c97eSMatthias Ringwald     }
14882531c97eSMatthias Ringwald }
14892531c97eSMatthias Ringwald 
14902370d9c1SMatthias Ringwald // copy from btstack_util, just using a '-'
14912370d9c1SMatthias Ringwald static char bd_addr_to_str_buffer[6*3];  // 12:45:78:01:34:67\0
14922370d9c1SMatthias Ringwald char * bd_addr_to_str_dashed(const bd_addr_t addr){
14932370d9c1SMatthias Ringwald     // orig code
14942370d9c1SMatthias Ringwald     // sprintf(bd_addr_to_str_buffer, "%02x:%02x:%02x:%02x:%02x:%02x", addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
14952370d9c1SMatthias Ringwald     // sprintf-free code
14962370d9c1SMatthias Ringwald     char * p = bd_addr_to_str_buffer;
14972370d9c1SMatthias Ringwald     int i;
14982370d9c1SMatthias Ringwald     for (i = 0; i < 6 ; i++) {
14992370d9c1SMatthias Ringwald         uint8_t byte = addr[i];
15002370d9c1SMatthias Ringwald         *p++ = char_for_nibble(byte >> 4);
15012370d9c1SMatthias Ringwald         *p++ = char_for_nibble(byte & 0x0f);
15022370d9c1SMatthias Ringwald         *p++ = '-';
15032370d9c1SMatthias Ringwald     }
15042370d9c1SMatthias Ringwald     *--p = 0;
15052370d9c1SMatthias Ringwald     return (char *) bd_addr_to_str_buffer;
15062370d9c1SMatthias Ringwald }
15072370d9c1SMatthias Ringwald 
15082531c97eSMatthias Ringwald static uint8_t remote_name_event[2+1+6+DEVICE_NAME_LEN+1]; // +1 for \0 in log_info
15092531c97eSMatthias Ringwald static void daemon_packet_handler(void * connection, uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
15102531c97eSMatthias Ringwald     uint16_t cid;
15112531c97eSMatthias Ringwald     int i;
15122531c97eSMatthias Ringwald     bd_addr_t addr;
15132531c97eSMatthias Ringwald     switch (packet_type) {
15142531c97eSMatthias Ringwald         case HCI_EVENT_PACKET:
15152531c97eSMatthias Ringwald             deamon_status_event_handler(packet, size);
15160e2df43fSMatthias Ringwald             switch (hci_event_packet_get_type(packet)){
15172531c97eSMatthias Ringwald 
1518a05b2457SMatthias Ringwald                 case BTSTACK_EVENT_STATE:
1519a05b2457SMatthias Ringwald                     if (btstack_event_state_get_state(packet) != HCI_STATE_WORKING) break;
1520a05b2457SMatthias Ringwald                     if (tlv_setup_done) break;
1521e9b53984SMatthias Ringwald 
1522a05b2457SMatthias Ringwald                     // setup TLV using local address as part of the name
1523a05b2457SMatthias Ringwald                     gap_local_bd_addr(addr);
1524a05b2457SMatthias Ringwald                     log_info("BTstack up and running at %s",  bd_addr_to_str(addr));
15252370d9c1SMatthias Ringwald                     snprintf(string_buffer, sizeof(string_buffer), "%s/btstack_%s.tlv", btstack_server_storage_path, bd_addr_to_str_dashed(addr));
1526a05b2457SMatthias Ringwald                     tlv_impl = btstack_tlv_posix_init_instance(&tlv_context, string_buffer);
1527a05b2457SMatthias Ringwald                     btstack_tlv_set_instance(tlv_impl, &tlv_context);
1528a05b2457SMatthias Ringwald 
1529e9b53984SMatthias Ringwald                     // setup link key db
1530a05b2457SMatthias Ringwald                     hci_set_link_key_db(btstack_link_key_db_tlv_get_instance(tlv_impl, &tlv_context));
1531a05b2457SMatthias Ringwald 
1532a05b2457SMatthias Ringwald                     // init le device db to use TLV
1533a05b2457SMatthias Ringwald                     le_device_db_tlv_configure(tlv_impl, &tlv_context);
1534a05b2457SMatthias Ringwald                     le_device_db_init();
1535a05b2457SMatthias Ringwald                     le_device_db_set_local_bd_addr(addr);
1536a05b2457SMatthias Ringwald 
1537a05b2457SMatthias Ringwald                     tlv_setup_done = 1;
1538a05b2457SMatthias Ringwald                     break;
1539a05b2457SMatthias Ringwald 
15402531c97eSMatthias Ringwald                 case HCI_EVENT_NUMBER_OF_COMPLETED_PACKETS:
15412531c97eSMatthias Ringwald                     // ACL buffer freed...
15422531c97eSMatthias Ringwald                     daemon_retry_parked();
15432531c97eSMatthias Ringwald                     // no need to tell clients
15442531c97eSMatthias Ringwald                     return;
15452531c97eSMatthias Ringwald 
15462531c97eSMatthias Ringwald                 case HCI_EVENT_REMOTE_NAME_REQUEST_COMPLETE:
15472531c97eSMatthias Ringwald                     if (!btstack_device_name_db) break;
15482531c97eSMatthias Ringwald                     if (packet[2]) break; // status not ok
15492531c97eSMatthias Ringwald 
15502531c97eSMatthias Ringwald                     reverse_bd_addr(&packet[3], addr);
15512531c97eSMatthias Ringwald                     // fix for invalid remote names - terminate on 0xff
15522531c97eSMatthias Ringwald                     for (i=0; i<248;i++){
15532531c97eSMatthias Ringwald                         if (packet[9+i] == 0xff){
15542531c97eSMatthias Ringwald                             packet[9+i] = 0;
15552531c97eSMatthias Ringwald                             break;
15562531c97eSMatthias Ringwald                         }
15572531c97eSMatthias Ringwald                     }
15582531c97eSMatthias Ringwald                     packet[9+248] = 0;
15592531c97eSMatthias Ringwald                     btstack_device_name_db->put_name(addr, (device_name_t *)&packet[9]);
15602531c97eSMatthias Ringwald                     break;
15612531c97eSMatthias Ringwald 
15622531c97eSMatthias Ringwald                 case HCI_EVENT_INQUIRY_RESULT:
15632531c97eSMatthias Ringwald                 case HCI_EVENT_INQUIRY_RESULT_WITH_RSSI:{
15642531c97eSMatthias Ringwald                     if (!btstack_device_name_db) break;
15652531c97eSMatthias Ringwald 
15662531c97eSMatthias Ringwald                     // first send inq result packet
15672531c97eSMatthias Ringwald                     daemon_emit_packet(connection, packet_type, channel, packet, size);
15682531c97eSMatthias Ringwald 
15692531c97eSMatthias Ringwald                     // then send cached remote names
15702531c97eSMatthias Ringwald                     int offset = 3;
15712531c97eSMatthias Ringwald                     for (i=0; i<packet[2];i++){
15722531c97eSMatthias Ringwald                         reverse_bd_addr(&packet[offset], addr);
15732531c97eSMatthias Ringwald                         if (btstack_device_name_db->get_name(addr, (device_name_t *) &remote_name_event[9])){
15742531c97eSMatthias Ringwald                             remote_name_event[0] = DAEMON_EVENT_REMOTE_NAME_CACHED;
15752531c97eSMatthias Ringwald                             remote_name_event[1] = sizeof(remote_name_event) - 2 - 1;
15762531c97eSMatthias Ringwald                             remote_name_event[2] = 0;   // just to be compatible with HCI_EVENT_REMOTE_NAME_REQUEST_COMPLETE
15772531c97eSMatthias Ringwald                             reverse_bd_addr(addr, &remote_name_event[3]);
15782531c97eSMatthias Ringwald 
15792531c97eSMatthias Ringwald                             remote_name_event[9+248] = 0;   // assert \0 for log_info
15802531c97eSMatthias Ringwald                             log_info("DAEMON_EVENT_REMOTE_NAME_CACHED %s = '%s'", bd_addr_to_str(addr), &remote_name_event[9]);
15812531c97eSMatthias Ringwald                             hci_dump_packet(HCI_EVENT_PACKET, 0, remote_name_event, sizeof(remote_name_event)-1);
15822531c97eSMatthias Ringwald                             daemon_emit_packet(connection, HCI_EVENT_PACKET, channel, remote_name_event, sizeof(remote_name_event) -1);
15832531c97eSMatthias Ringwald                         }
15842531c97eSMatthias Ringwald                         offset += 14; // 6 + 1 + 1 + 1 + 3 + 2;
15852531c97eSMatthias Ringwald                     }
15862531c97eSMatthias Ringwald                     return;
15872531c97eSMatthias Ringwald                 }
15882531c97eSMatthias Ringwald 
158962c64df1SMatthias Ringwald                 case DAEMON_EVENT_RFCOMM_CREDITS:
15902531c97eSMatthias Ringwald                     // RFCOMM CREDITS received...
15912531c97eSMatthias Ringwald                     daemon_retry_parked();
15922531c97eSMatthias Ringwald                     break;
15932531c97eSMatthias Ringwald 
1594f8f6a918SMatthias Ringwald                 case RFCOMM_EVENT_CHANNEL_OPENED:
15952531c97eSMatthias Ringwald                     cid = little_endian_read_16(packet, 13);
15962531c97eSMatthias Ringwald                     connection = connection_for_rfcomm_cid(cid);
15972531c97eSMatthias Ringwald                     if (!connection) break;
15982531c97eSMatthias Ringwald                     if (packet[2]) {
15992531c97eSMatthias Ringwald                         daemon_remove_client_rfcomm_channel(connection, cid);
16002531c97eSMatthias Ringwald                     } else {
16012531c97eSMatthias Ringwald                         daemon_add_client_rfcomm_channel(connection, cid);
16022531c97eSMatthias Ringwald                     }
16032531c97eSMatthias Ringwald                     break;
16042531c97eSMatthias Ringwald                 case RFCOMM_EVENT_CHANNEL_CLOSED:
16052531c97eSMatthias Ringwald                     cid = little_endian_read_16(packet, 2);
16062531c97eSMatthias Ringwald                     connection = connection_for_rfcomm_cid(cid);
16072531c97eSMatthias Ringwald                     if (!connection) break;
16082531c97eSMatthias Ringwald                     daemon_remove_client_rfcomm_channel(connection, cid);
16092531c97eSMatthias Ringwald                     break;
161062c64df1SMatthias Ringwald                 case DAEMON_EVENT_RFCOMM_SERVICE_REGISTERED:
16112531c97eSMatthias Ringwald                     if (packet[2]) break;
16122531c97eSMatthias Ringwald                     daemon_add_client_rfcomm_service(connection, packet[3]);
16132531c97eSMatthias Ringwald                     break;
16142531c97eSMatthias Ringwald                 case L2CAP_EVENT_CHANNEL_OPENED:
16152531c97eSMatthias Ringwald                     cid = little_endian_read_16(packet, 13);
16162531c97eSMatthias Ringwald                     connection = connection_for_l2cap_cid(cid);
16172531c97eSMatthias Ringwald                     if (!connection) break;
16182531c97eSMatthias Ringwald                     if (packet[2]) {
16192531c97eSMatthias Ringwald                         daemon_remove_client_l2cap_channel(connection, cid);
16202531c97eSMatthias Ringwald                     } else {
16212531c97eSMatthias Ringwald                         daemon_add_client_l2cap_channel(connection, cid);
16222531c97eSMatthias Ringwald                     }
16232531c97eSMatthias Ringwald                     break;
16242531c97eSMatthias Ringwald                 case L2CAP_EVENT_CHANNEL_CLOSED:
16252531c97eSMatthias Ringwald                     cid = little_endian_read_16(packet, 2);
16262531c97eSMatthias Ringwald                     connection = connection_for_l2cap_cid(cid);
16272531c97eSMatthias Ringwald                     if (!connection) break;
16282531c97eSMatthias Ringwald                     daemon_remove_client_l2cap_channel(connection, cid);
16292531c97eSMatthias Ringwald                     break;
16302531c97eSMatthias Ringwald #if defined(ENABLE_BLE) && defined(HAVE_MALLOC)
16312531c97eSMatthias Ringwald                 case HCI_EVENT_DISCONNECTION_COMPLETE:
16322531c97eSMatthias Ringwald                     log_info("daemon : ignore HCI_EVENT_DISCONNECTION_COMPLETE ingnoring.");
16332531c97eSMatthias Ringwald                     // note: moved to gatt_client_handler because it's received here prematurely
16342531c97eSMatthias Ringwald                     // daemon_remove_gatt_client_helper(little_endian_read_16(packet, 3));
16352531c97eSMatthias Ringwald                     break;
16362531c97eSMatthias Ringwald #endif
16372531c97eSMatthias Ringwald                 default:
16382531c97eSMatthias Ringwald                     break;
16392531c97eSMatthias Ringwald             }
16402531c97eSMatthias Ringwald             break;
16412531c97eSMatthias Ringwald         case L2CAP_DATA_PACKET:
16422531c97eSMatthias Ringwald             connection = connection_for_l2cap_cid(channel);
16432531c97eSMatthias Ringwald             if (!connection) return;
16442531c97eSMatthias Ringwald             break;
16452531c97eSMatthias Ringwald         case RFCOMM_DATA_PACKET:
16462531c97eSMatthias Ringwald             connection = connection_for_l2cap_cid(channel);
16472531c97eSMatthias Ringwald             if (!connection) return;
16482531c97eSMatthias Ringwald             break;
16492531c97eSMatthias Ringwald         default:
16502531c97eSMatthias Ringwald             break;
16512531c97eSMatthias Ringwald     }
16522531c97eSMatthias Ringwald 
16532531c97eSMatthias Ringwald     daemon_emit_packet(connection, packet_type, channel, packet, size);
16542531c97eSMatthias Ringwald }
16552531c97eSMatthias Ringwald 
16561edc4fc7SMatthias Ringwald static void stack_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t * packet, uint16_t size){
16572531c97eSMatthias Ringwald     daemon_packet_handler(NULL, packet_type, channel, packet, size);
16582531c97eSMatthias Ringwald }
16592531c97eSMatthias Ringwald 
16602531c97eSMatthias Ringwald static void handle_sdp_rfcomm_service_result(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
16610e2df43fSMatthias Ringwald     switch (hci_event_packet_get_type(packet)){
16622531c97eSMatthias Ringwald         case SDP_EVENT_QUERY_RFCOMM_SERVICE:
16632531c97eSMatthias Ringwald         case SDP_EVENT_QUERY_COMPLETE:
16642531c97eSMatthias Ringwald             // already HCI Events, just forward them
16652531c97eSMatthias Ringwald             hci_dump_packet(HCI_EVENT_PACKET, 0, packet, size);
16662531c97eSMatthias Ringwald             socket_connection_send_packet(sdp_client_query_connection, HCI_EVENT_PACKET, 0, packet, size);
16672531c97eSMatthias Ringwald             break;
16682531c97eSMatthias Ringwald         default:
16692531c97eSMatthias Ringwald             break;
16702531c97eSMatthias Ringwald     }
16712531c97eSMatthias Ringwald }
16722531c97eSMatthias Ringwald 
16732531c97eSMatthias Ringwald static void sdp_client_assert_buffer(int size){
16742531c97eSMatthias Ringwald     if (size > attribute_value_buffer_size){
16752531c97eSMatthias Ringwald         log_error("SDP attribute value buffer size exceeded: available %d, required %d", attribute_value_buffer_size, size);
16762531c97eSMatthias Ringwald     }
16772531c97eSMatthias Ringwald }
16782531c97eSMatthias Ringwald 
16792531c97eSMatthias Ringwald // define new packet type SDP_CLIENT_PACKET
16802531c97eSMatthias Ringwald static void handle_sdp_client_query_result(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
16812531c97eSMatthias Ringwald     int event_len;
16822531c97eSMatthias Ringwald 
16830e2df43fSMatthias Ringwald     switch (hci_event_packet_get_type(packet)){
16842531c97eSMatthias Ringwald         case SDP_EVENT_QUERY_ATTRIBUTE_BYTE:
16852531c97eSMatthias Ringwald             sdp_client_assert_buffer(sdp_event_query_attribute_byte_get_attribute_length(packet));
16862531c97eSMatthias Ringwald             attribute_value[sdp_event_query_attribute_byte_get_data_offset(packet)] = sdp_event_query_attribute_byte_get_data(packet);
16872531c97eSMatthias Ringwald             if ((uint16_t)(sdp_event_query_attribute_byte_get_data_offset(packet)+1) == sdp_event_query_attribute_byte_get_attribute_length(packet)){
16882531c97eSMatthias Ringwald                 log_info_hexdump(attribute_value, sdp_event_query_attribute_byte_get_attribute_length(packet));
16892531c97eSMatthias Ringwald 
16902531c97eSMatthias Ringwald                 int event_len = 1 + 3 * 2 + sdp_event_query_attribute_byte_get_attribute_length(packet);
16912531c97eSMatthias Ringwald                 uint8_t event[event_len];
16922531c97eSMatthias Ringwald                 event[0] = SDP_EVENT_QUERY_ATTRIBUTE_VALUE;
16932531c97eSMatthias Ringwald                 little_endian_store_16(event, 1, sdp_event_query_attribute_byte_get_record_id(packet));
16942531c97eSMatthias Ringwald                 little_endian_store_16(event, 3, sdp_event_query_attribute_byte_get_attribute_id(packet));
16952531c97eSMatthias Ringwald                 little_endian_store_16(event, 5, (uint16_t)sdp_event_query_attribute_byte_get_attribute_length(packet));
16962531c97eSMatthias Ringwald                 memcpy(&event[7], attribute_value, sdp_event_query_attribute_byte_get_attribute_length(packet));
16972531c97eSMatthias Ringwald                 hci_dump_packet(SDP_CLIENT_PACKET, 0, event, event_len);
16982531c97eSMatthias Ringwald                 socket_connection_send_packet(sdp_client_query_connection, SDP_CLIENT_PACKET, 0, event, event_len);
16992531c97eSMatthias Ringwald             }
17002531c97eSMatthias Ringwald             break;
17012531c97eSMatthias Ringwald         case SDP_EVENT_QUERY_COMPLETE:
17022531c97eSMatthias Ringwald             event_len = packet[1] + 2;
17032531c97eSMatthias Ringwald             hci_dump_packet(HCI_EVENT_PACKET, 0, packet, event_len);
17042531c97eSMatthias Ringwald             socket_connection_send_packet(sdp_client_query_connection, HCI_EVENT_PACKET, 0, packet, event_len);
17052531c97eSMatthias Ringwald             break;
17062531c97eSMatthias Ringwald     }
17072531c97eSMatthias Ringwald }
17082531c97eSMatthias Ringwald 
17092531c97eSMatthias Ringwald static void power_notification_callback(POWER_NOTIFICATION_t notification){
17102531c97eSMatthias Ringwald     switch (notification) {
17112531c97eSMatthias Ringwald         case POWER_WILL_SLEEP:
17122531c97eSMatthias Ringwald             // let's sleep
17132531c97eSMatthias Ringwald             power_management_sleep = 1;
17142531c97eSMatthias Ringwald             hci_power_control(HCI_POWER_SLEEP);
17152531c97eSMatthias Ringwald             break;
17162531c97eSMatthias Ringwald         case POWER_WILL_WAKE_UP:
17172531c97eSMatthias Ringwald             // assume that all clients use Bluetooth -> if connection, start Bluetooth
17182531c97eSMatthias Ringwald             power_management_sleep = 0;
17192531c97eSMatthias Ringwald             if (clients_require_power_on()) {
17202531c97eSMatthias Ringwald                 hci_power_control(HCI_POWER_ON);
17212531c97eSMatthias Ringwald             }
17222531c97eSMatthias Ringwald             break;
17232531c97eSMatthias Ringwald         default:
17242531c97eSMatthias Ringwald             break;
17252531c97eSMatthias Ringwald     }
17262531c97eSMatthias Ringwald }
17272531c97eSMatthias Ringwald 
17282531c97eSMatthias Ringwald static void daemon_sigint_handler(int param){
17292531c97eSMatthias Ringwald 
17302531c97eSMatthias Ringwald #ifdef HAVE_PLATFORM_IPHONE_OS
17312531c97eSMatthias Ringwald     // notify daemons
17322531c97eSMatthias Ringwald     notify_post("ch.ringwald.btstack.stopped");
17332531c97eSMatthias Ringwald #endif
17342531c97eSMatthias Ringwald 
17352531c97eSMatthias Ringwald     log_info(" <= SIGINT received, shutting down..\n");
17362531c97eSMatthias Ringwald 
17372531c97eSMatthias Ringwald     hci_power_control( HCI_POWER_OFF);
17382531c97eSMatthias Ringwald     hci_close();
17392531c97eSMatthias Ringwald 
17402531c97eSMatthias Ringwald     log_info("Good bye, see you.\n");
17412531c97eSMatthias Ringwald 
17422531c97eSMatthias Ringwald     exit(0);
17432531c97eSMatthias Ringwald }
17442531c97eSMatthias Ringwald 
17452531c97eSMatthias Ringwald // MARK: manage power off timer
17462531c97eSMatthias Ringwald 
17472531c97eSMatthias Ringwald #define USE_POWER_OFF_TIMER
17482531c97eSMatthias Ringwald 
17492531c97eSMatthias Ringwald static void stop_power_off_timer(void){
17502531c97eSMatthias Ringwald #ifdef USE_POWER_OFF_TIMER
17512531c97eSMatthias Ringwald     if (timeout_active) {
17522531c97eSMatthias Ringwald         btstack_run_loop_remove_timer(&timeout);
17532531c97eSMatthias Ringwald         timeout_active = 0;
17542531c97eSMatthias Ringwald     }
17552531c97eSMatthias Ringwald #endif
17562531c97eSMatthias Ringwald }
17572531c97eSMatthias Ringwald 
17582531c97eSMatthias Ringwald static void start_power_off_timer(void){
17592531c97eSMatthias Ringwald #ifdef USE_POWER_OFF_TIMER
17602531c97eSMatthias Ringwald     stop_power_off_timer();
17612531c97eSMatthias Ringwald     btstack_run_loop_set_timer(&timeout, DAEMON_NO_ACTIVE_CLIENT_TIMEOUT);
17622531c97eSMatthias Ringwald     btstack_run_loop_add_timer(&timeout);
17632531c97eSMatthias Ringwald     timeout_active = 1;
17642531c97eSMatthias Ringwald #else
17652531c97eSMatthias Ringwald     hci_power_control(HCI_POWER_OFF);
17662531c97eSMatthias Ringwald #endif
17672531c97eSMatthias Ringwald }
17682531c97eSMatthias Ringwald 
17692531c97eSMatthias Ringwald // MARK: manage list of clients
17702531c97eSMatthias Ringwald 
17712531c97eSMatthias Ringwald 
17722531c97eSMatthias Ringwald static client_state_t * client_for_connection(connection_t *connection) {
17732531c97eSMatthias Ringwald     btstack_linked_item_t *it;
17742531c97eSMatthias Ringwald     for (it = (btstack_linked_item_t *) clients; it ; it = it->next){
17752531c97eSMatthias Ringwald         client_state_t * client_state = (client_state_t *) it;
17762531c97eSMatthias Ringwald         if (client_state->connection == connection) {
17772531c97eSMatthias Ringwald             return client_state;
17782531c97eSMatthias Ringwald         }
17792531c97eSMatthias Ringwald     }
17802531c97eSMatthias Ringwald     return NULL;
17812531c97eSMatthias Ringwald }
17822531c97eSMatthias Ringwald 
17832531c97eSMatthias Ringwald static void clients_clear_power_request(void){
17842531c97eSMatthias Ringwald     btstack_linked_item_t *it;
17852531c97eSMatthias Ringwald     for (it = (btstack_linked_item_t *) clients; it ; it = it->next){
17862531c97eSMatthias Ringwald         client_state_t * client_state = (client_state_t *) it;
17872531c97eSMatthias Ringwald         client_state->power_mode = HCI_POWER_OFF;
17882531c97eSMatthias Ringwald     }
17892531c97eSMatthias Ringwald }
17902531c97eSMatthias Ringwald 
17912531c97eSMatthias Ringwald static int clients_require_power_on(void){
17922531c97eSMatthias Ringwald 
17932531c97eSMatthias Ringwald     if (global_enable) return 1;
17942531c97eSMatthias Ringwald 
17952531c97eSMatthias Ringwald     btstack_linked_item_t *it;
17962531c97eSMatthias Ringwald     for (it = (btstack_linked_item_t *) clients; it ; it = it->next){
17972531c97eSMatthias Ringwald         client_state_t * client_state = (client_state_t *) it;
17982531c97eSMatthias Ringwald         if (client_state->power_mode == HCI_POWER_ON) {
17992531c97eSMatthias Ringwald             return 1;
18002531c97eSMatthias Ringwald         }
18012531c97eSMatthias Ringwald     }
18022531c97eSMatthias Ringwald     return 0;
18032531c97eSMatthias Ringwald }
18042531c97eSMatthias Ringwald 
18052531c97eSMatthias Ringwald static int clients_require_discoverable(void){
18062531c97eSMatthias Ringwald     btstack_linked_item_t *it;
18072531c97eSMatthias Ringwald     for (it = (btstack_linked_item_t *) clients; it ; it = it->next){
18082531c97eSMatthias Ringwald         client_state_t * client_state = (client_state_t *) it;
18092531c97eSMatthias Ringwald         if (client_state->discoverable) {
18102531c97eSMatthias Ringwald             return 1;
18112531c97eSMatthias Ringwald         }
18122531c97eSMatthias Ringwald     }
18132531c97eSMatthias Ringwald     return 0;
18142531c97eSMatthias Ringwald }
18152531c97eSMatthias Ringwald 
18162531c97eSMatthias Ringwald static void usage(const char * name) {
18172531c97eSMatthias Ringwald     printf("%s, BTstack background daemon\n", name);
181885fb0500SMatthias Ringwald     printf("usage: %s [--help] [--tcp]\n", name);
18192531c97eSMatthias Ringwald     printf("    --help   display this usage\n");
18202531c97eSMatthias Ringwald     printf("    --tcp    use TCP server on port %u\n", BTSTACK_PORT);
18216cf7652eSMatthias Ringwald     printf("Without the --tcp option, BTstack Server is listening on unix domain socket %s\n\n", BTSTACK_UNIX);
18222531c97eSMatthias Ringwald }
18232531c97eSMatthias Ringwald 
18242531c97eSMatthias Ringwald #ifdef HAVE_PLATFORM_IPHONE_OS
18252531c97eSMatthias Ringwald static void * btstack_run_loop_thread(void *context){
18262531c97eSMatthias Ringwald     btstack_run_loop_execute();
18272531c97eSMatthias Ringwald     return NULL;
18282531c97eSMatthias Ringwald }
18292531c97eSMatthias Ringwald #endif
18302531c97eSMatthias Ringwald 
18312531c97eSMatthias Ringwald #ifdef ENABLE_BLE
18322531c97eSMatthias Ringwald 
18332531c97eSMatthias Ringwald static void handle_gatt_client_event(uint8_t packet_type, uint16_t channel, uint8_t * packet, uint16_t size){
18342531c97eSMatthias Ringwald 
18352531c97eSMatthias Ringwald     // hack: handle disconnection_complete_here instead of main hci event packet handler
18362531c97eSMatthias Ringwald     // we receive a HCI event packet in disguise
18370e2df43fSMatthias Ringwald     if (hci_event_packet_get_type(packet) == HCI_EVENT_DISCONNECTION_COMPLETE){
18382531c97eSMatthias Ringwald         log_info("daemon hack: handle disconnection_complete in handle_gatt_client_event instead of main hci event packet handler");
1839fc64f94aSMatthias Ringwald         hci_con_handle_t con_handle = little_endian_read_16(packet, 3);
1840fc64f94aSMatthias Ringwald         daemon_remove_gatt_client_helper(con_handle);
18412531c97eSMatthias Ringwald         return;
18422531c97eSMatthias Ringwald     }
18432531c97eSMatthias Ringwald 
18442531c97eSMatthias Ringwald     // only handle GATT Events
18450e2df43fSMatthias Ringwald     switch(hci_event_packet_get_type(packet)){
18462531c97eSMatthias Ringwald         case GATT_EVENT_SERVICE_QUERY_RESULT:
18472531c97eSMatthias Ringwald         case GATT_EVENT_INCLUDED_SERVICE_QUERY_RESULT:
18482531c97eSMatthias Ringwald         case GATT_EVENT_NOTIFICATION:
18492531c97eSMatthias Ringwald         case GATT_EVENT_INDICATION:
18502531c97eSMatthias Ringwald         case GATT_EVENT_CHARACTERISTIC_QUERY_RESULT:
18512531c97eSMatthias Ringwald         case GATT_EVENT_ALL_CHARACTERISTIC_DESCRIPTORS_QUERY_RESULT:
18522531c97eSMatthias Ringwald         case GATT_EVENT_CHARACTERISTIC_DESCRIPTOR_QUERY_RESULT:
18532531c97eSMatthias Ringwald         case GATT_EVENT_LONG_CHARACTERISTIC_DESCRIPTOR_QUERY_RESULT:
18542531c97eSMatthias Ringwald         case GATT_EVENT_CHARACTERISTIC_VALUE_QUERY_RESULT:
18552531c97eSMatthias Ringwald         case GATT_EVENT_LONG_CHARACTERISTIC_VALUE_QUERY_RESULT:
18562531c97eSMatthias Ringwald         case GATT_EVENT_QUERY_COMPLETE:
18572531c97eSMatthias Ringwald            break;
18582531c97eSMatthias Ringwald         default:
18592531c97eSMatthias Ringwald             return;
18602531c97eSMatthias Ringwald     }
18612531c97eSMatthias Ringwald 
1862711e6c80SMatthias Ringwald     hci_con_handle_t con_handle = little_endian_read_16(packet, 2);
18632531c97eSMatthias Ringwald     btstack_linked_list_gatt_client_helper_t * gatt_client_helper = daemon_get_gatt_client_helper(con_handle);
18642531c97eSMatthias Ringwald     if (!gatt_client_helper){
18652531c97eSMatthias Ringwald         log_info("daemon handle_gatt_client_event: gc helper for handle 0x%2x is NULL.", con_handle);
18662531c97eSMatthias Ringwald         return;
18672531c97eSMatthias Ringwald     }
18682531c97eSMatthias Ringwald 
18692531c97eSMatthias Ringwald     connection_t *connection = NULL;
18702531c97eSMatthias Ringwald 
18712531c97eSMatthias Ringwald     // daemon doesn't track which connection subscribed to this particular handle, so we just notify all connections
18720e2df43fSMatthias Ringwald     switch(hci_event_packet_get_type(packet)){
18732531c97eSMatthias Ringwald         case GATT_EVENT_NOTIFICATION:
18742531c97eSMatthias Ringwald         case GATT_EVENT_INDICATION:{
18752531c97eSMatthias Ringwald             hci_dump_packet(HCI_EVENT_PACKET, 0, packet, size);
18762531c97eSMatthias Ringwald 
18772531c97eSMatthias Ringwald             btstack_linked_item_t *it;
18782531c97eSMatthias Ringwald             for (it = (btstack_linked_item_t *) clients; it ; it = it->next){
18792531c97eSMatthias Ringwald                 client_state_t * client_state = (client_state_t *) it;
18802531c97eSMatthias Ringwald                 socket_connection_send_packet(client_state->connection, HCI_EVENT_PACKET, 0, packet, size);
18812531c97eSMatthias Ringwald             }
18822531c97eSMatthias Ringwald             return;
18832531c97eSMatthias Ringwald         }
18842531c97eSMatthias Ringwald         default:
18852531c97eSMatthias Ringwald             break;
18862531c97eSMatthias Ringwald     }
18872531c97eSMatthias Ringwald 
18882531c97eSMatthias Ringwald     // otherwise, we have to have an active connection
18892531c97eSMatthias Ringwald     connection = gatt_client_helper->active_connection;
18902531c97eSMatthias Ringwald     uint16_t offset;
18912531c97eSMatthias Ringwald     uint16_t length;
18922531c97eSMatthias Ringwald 
18932531c97eSMatthias Ringwald     if (!connection) return;
18942531c97eSMatthias Ringwald 
18950e2df43fSMatthias Ringwald     switch(hci_event_packet_get_type(packet)){
18962531c97eSMatthias Ringwald 
18972531c97eSMatthias Ringwald         case GATT_EVENT_SERVICE_QUERY_RESULT:
18982531c97eSMatthias Ringwald         case GATT_EVENT_INCLUDED_SERVICE_QUERY_RESULT:
18992531c97eSMatthias Ringwald         case GATT_EVENT_CHARACTERISTIC_QUERY_RESULT:
19002531c97eSMatthias Ringwald         case GATT_EVENT_CHARACTERISTIC_VALUE_QUERY_RESULT:
19012531c97eSMatthias Ringwald         case GATT_EVENT_CHARACTERISTIC_DESCRIPTOR_QUERY_RESULT:
19022531c97eSMatthias Ringwald         case GATT_EVENT_ALL_CHARACTERISTIC_DESCRIPTORS_QUERY_RESULT:
19032531c97eSMatthias Ringwald             hci_dump_packet(HCI_EVENT_PACKET, 0, packet, size);
19042531c97eSMatthias Ringwald             socket_connection_send_packet(connection, HCI_EVENT_PACKET, 0, packet, size);
19052531c97eSMatthias Ringwald             break;
19062531c97eSMatthias Ringwald 
19072531c97eSMatthias Ringwald         case GATT_EVENT_LONG_CHARACTERISTIC_VALUE_QUERY_RESULT:
19082531c97eSMatthias Ringwald         case GATT_EVENT_LONG_CHARACTERISTIC_DESCRIPTOR_QUERY_RESULT:
19092531c97eSMatthias Ringwald             offset = little_endian_read_16(packet, 6);
19102531c97eSMatthias Ringwald             length = little_endian_read_16(packet, 8);
19110e2df43fSMatthias Ringwald             gatt_client_helper->characteristic_buffer[0] = hci_event_packet_get_type(packet);  // store type (characteristic/descriptor)
19122531c97eSMatthias Ringwald             gatt_client_helper->characteristic_handle    = little_endian_read_16(packet, 4);   // store attribute handle
19132531c97eSMatthias Ringwald             gatt_client_helper->characteristic_length = offset + length;            // update length
19142531c97eSMatthias Ringwald             memcpy(&gatt_client_helper->characteristic_buffer[10 + offset], &packet[10], length);
19152531c97eSMatthias Ringwald             break;
19162531c97eSMatthias Ringwald 
19172531c97eSMatthias Ringwald         case GATT_EVENT_QUERY_COMPLETE:{
19182531c97eSMatthias Ringwald             gatt_client_helper->active_connection = NULL;
19192531c97eSMatthias Ringwald             if (gatt_client_helper->characteristic_length){
19202531c97eSMatthias Ringwald                 // send re-combined long characteristic value or long characteristic descriptor value
19212531c97eSMatthias Ringwald                 uint8_t * event = gatt_client_helper->characteristic_buffer;
19222531c97eSMatthias Ringwald                 uint16_t event_size = 10 + gatt_client_helper->characteristic_length;
19232531c97eSMatthias Ringwald                 // event[0] == already set by previsous case
19242531c97eSMatthias Ringwald                 event[1] = 8 + gatt_client_helper->characteristic_length;
19252531c97eSMatthias Ringwald                 little_endian_store_16(event, 2, little_endian_read_16(packet, 2));
19262531c97eSMatthias Ringwald                 little_endian_store_16(event, 4, gatt_client_helper->characteristic_handle);
19272531c97eSMatthias Ringwald                 little_endian_store_16(event, 6, 0);   // offset
19282531c97eSMatthias Ringwald                 little_endian_store_16(event, 8, gatt_client_helper->characteristic_length);
19292531c97eSMatthias Ringwald                 hci_dump_packet(HCI_EVENT_PACKET, 0, event, event_size);
19302531c97eSMatthias Ringwald                 socket_connection_send_packet(connection, HCI_EVENT_PACKET, 0, event, event_size);
19312531c97eSMatthias Ringwald                 gatt_client_helper->characteristic_length = 0;
19322531c97eSMatthias Ringwald             }
19332531c97eSMatthias Ringwald             hci_dump_packet(HCI_EVENT_PACKET, 0, packet, size);
19342531c97eSMatthias Ringwald             socket_connection_send_packet(connection, HCI_EVENT_PACKET, 0, packet, size);
19352531c97eSMatthias Ringwald             break;
19362531c97eSMatthias Ringwald         }
19372531c97eSMatthias Ringwald         default:
19382531c97eSMatthias Ringwald             break;
19392531c97eSMatthias Ringwald     }
19402531c97eSMatthias Ringwald }
19412531c97eSMatthias Ringwald #endif
19422531c97eSMatthias Ringwald 
19432531c97eSMatthias Ringwald static char hostname[30];
19442531c97eSMatthias Ringwald 
1945ee252d54SMatthias Ringwald int btstack_server_run(int tcp_flag){
194642963eceSMatthias Ringwald 
19472531c97eSMatthias Ringwald     if (tcp_flag){
19486cf7652eSMatthias Ringwald         printf("BTstack Server started on port %u\n", BTSTACK_PORT);
19492531c97eSMatthias Ringwald     } else {
19506cf7652eSMatthias Ringwald         printf("BTstack Server started on socket %s\n", BTSTACK_UNIX);
19516cf7652eSMatthias Ringwald     }
19526cf7652eSMatthias Ringwald 
19536cf7652eSMatthias Ringwald     // handle default init
19546cf7652eSMatthias Ringwald     if (!btstack_server_storage_path){
1955fb4ddcf3SMatthias Ringwald #ifdef _WIN32
1956b6a1d731SMatthias Ringwald         btstack_server_storage_path = strdup(".");
1957fb4ddcf3SMatthias Ringwald #else
19586cf7652eSMatthias Ringwald         btstack_server_storage_path = strdup("/tmp");
1959fb4ddcf3SMatthias Ringwald #endif
19602531c97eSMatthias Ringwald     }
19612531c97eSMatthias Ringwald 
19622531c97eSMatthias Ringwald     // make stdout unbuffered
19632531c97eSMatthias Ringwald     setbuf(stdout, NULL);
19642531c97eSMatthias Ringwald 
19652531c97eSMatthias Ringwald     // handle CTRL-c
19662531c97eSMatthias Ringwald     signal(SIGINT, daemon_sigint_handler);
19672531c97eSMatthias Ringwald     // handle SIGTERM - suggested for launchd
19682531c97eSMatthias Ringwald     signal(SIGTERM, daemon_sigint_handler);
19692531c97eSMatthias Ringwald 
19709490bce5SMatthias Ringwald     socket_connection_init();
19712531c97eSMatthias Ringwald 
19722531c97eSMatthias Ringwald     btstack_control_t * control = NULL;
1973ba2b4ec9SMatthias Ringwald     void * config = NULL;
1974a046efa6SMatthias Ringwald     const btstack_uart_block_t * uart_block_implementation = NULL;
1975a046efa6SMatthias Ringwald     (void) uart_block_implementation;
19762531c97eSMatthias Ringwald 
19772531c97eSMatthias Ringwald #ifdef HAVE_TRANSPORT_H4
19782531c97eSMatthias Ringwald     hci_transport_config_uart.type = HCI_TRANSPORT_CONFIG_UART;
19792531c97eSMatthias Ringwald     hci_transport_config_uart.baudrate_init = UART_SPEED;
19802531c97eSMatthias Ringwald     hci_transport_config_uart.baudrate_main = 0;
19812531c97eSMatthias Ringwald     hci_transport_config_uart.flowcontrol = 1;
19822531c97eSMatthias Ringwald     hci_transport_config_uart.device_name   = UART_DEVICE;
1983a046efa6SMatthias Ringwald 
1984a046efa6SMatthias Ringwald #ifndef HAVE_PLATFORM_IPHONE_OS
1985b9dcd1ccSMatthias Ringwald #ifdef _WIN32
1986b9dcd1ccSMatthias Ringwald     uart_block_implementation = btstack_uart_block_windows_instance();
1987b9dcd1ccSMatthias Ringwald #else
1988a046efa6SMatthias Ringwald     uart_block_implementation = btstack_uart_block_posix_instance();
1989a046efa6SMatthias Ringwald #endif
1990b9dcd1ccSMatthias Ringwald #endif
19912531c97eSMatthias Ringwald 
19922531c97eSMatthias Ringwald #ifdef HAVE_PLATFORM_IPHONE_OS
19932531c97eSMatthias Ringwald     // use default (max) UART baudrate over netgraph interface
19942531c97eSMatthias Ringwald     hci_transport_config_uart.baudrate_init = 0;
19952531c97eSMatthias Ringwald #endif
19962531c97eSMatthias Ringwald 
19972531c97eSMatthias Ringwald     config = &hci_transport_config_uart;
1998a046efa6SMatthias Ringwald     transport = hci_transport_h4_instance(uart_block_implementation);
19992531c97eSMatthias Ringwald #endif
20002531c97eSMatthias Ringwald 
20012531c97eSMatthias Ringwald #ifdef HAVE_TRANSPORT_USB
20022531c97eSMatthias Ringwald     transport = hci_transport_usb_instance();
20032531c97eSMatthias Ringwald #endif
20042531c97eSMatthias Ringwald 
20052531c97eSMatthias Ringwald #ifdef HAVE_PLATFORM_IPHONE_OS
20062531c97eSMatthias Ringwald     control = &btstack_control_iphone;
20072531c97eSMatthias Ringwald     if (btstack_control_iphone_power_management_supported()){
20082531c97eSMatthias Ringwald         hci_transport_h4_iphone_set_enforce_wake_device("/dev/btwake");
20092531c97eSMatthias Ringwald     }
20102531c97eSMatthias Ringwald     bluetooth_status_handler = platform_iphone_status_handler;
20112531c97eSMatthias Ringwald     platform_iphone_register_window_manager_restart(update_ui_status);
20122531c97eSMatthias Ringwald     platform_iphone_register_preferences_changed(preferences_changed_callback);
20132531c97eSMatthias Ringwald #endif
20142531c97eSMatthias Ringwald 
20152531c97eSMatthias Ringwald #ifdef BTSTACK_DEVICE_NAME_DB_INSTANCE
20162531c97eSMatthias Ringwald     btstack_device_name_db = BTSTACK_DEVICE_NAME_DB_INSTANCE();
20172531c97eSMatthias Ringwald #endif
20182531c97eSMatthias Ringwald 
2019b9dcd1ccSMatthias Ringwald #ifdef _WIN32
2020b9dcd1ccSMatthias Ringwald     btstack_run_loop_init(btstack_run_loop_windows_get_instance());
2021b9dcd1ccSMatthias Ringwald #else
20222531c97eSMatthias Ringwald     btstack_run_loop_init(btstack_run_loop_posix_get_instance());
2023b9dcd1ccSMatthias Ringwald #endif
20242531c97eSMatthias Ringwald 
20252531c97eSMatthias Ringwald     // init power management notifications
20262531c97eSMatthias Ringwald     if (control && control->register_for_power_notifications){
20272531c97eSMatthias Ringwald         control->register_for_power_notifications(power_notification_callback);
20282531c97eSMatthias Ringwald     }
20292531c97eSMatthias Ringwald 
20302531c97eSMatthias Ringwald     // logging
20312531c97eSMatthias Ringwald     loggingEnabled = 0;
20322531c97eSMatthias Ringwald     int newLoggingEnabled = 1;
20332531c97eSMatthias Ringwald #ifdef HAVE_PLATFORM_IPHONE_OS
20342531c97eSMatthias Ringwald     // iPhone has toggle in Preferences.app
20352531c97eSMatthias Ringwald     newLoggingEnabled = platform_iphone_logging_enabled();
20362531c97eSMatthias Ringwald #endif
20372531c97eSMatthias Ringwald     daemon_set_logging_enabled(newLoggingEnabled);
20382531c97eSMatthias Ringwald 
20392531c97eSMatthias Ringwald     // dump version
2040a05b2457SMatthias Ringwald     log_info("BTStack Server started\n");
20412531c97eSMatthias Ringwald     log_info("version %s, build %s", BTSTACK_VERSION, BTSTACK_DATE);
20422531c97eSMatthias Ringwald 
20432531c97eSMatthias Ringwald     // init HCI
20442531c97eSMatthias Ringwald     hci_init(transport, config);
20452531c97eSMatthias Ringwald     if (btstack_link_key_db){
20462531c97eSMatthias Ringwald         hci_set_link_key_db(btstack_link_key_db);
20472531c97eSMatthias Ringwald     }
20482531c97eSMatthias Ringwald     if (control){
20492531c97eSMatthias Ringwald         hci_set_control(control);
20502531c97eSMatthias Ringwald     }
20512531c97eSMatthias Ringwald 
20522531c97eSMatthias Ringwald     // hostname for POSIX systems
20532531c97eSMatthias Ringwald     gethostname(hostname, 30);
20542531c97eSMatthias Ringwald     hostname[29] = '\0';
20552531c97eSMatthias Ringwald     gap_set_local_name(hostname);
20562531c97eSMatthias Ringwald 
20572531c97eSMatthias Ringwald #ifdef HAVE_PLATFORM_IPHONE_OS
20582531c97eSMatthias Ringwald     // iPhone doesn't use SSP yet as there's no UI for it yet and auto accept is not an option
20592531c97eSMatthias Ringwald     gap_ssp_set_enable(0);
20602531c97eSMatthias Ringwald #endif
20612531c97eSMatthias Ringwald 
20622531c97eSMatthias Ringwald     // register for HCI events
20631edc4fc7SMatthias Ringwald     hci_event_callback_registration.callback = &stack_packet_handler;
20642531c97eSMatthias Ringwald     hci_add_event_handler(&hci_event_callback_registration);
20652531c97eSMatthias Ringwald 
20662531c97eSMatthias Ringwald     // init L2CAP
20672531c97eSMatthias Ringwald     l2cap_init();
20681edc4fc7SMatthias Ringwald     l2cap_register_packet_handler(&stack_packet_handler);
20692531c97eSMatthias Ringwald     timeout.process = daemon_no_connections_timeout;
20702531c97eSMatthias Ringwald 
20712531c97eSMatthias Ringwald #ifdef ENABLE_RFCOMM
20722531c97eSMatthias Ringwald     log_info("config.h: ENABLE_RFCOMM\n");
20732531c97eSMatthias Ringwald     rfcomm_init();
20742531c97eSMatthias Ringwald #endif
20752531c97eSMatthias Ringwald 
20762531c97eSMatthias Ringwald #ifdef ENABLE_SDP
20772531c97eSMatthias Ringwald     sdp_init();
20782531c97eSMatthias Ringwald #endif
20792531c97eSMatthias Ringwald 
20802531c97eSMatthias Ringwald #ifdef ENABLE_BLE
20811edc4fc7SMatthias Ringwald     sm_init();
20821edc4fc7SMatthias Ringwald     sm_event_callback_registration.callback = &stack_packet_handler;
20831edc4fc7SMatthias Ringwald     sm_add_event_handler(&sm_event_callback_registration);
20842531c97eSMatthias Ringwald     // sm_set_io_capabilities(IO_CAPABILITY_DISPLAY_ONLY);
20852531c97eSMatthias Ringwald     // sm_set_authentication_requirements( SM_AUTHREQ_BONDING | SM_AUTHREQ_MITM_PROTECTION);
20862531c97eSMatthias Ringwald 
20871edc4fc7SMatthias Ringwald     // GATT Client
20881edc4fc7SMatthias Ringwald     gatt_client_init();
20891edc4fc7SMatthias Ringwald 
20902531c97eSMatthias Ringwald     // GATT Server - empty attribute database
20912531c97eSMatthias Ringwald     att_server_init(NULL, NULL, NULL);
20922531c97eSMatthias Ringwald 
20932531c97eSMatthias Ringwald #endif
20942531c97eSMatthias Ringwald 
20952531c97eSMatthias Ringwald #ifdef USE_LAUNCHD
20962531c97eSMatthias Ringwald     socket_connection_create_launchd();
20972531c97eSMatthias Ringwald #else
20982531c97eSMatthias Ringwald     // create server
20992531c97eSMatthias Ringwald     if (tcp_flag) {
21002531c97eSMatthias Ringwald         socket_connection_create_tcp(BTSTACK_PORT);
21012531c97eSMatthias Ringwald     } else {
210242963eceSMatthias Ringwald #ifdef HAVE_UNIX_SOCKETS
21032531c97eSMatthias Ringwald         socket_connection_create_unix(BTSTACK_UNIX);
210442963eceSMatthias Ringwald #endif
21052531c97eSMatthias Ringwald     }
21062531c97eSMatthias Ringwald #endif
21072531c97eSMatthias Ringwald     socket_connection_register_packet_callback(&daemon_client_handler);
21082531c97eSMatthias Ringwald 
21092531c97eSMatthias Ringwald #ifdef HAVE_PLATFORM_IPHONE_OS
21102531c97eSMatthias Ringwald     // notify daemons
21112531c97eSMatthias Ringwald     notify_post("ch.ringwald.btstack.started");
21122531c97eSMatthias Ringwald 
21132531c97eSMatthias Ringwald     // spawn thread to have BTstack run loop on new thread, while main thread is used to keep CFRunLoop
21142531c97eSMatthias Ringwald     pthread_t run_loop;
21152531c97eSMatthias Ringwald     pthread_create(&run_loop, NULL, &btstack_run_loop_thread, NULL);
21162531c97eSMatthias Ringwald 
21172531c97eSMatthias Ringwald     // needed to receive notifications
21182531c97eSMatthias Ringwald     CFRunLoopRun();
21192531c97eSMatthias Ringwald #endif
21202531c97eSMatthias Ringwald         // go!
21212531c97eSMatthias Ringwald     btstack_run_loop_execute();
21222531c97eSMatthias Ringwald     return 0;
21232531c97eSMatthias Ringwald }
212485fb0500SMatthias Ringwald 
21254c293e47SMatthias Ringwald int btstack_server_run_tcp(void){
21264c293e47SMatthias Ringwald      return btstack_server_run(1);
21274c293e47SMatthias Ringwald }
2128ee252d54SMatthias Ringwald 
212985fb0500SMatthias Ringwald int main (int argc,  char * const * argv){
213085fb0500SMatthias Ringwald 
213185fb0500SMatthias Ringwald     int tcp_flag = 0;
213285fb0500SMatthias Ringwald     struct option long_options[] = {
213385fb0500SMatthias Ringwald         { "tcp", no_argument, &tcp_flag, 1 },
213485fb0500SMatthias Ringwald         { "help", no_argument, 0, 0 },
213585fb0500SMatthias Ringwald         { 0,0,0,0 } // This is a filler for -1
213685fb0500SMatthias Ringwald     };
213785fb0500SMatthias Ringwald 
213885fb0500SMatthias Ringwald     while (1) {
213985fb0500SMatthias Ringwald         int c;
214085fb0500SMatthias Ringwald         int option_index = -1;
214185fb0500SMatthias Ringwald         c = getopt_long(argc, argv, "h", long_options, &option_index);
214285fb0500SMatthias Ringwald         if (c == -1) break; // no more option
214385fb0500SMatthias Ringwald 
214485fb0500SMatthias Ringwald         // treat long parameter first
214585fb0500SMatthias Ringwald         if (option_index == -1) {
214685fb0500SMatthias Ringwald             switch (c) {
214785fb0500SMatthias Ringwald                 case '?':
214885fb0500SMatthias Ringwald                 case 'h':
214985fb0500SMatthias Ringwald                     usage(argv[0]);
215085fb0500SMatthias Ringwald                     return 0;
215185fb0500SMatthias Ringwald                     break;
215285fb0500SMatthias Ringwald             }
215385fb0500SMatthias Ringwald         } else {
215485fb0500SMatthias Ringwald             switch (option_index) {
215585fb0500SMatthias Ringwald                 case 1:
215685fb0500SMatthias Ringwald                     usage(argv[0]);
215785fb0500SMatthias Ringwald                     return 0;
215885fb0500SMatthias Ringwald                     break;
215985fb0500SMatthias Ringwald             }
216085fb0500SMatthias Ringwald         }
216185fb0500SMatthias Ringwald     }
216285fb0500SMatthias Ringwald 
216385fb0500SMatthias Ringwald #ifndef HAVE_UNIX_SOCKETS
216485fb0500SMatthias Ringwald     // TCP is default if there are no unix sockets
216585fb0500SMatthias Ringwald     tcp_flag = 1;
216685fb0500SMatthias Ringwald #endif
216785fb0500SMatthias Ringwald 
216885fb0500SMatthias Ringwald     btstack_server_run(tcp_flag);
216985fb0500SMatthias Ringwald }
21706cf7652eSMatthias Ringwald 
21716cf7652eSMatthias Ringwald void btstack_server_set_storage_path(const char * path){
21726cf7652eSMatthias Ringwald     if (btstack_server_storage_path){
21736cf7652eSMatthias Ringwald         free((void*)btstack_server_storage_path);
21746cf7652eSMatthias Ringwald         btstack_server_storage_path = NULL;
21756cf7652eSMatthias Ringwald     }
21766cf7652eSMatthias Ringwald     btstack_server_storage_path = strdup(path);
21776cf7652eSMatthias Ringwald     log_info("Storage path %s", btstack_server_storage_path);
21786cf7652eSMatthias Ringwald }
2179