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