xref: /btstack/src/ble/att_server.c (revision 9828b48a18fd045e623340d8146cb433501b62d5)
13deb3ec6SMatthias Ringwald /*
23deb3ec6SMatthias Ringwald  * Copyright (C) 2014 BlueKitchen GmbH
33deb3ec6SMatthias Ringwald  *
43deb3ec6SMatthias Ringwald  * Redistribution and use in source and binary forms, with or without
53deb3ec6SMatthias Ringwald  * modification, are permitted provided that the following conditions
63deb3ec6SMatthias Ringwald  * are met:
73deb3ec6SMatthias Ringwald  *
83deb3ec6SMatthias Ringwald  * 1. Redistributions of source code must retain the above copyright
93deb3ec6SMatthias Ringwald  *    notice, this list of conditions and the following disclaimer.
103deb3ec6SMatthias Ringwald  * 2. Redistributions in binary form must reproduce the above copyright
113deb3ec6SMatthias Ringwald  *    notice, this list of conditions and the following disclaimer in the
123deb3ec6SMatthias Ringwald  *    documentation and/or other materials provided with the distribution.
133deb3ec6SMatthias Ringwald  * 3. Neither the name of the copyright holders nor the names of
143deb3ec6SMatthias Ringwald  *    contributors may be used to endorse or promote products derived
153deb3ec6SMatthias Ringwald  *    from this software without specific prior written permission.
163deb3ec6SMatthias Ringwald  * 4. Any redistribution, use, or modification is done solely for
173deb3ec6SMatthias Ringwald  *    personal benefit and not for any commercial purpose or for
183deb3ec6SMatthias Ringwald  *    monetary gain.
193deb3ec6SMatthias Ringwald  *
203deb3ec6SMatthias Ringwald  * THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS
213deb3ec6SMatthias Ringwald  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
223deb3ec6SMatthias Ringwald  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
232fca4dadSMilanka Ringwald  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BLUEKITCHEN
242fca4dadSMilanka Ringwald  * GMBH OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
253deb3ec6SMatthias Ringwald  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
263deb3ec6SMatthias Ringwald  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
273deb3ec6SMatthias Ringwald  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
283deb3ec6SMatthias Ringwald  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
293deb3ec6SMatthias Ringwald  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
303deb3ec6SMatthias Ringwald  * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
313deb3ec6SMatthias Ringwald  * SUCH DAMAGE.
323deb3ec6SMatthias Ringwald  *
333deb3ec6SMatthias Ringwald  * Please inquire about commercial licensing options at
343deb3ec6SMatthias Ringwald  * [email protected]
353deb3ec6SMatthias Ringwald  *
363deb3ec6SMatthias Ringwald  */
373deb3ec6SMatthias Ringwald 
38e501bae0SMatthias Ringwald #define BTSTACK_FILE__ "att_server.c"
39ab2c6ae4SMatthias Ringwald 
403deb3ec6SMatthias Ringwald 
413deb3ec6SMatthias Ringwald //
423deb3ec6SMatthias Ringwald // ATT Server Globals
433deb3ec6SMatthias Ringwald //
443deb3ec6SMatthias Ringwald 
453deb3ec6SMatthias Ringwald #include <stdint.h>
463deb3ec6SMatthias Ringwald #include <string.h>
473deb3ec6SMatthias Ringwald #include <inttypes.h>
483deb3ec6SMatthias Ringwald 
497907f069SMatthias Ringwald #include "btstack_config.h"
503deb3ec6SMatthias Ringwald 
51296289e3SMatthias Ringwald #include "ble/att_dispatch.h"
5259c6af15SMatthias Ringwald #include "ble/att_db.h"
5359c6af15SMatthias Ringwald #include "ble/att_server.h"
5459c6af15SMatthias Ringwald #include "ble/core.h"
5559c6af15SMatthias Ringwald #include "ble/le_device_db.h"
5659c6af15SMatthias Ringwald #include "ble/sm.h"
5716ece135SMatthias Ringwald #include "btstack_debug.h"
580e2df43fSMatthias Ringwald #include "btstack_event.h"
593deb3ec6SMatthias Ringwald #include "btstack_memory.h"
600e2df43fSMatthias Ringwald #include "btstack_run_loop.h"
6159c6af15SMatthias Ringwald #include "gap.h"
623deb3ec6SMatthias Ringwald #include "hci.h"
633deb3ec6SMatthias Ringwald #include "hci_dump.h"
643deb3ec6SMatthias Ringwald #include "l2cap.h"
65bf78aac6SMatthias Ringwald #include "btstack_tlv.h"
66d1a1f6a4SMatthias Ringwald #ifdef ENABLE_LE_SIGNED_WRITE
67d1a1f6a4SMatthias Ringwald #include "ble/sm.h"
6820d4358dSMatthias Ringwald #include "bluetooth_psm.h"
6920d4358dSMatthias Ringwald 
70d1a1f6a4SMatthias Ringwald #endif
71bf78aac6SMatthias Ringwald 
7203f53d81SMatthias Ringwald #ifdef ENABLE_TESTING_SUPPORT
7303f53d81SMatthias Ringwald #include <stdio.h>
7403f53d81SMatthias Ringwald #endif
7503f53d81SMatthias Ringwald 
766afb9acaSMatthias Ringwald #ifndef NVN_NUM_GATT_SERVER_CCC
776afb9acaSMatthias Ringwald #define NVN_NUM_GATT_SERVER_CCC 20
78bf78aac6SMatthias Ringwald #endif
793deb3ec6SMatthias Ringwald 
80cd45e970SMatthias Ringwald static void att_run_for_context(att_server_t * att_server, att_connection_t * att_connection);
8101ac2008SMatthias Ringwald static att_write_callback_t att_server_write_callback_for_handle(uint16_t handle);
825d07396bSMatthias Ringwald static btstack_packet_handler_t att_server_packet_handler_for_handle(uint16_t handle);
8348364364SMatthias Ringwald static void att_server_handle_can_send_now(void);
849a1f55eaSMatthias Ringwald static void att_server_persistent_ccc_restore(att_server_t * att_server, att_connection_t * att_connection);
85fe3d0cbaSMatthias Ringwald static void att_server_persistent_ccc_clear(att_server_t * att_server);
8626b42dcfSMatthias Ringwald static void att_server_handle_att_pdu(att_server_t * att_server, att_connection_t * att_connection, uint8_t * packet, uint16_t size);
873deb3ec6SMatthias Ringwald 
883551936eSMatthias Ringwald typedef enum {
8938b893aaSMilanka Ringwald     ATT_SERVER_RUN_PHASE_1_REQUESTS = 0,
903551936eSMatthias Ringwald     ATT_SERVER_RUN_PHASE_2_INDICATIONS,
913551936eSMatthias Ringwald     ATT_SERVER_RUN_PHASE_3_NOTIFICATIONS,
923551936eSMatthias Ringwald } att_server_run_phase_t;
933551936eSMatthias Ringwald 
946a540790SMatthias Ringwald //
956a540790SMatthias Ringwald typedef struct {
966a540790SMatthias Ringwald     uint32_t seq_nr;
976a540790SMatthias Ringwald     uint16_t att_handle;
986a540790SMatthias Ringwald     uint8_t  value;
996a540790SMatthias Ringwald     uint8_t  device_index;
1006a540790SMatthias Ringwald } persistent_ccc_entry_t;
1016a540790SMatthias Ringwald 
10218707219SMatthias Ringwald // global
1031a389cdcSMatthias Ringwald static btstack_packet_callback_registration_t hci_event_callback_registration;
104406722e4SMatthias Ringwald static btstack_packet_callback_registration_t sm_event_callback_registration;
10535d7f2dfSMilanka Ringwald static btstack_packet_handler_t               att_client_packet_handler;
1063d71c7a4SMatthias Ringwald static btstack_linked_list_t                  service_handlers;
1075f141511SMatthias Ringwald static btstack_context_callback_registration_t att_client_waiting_for_can_send_registration;
10818707219SMatthias Ringwald 
1093d71c7a4SMatthias Ringwald static att_read_callback_t                    att_server_client_read_callback;
1103d71c7a4SMatthias Ringwald static att_write_callback_t                   att_server_client_write_callback;
1113d71c7a4SMatthias Ringwald 
1126438547aSMatthias Ringwald // round robin
1136438547aSMatthias Ringwald static hci_con_handle_t att_server_last_can_send_now = HCI_CON_HANDLE_INVALID;
114bf78aac6SMatthias Ringwald 
115c2cbe117SMatthias Ringwald #ifdef ENABLE_GATT_OVER_EATT
116c2cbe117SMatthias Ringwald typedef struct {
117c2cbe117SMatthias Ringwald     btstack_linked_item_t item;
118c2cbe117SMatthias Ringwald     att_server_t     att_server;
119c2cbe117SMatthias Ringwald     att_connection_t att_connection;
120c2cbe117SMatthias Ringwald     uint8_t * receive_buffer;
121c2cbe117SMatthias Ringwald     uint8_t * send_buffer;
122c2cbe117SMatthias Ringwald } att_server_eatt_bearer_t;
12340f8d8f2SMatthias Ringwald static att_server_eatt_bearer_t * att_server_eatt_bearer_for_con_handle(hci_con_handle_t con_handle);
124c2cbe117SMatthias Ringwald static btstack_linked_list_t att_server_eatt_bearer_pool;
125c2cbe117SMatthias Ringwald static btstack_linked_list_t att_server_eatt_bearer_active;
126c2cbe117SMatthias Ringwald #endif
127c2cbe117SMatthias Ringwald 
12802b78fc8SMatthias Ringwald #ifdef ENABLE_LE_SIGNED_WRITE
12926567ee7SMatthias Ringwald static bool att_server_connections_for_state(att_server_state_t state, att_server_t ** att_server_out, att_connection_t ** att_connection_out){
13018707219SMatthias Ringwald     btstack_linked_list_iterator_t it;
13118707219SMatthias Ringwald     hci_connections_get_iterator(&it);
13218707219SMatthias Ringwald     while(btstack_linked_list_iterator_has_next(&it)){
13326567ee7SMatthias Ringwald         hci_connection_t * hci_connection = (hci_connection_t *) btstack_linked_list_iterator_next(&it);
13426567ee7SMatthias Ringwald         if (hci_connection->att_server.state == state) {
13526567ee7SMatthias Ringwald             *att_server_out     = &hci_connection->att_server;
13626567ee7SMatthias Ringwald             *att_connection_out = &hci_connection->att_connection;
13726567ee7SMatthias Ringwald             return true;
13818707219SMatthias Ringwald         }
13926567ee7SMatthias Ringwald     }
140c2cbe117SMatthias Ringwald 
141c2cbe117SMatthias Ringwald #ifdef ENABLE_GATT_OVER_EATT
142c2cbe117SMatthias Ringwald     btstack_linked_list_iterator_init(&it, &att_server_eatt_bearer_active);
143c2cbe117SMatthias Ringwald     while(btstack_linked_list_iterator_has_next(&it)){
144c2cbe117SMatthias Ringwald         att_server_eatt_bearer_t * eatt_bearer = (att_server_eatt_bearer_t *) btstack_linked_list_iterator_next(&it);
145c2cbe117SMatthias Ringwald         if (eatt_bearer->att_server.state == state) {
146c2cbe117SMatthias Ringwald             *att_server_out     = &eatt_bearer->att_server;
147c2cbe117SMatthias Ringwald             *att_connection_out = &eatt_bearer->att_connection;
148c2cbe117SMatthias Ringwald             return true;
149c2cbe117SMatthias Ringwald         }
150c2cbe117SMatthias Ringwald     }
151c2cbe117SMatthias Ringwald #endif
152c2cbe117SMatthias Ringwald 
15326567ee7SMatthias Ringwald     return false;
15418707219SMatthias Ringwald }
15502b78fc8SMatthias Ringwald #endif
156bb38f057SMatthias Ringwald 
1573f9b77dbSMatthias Ringwald static void att_server_request_can_send_now(att_server_t * att_server, att_connection_t * att_connection ){
15823079b39SMatthias Ringwald     switch (att_server->bearer_type){
15923079b39SMatthias Ringwald         case ATT_BEARER_UNENHANCED_LE:
16023079b39SMatthias Ringwald #ifdef ENABLE_GATT_OVER_CLASSIC
16123079b39SMatthias Ringwald         case ATT_BEARER_UNENHANCED_CLASSIC:
1622954c397SMatthias Ringwald             /* fall through */
1632954c397SMatthias Ringwald #endif
164328bed13SMatthias Ringwald             att_dispatch_server_request_can_send_now_event(att_connection->con_handle);
165328bed13SMatthias Ringwald             break;
1662954c397SMatthias Ringwald #ifdef ENABLE_GATT_OVER_EATT
1672954c397SMatthias Ringwald         case ATT_BEARER_ENHANCED_LE:
16823079b39SMatthias Ringwald             l2cap_request_can_send_now_event(att_server->l2cap_cid);
16923079b39SMatthias Ringwald             break;
17023079b39SMatthias Ringwald #endif
17123079b39SMatthias Ringwald         default:
17223079b39SMatthias Ringwald             btstack_unreachable();
17323079b39SMatthias Ringwald             break;
17423079b39SMatthias Ringwald     }
175c8c6e9b4SMatthias Ringwald }
176c8c6e9b4SMatthias Ringwald 
17737a8059dSMatthias Ringwald static bool att_server_can_send_packet(att_server_t * att_server, att_connection_t * att_connection){
17823079b39SMatthias Ringwald     switch (att_server->bearer_type) {
17923079b39SMatthias Ringwald         case ATT_BEARER_UNENHANCED_LE:
18023079b39SMatthias Ringwald #ifdef ENABLE_GATT_OVER_CLASSIC
18123079b39SMatthias Ringwald         case ATT_BEARER_UNENHANCED_CLASSIC:
1822954c397SMatthias Ringwald             /* fall through */
1832954c397SMatthias Ringwald #endif
184328bed13SMatthias Ringwald             return att_dispatch_server_can_send_now(att_connection->con_handle);
1852954c397SMatthias Ringwald #ifdef ENABLE_GATT_OVER_EATT
1862954c397SMatthias Ringwald         case ATT_BEARER_ENHANCED_LE:
1872954c397SMatthias Ringwald             return l2cap_can_send_packet_now(att_server->l2cap_cid);
18823079b39SMatthias Ringwald #endif
18923079b39SMatthias Ringwald         default:
19023079b39SMatthias Ringwald             btstack_unreachable();
19123079b39SMatthias Ringwald             break;
19223079b39SMatthias Ringwald     }
19323079b39SMatthias Ringwald     return false;
194c0f26e1cSMatthias Ringwald }
195c0f26e1cSMatthias Ringwald 
1963deb3ec6SMatthias Ringwald static void att_handle_value_indication_notify_client(uint8_t status, uint16_t client_handle, uint16_t attribute_handle){
1975d07396bSMatthias Ringwald     btstack_packet_handler_t packet_handler = att_server_packet_handler_for_handle(attribute_handle);
1985d07396bSMatthias Ringwald     if (!packet_handler) return;
1993deb3ec6SMatthias Ringwald 
2003deb3ec6SMatthias Ringwald     uint8_t event[7];
2013deb3ec6SMatthias Ringwald     int pos = 0;
2025611a760SMatthias Ringwald     event[pos++] = ATT_EVENT_HANDLE_VALUE_INDICATION_COMPLETE;
2034ea43905SMatthias Ringwald     event[pos++] = sizeof(event) - 2u;
2043deb3ec6SMatthias Ringwald     event[pos++] = status;
205f8fbdce0SMatthias Ringwald     little_endian_store_16(event, pos, client_handle);
2063deb3ec6SMatthias Ringwald     pos += 2;
207f8fbdce0SMatthias Ringwald     little_endian_store_16(event, pos, attribute_handle);
208a444112bSMatthias Ringwald     (*packet_handler)(HCI_EVENT_PACKET, 0, &event[0], sizeof(event));
2093deb3ec6SMatthias Ringwald }
2103deb3ec6SMatthias Ringwald 
2115d07396bSMatthias Ringwald static void att_emit_event_to_all(const uint8_t * event, uint16_t size){
2125d07396bSMatthias Ringwald     // dispatch to app level handler
2139305033eSMatthias Ringwald     if (att_client_packet_handler != NULL){
2145d07396bSMatthias Ringwald         (*att_client_packet_handler)(HCI_EVENT_PACKET, 0, (uint8_t*) event, size);
2155d07396bSMatthias Ringwald     }
2163deb3ec6SMatthias Ringwald 
2175d07396bSMatthias Ringwald     // dispatch to service handlers
2185d07396bSMatthias Ringwald     btstack_linked_list_iterator_t it;
2195d07396bSMatthias Ringwald     btstack_linked_list_iterator_init(&it, &service_handlers);
2205d07396bSMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
2215d07396bSMatthias Ringwald         att_service_handler_t * handler = (att_service_handler_t*) btstack_linked_list_iterator_next(&it);
2225d07396bSMatthias Ringwald         if (!handler->packet_handler) continue;
2235d07396bSMatthias Ringwald         (*handler->packet_handler)(HCI_EVENT_PACKET, 0, (uint8_t*) event, size);
2245d07396bSMatthias Ringwald     }
2255d07396bSMatthias Ringwald }
2265d07396bSMatthias Ringwald 
2275d07396bSMatthias Ringwald static void att_emit_mtu_event(hci_con_handle_t con_handle, uint16_t mtu){
2283deb3ec6SMatthias Ringwald     uint8_t event[6];
2293deb3ec6SMatthias Ringwald     int pos = 0;
2305611a760SMatthias Ringwald     event[pos++] = ATT_EVENT_MTU_EXCHANGE_COMPLETE;
2314ea43905SMatthias Ringwald     event[pos++] = sizeof(event) - 2u;
232fc64f94aSMatthias Ringwald     little_endian_store_16(event, pos, con_handle);
2333deb3ec6SMatthias Ringwald     pos += 2;
234f8fbdce0SMatthias Ringwald     little_endian_store_16(event, pos, mtu);
2355d07396bSMatthias Ringwald 
2365d07396bSMatthias Ringwald     // also dispatch to GATT Clients
237b12646c5SJakob Krantz     att_dispatch_server_mtu_exchanged(con_handle, mtu);
2385d07396bSMatthias Ringwald 
2395d07396bSMatthias Ringwald     // dispatch to app level handler and service handlers
2405d07396bSMatthias Ringwald     att_emit_event_to_all(&event[0], sizeof(event));
2413deb3ec6SMatthias Ringwald }
2423deb3ec6SMatthias Ringwald 
2435f141511SMatthias Ringwald static void att_emit_can_send_now_event(void * context){
2445f141511SMatthias Ringwald     UNUSED(context);
2453c97b242SMatthias Ringwald     if (!att_client_packet_handler) return;
2463c97b242SMatthias Ringwald 
2471b96b007SMatthias Ringwald     uint8_t event[] = { ATT_EVENT_CAN_SEND_NOW, 0};
2481b96b007SMatthias Ringwald     (*att_client_packet_handler)(HCI_EVENT_PACKET, 0, &event[0], sizeof(event));
2491b96b007SMatthias Ringwald }
2501b96b007SMatthias Ringwald 
2516d2214cbSMatthias Ringwald static void att_emit_connected_event(att_server_t * att_server,  att_connection_t * att_connection){
252ff1bec95SMatthias Ringwald     uint8_t event[11];
253ff1bec95SMatthias Ringwald     int pos = 0;
254ff1bec95SMatthias Ringwald     event[pos++] = ATT_EVENT_CONNECTED;
2554ea43905SMatthias Ringwald     event[pos++] = sizeof(event) - 2u;
256ff1bec95SMatthias Ringwald     event[pos++] = att_server->peer_addr_type;
257ff1bec95SMatthias Ringwald     reverse_bd_addr(att_server->peer_address, &event[pos]);
258ff1bec95SMatthias Ringwald     pos += 6;
259b6df12b6SMatthias Ringwald     little_endian_store_16(event, pos, att_connection->con_handle);
260ff1bec95SMatthias Ringwald     pos += 2;
261ff1bec95SMatthias Ringwald 
262ff1bec95SMatthias Ringwald     // dispatch to app level handler and service handlers
263ff1bec95SMatthias Ringwald     att_emit_event_to_all(&event[0], sizeof(event));
264ff1bec95SMatthias Ringwald }
265ff1bec95SMatthias Ringwald 
266ff1bec95SMatthias Ringwald 
2676187ad4cSMatthias Ringwald static void att_emit_disconnected_event(uint16_t con_handle){
268ff1bec95SMatthias Ringwald     uint8_t event[4];
269ff1bec95SMatthias Ringwald     int pos = 0;
270ff1bec95SMatthias Ringwald     event[pos++] = ATT_EVENT_DISCONNECTED;
2714ea43905SMatthias Ringwald     event[pos++] = sizeof(event) - 2u;
2726187ad4cSMatthias Ringwald     little_endian_store_16(event, pos, con_handle);
273ff1bec95SMatthias Ringwald     pos += 2;
274ff1bec95SMatthias Ringwald 
275ff1bec95SMatthias Ringwald     // dispatch to app level handler and service handlers
276ff1bec95SMatthias Ringwald     att_emit_event_to_all(&event[0], sizeof(event));
277ff1bec95SMatthias Ringwald }
278ff1bec95SMatthias Ringwald 
279ec820d77SMatthias Ringwald static void att_handle_value_indication_timeout(btstack_timer_source_t *ts){
28054178543SMatthias Ringwald     void * context = btstack_run_loop_get_timer_context(ts);
28154178543SMatthias Ringwald     hci_con_handle_t con_handle = (hci_con_handle_t) (uintptr_t) context;
28268591e36SMatthias Ringwald     hci_connection_t * hci_connection = hci_connection_for_handle(con_handle);
28368591e36SMatthias Ringwald     if (!hci_connection) return;
28468591e36SMatthias Ringwald     // @note: after a transaction timeout, no more requests shall be sent over this ATT Bearer
285bce48a26SMatthias Ringwald     // (that's why we don't reset the value_indication_handle)
286b6df12b6SMatthias Ringwald     att_server_t * att_server = &hci_connection->att_server;
28718707219SMatthias Ringwald     uint16_t att_handle = att_server->value_indication_handle;
288388fa7c4SMatthias Ringwald     att_connection_t * att_connection = &hci_connection->att_connection;
28938b893aaSMilanka Ringwald     att_handle_value_indication_notify_client((uint8_t)ATT_HANDLE_VALUE_INDICATION_TIMEOUT, att_connection->con_handle, att_handle);
2903deb3ec6SMatthias Ringwald }
2913deb3ec6SMatthias Ringwald 
29252e211deSMatthias Ringwald static void att_server_event_packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
2939ec2630cSMatthias Ringwald 
2947dad9ff8SMatthias Ringwald     UNUSED(channel); // ok: there is no channel
2957dad9ff8SMatthias Ringwald     UNUSED(size);    // ok: handling own l2cap events
2963deb3ec6SMatthias Ringwald 
29718707219SMatthias Ringwald     att_server_t * att_server;
298b6df12b6SMatthias Ringwald     att_connection_t * att_connection;
29918707219SMatthias Ringwald     hci_con_handle_t con_handle;
30068591e36SMatthias Ringwald     hci_connection_t * hci_connection;
30118707219SMatthias Ringwald 
3023deb3ec6SMatthias Ringwald     switch (packet_type) {
3033deb3ec6SMatthias Ringwald 
3043deb3ec6SMatthias Ringwald         case HCI_EVENT_PACKET:
3050e2df43fSMatthias Ringwald             switch (hci_event_packet_get_type(packet)) {
3063deb3ec6SMatthias Ringwald                 case HCI_EVENT_LE_META:
3073deb3ec6SMatthias Ringwald                     switch (packet[2]) {
3083deb3ec6SMatthias Ringwald                         case HCI_SUBEVENT_LE_CONNECTION_COMPLETE:
30918707219SMatthias Ringwald                             con_handle = little_endian_read_16(packet, 4);
31068591e36SMatthias Ringwald                             hci_connection = hci_connection_for_handle(con_handle);
31168591e36SMatthias Ringwald                             if (!hci_connection) break;
31268591e36SMatthias Ringwald                             att_server = &hci_connection->att_server;
3133deb3ec6SMatthias Ringwald                         	// store connection info
31418707219SMatthias Ringwald                         	att_server->peer_addr_type = packet[7];
31518707219SMatthias Ringwald                             reverse_bd_addr(&packet[8], att_server->peer_address);
316388fa7c4SMatthias Ringwald                             att_connection = &hci_connection->att_connection;
317b6df12b6SMatthias Ringwald                             att_connection->con_handle = con_handle;
3183deb3ec6SMatthias Ringwald                             // reset connection properties
31918707219SMatthias Ringwald                             att_server->state = ATT_SERVER_IDLE;
32023079b39SMatthias Ringwald                             att_server->bearer_type = ATT_BEARER_UNENHANCED_LE;
321b6df12b6SMatthias Ringwald                             att_connection->mtu = ATT_DEFAULT_MTU;
322b6df12b6SMatthias Ringwald                             att_connection->max_mtu = l2cap_max_le_mtu();
323b6df12b6SMatthias Ringwald                             if (att_connection->max_mtu > ATT_REQUEST_BUFFER_SIZE){
324b6df12b6SMatthias Ringwald                                 att_connection->max_mtu = ATT_REQUEST_BUFFER_SIZE;
32599c58ad0SMatthias Ringwald                             }
32638b893aaSMilanka Ringwald                             att_connection->encryption_key_size = 0u;
32738b893aaSMilanka Ringwald                             att_connection->authenticated = 0u;
32838b893aaSMilanka Ringwald 		                	att_connection->authorized = 0u;
329b2c1e52cSMatthias Ringwald                             // workaround: identity resolving can already be complete, at least store result
330b2c1e52cSMatthias Ringwald                             att_server->ir_le_device_db_index = sm_le_device_index(con_handle);
33138b893aaSMilanka Ringwald                             att_server->ir_lookup_active = 0u;
33238b893aaSMilanka Ringwald                             att_server->pairing_active = 0u;
333ff1bec95SMatthias Ringwald                             // notify all - old
3345d07396bSMatthias Ringwald                             att_emit_event_to_all(packet, size);
335ff1bec95SMatthias Ringwald                             // notify all - new
3366d2214cbSMatthias Ringwald                             att_emit_connected_event(att_server, att_connection);
3373deb3ec6SMatthias Ringwald                             break;
3383deb3ec6SMatthias Ringwald 
3393deb3ec6SMatthias Ringwald                         default:
3403deb3ec6SMatthias Ringwald                             break;
3413deb3ec6SMatthias Ringwald                     }
3423deb3ec6SMatthias Ringwald                     break;
3433deb3ec6SMatthias Ringwald 
3443deb3ec6SMatthias Ringwald                 case HCI_EVENT_ENCRYPTION_CHANGE:
3458601e696SMatthias Ringwald                 case HCI_EVENT_ENCRYPTION_CHANGE_V2:
3463deb3ec6SMatthias Ringwald                 case HCI_EVENT_ENCRYPTION_KEY_REFRESH_COMPLETE:
3473deb3ec6SMatthias Ringwald                 	// check handle
34818707219SMatthias Ringwald                     con_handle = little_endian_read_16(packet, 3);
34968591e36SMatthias Ringwald                     hci_connection = hci_connection_for_handle(con_handle);
35068591e36SMatthias Ringwald                     if (!hci_connection) break;
351914988a1SMatthias Ringwald                     if (gap_get_connection_type(con_handle) != GAP_CONNECTION_LE) break;
352914988a1SMatthias Ringwald                     // update security params
35368591e36SMatthias Ringwald                     att_server = &hci_connection->att_server;
354388fa7c4SMatthias Ringwald                     att_connection = &hci_connection->att_connection;
355b6df12b6SMatthias Ringwald                     att_connection->encryption_key_size = gap_encryption_key_size(con_handle);
356ff3f1026SMatthias Ringwald                     att_connection->authenticated = gap_authenticated(con_handle) ? 1 : 0;
357f461b3dfSMatthias Ringwald                     att_connection->secure_connection = gap_secure_connection(con_handle) ? 1 : 0;
358914988a1SMatthias Ringwald                     log_info("encrypted key size %u, authenticated %u, secure connection %u",
359b6df12b6SMatthias Ringwald                         att_connection->encryption_key_size, att_connection->authenticated, att_connection->secure_connection);
360914988a1SMatthias Ringwald                     if (hci_event_packet_get_type(packet) == HCI_EVENT_ENCRYPTION_CHANGE){
3614097998aSMatthias Ringwald                         // restore CCC values when encrypted for LE Connections
36222bfc225SMilanka Ringwald                         if (hci_event_encryption_change_get_encryption_enabled(packet) != 0){
3639a1f55eaSMatthias Ringwald                             att_server_persistent_ccc_restore(att_server, att_connection);
36401ac2008SMatthias Ringwald                         }
36501ac2008SMatthias Ringwald                     }
366cd45e970SMatthias Ringwald                     att_run_for_context(att_server, att_connection);
3673deb3ec6SMatthias Ringwald                     break;
3683deb3ec6SMatthias Ringwald 
3693deb3ec6SMatthias Ringwald                 case HCI_EVENT_DISCONNECTION_COMPLETE:
37070a390c7SMatthias Ringwald                     // check handle
37118707219SMatthias Ringwald                     con_handle = hci_event_disconnection_complete_get_connection_handle(packet);
37268591e36SMatthias Ringwald                     hci_connection = hci_connection_for_handle(con_handle);
37368591e36SMatthias Ringwald                     if (!hci_connection) break;
37468591e36SMatthias Ringwald                     att_server = &hci_connection->att_server;
375388fa7c4SMatthias Ringwald                     att_connection = &hci_connection->att_connection;
376b6df12b6SMatthias Ringwald                     att_clear_transaction_queue(att_connection);
377b6df12b6SMatthias Ringwald                     att_connection->con_handle = 0;
378760ad805SMatthias Ringwald                     att_server->pairing_active = 0;
37918707219SMatthias Ringwald                     att_server->state = ATT_SERVER_IDLE;
38038b893aaSMilanka Ringwald                     if (att_server->value_indication_handle != 0u){
38127328ecbSMatthias Ringwald                         btstack_run_loop_remove_timer(&att_server->value_indication_timer);
382bce48a26SMatthias Ringwald                         uint16_t att_handle = att_server->value_indication_handle;
38338b893aaSMilanka Ringwald                         att_server->value_indication_handle = 0u; // reset error state
38438b893aaSMilanka Ringwald                         att_handle_value_indication_notify_client((uint8_t)ATT_HANDLE_VALUE_INDICATION_DISCONNECT, att_connection->con_handle, att_handle);
385bce48a26SMatthias Ringwald                     }
386ff1bec95SMatthias Ringwald                     // notify all - new
3876187ad4cSMatthias Ringwald                     att_emit_disconnected_event(con_handle);
388ff1bec95SMatthias Ringwald                     // notify all - old
3895d07396bSMatthias Ringwald                     att_emit_event_to_all(packet, size);
3903deb3ec6SMatthias Ringwald                     break;
3913deb3ec6SMatthias Ringwald 
392760ad805SMatthias Ringwald                 // Identity Resolving
3935611a760SMatthias Ringwald                 case SM_EVENT_IDENTITY_RESOLVING_STARTED:
39418707219SMatthias Ringwald                     con_handle = sm_event_identity_resolving_started_get_handle(packet);
39568591e36SMatthias Ringwald                     hci_connection = hci_connection_for_handle(con_handle);
39668591e36SMatthias Ringwald                     if (!hci_connection) break;
39768591e36SMatthias Ringwald                     att_server = &hci_connection->att_server;
3985611a760SMatthias Ringwald                     log_info("SM_EVENT_IDENTITY_RESOLVING_STARTED");
39930c8e114SMatthias Ringwald                     att_server->ir_lookup_active = 1;
4003deb3ec6SMatthias Ringwald                     break;
4015611a760SMatthias Ringwald                 case SM_EVENT_IDENTITY_RESOLVING_SUCCEEDED:
402760ad805SMatthias Ringwald                     con_handle = sm_event_identity_created_get_handle(packet);
40368591e36SMatthias Ringwald                     hci_connection = hci_connection_for_handle(con_handle);
40468591e36SMatthias Ringwald                     if (!hci_connection) return;
405acb2a577SMatthias Ringwald                     att_connection = &hci_connection->att_connection;
40668591e36SMatthias Ringwald                     att_server = &hci_connection->att_server;
40730c8e114SMatthias Ringwald                     att_server->ir_lookup_active = 0;
4081b7acd0dSMatthias Ringwald                     att_server->ir_le_device_db_index = sm_event_identity_resolving_succeeded_get_index(packet);
4091b7acd0dSMatthias Ringwald                     log_info("SM_EVENT_IDENTITY_RESOLVING_SUCCEEDED");
410cd45e970SMatthias Ringwald                     att_run_for_context(att_server, att_connection);
4113deb3ec6SMatthias Ringwald                     break;
4125611a760SMatthias Ringwald                 case SM_EVENT_IDENTITY_RESOLVING_FAILED:
41318707219SMatthias Ringwald                     con_handle = sm_event_identity_resolving_failed_get_handle(packet);
41468591e36SMatthias Ringwald                     hci_connection = hci_connection_for_handle(con_handle);
41568591e36SMatthias Ringwald                     if (!hci_connection) break;
416acb2a577SMatthias Ringwald                     att_connection = &hci_connection->att_connection;
41768591e36SMatthias Ringwald                     att_server = &hci_connection->att_server;
4185611a760SMatthias Ringwald                     log_info("SM_EVENT_IDENTITY_RESOLVING_FAILED");
41930c8e114SMatthias Ringwald                     att_server->ir_lookup_active = 0;
42018707219SMatthias Ringwald                     att_server->ir_le_device_db_index = -1;
421cd45e970SMatthias Ringwald                     att_run_for_context(att_server, att_connection);
4223deb3ec6SMatthias Ringwald                     break;
423760ad805SMatthias Ringwald 
424760ad805SMatthias Ringwald                 // Pairing started - delete stored CCC values
425760ad805SMatthias Ringwald                 // - assumes pairing indicates either new device or re-pairing, in both cases there should be no stored CCC values
426760ad805SMatthias Ringwald                 // - assumes that all events have the con handle as the first field
427760ad805SMatthias Ringwald                 case SM_EVENT_JUST_WORKS_REQUEST:
428760ad805SMatthias Ringwald                 case SM_EVENT_PASSKEY_DISPLAY_NUMBER:
429760ad805SMatthias Ringwald                 case SM_EVENT_PASSKEY_INPUT_NUMBER:
430760ad805SMatthias Ringwald                 case SM_EVENT_NUMERIC_COMPARISON_REQUEST:
431760ad805SMatthias Ringwald                     con_handle = sm_event_just_works_request_get_handle(packet);
43268591e36SMatthias Ringwald                     hci_connection = hci_connection_for_handle(con_handle);
43368591e36SMatthias Ringwald                     if (!hci_connection) break;
43468591e36SMatthias Ringwald                     att_server = &hci_connection->att_server;
435760ad805SMatthias Ringwald                     log_info("SM Pairing started");
43601c0691bSMatthias Ringwald                     att_server->pairing_active = 1;
437760ad805SMatthias Ringwald                     if (att_server->ir_le_device_db_index < 0) break;
43801c0691bSMatthias Ringwald                     att_server_persistent_ccc_clear(att_server);
439760ad805SMatthias Ringwald                     // index not valid anymore
440760ad805SMatthias Ringwald                     att_server->ir_le_device_db_index = -1;
441760ad805SMatthias Ringwald                     break;
442760ad805SMatthias Ringwald 
4431b7acd0dSMatthias Ringwald                 // Bonding completed
444760ad805SMatthias Ringwald                 case SM_EVENT_IDENTITY_CREATED:
445760ad805SMatthias Ringwald                     con_handle = sm_event_identity_created_get_handle(packet);
44668591e36SMatthias Ringwald                     hci_connection = hci_connection_for_handle(con_handle);
44768591e36SMatthias Ringwald                     if (!hci_connection) return;
448acb2a577SMatthias Ringwald                     att_connection = &hci_connection->att_connection;
44968591e36SMatthias Ringwald                     att_server = &hci_connection->att_server;
450760ad805SMatthias Ringwald                     att_server->pairing_active = 0;
4511b7acd0dSMatthias Ringwald                     att_server->ir_le_device_db_index = sm_event_identity_created_get_index(packet);
452cd45e970SMatthias Ringwald                     att_run_for_context(att_server, att_connection);
4531b7acd0dSMatthias Ringwald                     break;
4541b7acd0dSMatthias Ringwald 
4551b7acd0dSMatthias Ringwald                 // Pairing complete (with/without bonding=storing of pairing information)
4561b7acd0dSMatthias Ringwald                 case SM_EVENT_PAIRING_COMPLETE:
4571b7acd0dSMatthias Ringwald                     con_handle = sm_event_pairing_complete_get_handle(packet);
45868591e36SMatthias Ringwald                     hci_connection = hci_connection_for_handle(con_handle);
45968591e36SMatthias Ringwald                     if (!hci_connection) return;
460acb2a577SMatthias Ringwald                     att_connection = &hci_connection->att_connection;
46168591e36SMatthias Ringwald                     att_server = &hci_connection->att_server;
4621b7acd0dSMatthias Ringwald                     att_server->pairing_active = 0;
463cd45e970SMatthias Ringwald                     att_run_for_context(att_server, att_connection);
464760ad805SMatthias Ringwald                     break;
465760ad805SMatthias Ringwald 
466760ad805SMatthias Ringwald                 // Authorization
4675611a760SMatthias Ringwald                 case SM_EVENT_AUTHORIZATION_RESULT: {
46818707219SMatthias Ringwald                     con_handle = sm_event_authorization_result_get_handle(packet);
46968591e36SMatthias Ringwald                     hci_connection = hci_connection_for_handle(con_handle);
47068591e36SMatthias Ringwald                     if (!hci_connection) break;
471388fa7c4SMatthias Ringwald                     att_connection = &hci_connection->att_connection;
472acb2a577SMatthias Ringwald                     att_server = &hci_connection->att_server;
473b6df12b6SMatthias Ringwald                     att_connection->authorized = sm_event_authorization_result_get_authorization_result(packet);
4743f9b77dbSMatthias Ringwald                     att_server_request_can_send_now(att_server, att_connection);
4753deb3ec6SMatthias Ringwald                 	break;
4763deb3ec6SMatthias Ringwald                 }
4773deb3ec6SMatthias Ringwald                 default:
4783deb3ec6SMatthias Ringwald                     break;
4793deb3ec6SMatthias Ringwald             }
48065b44ffdSMatthias Ringwald             break;
48165b44ffdSMatthias Ringwald         default:
48265b44ffdSMatthias Ringwald             break;
4833deb3ec6SMatthias Ringwald     }
4843deb3ec6SMatthias Ringwald }
4853deb3ec6SMatthias Ringwald 
4860f70c52eSMatthias Ringwald static uint8_t
4870f70c52eSMatthias Ringwald att_server_send_prepared(const att_server_t *att_server, const att_connection_t *att_connection, uint8_t *buffer,
4880f70c52eSMatthias Ringwald                          uint16_t size) {
489d415948cSMatthias Ringwald     uint8_t status = ERROR_CODE_SUCCESS;
490d415948cSMatthias Ringwald     switch (att_server->bearer_type) {
491d415948cSMatthias Ringwald         case ATT_BEARER_UNENHANCED_LE:
492d415948cSMatthias Ringwald             status = l2cap_send_prepared_connectionless(att_connection->con_handle, L2CAP_CID_ATTRIBUTE_PROTOCOL, size);
49340f8d8f2SMatthias Ringwald             break;
494d415948cSMatthias Ringwald #ifdef ENABLE_GATT_OVER_CLASSIC
495d415948cSMatthias Ringwald         case ATT_BEARER_UNENHANCED_CLASSIC:
496d415948cSMatthias Ringwald             status = l2cap_send_prepared(att_server->l2cap_cid, size);
497d415948cSMatthias Ringwald             break;
498d415948cSMatthias Ringwald #endif
4990f70c52eSMatthias Ringwald #ifdef ENABLE_GATT_OVER_EATT
5000f70c52eSMatthias Ringwald         case ATT_BEARER_ENHANCED_LE:
5010f70c52eSMatthias Ringwald             btstack_assert(buffer != NULL);
5020f70c52eSMatthias Ringwald             status = l2cap_send(att_server->l2cap_cid, buffer, size);
5030f70c52eSMatthias Ringwald             break;
5040f70c52eSMatthias Ringwald #endif
505d415948cSMatthias Ringwald         default:
506d415948cSMatthias Ringwald             btstack_unreachable();
507d415948cSMatthias Ringwald             break;
508d415948cSMatthias Ringwald     }
509d415948cSMatthias Ringwald     return status;
510d415948cSMatthias Ringwald }
511d415948cSMatthias Ringwald 
5127a766ebfSMatthias Ringwald #ifdef ENABLE_LE_SIGNED_WRITE
5133deb3ec6SMatthias Ringwald static void att_signed_write_handle_cmac_result(uint8_t hash[8]){
51426567ee7SMatthias Ringwald     att_server_t * att_server = NULL;
51526567ee7SMatthias Ringwald     att_connection_t * att_connection = NULL;
51626567ee7SMatthias Ringwald     bool found = att_server_connections_for_state(ATT_SERVER_W4_SIGNED_WRITE_VALIDATION, &att_server, &att_connection);
5173deb3ec6SMatthias Ringwald 
518c2cbe117SMatthias Ringwald     if (found == false){
519c2cbe117SMatthias Ringwald         return;
520c2cbe117SMatthias Ringwald     }
521c2cbe117SMatthias Ringwald 
5223deb3ec6SMatthias Ringwald     uint8_t hash_flipped[8];
5239c80e4ccSMatthias Ringwald     reverse_64(hash, hash_flipped);
52426567ee7SMatthias Ringwald     if (memcmp(hash_flipped, &att_server->request_buffer[att_server->request_size-8], 8) != 0){
5253deb3ec6SMatthias Ringwald         log_info("ATT Signed Write, invalid signature");
52603f53d81SMatthias Ringwald #ifdef ENABLE_TESTING_SUPPORT
52703f53d81SMatthias Ringwald         printf("ATT Signed Write, invalid signature\n");
52803f53d81SMatthias Ringwald #endif
52918707219SMatthias Ringwald         att_server->state = ATT_SERVER_IDLE;
5303deb3ec6SMatthias Ringwald         return;
5313deb3ec6SMatthias Ringwald     }
5323deb3ec6SMatthias Ringwald     log_info("ATT Signed Write, valid signature");
53303f53d81SMatthias Ringwald #ifdef ENABLE_TESTING_SUPPORT
53403f53d81SMatthias Ringwald     printf("ATT Signed Write, valid signature\n");
53503f53d81SMatthias Ringwald #endif
5363deb3ec6SMatthias Ringwald 
5373deb3ec6SMatthias Ringwald     // update sequence number
53818707219SMatthias Ringwald     uint32_t counter_packet = little_endian_read_32(att_server->request_buffer, att_server->request_size-12);
53918707219SMatthias Ringwald     le_device_db_remote_counter_set(att_server->ir_le_device_db_index, counter_packet+1);
54018707219SMatthias Ringwald     att_server->state = ATT_SERVER_REQUEST_RECEIVED_AND_VALIDATED;
5413f9b77dbSMatthias Ringwald     att_server_request_can_send_now(att_server, att_connection);
5423deb3ec6SMatthias Ringwald }
5437a766ebfSMatthias Ringwald #endif
54488a48dd8SMatthias Ringwald 
54518707219SMatthias Ringwald // pre: att_server->state == ATT_SERVER_REQUEST_RECEIVED_AND_VALIDATED
546b06f2579SMatthias Ringwald // pre: can send now
5479988bc8aSMatthias Ringwald // uses l2cap outgoing buffer if no eatt_buffer provided
548b06f2579SMatthias Ringwald // returns: 1 if packet was sent
5499988bc8aSMatthias Ringwald static int
5509988bc8aSMatthias Ringwald att_server_process_validated_request(att_server_t *att_server, att_connection_t *att_connection, uint8_t *eatt_buffer) {
551b06f2579SMatthias Ringwald 
5529988bc8aSMatthias Ringwald     uint8_t * att_response_buffer;
5539988bc8aSMatthias Ringwald     if (eatt_buffer != NULL){
5549988bc8aSMatthias Ringwald         att_response_buffer = eatt_buffer;
5559988bc8aSMatthias Ringwald     } else {
556b06f2579SMatthias Ringwald         l2cap_reserve_packet_buffer();
5579988bc8aSMatthias Ringwald         att_response_buffer = l2cap_get_outgoing_buffer();
5589988bc8aSMatthias Ringwald     }
5599988bc8aSMatthias Ringwald 
5607a293e22SMatthias Ringwald     uint16_t  att_response_size = 0;
5617a293e22SMatthias Ringwald     // Send Error Response for MTU Request over connection-oriented channel
5627a293e22SMatthias Ringwald     if ((att_server->bearer_type != ATT_BEARER_UNENHANCED_LE) && (att_server->request_buffer[0] == ATT_EXCHANGE_MTU_REQUEST)){
5637a293e22SMatthias Ringwald         att_response_size = 5;
5647a293e22SMatthias Ringwald         att_response_buffer[0] = ATT_ERROR_RESPONSE;
5657a293e22SMatthias Ringwald         att_response_buffer[1] = ATT_EXCHANGE_MTU_REQUEST;
5667a293e22SMatthias Ringwald         att_response_buffer[2] = 0;
5677a293e22SMatthias Ringwald         att_response_buffer[3] = 0;
5687a293e22SMatthias Ringwald         att_response_buffer[4] = ATT_ERROR_REQUEST_NOT_SUPPORTED;
5697a293e22SMatthias Ringwald     } else {
5707a293e22SMatthias Ringwald         att_response_size = att_handle_request(att_connection, att_server->request_buffer, att_server->request_size, att_response_buffer);
5717a293e22SMatthias Ringwald     }
572b06f2579SMatthias Ringwald 
573beb20288SMatthias Ringwald #ifdef ENABLE_ATT_DELAYED_RESPONSE
574c1ab6cc1SMatthias Ringwald     if ((att_response_size == ATT_READ_RESPONSE_PENDING) || (att_response_size == ATT_INTERNAL_WRITE_RESPONSE_PENDING)){
575e404a688SMatthias Ringwald         // update state
576beb20288SMatthias Ringwald         att_server->state = ATT_SERVER_RESPONSE_PENDING;
577e404a688SMatthias Ringwald 
57856c3a347SMatthias Ringwald         // callback with handle ATT_READ_RESPONSE_PENDING for reads
57956c3a347SMatthias Ringwald         if (att_response_size == ATT_READ_RESPONSE_PENDING){
580b6df12b6SMatthias Ringwald             att_server_client_read_callback(att_connection->con_handle, ATT_READ_RESPONSE_PENDING, 0, NULL, 0);
58156c3a347SMatthias Ringwald         }
582e8e7403eSMatthias Ringwald 
583e8e7403eSMatthias Ringwald         // free reserved buffer
5849988bc8aSMatthias Ringwald         if (eatt_buffer == NULL){
585e8e7403eSMatthias Ringwald             l2cap_release_packet_buffer();
5869988bc8aSMatthias Ringwald         }
587e8e7403eSMatthias Ringwald         return 0;
588e404a688SMatthias Ringwald     }
589e404a688SMatthias Ringwald #endif
590e404a688SMatthias Ringwald 
591b06f2579SMatthias Ringwald     // intercept "insufficient authorization" for authenticated connections to allow for user authorization
5924ea43905SMatthias Ringwald     if ((att_response_size     >= 4u)
593b06f2579SMatthias Ringwald     && (att_response_buffer[0] == ATT_ERROR_RESPONSE)
594b06f2579SMatthias Ringwald     && (att_response_buffer[4] == ATT_ERROR_INSUFFICIENT_AUTHORIZATION)
59538b893aaSMilanka Ringwald     && (att_connection->authenticated != 0u)){
596b06f2579SMatthias Ringwald 
597b6df12b6SMatthias Ringwald         switch (gap_authorization_state(att_connection->con_handle)){
598b06f2579SMatthias Ringwald             case AUTHORIZATION_UNKNOWN:
5999988bc8aSMatthias Ringwald                 if (eatt_buffer == NULL){
600b06f2579SMatthias Ringwald                     l2cap_release_packet_buffer();
6019988bc8aSMatthias Ringwald                 }
602b6df12b6SMatthias Ringwald                 sm_request_pairing(att_connection->con_handle);
603b06f2579SMatthias Ringwald                 return 0;
604b06f2579SMatthias Ringwald             case AUTHORIZATION_PENDING:
6059988bc8aSMatthias Ringwald                 if (eatt_buffer == NULL){
606b06f2579SMatthias Ringwald                     l2cap_release_packet_buffer();
6079988bc8aSMatthias Ringwald                 }
608b06f2579SMatthias Ringwald                 return 0;
609b06f2579SMatthias Ringwald             default:
610b06f2579SMatthias Ringwald                 break;
611b06f2579SMatthias Ringwald         }
612b06f2579SMatthias Ringwald     }
613b06f2579SMatthias Ringwald 
61418707219SMatthias Ringwald     att_server->state = ATT_SERVER_IDLE;
6154ea43905SMatthias Ringwald     if (att_response_size == 0u) {
6169988bc8aSMatthias Ringwald         if (eatt_buffer == NULL){
617b06f2579SMatthias Ringwald             l2cap_release_packet_buffer();
6189988bc8aSMatthias Ringwald         }
619b06f2579SMatthias Ringwald         return 0;
620b06f2579SMatthias Ringwald     }
621b06f2579SMatthias Ringwald 
6229988bc8aSMatthias Ringwald     (void) att_server_send_prepared(att_server, att_connection, eatt_buffer, att_response_size);
623b06f2579SMatthias Ringwald 
624b06f2579SMatthias Ringwald     // notify client about MTU exchange result
625b06f2579SMatthias Ringwald     if (att_response_buffer[0] == ATT_EXCHANGE_MTU_RESPONSE){
626b6df12b6SMatthias Ringwald         att_emit_mtu_event(att_connection->con_handle, att_connection->mtu);
627b06f2579SMatthias Ringwald     }
628b06f2579SMatthias Ringwald     return 1;
629b06f2579SMatthias Ringwald }
630b06f2579SMatthias Ringwald 
631beb20288SMatthias Ringwald #ifdef ENABLE_ATT_DELAYED_RESPONSE
6329816429dSMatthias Ringwald uint8_t att_server_response_ready(hci_con_handle_t con_handle){
63368591e36SMatthias Ringwald     hci_connection_t * hci_connection = hci_connection_for_handle(con_handle);
63468591e36SMatthias Ringwald     if (!hci_connection) return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
63568591e36SMatthias Ringwald     att_server_t * att_server = &hci_connection->att_server;
6363f9b77dbSMatthias Ringwald     att_connection_t * att_connection = &hci_connection->att_connection;
637beb20288SMatthias Ringwald     if (att_server->state != ATT_SERVER_RESPONSE_PENDING)   return ERROR_CODE_COMMAND_DISALLOWED;
638e404a688SMatthias Ringwald 
639e404a688SMatthias Ringwald     att_server->state = ATT_SERVER_REQUEST_RECEIVED_AND_VALIDATED;
6403f9b77dbSMatthias Ringwald     att_server_request_can_send_now(att_server, att_connection);
641e404a688SMatthias Ringwald     return ERROR_CODE_SUCCESS;
642e404a688SMatthias Ringwald }
643e404a688SMatthias Ringwald #endif
644e404a688SMatthias Ringwald 
645cd45e970SMatthias Ringwald static void att_run_for_context(att_server_t * att_server, att_connection_t * att_connection){
64618707219SMatthias Ringwald     switch (att_server->state){
6473deb3ec6SMatthias Ringwald         case ATT_SERVER_REQUEST_RECEIVED:
64823079b39SMatthias Ringwald             switch (att_server->bearer_type){
64923079b39SMatthias Ringwald                 case ATT_BEARER_UNENHANCED_LE:
6500234fbbcSMatthias Ringwald                     // wait until re-encryption as central is complete
65123079b39SMatthias Ringwald                     if (gap_reconnect_security_setup_active(att_connection->con_handle)) {
65223079b39SMatthias Ringwald                         return;
65323079b39SMatthias Ringwald                     };
65423079b39SMatthias Ringwald                     break;
6552954c397SMatthias Ringwald #if defined(ENABLE_GATT_OVER_CLASSIC) || defined (ENABLE_GATT_OVER_EATT)
65623079b39SMatthias Ringwald #ifdef ENABLE_GATT_OVER_CLASSIC
65723079b39SMatthias Ringwald                 case ATT_BEARER_UNENHANCED_CLASSIC:
6582954c397SMatthias Ringwald                     /* fall through */
6592954c397SMatthias Ringwald #endif
6602954c397SMatthias Ringwald #ifdef ENABLE_GATT_OVER_EATT
6612954c397SMatthias Ringwald                 case ATT_BEARER_ENHANCED_LE:
6622954c397SMatthias Ringwald #endif
66323079b39SMatthias Ringwald                     // ok
66423079b39SMatthias Ringwald                     break;
66523079b39SMatthias Ringwald #endif
66623079b39SMatthias Ringwald                 default:
66723079b39SMatthias Ringwald                     btstack_unreachable();
66823079b39SMatthias Ringwald                     break;
66948364364SMatthias Ringwald             }
6700234fbbcSMatthias Ringwald 
671760ad805SMatthias Ringwald             // wait until pairing is complete
672760ad805SMatthias Ringwald             if (att_server->pairing_active) break;
673760ad805SMatthias Ringwald 
6747a766ebfSMatthias Ringwald #ifdef ENABLE_LE_SIGNED_WRITE
67518707219SMatthias Ringwald             if (att_server->request_buffer[0] == ATT_SIGNED_WRITE_COMMAND){
6763deb3ec6SMatthias Ringwald                 log_info("ATT Signed Write!");
6773deb3ec6SMatthias Ringwald                 if (!sm_cmac_ready()) {
6783deb3ec6SMatthias Ringwald                     log_info("ATT Signed Write, sm_cmac engine not ready. Abort");
67918707219SMatthias Ringwald                     att_server->state = ATT_SERVER_IDLE;
6803deb3ec6SMatthias Ringwald                     return;
6813deb3ec6SMatthias Ringwald                 }
68218707219SMatthias Ringwald                 if (att_server->request_size < (3 + 12)) {
6833deb3ec6SMatthias Ringwald                     log_info("ATT Signed Write, request to short. Abort.");
68418707219SMatthias Ringwald                     att_server->state = ATT_SERVER_IDLE;
6853deb3ec6SMatthias Ringwald                     return;
6863deb3ec6SMatthias Ringwald                 }
68718707219SMatthias Ringwald                 if (att_server->ir_lookup_active){
6883deb3ec6SMatthias Ringwald                     return;
6893deb3ec6SMatthias Ringwald                 }
69018707219SMatthias Ringwald                 if (att_server->ir_le_device_db_index < 0){
6913deb3ec6SMatthias Ringwald                     log_info("ATT Signed Write, CSRK not available");
69218707219SMatthias Ringwald                     att_server->state = ATT_SERVER_IDLE;
6933deb3ec6SMatthias Ringwald                     return;
6943deb3ec6SMatthias Ringwald                 }
6953deb3ec6SMatthias Ringwald 
6963deb3ec6SMatthias Ringwald                 // check counter
69718707219SMatthias Ringwald                 uint32_t counter_packet = little_endian_read_32(att_server->request_buffer, att_server->request_size-12);
69818707219SMatthias Ringwald                 uint32_t counter_db     = le_device_db_remote_counter_get(att_server->ir_le_device_db_index);
6993deb3ec6SMatthias Ringwald                 log_info("ATT Signed Write, DB counter %"PRIu32", packet counter %"PRIu32, counter_db, counter_packet);
7003deb3ec6SMatthias Ringwald                 if (counter_packet < counter_db){
7013deb3ec6SMatthias Ringwald                     log_info("ATT Signed Write, db reports higher counter, abort");
70218707219SMatthias Ringwald                     att_server->state = ATT_SERVER_IDLE;
7033deb3ec6SMatthias Ringwald                     return;
7043deb3ec6SMatthias Ringwald                 }
7053deb3ec6SMatthias Ringwald 
7063deb3ec6SMatthias Ringwald                 // signature is { sequence counter, secure hash }
7073deb3ec6SMatthias Ringwald                 sm_key_t csrk;
70818707219SMatthias Ringwald                 le_device_db_remote_csrk_get(att_server->ir_le_device_db_index, csrk);
70918707219SMatthias Ringwald                 att_server->state = ATT_SERVER_W4_SIGNED_WRITE_VALIDATION;
7103deb3ec6SMatthias Ringwald                 log_info("Orig Signature: ");
71118707219SMatthias Ringwald                 log_info_hexdump( &att_server->request_buffer[att_server->request_size-8], 8);
71218707219SMatthias Ringwald                 uint16_t attribute_handle = little_endian_read_16(att_server->request_buffer, 1);
71318707219SMatthias Ringwald                 sm_cmac_signed_write_start(csrk, att_server->request_buffer[0], attribute_handle, att_server->request_size - 15, &att_server->request_buffer[3], counter_packet, att_signed_write_handle_cmac_result);
7143deb3ec6SMatthias Ringwald                 return;
7153deb3ec6SMatthias Ringwald             }
7167a766ebfSMatthias Ringwald #endif
717b06f2579SMatthias Ringwald             // move on
71818707219SMatthias Ringwald             att_server->state = ATT_SERVER_REQUEST_RECEIVED_AND_VALIDATED;
7193f9b77dbSMatthias Ringwald             att_server_request_can_send_now(att_server, att_connection);
720b06f2579SMatthias Ringwald             break;
72188a48dd8SMatthias Ringwald 
7223deb3ec6SMatthias Ringwald         default:
7233deb3ec6SMatthias Ringwald             break;
7243deb3ec6SMatthias Ringwald     }
7253deb3ec6SMatthias Ringwald }
7263deb3ec6SMatthias Ringwald 
7271979f09cSMatthias Ringwald static bool att_server_data_ready_for_phase(att_server_t * att_server,  att_server_run_phase_t phase){
72890f03c80SMatthias Ringwald     switch (phase){
72990f03c80SMatthias Ringwald         case ATT_SERVER_RUN_PHASE_1_REQUESTS:
73090f03c80SMatthias Ringwald             return att_server->state == ATT_SERVER_REQUEST_RECEIVED_AND_VALIDATED;
73190f03c80SMatthias Ringwald         case ATT_SERVER_RUN_PHASE_2_INDICATIONS:
73238b893aaSMilanka Ringwald              return (!btstack_linked_list_empty(&att_server->indication_requests) && (att_server->value_indication_handle == 0u));
73390f03c80SMatthias Ringwald         case ATT_SERVER_RUN_PHASE_3_NOTIFICATIONS:
73490f03c80SMatthias Ringwald             return (!btstack_linked_list_empty(&att_server->notification_requests));
7357bbeb3adSMilanka Ringwald         default:
7367bbeb3adSMilanka Ringwald             btstack_assert(false);
7371979f09cSMatthias Ringwald             return false;
73890f03c80SMatthias Ringwald     }
7397bbeb3adSMilanka Ringwald }
74090f03c80SMatthias Ringwald 
7419d6c0193SMatthias Ringwald static void att_server_trigger_send_for_phase(att_server_t * att_server, att_connection_t * att_connection, att_server_run_phase_t phase){
74290f03c80SMatthias Ringwald     btstack_context_callback_registration_t * client;
74390f03c80SMatthias Ringwald     switch (phase){
74490f03c80SMatthias Ringwald         case ATT_SERVER_RUN_PHASE_1_REQUESTS:
7450f70c52eSMatthias Ringwald             att_server_process_validated_request(att_server, att_connection, NULL);
74690f03c80SMatthias Ringwald             break;
74790f03c80SMatthias Ringwald         case ATT_SERVER_RUN_PHASE_2_INDICATIONS:
74890f03c80SMatthias Ringwald             client = (btstack_context_callback_registration_t*) att_server->indication_requests;
74990f03c80SMatthias Ringwald             btstack_linked_list_remove(&att_server->indication_requests, (btstack_linked_item_t *) client);
75090f03c80SMatthias Ringwald             client->callback(client->context);
75190f03c80SMatthias Ringwald             break;
75290f03c80SMatthias Ringwald        case ATT_SERVER_RUN_PHASE_3_NOTIFICATIONS:
75390f03c80SMatthias Ringwald             client = (btstack_context_callback_registration_t*) att_server->notification_requests;
75490f03c80SMatthias Ringwald             btstack_linked_list_remove(&att_server->notification_requests, (btstack_linked_item_t *) client);
75590f03c80SMatthias Ringwald             client->callback(client->context);
75690f03c80SMatthias Ringwald             break;
7577bbeb3adSMilanka Ringwald         default:
7587bbeb3adSMilanka Ringwald             btstack_assert(false);
7597bbeb3adSMilanka Ringwald             break;
76090f03c80SMatthias Ringwald     }
76190f03c80SMatthias Ringwald }
76290f03c80SMatthias Ringwald 
7637eb16ee8SMatthias Ringwald static void att_server_handle_can_send_now(void){
764b06f2579SMatthias Ringwald 
7656438547aSMatthias Ringwald     hci_con_handle_t last_send_con_handle = HCI_CON_HANDLE_INVALID;
76668591e36SMatthias Ringwald     hci_connection_t * request_hci_connection   = NULL;
7671979f09cSMatthias Ringwald     bool can_send_now = true;
76838b893aaSMilanka Ringwald     uint8_t phase_index;
7696438547aSMatthias Ringwald 
7704395a000SMatthias Ringwald     for (phase_index = ATT_SERVER_RUN_PHASE_1_REQUESTS; phase_index <= ATT_SERVER_RUN_PHASE_3_NOTIFICATIONS; phase_index++){
7714395a000SMatthias Ringwald         att_server_run_phase_t phase = (att_server_run_phase_t) phase_index;
7726438547aSMatthias Ringwald         hci_con_handle_t skip_connections_until = att_server_last_can_send_now;
773ff3cc4a5SMatthias Ringwald         while (true){
7746438547aSMatthias Ringwald             btstack_linked_list_iterator_t it;
77518707219SMatthias Ringwald             hci_connections_get_iterator(&it);
77618707219SMatthias Ringwald             while(btstack_linked_list_iterator_has_next(&it)){
77718707219SMatthias Ringwald                 hci_connection_t * connection = (hci_connection_t *) btstack_linked_list_iterator_next(&it);
77818707219SMatthias Ringwald                 att_server_t * att_server = &connection->att_server;
779388fa7c4SMatthias Ringwald                 att_connection_t * att_connection = &connection->att_connection;
7806438547aSMatthias Ringwald 
7811979f09cSMatthias Ringwald                 bool data_ready = att_server_data_ready_for_phase(att_server, phase);
7826438547aSMatthias Ringwald 
783b6df12b6SMatthias Ringwald                 // log_debug("phase %u, handle 0x%04x, skip until 0x%04x, data ready %u", phase, att_connection->con_handle, skip_connections_until, data_ready);
7846438547aSMatthias Ringwald 
7856438547aSMatthias Ringwald                 // skip until last sender found (which is also skipped)
7866438547aSMatthias Ringwald                 if (skip_connections_until != HCI_CON_HANDLE_INVALID){
78768591e36SMatthias Ringwald                     if (data_ready && (request_hci_connection == NULL)){
78868591e36SMatthias Ringwald                         request_hci_connection = connection;
7896438547aSMatthias Ringwald                     }
790b6df12b6SMatthias Ringwald                     if (skip_connections_until == att_connection->con_handle){
7916438547aSMatthias Ringwald                         skip_connections_until = HCI_CON_HANDLE_INVALID;
7926438547aSMatthias Ringwald                     }
7936438547aSMatthias Ringwald                     continue;
7946438547aSMatthias Ringwald                 };
7956438547aSMatthias Ringwald 
79690f03c80SMatthias Ringwald                 if (data_ready){
797969a5bbaSMatthias Ringwald                     if (can_send_now){
7989d6c0193SMatthias Ringwald                         att_server_trigger_send_for_phase(att_server, att_connection, phase);
799b6df12b6SMatthias Ringwald                         last_send_con_handle = att_connection->con_handle;
80037a8059dSMatthias Ringwald                         can_send_now = att_server_can_send_packet(att_server, att_connection);
80190f03c80SMatthias Ringwald                         data_ready = att_server_data_ready_for_phase(att_server, phase);
80268591e36SMatthias Ringwald                         if (data_ready && (request_hci_connection == NULL)){
80368591e36SMatthias Ringwald                             request_hci_connection = connection;
804cbbb12d9SMatthias Ringwald                         }
805cbbb12d9SMatthias Ringwald                     } else {
80668591e36SMatthias Ringwald                         request_hci_connection = connection;
807f29a88d8SMatthias Ringwald                         break;
808cbbb12d9SMatthias Ringwald                     }
809cbbb12d9SMatthias Ringwald                 }
8103deb3ec6SMatthias Ringwald             }
8113deb3ec6SMatthias Ringwald 
8126438547aSMatthias Ringwald             // stop skipping (handles disconnect by last send connection)
8136438547aSMatthias Ringwald             skip_connections_until = HCI_CON_HANDLE_INVALID;
8146438547aSMatthias Ringwald 
8153551936eSMatthias Ringwald             // Exit loop, if we cannot send
816969a5bbaSMatthias Ringwald             if (!can_send_now) break;
817969a5bbaSMatthias Ringwald 
818969a5bbaSMatthias Ringwald             // Exit loop, if we can send but there are also no further request
81968591e36SMatthias Ringwald             if (request_hci_connection == NULL) break;
820969a5bbaSMatthias Ringwald 
821969a5bbaSMatthias Ringwald             // Finally, if we still can send and there are requests, just try again
82268591e36SMatthias Ringwald             request_hci_connection = NULL;
823969a5bbaSMatthias Ringwald         }
8246438547aSMatthias Ringwald         // update last send con handle for round robin
8256438547aSMatthias Ringwald         if (last_send_con_handle != HCI_CON_HANDLE_INVALID){
8266438547aSMatthias Ringwald             att_server_last_can_send_now = last_send_con_handle;
8276438547aSMatthias Ringwald         }
8283551936eSMatthias Ringwald     }
829969a5bbaSMatthias Ringwald 
83068591e36SMatthias Ringwald     if (request_hci_connection == NULL) return;
8313f9b77dbSMatthias Ringwald 
8323f9b77dbSMatthias Ringwald     att_server_t * att_server = &request_hci_connection->att_server;
8333f9b77dbSMatthias Ringwald     att_connection_t * att_connection = &request_hci_connection->att_connection;
8343f9b77dbSMatthias Ringwald     att_server_request_can_send_now(att_server, att_connection);
835969a5bbaSMatthias Ringwald }
836969a5bbaSMatthias Ringwald 
83726b42dcfSMatthias Ringwald static void att_server_handle_att_pdu(att_server_t * att_server, att_connection_t * att_connection, uint8_t * packet, uint16_t size){
83818707219SMatthias Ringwald 
839838bd521SMatthias Ringwald     uint8_t opcode  = packet[0u];
84038b893aaSMilanka Ringwald     uint8_t method  = opcode & 0x03fu;
841ed68ae9dSMilanka Ringwald     bool invalid = method > ATT_MULTIPLE_HANDLE_VALUE_NTF;
84238b893aaSMilanka Ringwald     bool command = (opcode & 0x40u) != 0u;
843838bd521SMatthias Ringwald 
844838bd521SMatthias Ringwald     // ignore invalid commands
845838bd521SMatthias Ringwald     if (invalid && command){
846838bd521SMatthias Ringwald         return;
847838bd521SMatthias Ringwald     }
848838bd521SMatthias Ringwald 
8493deb3ec6SMatthias Ringwald     // handle value indication confirms
85038b893aaSMilanka Ringwald     if ((opcode == ATT_HANDLE_VALUE_CONFIRMATION) && (att_server->value_indication_handle != 0u)){
85118707219SMatthias Ringwald         btstack_run_loop_remove_timer(&att_server->value_indication_timer);
85218707219SMatthias Ringwald         uint16_t att_handle = att_server->value_indication_handle;
85338b893aaSMilanka Ringwald         att_server->value_indication_handle = 0u;
85438b893aaSMilanka Ringwald         att_handle_value_indication_notify_client(0u, att_connection->con_handle, att_handle);
8553f9b77dbSMatthias Ringwald         att_server_request_can_send_now(att_server, att_connection);
8563deb3ec6SMatthias Ringwald         return;
8573deb3ec6SMatthias Ringwald     }
8583deb3ec6SMatthias Ringwald 
8596428eb5aSMatthias Ringwald     // directly process command
8606428eb5aSMatthias Ringwald     // note: signed write cannot be handled directly as authentication needs to be verified
861838bd521SMatthias Ringwald     if (opcode == ATT_WRITE_COMMAND){
862b6df12b6SMatthias Ringwald         att_handle_request(att_connection, packet, size, NULL);
8636428eb5aSMatthias Ringwald         return;
8646428eb5aSMatthias Ringwald     }
8656428eb5aSMatthias Ringwald 
8663deb3ec6SMatthias Ringwald     // check size
86718707219SMatthias Ringwald     if (size > sizeof(att_server->request_buffer)) {
868e0463bdcSMatthias Ringwald         log_info("drop att pdu 0x%02x as size %u > att_server->request_buffer %u", packet[0], size, (int) sizeof(att_server->request_buffer));
8696428eb5aSMatthias Ringwald         return;
8706428eb5aSMatthias Ringwald     }
8713deb3ec6SMatthias Ringwald 
872e0463bdcSMatthias Ringwald #ifdef ENABLE_LE_SIGNED_WRITE
873e0463bdcSMatthias Ringwald     // abort signed write validation if a new request comes in (but finish previous signed write if possible)
874e0463bdcSMatthias Ringwald     if (att_server->state == ATT_SERVER_W4_SIGNED_WRITE_VALIDATION){
875e0463bdcSMatthias Ringwald         if (packet[0] == ATT_SIGNED_WRITE_COMMAND){
876e0463bdcSMatthias Ringwald             log_info("skip new signed write request as previous is in validation");
877e0463bdcSMatthias Ringwald             return;
878e0463bdcSMatthias Ringwald         } else {
879e0463bdcSMatthias Ringwald             log_info("abort signed write validation to process new request");
880e0463bdcSMatthias Ringwald             att_server->state = ATT_SERVER_IDLE;
881e0463bdcSMatthias Ringwald         }
882e0463bdcSMatthias Ringwald     }
883e0463bdcSMatthias Ringwald #endif
8843deb3ec6SMatthias Ringwald     // last request still in processing?
88518707219SMatthias Ringwald     if (att_server->state != ATT_SERVER_IDLE){
886e0463bdcSMatthias Ringwald         log_info("skip att pdu 0x%02x as server not idle (state %u)", packet[0], att_server->state);
8876428eb5aSMatthias Ringwald         return;
8886428eb5aSMatthias Ringwald     }
8893deb3ec6SMatthias Ringwald 
8903deb3ec6SMatthias Ringwald     // store request
89118707219SMatthias Ringwald     att_server->state = ATT_SERVER_REQUEST_RECEIVED;
89218707219SMatthias Ringwald     att_server->request_size = size;
8936535961aSMatthias Ringwald     (void)memcpy(att_server->request_buffer, packet, size);
8943deb3ec6SMatthias Ringwald 
895cd45e970SMatthias Ringwald     att_run_for_context(att_server, att_connection);
89641772f37SMatthias Ringwald }
89741772f37SMatthias Ringwald 
89852e211deSMatthias Ringwald static void att_server_dispatch_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
89968591e36SMatthias Ringwald     hci_connection_t * hci_connection;
900b6df12b6SMatthias Ringwald     att_connection_t * att_connection;
90126b42dcfSMatthias Ringwald     att_server_t     * att_server;
90252e211deSMatthias Ringwald #ifdef ENABLE_GATT_OVER_CLASSIC
90352e211deSMatthias Ringwald     hci_con_handle_t con_handle;
90452e211deSMatthias Ringwald     bd_addr_t        address;
90552e211deSMatthias Ringwald     btstack_linked_list_iterator_t it;
90652e211deSMatthias Ringwald #endif
90741772f37SMatthias Ringwald 
90841772f37SMatthias Ringwald     switch (packet_type){
90941772f37SMatthias Ringwald         case HCI_EVENT_PACKET:
91041772f37SMatthias Ringwald             switch (packet[0]){
91152e211deSMatthias Ringwald #ifdef ENABLE_GATT_OVER_CLASSIC
91252e211deSMatthias Ringwald                 case L2CAP_EVENT_CHANNEL_OPENED:
91352e211deSMatthias Ringwald                     con_handle = l2cap_event_channel_opened_get_handle(packet);
91452e211deSMatthias Ringwald                     hci_connection = hci_connection_for_handle(con_handle);
91552e211deSMatthias Ringwald                     if (!hci_connection) break;
91652e211deSMatthias Ringwald                     att_server = &hci_connection->att_server;
91752e211deSMatthias Ringwald                     // store connection info
91852e211deSMatthias Ringwald                     att_server->bearer_type = ATT_BEARER_UNENHANCED_CLASSIC;
91952e211deSMatthias Ringwald                     att_server->peer_addr_type = BD_ADDR_TYPE_ACL;
92052e211deSMatthias Ringwald                     l2cap_event_channel_opened_get_address(packet, att_server->peer_address);
92152e211deSMatthias Ringwald                     att_connection = &hci_connection->att_connection;
92252e211deSMatthias Ringwald                     att_connection->con_handle = con_handle;
92352e211deSMatthias Ringwald                     // reset connection properties
92452e211deSMatthias Ringwald                     att_server->state = ATT_SERVER_IDLE;
92552e211deSMatthias Ringwald                     att_connection->mtu = l2cap_event_channel_opened_get_remote_mtu(packet);
92652e211deSMatthias Ringwald                     att_connection->max_mtu = l2cap_max_mtu();
92752e211deSMatthias Ringwald                     if (att_connection->max_mtu > ATT_REQUEST_BUFFER_SIZE){
92852e211deSMatthias Ringwald                         att_connection->max_mtu = ATT_REQUEST_BUFFER_SIZE;
92952e211deSMatthias Ringwald                     }
93052e211deSMatthias Ringwald 
93152e211deSMatthias Ringwald                     log_info("Connection opened %s, l2cap cid %04x, mtu %u", bd_addr_to_str(address), att_server->l2cap_cid, att_connection->mtu);
93252e211deSMatthias Ringwald 
93352e211deSMatthias Ringwald                     // update security params
93452e211deSMatthias Ringwald                     att_connection->encryption_key_size = gap_encryption_key_size(con_handle);
93552e211deSMatthias Ringwald                     att_connection->authenticated = gap_authenticated(con_handle);
93652e211deSMatthias Ringwald                     att_connection->secure_connection = gap_secure_connection(con_handle);
93752e211deSMatthias Ringwald                     log_info("encrypted key size %u, authenticated %u, secure connection %u",
93852e211deSMatthias Ringwald                              att_connection->encryption_key_size, att_connection->authenticated, att_connection->secure_connection);
93952e211deSMatthias Ringwald 
94052e211deSMatthias Ringwald                     // notify connection opened
94152e211deSMatthias Ringwald                     att_emit_connected_event(att_server, att_connection);
94252e211deSMatthias Ringwald 
94352e211deSMatthias Ringwald                     // restore persisten ccc if encrypted
94452e211deSMatthias Ringwald                     if ( gap_security_level(con_handle) >= LEVEL_2){
94552e211deSMatthias Ringwald                         att_server_persistent_ccc_restore(att_server, att_connection);
94652e211deSMatthias Ringwald                     }
94752e211deSMatthias Ringwald                     // TODO: what to do about le device db?
94852e211deSMatthias Ringwald                     att_server->pairing_active = 0;
94952e211deSMatthias Ringwald                     break;
95052e211deSMatthias Ringwald #endif
95141772f37SMatthias Ringwald                 case L2CAP_EVENT_CAN_SEND_NOW:
95241772f37SMatthias Ringwald                     att_server_handle_can_send_now();
95341772f37SMatthias Ringwald                     break;
95441772f37SMatthias Ringwald                 case ATT_EVENT_MTU_EXCHANGE_COMPLETE:
95541772f37SMatthias Ringwald                     // GATT client has negotiated the mtu for this connection
95652e211deSMatthias Ringwald                     hci_connection = hci_connection_for_handle(channel);
95768591e36SMatthias Ringwald                     if (!hci_connection) break;
958388fa7c4SMatthias Ringwald                     att_connection = &hci_connection->att_connection;
959b6df12b6SMatthias Ringwald                     att_connection->mtu = little_endian_read_16(packet, 4);
96041772f37SMatthias Ringwald                     break;
96141772f37SMatthias Ringwald                 default:
96241772f37SMatthias Ringwald                     break;
96341772f37SMatthias Ringwald             }
96441772f37SMatthias Ringwald             break;
96541772f37SMatthias Ringwald 
96641772f37SMatthias Ringwald         case ATT_DATA_PACKET:
96752e211deSMatthias Ringwald             log_debug("ATT Packet, handle 0x%04x", channel);
96852e211deSMatthias Ringwald             hci_connection = hci_connection_for_handle(channel);
96968591e36SMatthias Ringwald             if (!hci_connection) break;
97041772f37SMatthias Ringwald 
97126b42dcfSMatthias Ringwald             att_server = &hci_connection->att_server;
97226b42dcfSMatthias Ringwald             att_connection = &hci_connection->att_connection;
97326b42dcfSMatthias Ringwald             att_server_handle_att_pdu(att_server, att_connection, packet, size);
974372d62c4SMatthias Ringwald             break;
9757bbeb3adSMilanka Ringwald 
97652e211deSMatthias Ringwald #ifdef ENABLE_GATT_OVER_CLASSIC
97752e211deSMatthias Ringwald         case L2CAP_DATA_PACKET:
97852e211deSMatthias Ringwald             hci_connections_get_iterator(&it);
97952e211deSMatthias Ringwald             while(btstack_linked_list_iterator_has_next(&it)){
98052e211deSMatthias Ringwald                 hci_connection = (hci_connection_t *) btstack_linked_list_iterator_next(&it);
98152e211deSMatthias Ringwald                 att_server = &hci_connection->att_server;
98252e211deSMatthias Ringwald                 att_connection = &hci_connection->att_connection;
98352e211deSMatthias Ringwald                 if (att_server->l2cap_cid == channel) {
98452e211deSMatthias Ringwald                     att_server_handle_att_pdu(att_server, att_connection, packet, size);
98552e211deSMatthias Ringwald                     break;
98652e211deSMatthias Ringwald                 }
98752e211deSMatthias Ringwald             }
98852e211deSMatthias Ringwald             break;
98952e211deSMatthias Ringwald #endif
99052e211deSMatthias Ringwald 
9917bbeb3adSMilanka Ringwald         default:
9927bbeb3adSMilanka Ringwald             break;
993372d62c4SMatthias Ringwald     }
9943deb3ec6SMatthias Ringwald }
9953deb3ec6SMatthias Ringwald 
996bf78aac6SMatthias Ringwald // ---------------------
997bf78aac6SMatthias Ringwald // persistent CCC writes
998bf78aac6SMatthias Ringwald static uint32_t att_server_persistent_ccc_tag_for_index(uint8_t index){
9994ea43905SMatthias Ringwald     return ('B' << 24u) | ('T' << 16u) | ('C' << 8u) | index;
1000bf78aac6SMatthias Ringwald }
1001bf78aac6SMatthias Ringwald 
1002bf78aac6SMatthias Ringwald static void att_server_persistent_ccc_write(hci_con_handle_t con_handle, uint16_t att_handle, uint16_t value){
1003bf78aac6SMatthias Ringwald     // lookup att_server instance
100468591e36SMatthias Ringwald     hci_connection_t * hci_connection = hci_connection_for_handle(con_handle);
100568591e36SMatthias Ringwald     if (!hci_connection) return;
100668591e36SMatthias Ringwald     att_server_t * att_server = &hci_connection->att_server;
1007bf78aac6SMatthias Ringwald     int le_device_index = att_server->ir_le_device_db_index;
1008bf78aac6SMatthias Ringwald     log_info("Store CCC value 0x%04x for handle 0x%04x of remote %s, le device id %d", value, att_handle, bd_addr_to_str(att_server->peer_address), le_device_index);
10096a540790SMatthias Ringwald 
1010bf78aac6SMatthias Ringwald     // check if bonded
1011bf78aac6SMatthias Ringwald     if (le_device_index < 0) return;
10126a540790SMatthias Ringwald 
1013bf78aac6SMatthias Ringwald     // get btstack_tlv
1014bf78aac6SMatthias Ringwald     const btstack_tlv_t * tlv_impl = NULL;
1015bf78aac6SMatthias Ringwald     void * tlv_context;
1016bf78aac6SMatthias Ringwald     btstack_tlv_get_instance(&tlv_impl, &tlv_context);
1017bf78aac6SMatthias Ringwald     if (!tlv_impl) return;
10186a540790SMatthias Ringwald 
1019bf78aac6SMatthias Ringwald     // update ccc tag
1020bf78aac6SMatthias Ringwald     int index;
10216a540790SMatthias Ringwald     uint32_t highest_seq_nr = 0;
10226a540790SMatthias Ringwald     uint32_t lowest_seq_nr = 0;
10236a540790SMatthias Ringwald     uint32_t tag_for_lowest_seq_nr = 0;
10246a540790SMatthias Ringwald     uint32_t tag_for_empty = 0;
10256a540790SMatthias Ringwald     persistent_ccc_entry_t entry;
10266afb9acaSMatthias Ringwald     for (index=0; index<NVN_NUM_GATT_SERVER_CCC; index++){
1027bf78aac6SMatthias Ringwald         uint32_t tag = att_server_persistent_ccc_tag_for_index(index);
10286a540790SMatthias Ringwald         int len = tlv_impl->get_tag(tlv_context, tag, (uint8_t *) &entry, sizeof(persistent_ccc_entry_t));
10296a540790SMatthias Ringwald 
10306a540790SMatthias Ringwald         // empty/invalid tag
10316a540790SMatthias Ringwald         if (len != sizeof(persistent_ccc_entry_t)){
10326a540790SMatthias Ringwald             tag_for_empty = tag;
1033bf78aac6SMatthias Ringwald             continue;
1034bf78aac6SMatthias Ringwald         }
10356a540790SMatthias Ringwald         // update highest seq nr
10366a540790SMatthias Ringwald         if (entry.seq_nr > highest_seq_nr){
10376a540790SMatthias Ringwald             highest_seq_nr = entry.seq_nr;
10386a540790SMatthias Ringwald         }
10396a540790SMatthias Ringwald         // find entry with lowest seq nr
10404ea43905SMatthias Ringwald         if ((tag_for_lowest_seq_nr == 0u) || (entry.seq_nr < lowest_seq_nr)){
10416a540790SMatthias Ringwald             tag_for_lowest_seq_nr = tag;
10426a540790SMatthias Ringwald             lowest_seq_nr = entry.seq_nr;
10436a540790SMatthias Ringwald         }
10446a540790SMatthias Ringwald 
10456a540790SMatthias Ringwald         if (entry.device_index != le_device_index) continue;
10466a540790SMatthias Ringwald         if (entry.att_handle   != att_handle)      continue;
10476a540790SMatthias Ringwald 
10486a540790SMatthias Ringwald         // found matching entry
10499305033eSMatthias Ringwald         if (value != 0){
1050bf78aac6SMatthias Ringwald             // update
10516a540790SMatthias Ringwald             if (entry.value == value) {
1052760ad805SMatthias Ringwald                 log_info("CCC Index %u: Up-to-date", index);
1053760ad805SMatthias Ringwald                 return;
1054760ad805SMatthias Ringwald             }
1055348fc806SMatthias Ringwald             entry.value = (uint8_t) value;
10564ea43905SMatthias Ringwald             entry.seq_nr = highest_seq_nr + 1u;
1057760ad805SMatthias Ringwald             log_info("CCC Index %u: Store", index);
10580fe46bc1SMatthias Ringwald             int result = tlv_impl->store_tag(tlv_context, tag, (const uint8_t *) &entry, sizeof(persistent_ccc_entry_t));
10590fe46bc1SMatthias Ringwald             if (result != 0){
10600fe46bc1SMatthias Ringwald                 log_error("Store tag index %u failed", index);
10610fe46bc1SMatthias Ringwald             }
106201ac2008SMatthias Ringwald         } else {
106301ac2008SMatthias Ringwald             // delete
1064760ad805SMatthias Ringwald             log_info("CCC Index %u: Delete", index);
106501ac2008SMatthias Ringwald             tlv_impl->delete_tag(tlv_context, tag);
106601ac2008SMatthias Ringwald         }
1067bf78aac6SMatthias Ringwald         return;
1068bf78aac6SMatthias Ringwald     }
10696a540790SMatthias Ringwald 
10700fe46bc1SMatthias Ringwald     log_info("tag_for_empty %"PRIx32", tag_for_lowest_seq_nr %"PRIx32, tag_for_empty, tag_for_lowest_seq_nr);
10716a540790SMatthias Ringwald 
10724ea43905SMatthias Ringwald     if (value == 0u){
10736a540790SMatthias Ringwald         // done
10746a540790SMatthias Ringwald         return;
10756a540790SMatthias Ringwald     }
10766a540790SMatthias Ringwald 
107738b893aaSMilanka Ringwald     uint32_t tag_to_use = 0u;
107838b893aaSMilanka Ringwald     if (tag_for_empty != 0u){
10796a540790SMatthias Ringwald         tag_to_use = tag_for_empty;
10806a540790SMatthias Ringwald     } else if (tag_for_lowest_seq_nr){
10816a540790SMatthias Ringwald         tag_to_use = tag_for_lowest_seq_nr;
10826a540790SMatthias Ringwald     } else {
10836a540790SMatthias Ringwald         // should not happen
10846a540790SMatthias Ringwald         return;
10856a540790SMatthias Ringwald     }
1086bf78aac6SMatthias Ringwald     // store ccc tag
10874ea43905SMatthias Ringwald     entry.seq_nr       = highest_seq_nr + 1u;
10886a540790SMatthias Ringwald     entry.device_index = le_device_index;
10896a540790SMatthias Ringwald     entry.att_handle   = att_handle;
1090348fc806SMatthias Ringwald     entry.value        = (uint8_t) value;
10910fe46bc1SMatthias Ringwald     int result = tlv_impl->store_tag(tlv_context, tag_to_use, (uint8_t *) &entry, sizeof(persistent_ccc_entry_t));
10920fe46bc1SMatthias Ringwald     if (result != 0){
10930fe46bc1SMatthias Ringwald         log_error("Store tag index %u failed", index);
10940fe46bc1SMatthias Ringwald     }
1095bf78aac6SMatthias Ringwald }
1096bf78aac6SMatthias Ringwald 
1097fe3d0cbaSMatthias Ringwald static void att_server_persistent_ccc_clear(att_server_t * att_server){
1098760ad805SMatthias Ringwald     int le_device_index = att_server->ir_le_device_db_index;
1099760ad805SMatthias Ringwald     log_info("Clear CCC values of remote %s, le device id %d", bd_addr_to_str(att_server->peer_address), le_device_index);
1100760ad805SMatthias Ringwald     // check if bonded
1101760ad805SMatthias Ringwald     if (le_device_index < 0) return;
1102760ad805SMatthias Ringwald     // get btstack_tlv
1103760ad805SMatthias Ringwald     const btstack_tlv_t * tlv_impl = NULL;
1104760ad805SMatthias Ringwald     void * tlv_context;
1105760ad805SMatthias Ringwald     btstack_tlv_get_instance(&tlv_impl, &tlv_context);
1106760ad805SMatthias Ringwald     if (!tlv_impl) return;
1107760ad805SMatthias Ringwald     // get all ccc tag
1108760ad805SMatthias Ringwald     int index;
11096a540790SMatthias Ringwald     persistent_ccc_entry_t entry;
11106afb9acaSMatthias Ringwald     for (index=0;index<NVN_NUM_GATT_SERVER_CCC;index++){
1111760ad805SMatthias Ringwald         uint32_t tag = att_server_persistent_ccc_tag_for_index(index);
11126a540790SMatthias Ringwald         int len = tlv_impl->get_tag(tlv_context, tag, (uint8_t *) &entry, sizeof(persistent_ccc_entry_t));
11136a540790SMatthias Ringwald         if (len != sizeof(persistent_ccc_entry_t)) continue;
11146a540790SMatthias Ringwald         if (entry.device_index != le_device_index) continue;
1115760ad805SMatthias Ringwald         // delete entry
1116760ad805SMatthias Ringwald         log_info("CCC Index %u: Delete", index);
1117760ad805SMatthias Ringwald         tlv_impl->delete_tag(tlv_context, tag);
1118760ad805SMatthias Ringwald     }
1119760ad805SMatthias Ringwald }
1120760ad805SMatthias Ringwald 
11219a1f55eaSMatthias Ringwald static void att_server_persistent_ccc_restore(att_server_t * att_server, att_connection_t * att_connection){
112201ac2008SMatthias Ringwald     int le_device_index = att_server->ir_le_device_db_index;
112301ac2008SMatthias Ringwald     log_info("Restore CCC values of remote %s, le device id %d", bd_addr_to_str(att_server->peer_address), le_device_index);
11241b7acd0dSMatthias Ringwald     // check if bonded
11251b7acd0dSMatthias Ringwald     if (le_device_index < 0) return;
112601ac2008SMatthias Ringwald     // get btstack_tlv
112701ac2008SMatthias Ringwald     const btstack_tlv_t * tlv_impl = NULL;
112801ac2008SMatthias Ringwald     void * tlv_context;
112901ac2008SMatthias Ringwald     btstack_tlv_get_instance(&tlv_impl, &tlv_context);
113001ac2008SMatthias Ringwald     if (!tlv_impl) return;
113101ac2008SMatthias Ringwald     // get all ccc tag
113201ac2008SMatthias Ringwald     int index;
11336a540790SMatthias Ringwald     persistent_ccc_entry_t entry;
11346afb9acaSMatthias Ringwald     for (index=0;index<NVN_NUM_GATT_SERVER_CCC;index++){
113501ac2008SMatthias Ringwald         uint32_t tag = att_server_persistent_ccc_tag_for_index(index);
11366a540790SMatthias Ringwald         int len = tlv_impl->get_tag(tlv_context, tag, (uint8_t *) &entry, sizeof(persistent_ccc_entry_t));
11376a540790SMatthias Ringwald         if (len != sizeof(persistent_ccc_entry_t)) continue;
11386a540790SMatthias Ringwald         if (entry.device_index != le_device_index) continue;
113901ac2008SMatthias Ringwald         // simulate write callback
11406a540790SMatthias Ringwald         uint16_t attribute_handle = entry.att_handle;
114101ac2008SMatthias Ringwald         uint8_t  value[2];
11426a540790SMatthias Ringwald         little_endian_store_16(value, 0, entry.value);
114301ac2008SMatthias Ringwald         att_write_callback_t callback = att_server_write_callback_for_handle(attribute_handle);
114401ac2008SMatthias Ringwald         if (!callback) continue;
11456a540790SMatthias Ringwald         log_info("CCC Index %u: Set Attribute handle 0x%04x to value 0x%04x", index, attribute_handle, entry.value );
1146b6df12b6SMatthias Ringwald         (*callback)(att_connection->con_handle, attribute_handle, ATT_TRANSACTION_MODE_NONE, 0, value, sizeof(value));
114701ac2008SMatthias Ringwald     }
114801ac2008SMatthias Ringwald }
114901ac2008SMatthias Ringwald 
1150bf78aac6SMatthias Ringwald // persistent CCC writes
1151bf78aac6SMatthias Ringwald // ---------------------
11523d71c7a4SMatthias Ringwald 
11533d71c7a4SMatthias Ringwald // gatt service management
11543d71c7a4SMatthias Ringwald static att_service_handler_t * att_service_handler_for_handle(uint16_t handle){
11553d71c7a4SMatthias Ringwald     btstack_linked_list_iterator_t it;
11563d71c7a4SMatthias Ringwald     btstack_linked_list_iterator_init(&it, &service_handlers);
11573d71c7a4SMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
11583d71c7a4SMatthias Ringwald         att_service_handler_t * handler = (att_service_handler_t*) btstack_linked_list_iterator_next(&it);
11593d71c7a4SMatthias Ringwald         if (handler->start_handle > handle) continue;
11603d71c7a4SMatthias Ringwald         if (handler->end_handle   < handle) continue;
11613d71c7a4SMatthias Ringwald         return handler;
11623d71c7a4SMatthias Ringwald     }
11633d71c7a4SMatthias Ringwald     return NULL;
11643d71c7a4SMatthias Ringwald }
11653d71c7a4SMatthias Ringwald static att_read_callback_t att_server_read_callback_for_handle(uint16_t handle){
11663d71c7a4SMatthias Ringwald     att_service_handler_t * handler = att_service_handler_for_handle(handle);
11679305033eSMatthias Ringwald     if (handler != NULL) return handler->read_callback;
11683d71c7a4SMatthias Ringwald     return att_server_client_read_callback;
11693d71c7a4SMatthias Ringwald }
11703d71c7a4SMatthias Ringwald 
11713d71c7a4SMatthias Ringwald static att_write_callback_t att_server_write_callback_for_handle(uint16_t handle){
11723d71c7a4SMatthias Ringwald     att_service_handler_t * handler = att_service_handler_for_handle(handle);
11739305033eSMatthias Ringwald     if (handler != NULL) return handler->write_callback;
11743d71c7a4SMatthias Ringwald     return att_server_client_write_callback;
11753d71c7a4SMatthias Ringwald }
11763d71c7a4SMatthias Ringwald 
11775d07396bSMatthias Ringwald static btstack_packet_handler_t att_server_packet_handler_for_handle(uint16_t handle){
11785d07396bSMatthias Ringwald     att_service_handler_t * handler = att_service_handler_for_handle(handle);
11799305033eSMatthias Ringwald     if (handler != NULL) return handler->packet_handler;
11805d07396bSMatthias Ringwald     return att_client_packet_handler;
11815d07396bSMatthias Ringwald }
11825d07396bSMatthias Ringwald 
11833d71c7a4SMatthias Ringwald static void att_notify_write_callbacks(hci_con_handle_t con_handle, uint16_t transaction_mode){
11843d71c7a4SMatthias Ringwald     // notify all callbacks
11853d71c7a4SMatthias Ringwald     btstack_linked_list_iterator_t it;
11863d71c7a4SMatthias Ringwald     btstack_linked_list_iterator_init(&it, &service_handlers);
11873d71c7a4SMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
11883d71c7a4SMatthias Ringwald         att_service_handler_t * handler = (att_service_handler_t*) btstack_linked_list_iterator_next(&it);
11893d71c7a4SMatthias Ringwald         if (!handler->write_callback) continue;
11903d71c7a4SMatthias Ringwald         (*handler->write_callback)(con_handle, 0, transaction_mode, 0, NULL, 0);
11913d71c7a4SMatthias Ringwald     }
11923d71c7a4SMatthias Ringwald     if (!att_server_client_write_callback) return;
11933d71c7a4SMatthias Ringwald     (*att_server_client_write_callback)(con_handle, 0, transaction_mode, 0, NULL, 0);
11943d71c7a4SMatthias Ringwald }
11953d71c7a4SMatthias Ringwald 
11963d71c7a4SMatthias Ringwald // returns first reported error or 0
11973d71c7a4SMatthias Ringwald static uint8_t att_validate_prepared_write(hci_con_handle_t con_handle){
11983d71c7a4SMatthias Ringwald     btstack_linked_list_iterator_t it;
11993d71c7a4SMatthias Ringwald     btstack_linked_list_iterator_init(&it, &service_handlers);
12003d71c7a4SMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
12013d71c7a4SMatthias Ringwald         att_service_handler_t * handler = (att_service_handler_t*) btstack_linked_list_iterator_next(&it);
12023d71c7a4SMatthias Ringwald         if (!handler->write_callback) continue;
12033d71c7a4SMatthias Ringwald         uint8_t error_code = (*handler->write_callback)(con_handle, 0, ATT_TRANSACTION_MODE_VALIDATE, 0, NULL, 0);
120438b893aaSMilanka Ringwald         if (error_code != 0u) return error_code;
12053d71c7a4SMatthias Ringwald     }
12063d71c7a4SMatthias Ringwald     if (!att_server_client_write_callback) return 0;
12073d71c7a4SMatthias Ringwald     return (*att_server_client_write_callback)(con_handle, 0, ATT_TRANSACTION_MODE_VALIDATE, 0, NULL, 0);
12083d71c7a4SMatthias Ringwald }
12093d71c7a4SMatthias Ringwald 
12103d71c7a4SMatthias Ringwald static uint16_t att_server_read_callback(hci_con_handle_t con_handle, uint16_t attribute_handle, uint16_t offset, uint8_t * buffer, uint16_t buffer_size){
12113d71c7a4SMatthias Ringwald     att_read_callback_t callback = att_server_read_callback_for_handle(attribute_handle);
121201ac2008SMatthias Ringwald     if (!callback) return 0;
12133d71c7a4SMatthias Ringwald     return (*callback)(con_handle, attribute_handle, offset, buffer, buffer_size);
12143d71c7a4SMatthias Ringwald }
12153d71c7a4SMatthias Ringwald 
12163d71c7a4SMatthias Ringwald static int att_server_write_callback(hci_con_handle_t con_handle, uint16_t attribute_handle, uint16_t transaction_mode, uint16_t offset, uint8_t *buffer, uint16_t buffer_size){
12173d71c7a4SMatthias Ringwald     switch (transaction_mode){
12183d71c7a4SMatthias Ringwald         case ATT_TRANSACTION_MODE_VALIDATE:
12193d71c7a4SMatthias Ringwald             return att_validate_prepared_write(con_handle);
12203d71c7a4SMatthias Ringwald         case ATT_TRANSACTION_MODE_EXECUTE:
12213d71c7a4SMatthias Ringwald         case ATT_TRANSACTION_MODE_CANCEL:
12223d71c7a4SMatthias Ringwald             att_notify_write_callbacks(con_handle, transaction_mode);
12233d71c7a4SMatthias Ringwald             return 0;
12243d71c7a4SMatthias Ringwald         default:
12253d71c7a4SMatthias Ringwald             break;
12263d71c7a4SMatthias Ringwald     }
12273d71c7a4SMatthias Ringwald 
1228bf78aac6SMatthias Ringwald     // track CCC writes
12294ea43905SMatthias Ringwald     if (att_is_persistent_ccc(attribute_handle) && (offset == 0u) && (buffer_size == 2u)){
1230bf78aac6SMatthias Ringwald         att_server_persistent_ccc_write(con_handle, attribute_handle, little_endian_read_16(buffer, 0));
1231bf78aac6SMatthias Ringwald     }
1232bf78aac6SMatthias Ringwald 
123301ac2008SMatthias Ringwald     att_write_callback_t callback = att_server_write_callback_for_handle(attribute_handle);
123401ac2008SMatthias Ringwald     if (!callback) return 0;
12353d71c7a4SMatthias Ringwald     return (*callback)(con_handle, attribute_handle, transaction_mode, offset, buffer, buffer_size);
12363d71c7a4SMatthias Ringwald }
12373d71c7a4SMatthias Ringwald 
12383d71c7a4SMatthias Ringwald /**
12393d71c7a4SMatthias Ringwald  * @brief register read/write callbacks for specific handle range
12403d71c7a4SMatthias Ringwald  * @param att_service_handler_t
12413d71c7a4SMatthias Ringwald  */
12423d71c7a4SMatthias Ringwald void att_server_register_service_handler(att_service_handler_t * handler){
1243ec8f5414SMilanka Ringwald     bool att_server_registered = false;
1244ec8f5414SMilanka Ringwald     if (att_service_handler_for_handle(handler->start_handle)){
1245ec8f5414SMilanka Ringwald         att_server_registered = true;
1246ec8f5414SMilanka Ringwald     }
1247ec8f5414SMilanka Ringwald 
1248ec8f5414SMilanka Ringwald     if (att_service_handler_for_handle(handler->end_handle)){
1249ec8f5414SMilanka Ringwald         att_server_registered = true;
1250ec8f5414SMilanka Ringwald     }
1251ec8f5414SMilanka Ringwald 
1252ec8f5414SMilanka Ringwald     if (att_server_registered){
12533d71c7a4SMatthias Ringwald         log_error("handler for range 0x%04x-0x%04x already registered", handler->start_handle, handler->end_handle);
12543d71c7a4SMatthias Ringwald         return;
12553d71c7a4SMatthias Ringwald     }
12563d71c7a4SMatthias Ringwald     btstack_linked_list_add(&service_handlers, (btstack_linked_item_t*) handler);
12573d71c7a4SMatthias Ringwald }
12583d71c7a4SMatthias Ringwald 
12593deb3ec6SMatthias Ringwald void att_server_init(uint8_t const * db, att_read_callback_t read_callback, att_write_callback_t write_callback){
12603deb3ec6SMatthias Ringwald 
12613d71c7a4SMatthias Ringwald     // store callbacks
12623d71c7a4SMatthias Ringwald     att_server_client_read_callback  = read_callback;
12633d71c7a4SMatthias Ringwald     att_server_client_write_callback = write_callback;
12643d71c7a4SMatthias Ringwald 
12651a389cdcSMatthias Ringwald     // register for HCI Events
126652e211deSMatthias Ringwald     hci_event_callback_registration.callback = &att_server_event_packet_handler;
12671a389cdcSMatthias Ringwald     hci_add_event_handler(&hci_event_callback_registration);
12681a389cdcSMatthias Ringwald 
1269406722e4SMatthias Ringwald     // register for SM events
127052e211deSMatthias Ringwald     sm_event_callback_registration.callback = &att_server_event_packet_handler;
1271406722e4SMatthias Ringwald     sm_add_event_handler(&sm_event_callback_registration);
12723deb3ec6SMatthias Ringwald 
12731a389cdcSMatthias Ringwald     // and L2CAP ATT Server PDUs
127452e211deSMatthias Ringwald     att_dispatch_register_server(att_server_dispatch_packet_handler);
12753deb3ec6SMatthias Ringwald 
127670dca4d4SMatthias Ringwald #ifdef ENABLE_GATT_OVER_CLASSIC
127770dca4d4SMatthias Ringwald     // setup l2cap service
12786bf42d1fSMatthias Ringwald     att_dispatch_classic_register_service();
127970dca4d4SMatthias Ringwald #endif
128070dca4d4SMatthias Ringwald 
12813deb3ec6SMatthias Ringwald     att_set_db(db);
12823d71c7a4SMatthias Ringwald     att_set_read_callback(att_server_read_callback);
12833d71c7a4SMatthias Ringwald     att_set_write_callback(att_server_write_callback);
12843deb3ec6SMatthias Ringwald }
12853deb3ec6SMatthias Ringwald 
12863deb3ec6SMatthias Ringwald void att_server_register_packet_handler(btstack_packet_handler_t handler){
12873deb3ec6SMatthias Ringwald     att_client_packet_handler = handler;
12883deb3ec6SMatthias Ringwald }
12893deb3ec6SMatthias Ringwald 
1290cbbb12d9SMatthias Ringwald 
1291cbbb12d9SMatthias Ringwald // to be deprecated
1292c141988cSMatthias Ringwald int  att_server_can_send_packet_now(hci_con_handle_t con_handle){
129368591e36SMatthias Ringwald     hci_connection_t * hci_connection = hci_connection_for_handle(con_handle);
129468591e36SMatthias Ringwald     if (!hci_connection) return 0;
129537a8059dSMatthias Ringwald     att_server_t * att_server = &hci_connection->att_server;
129637a8059dSMatthias Ringwald     att_connection_t * att_connection = &hci_connection->att_connection;
129737a8059dSMatthias Ringwald     return att_server_can_send_packet(att_server, att_connection);
12981b96b007SMatthias Ringwald }
12991b96b007SMatthias Ringwald 
13009816429dSMatthias Ringwald uint8_t att_server_register_can_send_now_callback(btstack_context_callback_registration_t * callback_registration, hci_con_handle_t con_handle){
1301cbbb12d9SMatthias Ringwald     return att_server_request_to_send_notification(callback_registration, con_handle);
13023deb3ec6SMatthias Ringwald }
13033deb3ec6SMatthias Ringwald 
1304cbbb12d9SMatthias Ringwald void att_server_request_can_send_now_event(hci_con_handle_t con_handle){
1305cbbb12d9SMatthias Ringwald     att_client_waiting_for_can_send_registration.callback = &att_emit_can_send_now_event;
1306cbbb12d9SMatthias Ringwald     att_server_request_to_send_notification(&att_client_waiting_for_can_send_registration, con_handle);
1307cbbb12d9SMatthias Ringwald }
1308cbbb12d9SMatthias Ringwald // end of deprecated
1309cbbb12d9SMatthias Ringwald 
13109816429dSMatthias Ringwald uint8_t att_server_request_to_send_notification(btstack_context_callback_registration_t * callback_registration, hci_con_handle_t con_handle){
131168591e36SMatthias Ringwald     hci_connection_t * hci_connection = hci_connection_for_handle(con_handle);
131268591e36SMatthias Ringwald     if (!hci_connection) return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
131368591e36SMatthias Ringwald     att_server_t * att_server = &hci_connection->att_server;
13143f9b77dbSMatthias Ringwald     att_connection_t * att_connection = &hci_connection->att_connection;
1315c37df6f6SMatthias Ringwald     bool added = btstack_linked_list_add_tail(&att_server->notification_requests, (btstack_linked_item_t*) callback_registration);
13163f9b77dbSMatthias Ringwald     att_server_request_can_send_now(att_server, att_connection);
1317c37df6f6SMatthias Ringwald     if (added){
1318cbbb12d9SMatthias Ringwald         return ERROR_CODE_SUCCESS;
1319c37df6f6SMatthias Ringwald     } else {
1320c37df6f6SMatthias Ringwald         return ERROR_CODE_COMMAND_DISALLOWED;
1321c37df6f6SMatthias Ringwald     }
1322cbbb12d9SMatthias Ringwald }
1323cbbb12d9SMatthias Ringwald 
13249816429dSMatthias Ringwald uint8_t att_server_request_to_send_indication(btstack_context_callback_registration_t * callback_registration, hci_con_handle_t con_handle){
132568591e36SMatthias Ringwald     hci_connection_t * hci_connection = hci_connection_for_handle(con_handle);
132668591e36SMatthias Ringwald     if (!hci_connection) return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
132768591e36SMatthias Ringwald     att_server_t * att_server = &hci_connection->att_server;
13283f9b77dbSMatthias Ringwald     att_connection_t * att_connection = &hci_connection->att_connection;
1329c37df6f6SMatthias Ringwald     bool added = btstack_linked_list_add_tail(&att_server->indication_requests, (btstack_linked_item_t*) callback_registration);
13303f9b77dbSMatthias Ringwald     att_server_request_can_send_now(att_server, att_connection);
1331c37df6f6SMatthias Ringwald     if (added){
1332969a5bbaSMatthias Ringwald         return ERROR_CODE_SUCCESS;
1333c37df6f6SMatthias Ringwald     } else {
1334c37df6f6SMatthias Ringwald         return ERROR_CODE_COMMAND_DISALLOWED;
1335c37df6f6SMatthias Ringwald     }
1336bb38f057SMatthias Ringwald }
1337bb38f057SMatthias Ringwald 
1338d74c7b2bSMatthias Ringwald static uint8_t att_server_prepare_server_message(hci_con_handle_t con_handle, att_server_t ** out_att_server, att_connection_t ** out_att_connection, uint8_t ** out_packet_buffer){
1339d74c7b2bSMatthias Ringwald 
1340d74c7b2bSMatthias Ringwald     att_server_t *     att_server = NULL;
1341d74c7b2bSMatthias Ringwald     att_connection_t * att_connection = NULL;
1342d74c7b2bSMatthias Ringwald     uint8_t *          packet_buffer = NULL;
1343d74c7b2bSMatthias Ringwald 
1344d74c7b2bSMatthias Ringwald     // prefer enhanced bearer
1345d74c7b2bSMatthias Ringwald #ifdef ENABLE_GATT_OVER_EATT
1346d74c7b2bSMatthias Ringwald     att_server_eatt_bearer_t * eatt_bearer = att_server_eatt_bearer_for_con_handle(con_handle);
1347d74c7b2bSMatthias Ringwald     if (eatt_bearer != NULL){
1348d74c7b2bSMatthias Ringwald         att_server     = &eatt_bearer->att_server;
1349d74c7b2bSMatthias Ringwald         att_connection = &eatt_bearer->att_connection;
1350d74c7b2bSMatthias Ringwald         packet_buffer  = eatt_bearer->send_buffer;
1351d74c7b2bSMatthias Ringwald     } else
1352d74c7b2bSMatthias Ringwald #endif
1353d74c7b2bSMatthias Ringwald     {
1354d74c7b2bSMatthias Ringwald         hci_connection_t *hci_connection = hci_connection_for_handle(con_handle);
1355d74c7b2bSMatthias Ringwald         if (hci_connection != NULL) {
1356d74c7b2bSMatthias Ringwald             att_server     = &hci_connection->att_server;
1357d74c7b2bSMatthias Ringwald             att_connection = &hci_connection->att_connection;
1358d74c7b2bSMatthias Ringwald         }
1359d74c7b2bSMatthias Ringwald     }
1360d74c7b2bSMatthias Ringwald 
1361d74c7b2bSMatthias Ringwald     if (att_server == NULL) return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1362d74c7b2bSMatthias Ringwald     if (!att_server_can_send_packet(att_server, att_connection)) return BTSTACK_ACL_BUFFERS_FULL;
1363d74c7b2bSMatthias Ringwald 
1364d74c7b2bSMatthias Ringwald     if (packet_buffer == NULL){
1365d74c7b2bSMatthias Ringwald         l2cap_reserve_packet_buffer();
1366d74c7b2bSMatthias Ringwald         packet_buffer = l2cap_get_outgoing_buffer();
1367d74c7b2bSMatthias Ringwald     }
1368d74c7b2bSMatthias Ringwald 
1369d74c7b2bSMatthias Ringwald     *out_att_connection = att_connection;
1370d74c7b2bSMatthias Ringwald     *out_att_server = att_server;
1371d74c7b2bSMatthias Ringwald     *out_packet_buffer = packet_buffer;
1372d74c7b2bSMatthias Ringwald     return ERROR_CODE_SUCCESS;
1373d74c7b2bSMatthias Ringwald }
1374d74c7b2bSMatthias Ringwald 
13759816429dSMatthias Ringwald uint8_t att_server_notify(hci_con_handle_t con_handle, uint16_t attribute_handle, const uint8_t *value, uint16_t value_len){
13765683a8e4SMatthias Ringwald     att_server_t * att_server = NULL;
13775683a8e4SMatthias Ringwald     att_connection_t * att_connection = NULL;
13785683a8e4SMatthias Ringwald     uint8_t * packet_buffer = NULL;
137968591e36SMatthias Ringwald 
13805683a8e4SMatthias Ringwald     uint8_t status = att_server_prepare_server_message(con_handle, &att_server, &att_connection, &packet_buffer);
13815683a8e4SMatthias Ringwald     if (status != ERROR_CODE_SUCCESS){
13825683a8e4SMatthias Ringwald         return status;
13835683a8e4SMatthias Ringwald     }
13843deb3ec6SMatthias Ringwald 
1385b6df12b6SMatthias Ringwald     uint16_t size = att_prepare_handle_value_notification(att_connection, attribute_handle, value, value_len, packet_buffer);
1386d415948cSMatthias Ringwald 
13870f70c52eSMatthias Ringwald     return att_server_send_prepared(att_server, att_connection, NULL, size);
13883deb3ec6SMatthias Ringwald }
13893deb3ec6SMatthias Ringwald 
139040f8d8f2SMatthias Ringwald /**
139140f8d8f2SMatthias Ringwald  * @brief notify client about multiple attribute value changes
139240f8d8f2SMatthias Ringwald  * @param con_handle
139340f8d8f2SMatthias Ringwald  * @param num_attributes
139440f8d8f2SMatthias Ringwald  * @param attribute_handles[]
139540f8d8f2SMatthias Ringwald  * @param values_data[]
139640f8d8f2SMatthias Ringwald  * @param values_len[]
139740f8d8f2SMatthias Ringwald  * @return 0 if ok, error otherwise
139840f8d8f2SMatthias Ringwald  */
139940f8d8f2SMatthias Ringwald uint8_t att_server_multiple_notify(hci_con_handle_t con_handle, uint8_t num_attributes,
140040f8d8f2SMatthias Ringwald                                    const uint16_t * attribute_handles, const uint8_t ** values_data, const uint16_t * values_len){
140140f8d8f2SMatthias Ringwald 
140240f8d8f2SMatthias Ringwald     att_server_t * att_server = NULL;
140340f8d8f2SMatthias Ringwald     att_connection_t * att_connection = NULL;
140440f8d8f2SMatthias Ringwald     uint8_t * packet_buffer = NULL;
140540f8d8f2SMatthias Ringwald 
1406d74c7b2bSMatthias Ringwald     uint8_t status = att_server_prepare_server_message(con_handle, &att_server, &att_connection, &packet_buffer);
1407d74c7b2bSMatthias Ringwald     if (status != ERROR_CODE_SUCCESS){
1408d74c7b2bSMatthias Ringwald         return status;
140940f8d8f2SMatthias Ringwald     }
141040f8d8f2SMatthias Ringwald 
141140f8d8f2SMatthias Ringwald     uint16_t size = att_prepare_handle_value_multiple_notification(att_connection, num_attributes, attribute_handles, values_data, values_len, packet_buffer);
141240f8d8f2SMatthias Ringwald 
141340f8d8f2SMatthias Ringwald     return att_server_send_prepared(att_server, att_connection, packet_buffer, size);
141440f8d8f2SMatthias Ringwald }
141540f8d8f2SMatthias Ringwald 
14169816429dSMatthias Ringwald uint8_t att_server_indicate(hci_con_handle_t con_handle, uint16_t attribute_handle, const uint8_t *value, uint16_t value_len){
141718707219SMatthias Ringwald 
14185683a8e4SMatthias Ringwald     att_server_t * att_server = NULL;
14195683a8e4SMatthias Ringwald     att_connection_t * att_connection = NULL;
14205683a8e4SMatthias Ringwald     uint8_t * packet_buffer = NULL;
14215683a8e4SMatthias Ringwald 
14225683a8e4SMatthias Ringwald     uint8_t status = att_server_prepare_server_message(con_handle, &att_server, &att_connection, &packet_buffer);
14235683a8e4SMatthias Ringwald     if (status != ERROR_CODE_SUCCESS){
14245683a8e4SMatthias Ringwald         return status;
14255683a8e4SMatthias Ringwald     }
14265683a8e4SMatthias Ringwald 
14275683a8e4SMatthias Ringwald     if (att_server->value_indication_handle != 0u) {
14285683a8e4SMatthias Ringwald         // free reserved packet buffer
14295683a8e4SMatthias Ringwald         if (att_server->bearer_type == ATT_BEARER_ENHANCED_LE){
14305683a8e4SMatthias Ringwald             l2cap_release_packet_buffer();
14315683a8e4SMatthias Ringwald         }
14325683a8e4SMatthias Ringwald         return ATT_HANDLE_VALUE_INDICATION_IN_PROGRESS;
14335683a8e4SMatthias Ringwald     }
14343deb3ec6SMatthias Ringwald 
14353deb3ec6SMatthias Ringwald     // track indication
143618707219SMatthias Ringwald     att_server->value_indication_handle = attribute_handle;
143718707219SMatthias Ringwald     btstack_run_loop_set_timer_handler(&att_server->value_indication_timer, att_handle_value_indication_timeout);
143818707219SMatthias Ringwald     btstack_run_loop_set_timer(&att_server->value_indication_timer, ATT_TRANSACTION_TIMEOUT_MS);
143918707219SMatthias Ringwald     btstack_run_loop_add_timer(&att_server->value_indication_timer);
14403deb3ec6SMatthias Ringwald 
1441b6df12b6SMatthias Ringwald     uint16_t size = att_prepare_handle_value_indication(att_connection, attribute_handle, value, value_len, packet_buffer);
144223079b39SMatthias Ringwald 
14430f70c52eSMatthias Ringwald     return att_server_send_prepared(att_server, att_connection, NULL, size);
14443deb3ec6SMatthias Ringwald }
14458f9132b5SMilanka Ringwald 
14468f9132b5SMilanka Ringwald uint16_t att_server_get_mtu(hci_con_handle_t con_handle){
144768591e36SMatthias Ringwald     hci_connection_t * hci_connection = hci_connection_for_handle(con_handle);
144868591e36SMatthias Ringwald     if (!hci_connection) return 0;
1449388fa7c4SMatthias Ringwald     att_connection_t * att_connection = &hci_connection->att_connection;
1450b6df12b6SMatthias Ringwald     return att_connection->mtu;
14518f9132b5SMilanka Ringwald }
145235d7f2dfSMilanka Ringwald 
145335d7f2dfSMilanka Ringwald void att_server_deinit(void){
145435d7f2dfSMilanka Ringwald     att_server_client_read_callback  = NULL;
145535d7f2dfSMilanka Ringwald     att_server_client_write_callback = NULL;
145635d7f2dfSMilanka Ringwald     att_client_packet_handler = NULL;
145735d7f2dfSMilanka Ringwald     service_handlers = NULL;
145835d7f2dfSMilanka Ringwald }
145920d4358dSMatthias Ringwald 
146020d4358dSMatthias Ringwald #ifdef ENABLE_GATT_OVER_EATT
14618d3bb68fSMatthias Ringwald 
146227afb094SMatthias Ringwald #define MAX_NR_EATT_CHANNELS 5
146327afb094SMatthias Ringwald 
146420d4358dSMatthias Ringwald static uint16_t att_server_eatt_receive_buffer_size;
14658d3bb68fSMatthias Ringwald static uint16_t att_server_eatt_send_buffer_size;
146620d4358dSMatthias Ringwald 
1467523bb989SMatthias Ringwald static att_server_eatt_bearer_t * att_server_eatt_bearer_for_cid(uint16_t cid){
1468523bb989SMatthias Ringwald     btstack_linked_list_iterator_t it;
1469523bb989SMatthias Ringwald     btstack_linked_list_iterator_init(&it, &att_server_eatt_bearer_active);
1470523bb989SMatthias Ringwald     while(btstack_linked_list_iterator_has_next(&it)){
1471523bb989SMatthias Ringwald         att_server_eatt_bearer_t * eatt_bearer = (att_server_eatt_bearer_t *) btstack_linked_list_iterator_next(&it);
1472f786dd08SMatthias Ringwald         if (eatt_bearer->att_server.l2cap_cid == cid) {
1473523bb989SMatthias Ringwald             return eatt_bearer;
1474523bb989SMatthias Ringwald         }
1475523bb989SMatthias Ringwald     }
1476523bb989SMatthias Ringwald     return NULL;
1477523bb989SMatthias Ringwald }
1478523bb989SMatthias Ringwald 
147940f8d8f2SMatthias Ringwald static att_server_eatt_bearer_t * att_server_eatt_bearer_for_con_handle(hci_con_handle_t con_handle){
148040f8d8f2SMatthias Ringwald     btstack_linked_list_iterator_t it;
148140f8d8f2SMatthias Ringwald     btstack_linked_list_iterator_init(&it, &att_server_eatt_bearer_active);
148240f8d8f2SMatthias Ringwald     while(btstack_linked_list_iterator_has_next(&it)){
148340f8d8f2SMatthias Ringwald         att_server_eatt_bearer_t * eatt_bearer = (att_server_eatt_bearer_t *) btstack_linked_list_iterator_next(&it);
148440f8d8f2SMatthias Ringwald         if (eatt_bearer->att_connection.con_handle == con_handle) {
148540f8d8f2SMatthias Ringwald             return eatt_bearer;
148640f8d8f2SMatthias Ringwald         }
148740f8d8f2SMatthias Ringwald     }
148840f8d8f2SMatthias Ringwald     return NULL;
148940f8d8f2SMatthias Ringwald }
149040f8d8f2SMatthias Ringwald 
149120d4358dSMatthias Ringwald static void att_server_eatt_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
149220d4358dSMatthias Ringwald     uint16_t cid;
149320d4358dSMatthias Ringwald     uint8_t status;
149420d4358dSMatthias Ringwald     uint16_t remote_mtu;
149520d4358dSMatthias Ringwald 
149620d4358dSMatthias Ringwald     uint8_t i;
149720d4358dSMatthias Ringwald     uint8_t num_requested_bearers;
149820d4358dSMatthias Ringwald     uint8_t num_accepted_bearers;
149927afb094SMatthias Ringwald     uint16_t initial_credits = L2CAP_LE_AUTOMATIC_CREDITS;
150027afb094SMatthias Ringwald     uint8_t * receive_buffers[MAX_NR_EATT_CHANNELS];
150127afb094SMatthias Ringwald     uint16_t cids[MAX_NR_EATT_CHANNELS];
150227afb094SMatthias Ringwald     att_server_eatt_bearer_t * eatt_bearers[MAX_NR_EATT_CHANNELS];
1503523bb989SMatthias Ringwald     att_server_eatt_bearer_t * eatt_bearer;
15042954c397SMatthias Ringwald     att_server_t * att_server;
15052954c397SMatthias Ringwald     att_connection_t * att_connection;
1506*9828b48aSMatthias Ringwald     hci_con_handle_t con_handle;
1507*9828b48aSMatthias Ringwald     hci_connection_t * hci_connection;
150820d4358dSMatthias Ringwald 
150920d4358dSMatthias Ringwald     switch (packet_type) {
151020d4358dSMatthias Ringwald 
151120d4358dSMatthias Ringwald         case L2CAP_DATA_PACKET:
1512f786dd08SMatthias Ringwald             eatt_bearer = att_server_eatt_bearer_for_cid(channel);
1513f786dd08SMatthias Ringwald             btstack_assert(eatt_bearer != NULL);
1514f786dd08SMatthias Ringwald             att_server = &eatt_bearer->att_server;
1515f786dd08SMatthias Ringwald             att_connection = &eatt_bearer->att_connection;
1516f786dd08SMatthias Ringwald             att_server_handle_att_pdu(att_server, att_connection, packet, size);
151720d4358dSMatthias Ringwald             break;
151820d4358dSMatthias Ringwald 
151920d4358dSMatthias Ringwald         case HCI_EVENT_PACKET:
152020d4358dSMatthias Ringwald             switch (packet[0]) {
152120d4358dSMatthias Ringwald 
152220d4358dSMatthias Ringwald                 case L2CAP_EVENT_CAN_SEND_NOW:
1523f786dd08SMatthias Ringwald                     cid = l2cap_event_packet_sent_get_local_cid(packet);
1524f786dd08SMatthias Ringwald                     eatt_bearer = att_server_eatt_bearer_for_cid(cid);
1525f786dd08SMatthias Ringwald                     btstack_assert(eatt_bearer != NULL);
1526f786dd08SMatthias Ringwald                     att_server = &eatt_bearer->att_server;
1527f786dd08SMatthias Ringwald                     att_connection = &eatt_bearer->att_connection;
1528f786dd08SMatthias Ringwald                     // only used for EATT request responses
1529f786dd08SMatthias Ringwald                     btstack_assert(att_server->state == ATT_SERVER_REQUEST_RECEIVED_AND_VALIDATED);
1530f786dd08SMatthias Ringwald                     att_server_process_validated_request(att_server, att_connection, eatt_bearer->send_buffer);
153120d4358dSMatthias Ringwald                     break;
153220d4358dSMatthias Ringwald 
153320d4358dSMatthias Ringwald                 case L2CAP_EVENT_PACKET_SENT:
153420d4358dSMatthias Ringwald                     cid = l2cap_event_packet_sent_get_local_cid(packet);
1535be4ca859SMatthias Ringwald                     eatt_bearer = att_server_eatt_bearer_for_cid(cid);
1536f786dd08SMatthias Ringwald                     btstack_assert(eatt_bearer != NULL);
15372954c397SMatthias Ringwald                     att_server = &eatt_bearer->att_server;
15382954c397SMatthias Ringwald                     att_connection = &eatt_bearer->att_connection;
15392954c397SMatthias Ringwald                     att_server_handle_att_pdu(att_server, att_connection, packet, size);
154020d4358dSMatthias Ringwald                     break;
154120d4358dSMatthias Ringwald 
154220d4358dSMatthias Ringwald                 case L2CAP_EVENT_ECBM_INCOMING_CONNECTION:
154320d4358dSMatthias Ringwald                     cid = l2cap_event_ecbm_incoming_connection_get_local_cid(packet);
1544*9828b48aSMatthias Ringwald 
1545*9828b48aSMatthias Ringwald                     // reject if outgoing l2cap connection active, L2CAP/TIM/BV-01-C
1546*9828b48aSMatthias Ringwald                     con_handle = l2cap_event_ecbm_incoming_connection_get_handle(packet);
1547*9828b48aSMatthias Ringwald                     hci_connection = hci_connection_for_handle(con_handle);
1548*9828b48aSMatthias Ringwald                     btstack_assert(hci_connection != NULL);
1549*9828b48aSMatthias Ringwald                     if (hci_connection->att_server.eatt_outgoing_active) {
1550*9828b48aSMatthias Ringwald                         hci_connection->att_server.incoming_connection_request = true;
1551*9828b48aSMatthias Ringwald                         l2cap_ecbm_decline_channels(cid, L2CAP_ECBM_CONNECTION_RESULT_SOME_REFUSED_INSUFFICIENT_RESOURCES_AVAILABLE );
1552*9828b48aSMatthias Ringwald                         log_info("Decline incoming connection from %s", bd_addr_to_str(hci_connection->address));
1553*9828b48aSMatthias Ringwald                     } else {
155420d4358dSMatthias Ringwald                         num_requested_bearers = l2cap_event_ecbm_incoming_connection_get_num_channels(packet);
155520d4358dSMatthias Ringwald                         for (i = 0; i < num_requested_bearers; i++){
1556c2cbe117SMatthias Ringwald                             eatt_bearers[i] = (att_server_eatt_bearer_t *) btstack_linked_list_pop(&att_server_eatt_bearer_pool);
155720d4358dSMatthias Ringwald                             if (eatt_bearers[i] == NULL) {
155820d4358dSMatthias Ringwald                                 break;
155920d4358dSMatthias Ringwald                             }
1560be4ca859SMatthias Ringwald                             eatt_bearers[i]->att_connection.con_handle = l2cap_event_ecbm_incoming_connection_get_handle(packet);
1561f786dd08SMatthias Ringwald                             eatt_bearers[i]->att_server.bearer_type = ATT_BEARER_ENHANCED_LE;
1562735b0222SMatthias Ringwald                             receive_buffers[i] = eatt_bearers[i]->receive_buffer;
15636b236cb0SMatthias Ringwald                             btstack_linked_list_add(&att_server_eatt_bearer_active, (btstack_linked_item_t *) eatt_bearers[i]);
156420d4358dSMatthias Ringwald                         }
156520d4358dSMatthias Ringwald                         num_accepted_bearers = i;
156620d4358dSMatthias Ringwald                         status = l2cap_ecbm_accept_channels(cid, num_accepted_bearers, initial_credits, att_server_eatt_receive_buffer_size, receive_buffers, cids);
156720d4358dSMatthias Ringwald                         btstack_assert(status == ERROR_CODE_SUCCESS);
1568c2cbe117SMatthias Ringwald                         log_info("requested %u, accepted %u", num_requested_bearers, num_accepted_bearers);
15696b236cb0SMatthias Ringwald                         for (i=0;i<num_accepted_bearers;i++){
1570c2cbe117SMatthias Ringwald                             log_info("eatt l2cap cid: 0x%04x", cids[i]);
1571f786dd08SMatthias Ringwald                             eatt_bearers[i]->att_server.l2cap_cid = cids[i];
15726b236cb0SMatthias Ringwald                         }
1573*9828b48aSMatthias Ringwald                     }
157420d4358dSMatthias Ringwald                     break;
157520d4358dSMatthias Ringwald 
157620d4358dSMatthias Ringwald                 case L2CAP_EVENT_ECBM_CHANNEL_OPENED:
157720d4358dSMatthias Ringwald                     cid         = l2cap_event_ecbm_channel_opened_get_local_cid(packet);
1578c2cbe117SMatthias Ringwald                     status      = l2cap_event_ecbm_channel_opened_get_status(packet);
1579c2cbe117SMatthias Ringwald                     remote_mtu  = l2cap_event_ecbm_channel_opened_get_remote_mtu(packet);
1580be4ca859SMatthias Ringwald                     eatt_bearer = att_server_eatt_bearer_for_cid(cid);
1581be4ca859SMatthias Ringwald                     btstack_assert(eatt_bearer != NULL);
1582c2cbe117SMatthias Ringwald                     eatt_bearer->att_connection.mtu_exchanged = true;
1583c2cbe117SMatthias Ringwald                     eatt_bearer->att_connection.mtu = remote_mtu;
1584be4ca859SMatthias Ringwald                     eatt_bearer->att_connection.max_mtu = remote_mtu;
158520d4358dSMatthias Ringwald                     log_info("L2CAP_EVENT_ECBM_CHANNEL_OPENED - cid 0x%04x mtu %u, status 0x%02x", cid, remote_mtu, status);
158620d4358dSMatthias Ringwald                     break;
158720d4358dSMatthias Ringwald 
158820d4358dSMatthias Ringwald                 case L2CAP_EVENT_ECBM_RECONFIGURED:
158920d4358dSMatthias Ringwald                     break;
159020d4358dSMatthias Ringwald 
1591523bb989SMatthias Ringwald                 case L2CAP_EVENT_CHANNEL_CLOSED:
1592523bb989SMatthias Ringwald                     eatt_bearer = att_server_eatt_bearer_for_cid(l2cap_event_channel_closed_get_local_cid(packet));
1593523bb989SMatthias Ringwald                     btstack_assert(eatt_bearers != NULL);
1594523bb989SMatthias Ringwald 
1595523bb989SMatthias Ringwald                     // TODO: finalize - abort queued writes
1596523bb989SMatthias Ringwald 
159727afb094SMatthias Ringwald                     btstack_linked_list_remove(&att_server_eatt_bearer_active, (btstack_linked_item_t  *) eatt_bearer);
1598523bb989SMatthias Ringwald                     btstack_linked_list_add(&att_server_eatt_bearer_pool, (btstack_linked_item_t  *) eatt_bearer);
1599523bb989SMatthias Ringwald                     break;
160020d4358dSMatthias Ringwald                 default:
160120d4358dSMatthias Ringwald                     break;
160220d4358dSMatthias Ringwald             }
160327afb094SMatthias Ringwald             break;
160427afb094SMatthias Ringwald         default:
160527afb094SMatthias Ringwald             btstack_unreachable();
160627afb094SMatthias Ringwald             break;
160720d4358dSMatthias Ringwald     }
160820d4358dSMatthias Ringwald }
160920d4358dSMatthias Ringwald 
161020d4358dSMatthias Ringwald // create eatt bearers
161120d4358dSMatthias Ringwald uint8_t att_server_eatt_init(uint8_t num_eatt_bearers, uint8_t * storage_buffer, uint16_t storage_size){
161220d4358dSMatthias Ringwald     uint16_t size_for_structs = num_eatt_bearers * sizeof(att_server_eatt_bearer_t);
161320d4358dSMatthias Ringwald     if (storage_size < size_for_structs) {
161420d4358dSMatthias Ringwald         return ERROR_CODE_MEMORY_CAPACITY_EXCEEDED;
161520d4358dSMatthias Ringwald     }
161620d4358dSMatthias Ringwald 
161720d4358dSMatthias Ringwald     // TODO: The minimum ATT_MTU for an Enhanced ATT bearer is 64 octets.
161820d4358dSMatthias Ringwald 
161920d4358dSMatthias Ringwald     memset(storage_buffer, 0, storage_size);
16208d3bb68fSMatthias Ringwald     uint16_t buffer_size_per_bearer = ((storage_size - size_for_structs) / num_eatt_bearers);
16218d3bb68fSMatthias Ringwald     att_server_eatt_receive_buffer_size = buffer_size_per_bearer / 2;
16228d3bb68fSMatthias Ringwald     att_server_eatt_send_buffer_size    = buffer_size_per_bearer / 2;
1623735b0222SMatthias Ringwald     uint8_t * bearer_buffer = &storage_buffer[size_for_structs];
162420d4358dSMatthias Ringwald     uint8_t i;
162520d4358dSMatthias Ringwald     att_server_eatt_bearer_t * eatt_bearer = (att_server_eatt_bearer_t *) storage_buffer;
1626be4ca859SMatthias Ringwald     log_info("%u EATT bearers with receive buffer size %u",
1627be4ca859SMatthias Ringwald              num_eatt_bearers, att_server_eatt_receive_buffer_size);
162820d4358dSMatthias Ringwald     for (i=0;i<num_eatt_bearers;i++){
1629be4ca859SMatthias Ringwald         eatt_bearer->att_connection.con_handle = HCI_CON_HANDLE_INVALID;
1630735b0222SMatthias Ringwald         eatt_bearer->receive_buffer = bearer_buffer;
1631735b0222SMatthias Ringwald         bearer_buffer += att_server_eatt_receive_buffer_size;
16328d3bb68fSMatthias Ringwald         eatt_bearer->send_buffer = bearer_buffer;
16338d3bb68fSMatthias Ringwald         bearer_buffer += att_server_eatt_send_buffer_size;
16346b236cb0SMatthias Ringwald         btstack_linked_list_add(&att_server_eatt_bearer_pool, (btstack_linked_item_t *) eatt_bearer);
163520d4358dSMatthias Ringwald         eatt_bearer++;
163620d4358dSMatthias Ringwald     }
163720d4358dSMatthias Ringwald     // TODO: define minimum EATT MTU
1638989c5498SMatthias Ringwald     l2cap_ecbm_register_service(att_server_eatt_handler, BLUETOOTH_PSM_EATT, 64, 0, false);
163920d4358dSMatthias Ringwald 
164020d4358dSMatthias Ringwald     return 0;
164120d4358dSMatthias Ringwald }
164220d4358dSMatthias Ringwald #endif