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