143625864Smatthias.ringwald /* 2a0c35809S[email protected] * Copyright (C) 2014 BlueKitchen GmbH 31713bceaSmatthias.ringwald * 41713bceaSmatthias.ringwald * Redistribution and use in source and binary forms, with or without 51713bceaSmatthias.ringwald * modification, are permitted provided that the following conditions 61713bceaSmatthias.ringwald * are met: 71713bceaSmatthias.ringwald * 81713bceaSmatthias.ringwald * 1. Redistributions of source code must retain the above copyright 91713bceaSmatthias.ringwald * notice, this list of conditions and the following disclaimer. 101713bceaSmatthias.ringwald * 2. Redistributions in binary form must reproduce the above copyright 111713bceaSmatthias.ringwald * notice, this list of conditions and the following disclaimer in the 121713bceaSmatthias.ringwald * documentation and/or other materials provided with the distribution. 131713bceaSmatthias.ringwald * 3. Neither the name of the copyright holders nor the names of 141713bceaSmatthias.ringwald * contributors may be used to endorse or promote products derived 151713bceaSmatthias.ringwald * from this software without specific prior written permission. 166b64433eSmatthias.ringwald * 4. Any redistribution, use, or modification is done solely for 176b64433eSmatthias.ringwald * personal benefit and not for any commercial purpose or for 186b64433eSmatthias.ringwald * monetary gain. 191713bceaSmatthias.ringwald * 20a0c35809S[email protected] * THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS 211713bceaSmatthias.ringwald * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 221713bceaSmatthias.ringwald * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 231713bceaSmatthias.ringwald * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL MATTHIAS 241713bceaSmatthias.ringwald * RINGWALD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 251713bceaSmatthias.ringwald * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 261713bceaSmatthias.ringwald * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 271713bceaSmatthias.ringwald * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 281713bceaSmatthias.ringwald * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 291713bceaSmatthias.ringwald * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF 301713bceaSmatthias.ringwald * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 311713bceaSmatthias.ringwald * SUCH DAMAGE. 321713bceaSmatthias.ringwald * 33a0c35809S[email protected] * Please inquire about commercial licensing options at 34a0c35809S[email protected] * [email protected] 356b64433eSmatthias.ringwald * 361713bceaSmatthias.ringwald */ 371713bceaSmatthias.ringwald 38ab2c6ae4SMatthias Ringwald #define __BTSTACK_FILE__ "l2cap.c" 39ab2c6ae4SMatthias Ringwald 401713bceaSmatthias.ringwald /* 4143625864Smatthias.ringwald * l2cap.c 4243625864Smatthias.ringwald * 4343625864Smatthias.ringwald * Logical Link Control and Adaption Protocl (L2CAP) 4443625864Smatthias.ringwald * 4543625864Smatthias.ringwald * Created by Matthias Ringwald on 5/16/09. 4643625864Smatthias.ringwald */ 4743625864Smatthias.ringwald 4843625864Smatthias.ringwald #include "l2cap.h" 49645658c9Smatthias.ringwald #include "hci.h" 502b3c6c9bSmatthias.ringwald #include "hci_dump.h" 51235946f1SMatthias Ringwald #include "bluetooth_sdp.h" 5216ece135SMatthias Ringwald #include "btstack_debug.h" 530e2df43fSMatthias Ringwald #include "btstack_event.h" 54d3a9df87Smatthias.ringwald #include "btstack_memory.h" 5543625864Smatthias.ringwald 56cab29d48SMatthias Ringwald #ifdef ENABLE_LE_DATA_CHANNELS 5783fd9c76SMatthias Ringwald #include "ble/sm.h" 5883fd9c76SMatthias Ringwald #endif 5983fd9c76SMatthias Ringwald 6043625864Smatthias.ringwald #include <stdarg.h> 6143625864Smatthias.ringwald #include <string.h> 6243625864Smatthias.ringwald 6343625864Smatthias.ringwald #include <stdio.h> 6443625864Smatthias.ringwald 654c744e21Smatthias.ringwald // nr of buffered acl packets in outgoing queue to get max performance 664c744e21Smatthias.ringwald #define NR_BUFFERED_ACL_PACKETS 3 674c744e21Smatthias.ringwald 6839bda6d5Smatthias.ringwald // used to cache l2cap rejects, echo, and informational requests 69e16a9cacSmatthias.ringwald #define NR_PENDING_SIGNALING_RESPONSES 3 7039bda6d5Smatthias.ringwald 7185aeef60SMatthias Ringwald // nr of credits provided to remote if credits fall below watermark 7285aeef60SMatthias Ringwald #define L2CAP_LE_DATA_CHANNELS_AUTOMATIC_CREDITS_WATERMARK 5 7385aeef60SMatthias Ringwald #define L2CAP_LE_DATA_CHANNELS_AUTOMATIC_CREDITS_INCREMENT 5 7485aeef60SMatthias Ringwald 7500d93d79Smatthias.ringwald // offsets for L2CAP SIGNALING COMMANDS 7600d93d79Smatthias.ringwald #define L2CAP_SIGNALING_COMMAND_CODE_OFFSET 0 7700d93d79Smatthias.ringwald #define L2CAP_SIGNALING_COMMAND_SIGID_OFFSET 1 7800d93d79Smatthias.ringwald #define L2CAP_SIGNALING_COMMAND_LENGTH_OFFSET 2 7900d93d79Smatthias.ringwald #define L2CAP_SIGNALING_COMMAND_DATA_OFFSET 4 8000d93d79Smatthias.ringwald 815628cf69SMatthias Ringwald // internal table 825628cf69SMatthias Ringwald #define L2CAP_FIXED_CHANNEL_TABLE_INDEX_ATTRIBUTE_PROTOCOL 0 835628cf69SMatthias Ringwald #define L2CAP_FIXED_CHANNEL_TABLE_INDEX_SECURITY_MANAGER_PROTOCOL 1 845628cf69SMatthias Ringwald #define L2CAP_FIXED_CHANNEL_TABLE_INDEX_CONNECTIONLESS_CHANNEL 2 855628cf69SMatthias Ringwald #define L2CAP_FIXED_CHANNEL_TABLE_SIZE (L2CAP_FIXED_CHANNEL_TABLE_INDEX_CONNECTIONLESS_CHANNEL+1) 865628cf69SMatthias Ringwald 8709e9d05bSMatthias Ringwald #if defined(ENABLE_LE_DATA_CHANNELS) || defined(ENABLE_CLASSIC) 8809e9d05bSMatthias Ringwald #define L2CAP_USES_CHANNELS 8909e9d05bSMatthias Ringwald #endif 9009e9d05bSMatthias Ringwald 9133c40538SMatthias Ringwald // prototypes 9233c40538SMatthias Ringwald static void l2cap_hci_event_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size); 933d50b4baSMatthias Ringwald static void l2cap_acl_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size ); 9430725612SMatthias Ringwald static void l2cap_notify_channel_can_send(void); 9509e9d05bSMatthias Ringwald static void l2cap_emit_can_send_now(btstack_packet_handler_t packet_handler, uint16_t channel); 9609e9d05bSMatthias Ringwald #ifdef ENABLE_CLASSIC 9709e9d05bSMatthias Ringwald static void l2cap_finialize_channel_close(l2cap_channel_t *channel); 9809e9d05bSMatthias Ringwald static inline l2cap_service_t * l2cap_get_service(uint16_t psm); 9909e9d05bSMatthias Ringwald static void l2cap_emit_channel_opened(l2cap_channel_t *channel, uint8_t status); 10009e9d05bSMatthias Ringwald static void l2cap_emit_channel_closed(l2cap_channel_t *channel); 10109e9d05bSMatthias Ringwald static void l2cap_emit_incoming_connection(l2cap_channel_t *channel); 10209e9d05bSMatthias Ringwald static int l2cap_channel_ready_for_open(l2cap_channel_t *channel); 10309e9d05bSMatthias Ringwald #endif 104cab29d48SMatthias Ringwald #ifdef ENABLE_LE_DATA_CHANNELS 10557be49d6SMatthias Ringwald static void l2cap_emit_le_channel_opened(l2cap_channel_t *channel, uint8_t status); 10657be49d6SMatthias Ringwald static void l2cap_emit_le_incoming_connection(l2cap_channel_t *channel); 10757be49d6SMatthias Ringwald static l2cap_channel_t * l2cap_le_get_channel_for_local_cid(uint16_t local_cid); 10844276248SMatthias Ringwald static void l2cap_le_notify_channel_can_send(l2cap_channel_t *channel); 109828a7f7aSMatthias Ringwald static void l2cap_le_finialize_channel_close(l2cap_channel_t *channel); 110e7d0c9aaSMatthias Ringwald static inline l2cap_service_t * l2cap_le_get_service(uint16_t psm); 111e7d0c9aaSMatthias Ringwald #endif 11233c40538SMatthias Ringwald 1135628cf69SMatthias Ringwald typedef struct l2cap_fixed_channel { 1145628cf69SMatthias Ringwald btstack_packet_handler_t callback; 1152125de09SMatthias Ringwald uint8_t waiting_for_can_send_now; 1165628cf69SMatthias Ringwald } l2cap_fixed_channel_t; 1175628cf69SMatthias Ringwald 11809e9d05bSMatthias Ringwald #ifdef ENABLE_CLASSIC 1195628cf69SMatthias Ringwald static btstack_linked_list_t l2cap_channels; 1205628cf69SMatthias Ringwald static btstack_linked_list_t l2cap_services; 12109e9d05bSMatthias Ringwald static uint8_t require_security_level2_for_outgoing_sdp; 12209e9d05bSMatthias Ringwald #endif 12357be49d6SMatthias Ringwald 12457be49d6SMatthias Ringwald #ifdef ENABLE_LE_DATA_CHANNELS 1255628cf69SMatthias Ringwald static btstack_linked_list_t l2cap_le_channels; 1265628cf69SMatthias Ringwald static btstack_linked_list_t l2cap_le_services; 12757be49d6SMatthias Ringwald #endif 12839bda6d5Smatthias.ringwald 12939bda6d5Smatthias.ringwald // used to cache l2cap rejects, echo, and informational requests 1302b83fb7dSmatthias.ringwald static l2cap_signaling_response_t signaling_responses[NR_PENDING_SIGNALING_RESPONSES]; 1312b83fb7dSmatthias.ringwald static int signaling_responses_pending; 1322b83fb7dSmatthias.ringwald 133fb37a842SMatthias Ringwald static btstack_packet_callback_registration_t hci_event_callback_registration; 1345628cf69SMatthias Ringwald static l2cap_fixed_channel_t fixed_channels[L2CAP_FIXED_CHANNEL_TABLE_SIZE]; 13539bda6d5Smatthias.ringwald 136*d6ed9f9cSMatthias Ringwald #ifdef ENABLE_BLE 137*d6ed9f9cSMatthias Ringwald // only used for connection parameter update events 138*d6ed9f9cSMatthias Ringwald static btstack_packet_handler_t l2cap_event_packet_handler; 139*d6ed9f9cSMatthias Ringwald #endif 140*d6ed9f9cSMatthias Ringwald 14134e7e577SMatthias Ringwald static uint16_t l2cap_fixed_channel_table_channel_id_for_index(int index){ 14234e7e577SMatthias Ringwald switch (index){ 14334e7e577SMatthias Ringwald case L2CAP_FIXED_CHANNEL_TABLE_INDEX_ATTRIBUTE_PROTOCOL: 14434e7e577SMatthias Ringwald return L2CAP_CID_ATTRIBUTE_PROTOCOL; 14534e7e577SMatthias Ringwald case L2CAP_FIXED_CHANNEL_TABLE_INDEX_SECURITY_MANAGER_PROTOCOL: 14634e7e577SMatthias Ringwald return L2CAP_CID_SECURITY_MANAGER_PROTOCOL; 14734e7e577SMatthias Ringwald case L2CAP_FIXED_CHANNEL_TABLE_INDEX_CONNECTIONLESS_CHANNEL: 14834e7e577SMatthias Ringwald return L2CAP_CID_CONNECTIONLESS_CHANNEL; 14934e7e577SMatthias Ringwald default: 15034e7e577SMatthias Ringwald return 0; 15134e7e577SMatthias Ringwald } 15234e7e577SMatthias Ringwald } 1535628cf69SMatthias Ringwald static int l2cap_fixed_channel_table_index_for_channel_id(uint16_t channel_id){ 1545628cf69SMatthias Ringwald switch (channel_id){ 1555628cf69SMatthias Ringwald case L2CAP_CID_ATTRIBUTE_PROTOCOL: 1565628cf69SMatthias Ringwald return L2CAP_FIXED_CHANNEL_TABLE_INDEX_ATTRIBUTE_PROTOCOL; 1575628cf69SMatthias Ringwald case L2CAP_CID_SECURITY_MANAGER_PROTOCOL: 1585628cf69SMatthias Ringwald return L2CAP_FIXED_CHANNEL_TABLE_INDEX_SECURITY_MANAGER_PROTOCOL; 1595628cf69SMatthias Ringwald case L2CAP_CID_CONNECTIONLESS_CHANNEL: 1605628cf69SMatthias Ringwald return L2CAP_FIXED_CHANNEL_TABLE_INDEX_CONNECTIONLESS_CHANNEL; 1615628cf69SMatthias Ringwald default: 1625628cf69SMatthias Ringwald return -1; 1635628cf69SMatthias Ringwald } 1645628cf69SMatthias Ringwald } 16539bda6d5Smatthias.ringwald 16634e7e577SMatthias Ringwald static int l2cap_fixed_channel_table_index_is_le(int index){ 16734e7e577SMatthias Ringwald if (index == L2CAP_CID_CONNECTIONLESS_CHANNEL) return 0; 16834e7e577SMatthias Ringwald return 1; 16934e7e577SMatthias Ringwald } 17034e7e577SMatthias Ringwald 17171de195eSMatthias Ringwald void l2cap_init(void){ 1722b83fb7dSmatthias.ringwald signaling_responses_pending = 0; 173808a48abSmatthias.ringwald 17409e9d05bSMatthias Ringwald #ifdef ENABLE_CLASSIC 175f5454fc6Smatthias.ringwald l2cap_channels = NULL; 176f5454fc6Smatthias.ringwald l2cap_services = NULL; 17709e9d05bSMatthias Ringwald require_security_level2_for_outgoing_sdp = 0; 17809e9d05bSMatthias Ringwald #endif 179a3dc965aSMatthias Ringwald 180a3dc965aSMatthias Ringwald #ifdef ENABLE_LE_DATA_CHANNELS 1817192e786SMatthias Ringwald l2cap_le_services = NULL; 1827192e786SMatthias Ringwald l2cap_le_channels = NULL; 183a3dc965aSMatthias Ringwald #endif 184f5454fc6Smatthias.ringwald 185*d6ed9f9cSMatthias Ringwald #ifdef ENABLE_BLE 18633c40538SMatthias Ringwald l2cap_event_packet_handler = NULL; 187*d6ed9f9cSMatthias Ringwald #endif 1885628cf69SMatthias Ringwald memset(fixed_channels, 0, sizeof(fixed_channels)); 189f5454fc6Smatthias.ringwald 190fcadd0caSmatthias.ringwald // 1912718e2e7Smatthias.ringwald // register callback with HCI 192fcadd0caSmatthias.ringwald // 193d9a7306aSMatthias Ringwald hci_event_callback_registration.callback = &l2cap_hci_event_handler; 194fb37a842SMatthias Ringwald hci_add_event_handler(&hci_event_callback_registration); 195fb37a842SMatthias Ringwald 196d9a7306aSMatthias Ringwald hci_register_acl_packet_handler(&l2cap_acl_handler); 197fb37a842SMatthias Ringwald 198be005ed6SMatthias Ringwald #ifdef ENABLE_CLASSIC 19915a95bd5SMatthias Ringwald gap_connectable_control(0); // no services yet 200be005ed6SMatthias Ringwald #endif 201fcadd0caSmatthias.ringwald } 202fcadd0caSmatthias.ringwald 203ffbf8201SMatthias Ringwald void l2cap_register_packet_handler(void (*handler)(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size)){ 204*d6ed9f9cSMatthias Ringwald #ifdef ENABLE_BLE 20533c40538SMatthias Ringwald l2cap_event_packet_handler = handler; 206*d6ed9f9cSMatthias Ringwald #else 207*d6ed9f9cSMatthias Ringwald UNUSED(handler); 208*d6ed9f9cSMatthias Ringwald #endif 2091e6aba47Smatthias.ringwald } 2101e6aba47Smatthias.ringwald 21109e9d05bSMatthias Ringwald void l2cap_request_can_send_fix_channel_now_event(hci_con_handle_t con_handle, uint16_t channel_id){ 2129ec2630cSMatthias Ringwald UNUSED(con_handle); 2139ec2630cSMatthias Ringwald 21409e9d05bSMatthias Ringwald int index = l2cap_fixed_channel_table_index_for_channel_id(channel_id); 21509e9d05bSMatthias Ringwald if (index < 0) return; 21609e9d05bSMatthias Ringwald fixed_channels[index].waiting_for_can_send_now = 1; 21709e9d05bSMatthias Ringwald l2cap_notify_channel_can_send(); 21809e9d05bSMatthias Ringwald } 21909e9d05bSMatthias Ringwald 22009e9d05bSMatthias Ringwald int l2cap_can_send_fixed_channel_packet_now(hci_con_handle_t con_handle, uint16_t channel_id){ 2219ec2630cSMatthias Ringwald UNUSED(channel_id); 2229ec2630cSMatthias Ringwald 22309e9d05bSMatthias Ringwald return hci_can_send_acl_packet_now(con_handle); 22409e9d05bSMatthias Ringwald } 22509e9d05bSMatthias Ringwald 22609e9d05bSMatthias Ringwald uint8_t *l2cap_get_outgoing_buffer(void){ 22709e9d05bSMatthias Ringwald return hci_get_outgoing_packet_buffer() + COMPLETE_L2CAP_HEADER; // 8 bytes 22809e9d05bSMatthias Ringwald } 22909e9d05bSMatthias Ringwald 23009e9d05bSMatthias Ringwald int l2cap_reserve_packet_buffer(void){ 23109e9d05bSMatthias Ringwald return hci_reserve_packet_buffer(); 23209e9d05bSMatthias Ringwald } 23309e9d05bSMatthias Ringwald 23409e9d05bSMatthias Ringwald void l2cap_release_packet_buffer(void){ 23509e9d05bSMatthias Ringwald hci_release_packet_buffer(); 23609e9d05bSMatthias Ringwald } 23709e9d05bSMatthias Ringwald 238f511cefaSMatthias Ringwald static void l2cap_setup_header(uint8_t * acl_buffer, hci_con_handle_t con_handle, uint8_t packet_boundary, uint16_t remote_cid, uint16_t len){ 23909e9d05bSMatthias Ringwald // 0 - Connection handle : PB=pb : BC=00 240f511cefaSMatthias Ringwald little_endian_store_16(acl_buffer, 0, con_handle | (packet_boundary << 12) | (0 << 14)); 24109e9d05bSMatthias Ringwald // 2 - ACL length 24209e9d05bSMatthias Ringwald little_endian_store_16(acl_buffer, 2, len + 4); 24309e9d05bSMatthias Ringwald // 4 - L2CAP packet length 24409e9d05bSMatthias Ringwald little_endian_store_16(acl_buffer, 4, len + 0); 24509e9d05bSMatthias Ringwald // 6 - L2CAP channel DEST 24609e9d05bSMatthias Ringwald little_endian_store_16(acl_buffer, 6, remote_cid); 24709e9d05bSMatthias Ringwald } 24809e9d05bSMatthias Ringwald 249f511cefaSMatthias Ringwald // assumption - only on LE connections 25009e9d05bSMatthias Ringwald int l2cap_send_prepared_connectionless(hci_con_handle_t con_handle, uint16_t cid, uint16_t len){ 25109e9d05bSMatthias Ringwald 25209e9d05bSMatthias Ringwald if (!hci_is_packet_buffer_reserved()){ 25309e9d05bSMatthias Ringwald log_error("l2cap_send_prepared_connectionless called without reserving packet first"); 25409e9d05bSMatthias Ringwald return BTSTACK_ACL_BUFFERS_FULL; 25509e9d05bSMatthias Ringwald } 25609e9d05bSMatthias Ringwald 25709e9d05bSMatthias Ringwald if (!hci_can_send_prepared_acl_packet_now(con_handle)){ 25809e9d05bSMatthias Ringwald log_info("l2cap_send_prepared_connectionless handle 0x%02x, cid 0x%02x, cannot send", con_handle, cid); 25909e9d05bSMatthias Ringwald return BTSTACK_ACL_BUFFERS_FULL; 26009e9d05bSMatthias Ringwald } 26109e9d05bSMatthias Ringwald 26209e9d05bSMatthias Ringwald log_debug("l2cap_send_prepared_connectionless handle %u, cid 0x%02x", con_handle, cid); 26309e9d05bSMatthias Ringwald 26409e9d05bSMatthias Ringwald uint8_t *acl_buffer = hci_get_outgoing_packet_buffer(); 265f511cefaSMatthias Ringwald l2cap_setup_header(acl_buffer, con_handle, 0, cid, len); 26609e9d05bSMatthias Ringwald // send 26709e9d05bSMatthias Ringwald return hci_send_acl_packet_buffer(len+8); 26809e9d05bSMatthias Ringwald } 26909e9d05bSMatthias Ringwald 270f511cefaSMatthias Ringwald // assumption - only on LE connections 27109e9d05bSMatthias Ringwald int l2cap_send_connectionless(hci_con_handle_t con_handle, uint16_t cid, uint8_t *data, uint16_t len){ 27209e9d05bSMatthias Ringwald 27309e9d05bSMatthias Ringwald if (!hci_can_send_acl_packet_now(con_handle)){ 27409e9d05bSMatthias Ringwald log_info("l2cap_send cid 0x%02x, cannot send", cid); 27509e9d05bSMatthias Ringwald return BTSTACK_ACL_BUFFERS_FULL; 27609e9d05bSMatthias Ringwald } 27709e9d05bSMatthias Ringwald 27809e9d05bSMatthias Ringwald hci_reserve_packet_buffer(); 27909e9d05bSMatthias Ringwald uint8_t *acl_buffer = hci_get_outgoing_packet_buffer(); 28009e9d05bSMatthias Ringwald 28109e9d05bSMatthias Ringwald memcpy(&acl_buffer[8], data, len); 28209e9d05bSMatthias Ringwald 28309e9d05bSMatthias Ringwald return l2cap_send_prepared_connectionless(con_handle, cid, len); 28409e9d05bSMatthias Ringwald } 28509e9d05bSMatthias Ringwald 28609e9d05bSMatthias Ringwald static void l2cap_emit_can_send_now(btstack_packet_handler_t packet_handler, uint16_t channel) { 287d9d23054SMatthias Ringwald log_debug("L2CAP_EVENT_CHANNEL_CAN_SEND_NOW local_cid 0x%x", channel); 28809e9d05bSMatthias Ringwald uint8_t event[4]; 28909e9d05bSMatthias Ringwald event[0] = L2CAP_EVENT_CAN_SEND_NOW; 29009e9d05bSMatthias Ringwald event[1] = sizeof(event) - 2; 29109e9d05bSMatthias Ringwald little_endian_store_16(event, 2, channel); 29209e9d05bSMatthias Ringwald hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event)); 29309e9d05bSMatthias Ringwald packet_handler(HCI_EVENT_PACKET, channel, event, sizeof(event)); 29409e9d05bSMatthias Ringwald } 29509e9d05bSMatthias Ringwald 29609e9d05bSMatthias Ringwald #ifdef L2CAP_USES_CHANNELS 29717a9b554SMatthias Ringwald static void l2cap_dispatch_to_channel(l2cap_channel_t *channel, uint8_t type, uint8_t * data, uint16_t size){ 29858de5610Smatthias.ringwald (* (channel->packet_handler))(type, channel->local_cid, data, size); 29958de5610Smatthias.ringwald } 30058de5610Smatthias.ringwald 30144276248SMatthias Ringwald static void l2cap_emit_simple_event_with_cid(l2cap_channel_t * channel, uint8_t event_code){ 30244276248SMatthias Ringwald uint8_t event[4]; 30344276248SMatthias Ringwald event[0] = event_code; 30444276248SMatthias Ringwald event[1] = sizeof(event) - 2; 30544276248SMatthias Ringwald little_endian_store_16(event, 2, channel->local_cid); 30644276248SMatthias Ringwald hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event)); 30744276248SMatthias Ringwald l2cap_dispatch_to_channel(channel, HCI_EVENT_PACKET, event, sizeof(event)); 30844276248SMatthias Ringwald } 30909e9d05bSMatthias Ringwald #endif 31044276248SMatthias Ringwald 31109e9d05bSMatthias Ringwald #ifdef ENABLE_CLASSIC 31258de5610Smatthias.ringwald void l2cap_emit_channel_opened(l2cap_channel_t *channel, uint8_t status) { 313c9dc710bS[email protected] log_info("L2CAP_EVENT_CHANNEL_OPENED status 0x%x addr %s handle 0x%x psm 0x%x local_cid 0x%x remote_cid 0x%x local_mtu %u, remote_mtu %u, flush_timeout %u", 314fc64f94aSMatthias Ringwald status, bd_addr_to_str(channel->address), channel->con_handle, channel->psm, 315c9dc710bS[email protected] channel->local_cid, channel->remote_cid, channel->local_mtu, channel->remote_mtu, channel->flush_timeout); 316bab5f4f0SMatthias Ringwald uint8_t event[24]; 31758de5610Smatthias.ringwald event[0] = L2CAP_EVENT_CHANNEL_OPENED; 31858de5610Smatthias.ringwald event[1] = sizeof(event) - 2; 31958de5610Smatthias.ringwald event[2] = status; 320724d70a2SMatthias Ringwald reverse_bd_addr(channel->address, &event[3]); 321fc64f94aSMatthias Ringwald little_endian_store_16(event, 9, channel->con_handle); 322f8fbdce0SMatthias Ringwald little_endian_store_16(event, 11, channel->psm); 323f8fbdce0SMatthias Ringwald little_endian_store_16(event, 13, channel->local_cid); 324f8fbdce0SMatthias Ringwald little_endian_store_16(event, 15, channel->remote_cid); 325f8fbdce0SMatthias Ringwald little_endian_store_16(event, 17, channel->local_mtu); 326f8fbdce0SMatthias Ringwald little_endian_store_16(event, 19, channel->remote_mtu); 327f8fbdce0SMatthias Ringwald little_endian_store_16(event, 21, channel->flush_timeout); 328bab5f4f0SMatthias Ringwald event[23] = channel->state_var & L2CAP_CHANNEL_STATE_VAR_INCOMING ? 1 : 0; 32958de5610Smatthias.ringwald hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event)); 33017a9b554SMatthias Ringwald l2cap_dispatch_to_channel(channel, HCI_EVENT_PACKET, event, sizeof(event)); 33158de5610Smatthias.ringwald } 33258de5610Smatthias.ringwald 33344276248SMatthias Ringwald static void l2cap_emit_channel_closed(l2cap_channel_t *channel) { 334e0abb8e7S[email protected] log_info("L2CAP_EVENT_CHANNEL_CLOSED local_cid 0x%x", channel->local_cid); 33544276248SMatthias Ringwald l2cap_emit_simple_event_with_cid(channel, L2CAP_EVENT_CHANNEL_CLOSED); 33658de5610Smatthias.ringwald } 33758de5610Smatthias.ringwald 33844276248SMatthias Ringwald static void l2cap_emit_incoming_connection(l2cap_channel_t *channel) { 339e0abb8e7S[email protected] log_info("L2CAP_EVENT_INCOMING_CONNECTION addr %s handle 0x%x psm 0x%x local_cid 0x%x remote_cid 0x%x", 340fc64f94aSMatthias Ringwald bd_addr_to_str(channel->address), channel->con_handle, channel->psm, channel->local_cid, channel->remote_cid); 34158de5610Smatthias.ringwald uint8_t event[16]; 34258de5610Smatthias.ringwald event[0] = L2CAP_EVENT_INCOMING_CONNECTION; 34358de5610Smatthias.ringwald event[1] = sizeof(event) - 2; 344724d70a2SMatthias Ringwald reverse_bd_addr(channel->address, &event[2]); 345fc64f94aSMatthias Ringwald little_endian_store_16(event, 8, channel->con_handle); 346f8fbdce0SMatthias Ringwald little_endian_store_16(event, 10, channel->psm); 347f8fbdce0SMatthias Ringwald little_endian_store_16(event, 12, channel->local_cid); 348f8fbdce0SMatthias Ringwald little_endian_store_16(event, 14, channel->remote_cid); 34958de5610Smatthias.ringwald hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event)); 35017a9b554SMatthias Ringwald l2cap_dispatch_to_channel(channel, HCI_EVENT_PACKET, event, sizeof(event)); 3510af41d30Smatthias.ringwald } 352808a48abSmatthias.ringwald 3537f02f414SMatthias Ringwald static l2cap_channel_t * l2cap_get_channel_for_local_cid(uint16_t local_cid){ 354665d90f2SMatthias Ringwald btstack_linked_list_iterator_t it; 355665d90f2SMatthias Ringwald btstack_linked_list_iterator_init(&it, &l2cap_channels); 356665d90f2SMatthias Ringwald while (btstack_linked_list_iterator_has_next(&it)){ 357665d90f2SMatthias Ringwald l2cap_channel_t * channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it); 358b35f641cSmatthias.ringwald if ( channel->local_cid == local_cid) { 359f62db1e3Smatthias.ringwald return channel; 360f62db1e3Smatthias.ringwald } 361f62db1e3Smatthias.ringwald } 362f62db1e3Smatthias.ringwald return NULL; 363f62db1e3Smatthias.ringwald } 364f62db1e3Smatthias.ringwald 3650b9d7e78SMatthias Ringwald /// 3660b9d7e78SMatthias Ringwald 36730725612SMatthias Ringwald void l2cap_request_can_send_now_event(uint16_t local_cid){ 36830725612SMatthias Ringwald l2cap_channel_t *channel = l2cap_get_channel_for_local_cid(local_cid); 36930725612SMatthias Ringwald if (!channel) return; 37030725612SMatthias Ringwald channel->waiting_for_can_send_now = 1; 37130725612SMatthias Ringwald l2cap_notify_channel_can_send(); 37230725612SMatthias Ringwald } 37330725612SMatthias Ringwald 3746b1fde37Smatthias.ringwald int l2cap_can_send_packet_now(uint16_t local_cid){ 3756b1fde37Smatthias.ringwald l2cap_channel_t *channel = l2cap_get_channel_for_local_cid(local_cid); 3766b1fde37Smatthias.ringwald if (!channel) return 0; 3770b9d7e78SMatthias Ringwald return hci_can_send_acl_packet_now(channel->con_handle); 3787856fb31S[email protected] } 3797856fb31S[email protected] 38083e7cdd9SMatthias Ringwald int l2cap_can_send_prepared_packet_now(uint16_t local_cid){ 38183e7cdd9SMatthias Ringwald l2cap_channel_t *channel = l2cap_get_channel_for_local_cid(local_cid); 38283e7cdd9SMatthias Ringwald if (!channel) return 0; 3830b9d7e78SMatthias Ringwald return hci_can_send_prepared_acl_packet_now(channel->con_handle); 38483e7cdd9SMatthias Ringwald } 38596cbd662Smatthias.ringwald uint16_t l2cap_get_remote_mtu_for_local_cid(uint16_t local_cid){ 38696cbd662Smatthias.ringwald l2cap_channel_t * channel = l2cap_get_channel_for_local_cid(local_cid); 38796cbd662Smatthias.ringwald if (channel) { 38896cbd662Smatthias.ringwald return channel->remote_mtu; 38996cbd662Smatthias.ringwald } 39096cbd662Smatthias.ringwald return 0; 39196cbd662Smatthias.ringwald } 39296cbd662Smatthias.ringwald 393ec820d77SMatthias Ringwald static l2cap_channel_t * l2cap_channel_for_rtx_timer(btstack_timer_source_t * ts){ 394665d90f2SMatthias Ringwald btstack_linked_list_iterator_t it; 395665d90f2SMatthias Ringwald btstack_linked_list_iterator_init(&it, &l2cap_channels); 396665d90f2SMatthias Ringwald while (btstack_linked_list_iterator_has_next(&it)){ 397665d90f2SMatthias Ringwald l2cap_channel_t * channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it); 3985932bd7cS[email protected] if ( &channel->rtx == ts) { 3995932bd7cS[email protected] return channel; 4005932bd7cS[email protected] } 4015932bd7cS[email protected] } 4025932bd7cS[email protected] return NULL; 4035932bd7cS[email protected] } 4045932bd7cS[email protected] 405ec820d77SMatthias Ringwald static void l2cap_rtx_timeout(btstack_timer_source_t * ts){ 4065932bd7cS[email protected] l2cap_channel_t * channel = l2cap_channel_for_rtx_timer(ts); 40795d2c8f4SMatthias Ringwald if (!channel) return; 4085932bd7cS[email protected] 4095932bd7cS[email protected] log_info("l2cap_rtx_timeout for local cid 0x%02x", channel->local_cid); 4105932bd7cS[email protected] 4115932bd7cS[email protected] // "When terminating the channel, it is not necessary to send a L2CAP_DisconnectReq 4125932bd7cS[email protected] // and enter WAIT_DISCONNECT state. Channels can be transitioned directly to the CLOSED state." 4135932bd7cS[email protected] // notify client 4145932bd7cS[email protected] l2cap_emit_channel_opened(channel, L2CAP_CONNECTION_RESPONSE_RESULT_RTX_TIMEOUT); 4155932bd7cS[email protected] 4165932bd7cS[email protected] // discard channel 4179dcb2fb2S[email protected] // no need to stop timer here, it is removed from list during timer callback 418665d90f2SMatthias Ringwald btstack_linked_list_remove(&l2cap_channels, (btstack_linked_item_t *) channel); 4195932bd7cS[email protected] btstack_memory_l2cap_channel_free(channel); 4205932bd7cS[email protected] } 4215932bd7cS[email protected] 4225932bd7cS[email protected] static void l2cap_stop_rtx(l2cap_channel_t * channel){ 4235932bd7cS[email protected] log_info("l2cap_stop_rtx for local cid 0x%02x", channel->local_cid); 424528a4a3bSMatthias Ringwald btstack_run_loop_remove_timer(&channel->rtx); 4255932bd7cS[email protected] } 4265932bd7cS[email protected] 4275932bd7cS[email protected] static void l2cap_start_rtx(l2cap_channel_t * channel){ 4285932bd7cS[email protected] l2cap_stop_rtx(channel); 429cb0ff06bS[email protected] log_info("l2cap_start_rtx for local cid 0x%02x", channel->local_cid); 430528a4a3bSMatthias Ringwald btstack_run_loop_set_timer_handler(&channel->rtx, l2cap_rtx_timeout); 431528a4a3bSMatthias Ringwald btstack_run_loop_set_timer(&channel->rtx, L2CAP_RTX_TIMEOUT_MS); 432528a4a3bSMatthias Ringwald btstack_run_loop_add_timer(&channel->rtx); 4335932bd7cS[email protected] } 4345932bd7cS[email protected] 4355932bd7cS[email protected] static void l2cap_start_ertx(l2cap_channel_t * channel){ 4365932bd7cS[email protected] log_info("l2cap_start_ertx for local cid 0x%02x", channel->local_cid); 4375932bd7cS[email protected] l2cap_stop_rtx(channel); 438528a4a3bSMatthias Ringwald btstack_run_loop_set_timer_handler(&channel->rtx, l2cap_rtx_timeout); 439528a4a3bSMatthias Ringwald btstack_run_loop_set_timer(&channel->rtx, L2CAP_ERTX_TIMEOUT_MS); 440528a4a3bSMatthias Ringwald btstack_run_loop_add_timer(&channel->rtx); 4415932bd7cS[email protected] } 4425932bd7cS[email protected] 44371de195eSMatthias Ringwald void l2cap_require_security_level_2_for_outgoing_sdp(void){ 444ac301f95S[email protected] require_security_level2_for_outgoing_sdp = 1; 445ac301f95S[email protected] } 446ac301f95S[email protected] 447df3354fcS[email protected] static int l2cap_security_level_0_allowed_for_PSM(uint16_t psm){ 448235946f1SMatthias Ringwald return (psm == BLUETOOTH_PROTOCOL_SDP) && (!require_security_level2_for_outgoing_sdp); 449df3354fcS[email protected] } 4505932bd7cS[email protected] 4517f02f414SMatthias Ringwald static int l2cap_send_signaling_packet(hci_con_handle_t handle, L2CAP_SIGNALING_COMMANDS cmd, uint8_t identifier, ...){ 452a35252c8S[email protected] if (!hci_can_send_acl_packet_now(handle)){ 4539da54300S[email protected] log_info("l2cap_send_signaling_packet, cannot send"); 454b1d43497Smatthias.ringwald return BTSTACK_ACL_BUFFERS_FULL; 455b1d43497Smatthias.ringwald } 456b1d43497Smatthias.ringwald 4579da54300S[email protected] // log_info("l2cap_send_signaling_packet type %u", cmd); 4582a373862S[email protected] hci_reserve_packet_buffer(); 459facf93fdS[email protected] uint8_t *acl_buffer = hci_get_outgoing_packet_buffer(); 46058de5610Smatthias.ringwald va_list argptr; 46158de5610Smatthias.ringwald va_start(argptr, identifier); 46270efece1S[email protected] uint16_t len = l2cap_create_signaling_classic(acl_buffer, handle, cmd, identifier, argptr); 46358de5610Smatthias.ringwald va_end(argptr); 4649da54300S[email protected] // log_info("l2cap_send_signaling_packet con %u!", handle); 465826f7347S[email protected] return hci_send_acl_packet_buffer(len); 46658de5610Smatthias.ringwald } 46758de5610Smatthias.ringwald 468f511cefaSMatthias Ringwald // assumption - only on Classic connections 469b1d43497Smatthias.ringwald int l2cap_send_prepared(uint16_t local_cid, uint16_t len){ 470b1d43497Smatthias.ringwald 471c8b9416aS[email protected] if (!hci_is_packet_buffer_reserved()){ 472c8b9416aS[email protected] log_error("l2cap_send_prepared called without reserving packet first"); 473c8b9416aS[email protected] return BTSTACK_ACL_BUFFERS_FULL; 474c8b9416aS[email protected] } 475c8b9416aS[email protected] 47658de5610Smatthias.ringwald l2cap_channel_t * channel = l2cap_get_channel_for_local_cid(local_cid); 477b1d43497Smatthias.ringwald if (!channel) { 4789da54300S[email protected] log_error("l2cap_send_prepared no channel for cid 0x%02x", local_cid); 479b1d43497Smatthias.ringwald return -1; // TODO: define error 4806218e6f1Smatthias.ringwald } 4816218e6f1Smatthias.ringwald 482fc64f94aSMatthias Ringwald if (!hci_can_send_prepared_acl_packet_now(channel->con_handle)){ 4839da54300S[email protected] log_info("l2cap_send_prepared cid 0x%02x, cannot send", local_cid); 484a35252c8S[email protected] return BTSTACK_ACL_BUFFERS_FULL; 485a35252c8S[email protected] } 486a35252c8S[email protected] 487fc64f94aSMatthias Ringwald log_debug("l2cap_send_prepared cid 0x%02x, handle %u, 1 credit used", local_cid, channel->con_handle); 488b1d43497Smatthias.ringwald 489f511cefaSMatthias Ringwald // set non-flushable packet boundary flag if supported on Controller 490facf93fdS[email protected] uint8_t *acl_buffer = hci_get_outgoing_packet_buffer(); 491f511cefaSMatthias Ringwald uint8_t packet_boundary_flag = hci_non_flushable_packet_boundary_flag_supported() ? 0x00 : 0x02; 492f511cefaSMatthias Ringwald l2cap_setup_header(acl_buffer, channel->con_handle, packet_boundary_flag, channel->remote_cid, len); 49358de5610Smatthias.ringwald // send 4947f107edaSMatthias Ringwald return hci_send_acl_packet_buffer(len+8); 49558de5610Smatthias.ringwald } 49658de5610Smatthias.ringwald 497f511cefaSMatthias Ringwald // assumption - only on Classic connections 498ce8f182eSMatthias Ringwald int l2cap_send(uint16_t local_cid, uint8_t *data, uint16_t len){ 499b1d43497Smatthias.ringwald 500a35252c8S[email protected] l2cap_channel_t * channel = l2cap_get_channel_for_local_cid(local_cid); 501a35252c8S[email protected] if (!channel) { 502ce8f182eSMatthias Ringwald log_error("l2cap_send no channel for cid 0x%02x", local_cid); 503a35252c8S[email protected] return -1; // TODO: define error 504a35252c8S[email protected] } 505a35252c8S[email protected] 506f0efaa57S[email protected] if (len > channel->remote_mtu){ 507ce8f182eSMatthias Ringwald log_error("l2cap_send cid 0x%02x, data length exceeds remote MTU.", local_cid); 508f0efaa57S[email protected] return L2CAP_DATA_LEN_EXCEEDS_REMOTE_MTU; 509f0efaa57S[email protected] } 510f0efaa57S[email protected] 511fc64f94aSMatthias Ringwald if (!hci_can_send_acl_packet_now(channel->con_handle)){ 512ce8f182eSMatthias Ringwald log_info("l2cap_send cid 0x%02x, cannot send", local_cid); 513b1d43497Smatthias.ringwald return BTSTACK_ACL_BUFFERS_FULL; 514b1d43497Smatthias.ringwald } 515b1d43497Smatthias.ringwald 5162a373862S[email protected] hci_reserve_packet_buffer(); 517facf93fdS[email protected] uint8_t *acl_buffer = hci_get_outgoing_packet_buffer(); 518b1d43497Smatthias.ringwald 519b1d43497Smatthias.ringwald memcpy(&acl_buffer[8], data, len); 520b1d43497Smatthias.ringwald 521b1d43497Smatthias.ringwald return l2cap_send_prepared(local_cid, len); 522b1d43497Smatthias.ringwald } 523b1d43497Smatthias.ringwald 524fc64f94aSMatthias Ringwald int l2cap_send_echo_request(hci_con_handle_t con_handle, uint8_t *data, uint16_t len){ 525fc64f94aSMatthias Ringwald return l2cap_send_signaling_packet(con_handle, ECHO_REQUEST, 0x77, len, data); 5260e37e417S[email protected] } 5270e37e417S[email protected] 52828ca2b46S[email protected] static inline void channelStateVarSetFlag(l2cap_channel_t *channel, L2CAP_CHANNEL_STATE_VAR flag){ 52928ca2b46S[email protected] channel->state_var = (L2CAP_CHANNEL_STATE_VAR) (channel->state_var | flag); 53028ca2b46S[email protected] } 53128ca2b46S[email protected] 53228ca2b46S[email protected] static inline void channelStateVarClearFlag(l2cap_channel_t *channel, L2CAP_CHANNEL_STATE_VAR flag){ 53328ca2b46S[email protected] channel->state_var = (L2CAP_CHANNEL_STATE_VAR) (channel->state_var & ~flag); 53428ca2b46S[email protected] } 53509e9d05bSMatthias Ringwald #endif 53628ca2b46S[email protected] 53728ca2b46S[email protected] 53809e9d05bSMatthias Ringwald #ifdef ENABLE_BLE 53909e9d05bSMatthias Ringwald static int l2cap_send_le_signaling_packet(hci_con_handle_t handle, L2CAP_SIGNALING_COMMANDS cmd, uint8_t identifier, ...){ 54009e9d05bSMatthias Ringwald 54109e9d05bSMatthias Ringwald if (!hci_can_send_acl_packet_now(handle)){ 54209e9d05bSMatthias Ringwald log_info("l2cap_send_le_signaling_packet, cannot send"); 54309e9d05bSMatthias Ringwald return BTSTACK_ACL_BUFFERS_FULL; 54409e9d05bSMatthias Ringwald } 54509e9d05bSMatthias Ringwald 54609e9d05bSMatthias Ringwald // log_info("l2cap_send_le_signaling_packet type %u", cmd); 54709e9d05bSMatthias Ringwald hci_reserve_packet_buffer(); 54809e9d05bSMatthias Ringwald uint8_t *acl_buffer = hci_get_outgoing_packet_buffer(); 54909e9d05bSMatthias Ringwald va_list argptr; 55009e9d05bSMatthias Ringwald va_start(argptr, identifier); 55109e9d05bSMatthias Ringwald uint16_t len = l2cap_create_signaling_le(acl_buffer, handle, cmd, identifier, argptr); 55209e9d05bSMatthias Ringwald va_end(argptr); 55309e9d05bSMatthias Ringwald // log_info("l2cap_send_le_signaling_packet con %u!", handle); 55409e9d05bSMatthias Ringwald return hci_send_acl_packet_buffer(len); 55509e9d05bSMatthias Ringwald } 55609e9d05bSMatthias Ringwald #endif 55709e9d05bSMatthias Ringwald 55809e9d05bSMatthias Ringwald uint16_t l2cap_max_mtu(void){ 55909e9d05bSMatthias Ringwald return HCI_ACL_PAYLOAD_SIZE - L2CAP_HEADER_SIZE; 56009e9d05bSMatthias Ringwald } 56109e9d05bSMatthias Ringwald 56209e9d05bSMatthias Ringwald uint16_t l2cap_max_le_mtu(void){ 56309e9d05bSMatthias Ringwald return l2cap_max_mtu(); 56409e9d05bSMatthias Ringwald } 565b1d43497Smatthias.ringwald 5668158c421Smatthias.ringwald // MARK: L2CAP_RUN 5672cd0be45Smatthias.ringwald // process outstanding signaling tasks 5687f02f414SMatthias Ringwald static void l2cap_run(void){ 5692b83fb7dSmatthias.ringwald 57022c29ab4SMatthias Ringwald // log_info("l2cap_run: entered"); 57122c29ab4SMatthias Ringwald 5722b83fb7dSmatthias.ringwald // check pending signaling responses 5732b83fb7dSmatthias.ringwald while (signaling_responses_pending){ 5742b83fb7dSmatthias.ringwald 5752b83fb7dSmatthias.ringwald hci_con_handle_t handle = signaling_responses[0].handle; 576a35252c8S[email protected] 577a35252c8S[email protected] if (!hci_can_send_acl_packet_now(handle)) break; 578a35252c8S[email protected] 5792b83fb7dSmatthias.ringwald uint8_t sig_id = signaling_responses[0].sig_id; 580e74c5f58SMatthias Ringwald uint8_t response_code = signaling_responses[0].code; 5812b360848Smatthias.ringwald uint16_t infoType = signaling_responses[0].data; // INFORMATION_REQUEST 58263a7246aSmatthias.ringwald uint16_t result = signaling_responses[0].data; // CONNECTION_REQUEST, COMMAND_REJECT 583b3264428SMatthias Ringwald #ifdef ENABLE_CLASSIC 584b3264428SMatthias Ringwald uint16_t source_cid = signaling_responses[0].cid; // CONNECTION_REQUEST 585b3264428SMatthias Ringwald #endif 586f3963406SMatthias Ringwald UNUSED(infoType); 58709e9d05bSMatthias Ringwald 588f53da564S[email protected] // remove first item before sending (to avoid sending response mutliple times) 589f53da564S[email protected] signaling_responses_pending--; 590f53da564S[email protected] int i; 591f53da564S[email protected] for (i=0; i < signaling_responses_pending; i++){ 592f53da564S[email protected] memcpy(&signaling_responses[i], &signaling_responses[i+1], sizeof(l2cap_signaling_response_t)); 593f53da564S[email protected] } 594f53da564S[email protected] 595f53da564S[email protected] switch (response_code){ 59609e9d05bSMatthias Ringwald #ifdef ENABLE_CLASSIC 5972b360848Smatthias.ringwald case CONNECTION_REQUEST: 598e74c5f58SMatthias Ringwald l2cap_send_signaling_packet(handle, CONNECTION_RESPONSE, sig_id, source_cid, 0, result, 0); 5992bd8b7e7S[email protected] // also disconnect if result is 0x0003 - security blocked 6004d816277S[email protected] if (result == 0x0003){ 6012bd8b7e7S[email protected] hci_disconnect_security_block(handle); 6024d816277S[email protected] } 6032b360848Smatthias.ringwald break; 6042b83fb7dSmatthias.ringwald case ECHO_REQUEST: 6052b83fb7dSmatthias.ringwald l2cap_send_signaling_packet(handle, ECHO_RESPONSE, sig_id, 0, NULL); 6062b83fb7dSmatthias.ringwald break; 6072b83fb7dSmatthias.ringwald case INFORMATION_REQUEST: 6083b0484b3S[email protected] switch (infoType){ 6093b0484b3S[email protected] case 1: { // Connectionless MTU 6103b0484b3S[email protected] uint16_t connectionless_mtu = hci_max_acl_data_packet_length(); 6113b0484b3S[email protected] l2cap_send_signaling_packet(handle, INFORMATION_RESPONSE, sig_id, infoType, 0, sizeof(connectionless_mtu), &connectionless_mtu); 6123b0484b3S[email protected] } 613202c8a4cSMatthias Ringwald break; 6143b0484b3S[email protected] case 2: { // Extended Features Supported 615462e630dS[email protected] // extended features request supported, features: fixed channels, unicast connectionless data reception 616462e630dS[email protected] uint32_t features = 0x280; 6173b0484b3S[email protected] l2cap_send_signaling_packet(handle, INFORMATION_RESPONSE, sig_id, infoType, 0, sizeof(features), &features); 6183b0484b3S[email protected] } 619202c8a4cSMatthias Ringwald break; 6203b0484b3S[email protected] case 3: { // Fixed Channels Supported 6213b0484b3S[email protected] uint8_t map[8]; 6223b0484b3S[email protected] memset(map, 0, 8); 623288636a2SMatthias Ringwald map[0] = 0x06; // L2CAP Signaling Channel (0x02) + Connectionless reception (0x04) 6243b0484b3S[email protected] l2cap_send_signaling_packet(handle, INFORMATION_RESPONSE, sig_id, infoType, 0, sizeof(map), &map); 6253b0484b3S[email protected] } 626202c8a4cSMatthias Ringwald break; 6273b0484b3S[email protected] default: 6282b83fb7dSmatthias.ringwald // all other types are not supported 6292b83fb7dSmatthias.ringwald l2cap_send_signaling_packet(handle, INFORMATION_RESPONSE, sig_id, infoType, 1, 0, NULL); 6303b0484b3S[email protected] break; 6312b83fb7dSmatthias.ringwald } 6322b83fb7dSmatthias.ringwald break; 63363a7246aSmatthias.ringwald case COMMAND_REJECT: 6345ca8d57bS[email protected] l2cap_send_signaling_packet(handle, COMMAND_REJECT, sig_id, result, 0, NULL); 63563f0ac45SMatthias Ringwald break; 63609e9d05bSMatthias Ringwald #endif 637a9a4c409SMatthias Ringwald #ifdef ENABLE_BLE 63863f0ac45SMatthias Ringwald case LE_CREDIT_BASED_CONNECTION_REQUEST: 63963f0ac45SMatthias Ringwald l2cap_send_le_signaling_packet(handle, LE_CREDIT_BASED_CONNECTION_RESPONSE, sig_id, 0, 0, 0, 0, result); 64063f0ac45SMatthias Ringwald break; 64170efece1S[email protected] case COMMAND_REJECT_LE: 64270efece1S[email protected] l2cap_send_le_signaling_packet(handle, COMMAND_REJECT, sig_id, result, 0, NULL); 64363a7246aSmatthias.ringwald break; 64470efece1S[email protected] #endif 6452b83fb7dSmatthias.ringwald default: 6462b83fb7dSmatthias.ringwald // should not happen 6472b83fb7dSmatthias.ringwald break; 6482b83fb7dSmatthias.ringwald } 6492b83fb7dSmatthias.ringwald } 6502b83fb7dSmatthias.ringwald 651665d90f2SMatthias Ringwald btstack_linked_list_iterator_t it; 652f3963406SMatthias Ringwald UNUSED(it); 65309e9d05bSMatthias Ringwald 65409e9d05bSMatthias Ringwald #ifdef ENABLE_CLASSIC 65509e9d05bSMatthias Ringwald uint8_t config_options[4]; 656665d90f2SMatthias Ringwald btstack_linked_list_iterator_init(&it, &l2cap_channels); 657665d90f2SMatthias Ringwald while (btstack_linked_list_iterator_has_next(&it)){ 658baf94f06S[email protected] 659665d90f2SMatthias Ringwald l2cap_channel_t * channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it); 66022c29ab4SMatthias Ringwald // log_info("l2cap_run: channel %p, state %u, var 0x%02x", channel, channel->state, channel->state_var); 6612cd0be45Smatthias.ringwald switch (channel->state){ 6622cd0be45Smatthias.ringwald 663df3354fcS[email protected] case L2CAP_STATE_WAIT_INCOMING_SECURITY_LEVEL_UPDATE: 664ad671560S[email protected] case L2CAP_STATE_WAIT_CLIENT_ACCEPT_OR_REJECT: 665fc64f94aSMatthias Ringwald if (!hci_can_send_acl_packet_now(channel->con_handle)) break; 666a00031e2S[email protected] if (channel->state_var & L2CAP_CHANNEL_STATE_VAR_SEND_CONN_RESP_PEND) { 667ad671560S[email protected] channelStateVarClearFlag(channel, L2CAP_CHANNEL_STATE_VAR_SEND_CONN_RESP_PEND); 668fc64f94aSMatthias Ringwald l2cap_send_signaling_packet(channel->con_handle, CONNECTION_RESPONSE, channel->remote_sig_id, channel->local_cid, channel->remote_cid, 1, 0); 669ad671560S[email protected] } 670ad671560S[email protected] break; 671ad671560S[email protected] 67202b22dc4Smatthias.ringwald case L2CAP_STATE_WILL_SEND_CREATE_CONNECTION: 673baf94f06S[email protected] if (!hci_can_send_command_packet_now()) break; 67464472d52Smatthias.ringwald // send connection request - set state first 67564472d52Smatthias.ringwald channel->state = L2CAP_STATE_WAIT_CONNECTION_COMPLETE; 67602b22dc4Smatthias.ringwald // BD_ADDR, Packet_Type, Page_Scan_Repetition_Mode, Reserved, Clock_Offset, Allow_Role_Switch 6778f8108aaSmatthias.ringwald hci_send_cmd(&hci_create_connection, channel->address, hci_usable_acl_packet_types(), 0, 0, 0, 1); 67802b22dc4Smatthias.ringwald break; 67902b22dc4Smatthias.ringwald 680e7ff783cSmatthias.ringwald case L2CAP_STATE_WILL_SEND_CONNECTION_RESPONSE_DECLINE: 681fc64f94aSMatthias Ringwald if (!hci_can_send_acl_packet_now(channel->con_handle)) break; 68222c29ab4SMatthias Ringwald channel->state = L2CAP_STATE_INVALID; 683fc64f94aSMatthias Ringwald l2cap_send_signaling_packet(channel->con_handle, CONNECTION_RESPONSE, channel->remote_sig_id, channel->local_cid, channel->remote_cid, channel->reason, 0); 684e7ff783cSmatthias.ringwald // discard channel - l2cap_finialize_channel_close without sending l2cap close event 6859dcb2fb2S[email protected] l2cap_stop_rtx(channel); 686665d90f2SMatthias Ringwald btstack_linked_list_iterator_remove(&it); 687d3a9df87Smatthias.ringwald btstack_memory_l2cap_channel_free(channel); 688e7ff783cSmatthias.ringwald break; 689e7ff783cSmatthias.ringwald 690552d92a1Smatthias.ringwald case L2CAP_STATE_WILL_SEND_CONNECTION_RESPONSE_ACCEPT: 691fc64f94aSMatthias Ringwald if (!hci_can_send_acl_packet_now(channel->con_handle)) break; 692fa8473a4Smatthias.ringwald channel->state = L2CAP_STATE_CONFIG; 69328ca2b46S[email protected] channelStateVarSetFlag(channel, L2CAP_CHANNEL_STATE_VAR_SEND_CONF_REQ); 694fc64f94aSMatthias Ringwald l2cap_send_signaling_packet(channel->con_handle, CONNECTION_RESPONSE, channel->remote_sig_id, channel->local_cid, channel->remote_cid, 0, 0); 695552d92a1Smatthias.ringwald break; 696552d92a1Smatthias.ringwald 6976fdcc387Smatthias.ringwald case L2CAP_STATE_WILL_SEND_CONNECTION_REQUEST: 698fc64f94aSMatthias Ringwald if (!hci_can_send_acl_packet_now(channel->con_handle)) break; 6996fdcc387Smatthias.ringwald // success, start l2cap handshake 700b1988dceSmatthias.ringwald channel->local_sig_id = l2cap_next_sig_id(); 7016fdcc387Smatthias.ringwald channel->state = L2CAP_STATE_WAIT_CONNECT_RSP; 702fc64f94aSMatthias Ringwald l2cap_send_signaling_packet( channel->con_handle, CONNECTION_REQUEST, channel->local_sig_id, channel->psm, channel->local_cid); 7035932bd7cS[email protected] l2cap_start_rtx(channel); 7046fdcc387Smatthias.ringwald break; 7056fdcc387Smatthias.ringwald 706fa8473a4Smatthias.ringwald case L2CAP_STATE_CONFIG: 707fc64f94aSMatthias Ringwald if (!hci_can_send_acl_packet_now(channel->con_handle)) break; 70873cf2b3dSmatthias.ringwald if (channel->state_var & L2CAP_CHANNEL_STATE_VAR_SEND_CONF_RSP){ 70963a7246aSmatthias.ringwald uint16_t flags = 0; 71028ca2b46S[email protected] channelStateVarClearFlag(channel, L2CAP_CHANNEL_STATE_VAR_SEND_CONF_RSP); 71163a7246aSmatthias.ringwald if (channel->state_var & L2CAP_CHANNEL_STATE_VAR_SEND_CONF_RSP_CONT) { 71263a7246aSmatthias.ringwald flags = 1; 71363a7246aSmatthias.ringwald } else { 71428ca2b46S[email protected] channelStateVarSetFlag(channel, L2CAP_CHANNEL_STATE_VAR_SENT_CONF_RSP); 71563a7246aSmatthias.ringwald } 71663a7246aSmatthias.ringwald if (channel->state_var & L2CAP_CHANNEL_STATE_VAR_SEND_CONF_RSP_INVALID){ 717fc64f94aSMatthias Ringwald l2cap_send_signaling_packet(channel->con_handle, CONFIGURE_RESPONSE, channel->remote_sig_id, channel->remote_cid, flags, L2CAP_CONF_RESULT_UNKNOWN_OPTIONS, 0, NULL); 71863a7246aSmatthias.ringwald } else if (channel->state_var & L2CAP_CHANNEL_STATE_VAR_SEND_CONF_RSP_MTU){ 71963a7246aSmatthias.ringwald config_options[0] = 1; // MTU 72063a7246aSmatthias.ringwald config_options[1] = 2; // len param 721f8fbdce0SMatthias Ringwald little_endian_store_16( (uint8_t*)&config_options, 2, channel->remote_mtu); 722fc64f94aSMatthias Ringwald l2cap_send_signaling_packet(channel->con_handle, CONFIGURE_RESPONSE, channel->remote_sig_id, channel->remote_cid, flags, 0, 4, &config_options); 72363a7246aSmatthias.ringwald channelStateVarClearFlag(channel,L2CAP_CHANNEL_STATE_VAR_SEND_CONF_RSP_MTU); 72463a7246aSmatthias.ringwald } else { 725fc64f94aSMatthias Ringwald l2cap_send_signaling_packet(channel->con_handle, CONFIGURE_RESPONSE, channel->remote_sig_id, channel->remote_cid, flags, 0, 0, NULL); 72663a7246aSmatthias.ringwald } 72763a7246aSmatthias.ringwald channelStateVarClearFlag(channel, L2CAP_CHANNEL_STATE_VAR_SEND_CONF_RSP_CONT); 728fa8473a4Smatthias.ringwald } 72973cf2b3dSmatthias.ringwald else if (channel->state_var & L2CAP_CHANNEL_STATE_VAR_SEND_CONF_REQ){ 73028ca2b46S[email protected] channelStateVarClearFlag(channel, L2CAP_CHANNEL_STATE_VAR_SEND_CONF_REQ); 73128ca2b46S[email protected] channelStateVarSetFlag(channel, L2CAP_CHANNEL_STATE_VAR_SENT_CONF_REQ); 732b1988dceSmatthias.ringwald channel->local_sig_id = l2cap_next_sig_id(); 733ae280e73Smatthias.ringwald config_options[0] = 1; // MTU 734ae280e73Smatthias.ringwald config_options[1] = 2; // len param 735f8fbdce0SMatthias Ringwald little_endian_store_16( (uint8_t*)&config_options, 2, channel->local_mtu); 736fc64f94aSMatthias Ringwald l2cap_send_signaling_packet(channel->con_handle, CONFIGURE_REQUEST, channel->local_sig_id, channel->remote_cid, 0, 4, &config_options); 7375932bd7cS[email protected] l2cap_start_rtx(channel); 738fa8473a4Smatthias.ringwald } 739fa8473a4Smatthias.ringwald if (l2cap_channel_ready_for_open(channel)){ 740552d92a1Smatthias.ringwald channel->state = L2CAP_STATE_OPEN; 741552d92a1Smatthias.ringwald l2cap_emit_channel_opened(channel, 0); // success 742fa8473a4Smatthias.ringwald } 743552d92a1Smatthias.ringwald break; 744552d92a1Smatthias.ringwald 745e7ff783cSmatthias.ringwald case L2CAP_STATE_WILL_SEND_DISCONNECT_RESPONSE: 746fc64f94aSMatthias Ringwald if (!hci_can_send_acl_packet_now(channel->con_handle)) break; 74722c29ab4SMatthias Ringwald channel->state = L2CAP_STATE_INVALID; 748fc64f94aSMatthias Ringwald l2cap_send_signaling_packet( channel->con_handle, DISCONNECTION_RESPONSE, channel->remote_sig_id, channel->local_cid, channel->remote_cid); 7495932bd7cS[email protected] // we don't start an RTX timer for a disconnect - there's no point in closing the channel if the other side doesn't respond :) 750756102d3Smatthias.ringwald l2cap_finialize_channel_close(channel); // -- remove from list 751e7ff783cSmatthias.ringwald break; 752e7ff783cSmatthias.ringwald 753e7ff783cSmatthias.ringwald case L2CAP_STATE_WILL_SEND_DISCONNECT_REQUEST: 754fc64f94aSMatthias Ringwald if (!hci_can_send_acl_packet_now(channel->con_handle)) break; 755b1988dceSmatthias.ringwald channel->local_sig_id = l2cap_next_sig_id(); 7562cd0be45Smatthias.ringwald channel->state = L2CAP_STATE_WAIT_DISCONNECT; 757fc64f94aSMatthias Ringwald l2cap_send_signaling_packet( channel->con_handle, DISCONNECTION_REQUEST, channel->local_sig_id, channel->remote_cid, channel->local_cid); 7582cd0be45Smatthias.ringwald break; 7592cd0be45Smatthias.ringwald default: 7602cd0be45Smatthias.ringwald break; 7612cd0be45Smatthias.ringwald } 7622cd0be45Smatthias.ringwald } 76309e9d05bSMatthias Ringwald #endif 764da886c03S[email protected] 765cab29d48SMatthias Ringwald #ifdef ENABLE_LE_DATA_CHANNELS 766efedfb4cSMatthias Ringwald btstack_linked_list_iterator_init(&it, &l2cap_le_channels); 767efedfb4cSMatthias Ringwald while (btstack_linked_list_iterator_has_next(&it)){ 7687f107edaSMatthias Ringwald uint8_t * acl_buffer; 7697f107edaSMatthias Ringwald uint8_t * l2cap_payload; 7707f107edaSMatthias Ringwald uint16_t pos; 7717f107edaSMatthias Ringwald uint16_t payload_size; 772efedfb4cSMatthias Ringwald l2cap_channel_t * channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it); 773efedfb4cSMatthias Ringwald // log_info("l2cap_run: channel %p, state %u, var 0x%02x", channel, channel->state, channel->state_var); 774efedfb4cSMatthias Ringwald switch (channel->state){ 7755cb87675SMatthias Ringwald case L2CAP_STATE_WILL_SEND_LE_CONNECTION_REQUEST: 7765cb87675SMatthias Ringwald if (!hci_can_send_acl_packet_now(channel->con_handle)) break; 7775cb87675SMatthias Ringwald channel->state = L2CAP_STATE_WAIT_LE_CONNECTION_RESPONSE; 7785cb87675SMatthias Ringwald // le psm, source cid, mtu, mps, initial credits 7791b8b8d05SMatthias Ringwald channel->local_sig_id = l2cap_next_sig_id(); 78063f0ac45SMatthias Ringwald channel->credits_incoming = channel->new_credits_incoming; 78163f0ac45SMatthias Ringwald channel->new_credits_incoming = 0; 78263f0ac45SMatthias Ringwald l2cap_send_le_signaling_packet( channel->con_handle, LE_CREDIT_BASED_CONNECTION_REQUEST, channel->local_sig_id, channel->psm, channel->local_cid, channel->local_mtu, 23, channel->credits_incoming); 7835cb87675SMatthias Ringwald break; 78423017473SMatthias Ringwald case L2CAP_STATE_WILL_SEND_LE_CONNECTION_RESPONSE_ACCEPT: 78523017473SMatthias Ringwald if (!hci_can_send_acl_packet_now(channel->con_handle)) break; 78623017473SMatthias Ringwald // TODO: support larger MPS 78723017473SMatthias Ringwald channel->state = L2CAP_STATE_OPEN; 78863f0ac45SMatthias Ringwald channel->credits_incoming = channel->new_credits_incoming; 78963f0ac45SMatthias Ringwald channel->new_credits_incoming = 0; 79063f0ac45SMatthias Ringwald l2cap_send_le_signaling_packet(channel->con_handle, LE_CREDIT_BASED_CONNECTION_RESPONSE, channel->remote_sig_id, channel->local_cid, channel->local_mtu, 23, channel->credits_incoming, 0); 79164e11ca9SMatthias Ringwald // notify client 79244276248SMatthias Ringwald l2cap_emit_le_channel_opened(channel, 0); 79323017473SMatthias Ringwald break; 794e7d0c9aaSMatthias Ringwald case L2CAP_STATE_WILL_SEND_LE_CONNECTION_RESPONSE_DECLINE: 795e7d0c9aaSMatthias Ringwald if (!hci_can_send_acl_packet_now(channel->con_handle)) break; 796e7d0c9aaSMatthias Ringwald channel->state = L2CAP_STATE_INVALID; 79763f0ac45SMatthias Ringwald l2cap_send_le_signaling_packet(channel->con_handle, LE_CREDIT_BASED_CONNECTION_RESPONSE, channel->remote_sig_id, 0, 0, 0, 0, channel->reason); 798e7d0c9aaSMatthias Ringwald // discard channel - l2cap_finialize_channel_close without sending l2cap close event 799e7d0c9aaSMatthias Ringwald l2cap_stop_rtx(channel); 800e7d0c9aaSMatthias Ringwald btstack_linked_list_iterator_remove(&it); 801e7d0c9aaSMatthias Ringwald btstack_memory_l2cap_channel_free(channel); 802e7d0c9aaSMatthias Ringwald break; 8037f107edaSMatthias Ringwald case L2CAP_STATE_OPEN: 80485aeef60SMatthias Ringwald if (!hci_can_send_acl_packet_now(channel->con_handle)) break; 80585aeef60SMatthias Ringwald 80685aeef60SMatthias Ringwald // send credits 80785aeef60SMatthias Ringwald if (channel->new_credits_incoming){ 80885aeef60SMatthias Ringwald log_info("l2cap: sending %u credits", channel->new_credits_incoming); 80985aeef60SMatthias Ringwald channel->local_sig_id = l2cap_next_sig_id(); 81085aeef60SMatthias Ringwald uint16_t new_credits = channel->new_credits_incoming; 81185aeef60SMatthias Ringwald channel->new_credits_incoming = 0; 81285aeef60SMatthias Ringwald channel->credits_incoming += new_credits; 81385aeef60SMatthias Ringwald l2cap_send_le_signaling_packet(channel->con_handle, LE_FLOW_CONTROL_CREDIT, channel->local_sig_id, channel->remote_cid, new_credits); 81485aeef60SMatthias Ringwald break; 81585aeef60SMatthias Ringwald } 81685aeef60SMatthias Ringwald 81785aeef60SMatthias Ringwald // send data 8187f107edaSMatthias Ringwald if (!channel->send_sdu_buffer) break; 8197f107edaSMatthias Ringwald if (!channel->credits_outgoing) break; 82085aeef60SMatthias Ringwald 8217f107edaSMatthias Ringwald // send part of SDU 8227f107edaSMatthias Ringwald hci_reserve_packet_buffer(); 8237f107edaSMatthias Ringwald acl_buffer = hci_get_outgoing_packet_buffer(); 8247f107edaSMatthias Ringwald l2cap_payload = acl_buffer + 8; 8257f107edaSMatthias Ringwald pos = 0; 8267f107edaSMatthias Ringwald if (!channel->send_sdu_pos){ 8277f107edaSMatthias Ringwald // store SDU len 8287f107edaSMatthias Ringwald channel->send_sdu_pos += 2; 8297f107edaSMatthias Ringwald little_endian_store_16(l2cap_payload, pos, channel->send_sdu_len); 8307f107edaSMatthias Ringwald pos += 2; 8317f107edaSMatthias Ringwald } 8327f107edaSMatthias Ringwald payload_size = btstack_min(channel->send_sdu_len + 2 - channel->send_sdu_pos, channel->remote_mps - pos); 83385aeef60SMatthias Ringwald log_info("len %u, pos %u => payload %u, credits %u", channel->send_sdu_len, channel->send_sdu_pos, payload_size, channel->credits_outgoing); 8347f107edaSMatthias Ringwald memcpy(&l2cap_payload[pos], &channel->send_sdu_buffer[channel->send_sdu_pos-2], payload_size); // -2 for virtual SDU len 8357f107edaSMatthias Ringwald pos += payload_size; 8367f107edaSMatthias Ringwald channel->send_sdu_pos += payload_size; 837f511cefaSMatthias Ringwald l2cap_setup_header(acl_buffer, channel->con_handle, 0, channel->remote_cid, pos); 8387f107edaSMatthias Ringwald // done 8397f107edaSMatthias Ringwald 84085aeef60SMatthias Ringwald channel->credits_outgoing--; 8417f107edaSMatthias Ringwald 8427f107edaSMatthias Ringwald if (channel->send_sdu_pos >= channel->send_sdu_len + 2){ 8437f107edaSMatthias Ringwald channel->send_sdu_buffer = NULL; 84444276248SMatthias Ringwald // send done event 84544276248SMatthias Ringwald l2cap_emit_simple_event_with_cid(channel, L2CAP_EVENT_LE_PACKET_SENT); 84644276248SMatthias Ringwald // inform about can send now 84744276248SMatthias Ringwald l2cap_le_notify_channel_can_send(channel); 8487f107edaSMatthias Ringwald } 8497f107edaSMatthias Ringwald hci_send_acl_packet_buffer(8 + pos); 8507f107edaSMatthias Ringwald break; 851828a7f7aSMatthias Ringwald case L2CAP_STATE_WILL_SEND_DISCONNECT_REQUEST: 852828a7f7aSMatthias Ringwald if (!hci_can_send_acl_packet_now(channel->con_handle)) break; 853828a7f7aSMatthias Ringwald channel->local_sig_id = l2cap_next_sig_id(); 854828a7f7aSMatthias Ringwald channel->state = L2CAP_STATE_WAIT_DISCONNECT; 855828a7f7aSMatthias Ringwald l2cap_send_le_signaling_packet( channel->con_handle, DISCONNECTION_REQUEST, channel->local_sig_id, channel->remote_cid, channel->local_cid); 856828a7f7aSMatthias Ringwald break; 857828a7f7aSMatthias Ringwald case L2CAP_STATE_WILL_SEND_DISCONNECT_RESPONSE: 858828a7f7aSMatthias Ringwald if (!hci_can_send_acl_packet_now(channel->con_handle)) break; 859828a7f7aSMatthias Ringwald channel->state = L2CAP_STATE_INVALID; 860828a7f7aSMatthias Ringwald l2cap_send_le_signaling_packet( channel->con_handle, DISCONNECTION_RESPONSE, channel->remote_sig_id, channel->local_cid, channel->remote_cid); 861828a7f7aSMatthias Ringwald l2cap_le_finialize_channel_close(channel); // -- remove from list 862828a7f7aSMatthias Ringwald break; 863efedfb4cSMatthias Ringwald default: 864efedfb4cSMatthias Ringwald break; 865efedfb4cSMatthias Ringwald } 866efedfb4cSMatthias Ringwald } 86709e9d05bSMatthias Ringwald #endif 868efedfb4cSMatthias Ringwald 86909e9d05bSMatthias Ringwald #ifdef ENABLE_BLE 870da886c03S[email protected] // send l2cap con paramter update if necessary 871da886c03S[email protected] hci_connections_get_iterator(&it); 872665d90f2SMatthias Ringwald while(btstack_linked_list_iterator_has_next(&it)){ 873665d90f2SMatthias Ringwald hci_connection_t * connection = (hci_connection_t *) btstack_linked_list_iterator_next(&it); 8745d14fa8fSMatthias Ringwald if (connection->address_type != BD_ADDR_TYPE_LE_PUBLIC && connection->address_type != BD_ADDR_TYPE_LE_RANDOM) continue; 875b68d7bc3SMatthias Ringwald if (!hci_can_send_acl_packet_now(connection->con_handle)) continue; 876da886c03S[email protected] switch (connection->le_con_parameter_update_state){ 877b68d7bc3SMatthias Ringwald case CON_PARAMETER_UPDATE_SEND_REQUEST: 878b68d7bc3SMatthias Ringwald connection->le_con_parameter_update_state = CON_PARAMETER_UPDATE_NONE; 879b68d7bc3SMatthias Ringwald l2cap_send_le_signaling_packet(connection->con_handle, CONNECTION_PARAMETER_UPDATE_REQUEST, connection->le_con_param_update_identifier, 880b68d7bc3SMatthias Ringwald connection->le_conn_interval_min, connection->le_conn_interval_max, connection->le_conn_latency, connection->le_supervision_timeout); 881b68d7bc3SMatthias Ringwald break; 882da886c03S[email protected] case CON_PARAMETER_UPDATE_SEND_RESPONSE: 883b68d7bc3SMatthias Ringwald connection->le_con_parameter_update_state = CON_PARAMETER_UPDATE_CHANGE_HCI_CON_PARAMETERS; 884b68d7bc3SMatthias Ringwald l2cap_send_le_signaling_packet(connection->con_handle, CONNECTION_PARAMETER_UPDATE_RESPONSE, connection->le_con_param_update_identifier, 0); 885da886c03S[email protected] break; 886da886c03S[email protected] case CON_PARAMETER_UPDATE_DENY: 887b68d7bc3SMatthias Ringwald connection->le_con_parameter_update_state = CON_PARAMETER_UPDATE_NONE; 888b68d7bc3SMatthias Ringwald l2cap_send_le_signaling_packet(connection->con_handle, CONNECTION_PARAMETER_UPDATE_RESPONSE, connection->le_con_param_update_identifier, 1); 889da886c03S[email protected] break; 890da886c03S[email protected] default: 891da886c03S[email protected] break; 892da886c03S[email protected] } 893da886c03S[email protected] } 8944d7157c3S[email protected] #endif 895da886c03S[email protected] 89622c29ab4SMatthias Ringwald // log_info("l2cap_run: exit"); 8972cd0be45Smatthias.ringwald } 8982cd0be45Smatthias.ringwald 89909e9d05bSMatthias Ringwald #ifdef ENABLE_CLASSIC 900fc64f94aSMatthias Ringwald static void l2cap_handle_connection_complete(hci_con_handle_t con_handle, l2cap_channel_t * channel){ 9012df5dadcS[email protected] if (channel->state == L2CAP_STATE_WAIT_CONNECTION_COMPLETE || channel->state == L2CAP_STATE_WILL_SEND_CREATE_CONNECTION) { 9025533f01eS[email protected] log_info("l2cap_handle_connection_complete expected state"); 9032df5dadcS[email protected] // success, start l2cap handshake 904fc64f94aSMatthias Ringwald channel->con_handle = con_handle; 9052df5dadcS[email protected] // check remote SSP feature first 9062df5dadcS[email protected] channel->state = L2CAP_STATE_WAIT_REMOTE_SUPPORTED_FEATURES; 9072df5dadcS[email protected] } 9082df5dadcS[email protected] } 9092df5dadcS[email protected] 9102df5dadcS[email protected] static void l2cap_handle_remote_supported_features_received(l2cap_channel_t * channel){ 9112df5dadcS[email protected] if (channel->state != L2CAP_STATE_WAIT_REMOTE_SUPPORTED_FEATURES) return; 9122df5dadcS[email protected] 9132df5dadcS[email protected] // we have been waiting for remote supported features, if both support SSP, 914ac301f95S[email protected] log_info("l2cap received remote supported features, sec_level_0_allowed for psm %u = %u", channel->psm, l2cap_security_level_0_allowed_for_PSM(channel->psm)); 915fc64f94aSMatthias Ringwald if (gap_ssp_supported_on_both_sides(channel->con_handle) && !l2cap_security_level_0_allowed_for_PSM(channel->psm)){ 9162df5dadcS[email protected] // request security level 2 9172df5dadcS[email protected] channel->state = L2CAP_STATE_WAIT_OUTGOING_SECURITY_LEVEL_UPDATE; 918fc64f94aSMatthias Ringwald gap_request_security_level(channel->con_handle, LEVEL_2); 9192df5dadcS[email protected] return; 9202df5dadcS[email protected] } 9212df5dadcS[email protected] // fine, go ahead 9222df5dadcS[email protected] channel->state = L2CAP_STATE_WILL_SEND_CONNECTION_REQUEST; 9232df5dadcS[email protected] } 92409e9d05bSMatthias Ringwald #endif 9252df5dadcS[email protected] 92609e9d05bSMatthias Ringwald #ifdef L2CAP_USES_CHANNELS 927da144af5SMatthias Ringwald static l2cap_channel_t * l2cap_create_channel_entry(btstack_packet_handler_t packet_handler, bd_addr_t address, bd_addr_type_t address_type, 928da144af5SMatthias Ringwald uint16_t psm, uint16_t local_mtu, gap_security_level_t security_level){ 929da144af5SMatthias Ringwald 930da144af5SMatthias Ringwald l2cap_channel_t * channel = btstack_memory_l2cap_channel_get(); 931da144af5SMatthias Ringwald if (!channel) { 932da144af5SMatthias Ringwald return NULL; 933da144af5SMatthias Ringwald } 934da144af5SMatthias Ringwald 935da144af5SMatthias Ringwald // Init memory (make valgrind happy) 936da144af5SMatthias Ringwald memset(channel, 0, sizeof(l2cap_channel_t)); 937da144af5SMatthias Ringwald 938da144af5SMatthias Ringwald // fill in 939da144af5SMatthias Ringwald channel->packet_handler = packet_handler; 940da144af5SMatthias Ringwald bd_addr_copy(channel->address, address); 941da144af5SMatthias Ringwald channel->address_type = address_type; 942da144af5SMatthias Ringwald channel->psm = psm; 943da144af5SMatthias Ringwald channel->local_mtu = local_mtu; 944da144af5SMatthias Ringwald channel->remote_mtu = L2CAP_MINIMAL_MTU; 945da144af5SMatthias Ringwald channel->required_security_level = security_level; 946da144af5SMatthias Ringwald 947da144af5SMatthias Ringwald // 948da144af5SMatthias Ringwald channel->local_cid = l2cap_next_local_cid(); 949da144af5SMatthias Ringwald channel->con_handle = 0; 950da144af5SMatthias Ringwald 951da144af5SMatthias Ringwald // set initial state 952da144af5SMatthias Ringwald channel->state = L2CAP_STATE_WILL_SEND_CREATE_CONNECTION; 953da144af5SMatthias Ringwald channel->state_var = L2CAP_CHANNEL_STATE_VAR_NONE; 954da144af5SMatthias Ringwald channel->remote_sig_id = L2CAP_SIG_ID_INVALID; 955da144af5SMatthias Ringwald channel->local_sig_id = L2CAP_SIG_ID_INVALID; 956da144af5SMatthias Ringwald return channel; 957da144af5SMatthias Ringwald } 95809e9d05bSMatthias Ringwald #endif 95909e9d05bSMatthias Ringwald 96009e9d05bSMatthias Ringwald #ifdef ENABLE_CLASSIC 961da144af5SMatthias Ringwald 9629077cb15SMatthias Ringwald /** 9639077cb15SMatthias Ringwald * @brief Creates L2CAP channel to the PSM of a remote device with baseband address. A new baseband connection will be initiated if necessary. 9649077cb15SMatthias Ringwald * @param packet_handler 9659077cb15SMatthias Ringwald * @param address 9669077cb15SMatthias Ringwald * @param psm 9679077cb15SMatthias Ringwald * @param mtu 9689077cb15SMatthias Ringwald * @param local_cid 9699077cb15SMatthias Ringwald */ 9709077cb15SMatthias Ringwald 971da144af5SMatthias Ringwald uint8_t l2cap_create_channel(btstack_packet_handler_t channel_packet_handler, bd_addr_t address, uint16_t psm, uint16_t local_mtu, uint16_t * out_local_cid){ 972da144af5SMatthias Ringwald log_info("L2CAP_CREATE_CHANNEL addr %s psm 0x%x mtu %u", bd_addr_to_str(address), psm, local_mtu); 973da144af5SMatthias Ringwald 974da144af5SMatthias Ringwald if (local_mtu > l2cap_max_mtu()) { 975da144af5SMatthias Ringwald local_mtu = l2cap_max_mtu(); 976da144af5SMatthias Ringwald } 977da144af5SMatthias Ringwald 978da144af5SMatthias Ringwald l2cap_channel_t * channel = l2cap_create_channel_entry(channel_packet_handler, address, BD_ADDR_TYPE_CLASSIC, psm, local_mtu, LEVEL_0); 979fc64f94aSMatthias Ringwald if (!channel) { 9809077cb15SMatthias Ringwald return BTSTACK_MEMORY_ALLOC_FAILED; 9819077cb15SMatthias Ringwald } 9829077cb15SMatthias Ringwald 9839077cb15SMatthias Ringwald // add to connections list 984fc64f94aSMatthias Ringwald btstack_linked_list_add(&l2cap_channels, (btstack_linked_item_t *) channel); 9859077cb15SMatthias Ringwald 9869077cb15SMatthias Ringwald // store local_cid 9879077cb15SMatthias Ringwald if (out_local_cid){ 988fc64f94aSMatthias Ringwald *out_local_cid = channel->local_cid; 9899077cb15SMatthias Ringwald } 9909077cb15SMatthias Ringwald 9919077cb15SMatthias Ringwald // check if hci connection is already usable 9929077cb15SMatthias Ringwald hci_connection_t * conn = hci_connection_for_bd_addr_and_type(address, BD_ADDR_TYPE_CLASSIC); 9939077cb15SMatthias Ringwald if (conn){ 994add0254bSMatthias Ringwald log_info("l2cap_create_channel, hci connection already exists"); 995fc64f94aSMatthias Ringwald l2cap_handle_connection_complete(conn->con_handle, channel); 9969077cb15SMatthias Ringwald // check if remote supported fearures are already received 9979077cb15SMatthias Ringwald if (conn->bonding_flags & BONDING_RECEIVED_REMOTE_FEATURES) { 998fc64f94aSMatthias Ringwald l2cap_handle_remote_supported_features_received(channel); 9999077cb15SMatthias Ringwald } 10009077cb15SMatthias Ringwald } 10019077cb15SMatthias Ringwald 10029077cb15SMatthias Ringwald l2cap_run(); 10039077cb15SMatthias Ringwald 10049077cb15SMatthias Ringwald return 0; 10059077cb15SMatthias Ringwald } 10069077cb15SMatthias Ringwald 1007ce8f182eSMatthias Ringwald void 1008ce8f182eSMatthias Ringwald l2cap_disconnect(uint16_t local_cid, uint8_t reason){ 1009e0abb8e7S[email protected] log_info("L2CAP_DISCONNECT local_cid 0x%x reason 0x%x", local_cid, reason); 1010b35f641cSmatthias.ringwald // find channel for local_cid 1011b35f641cSmatthias.ringwald l2cap_channel_t * channel = l2cap_get_channel_for_local_cid(local_cid); 1012f62db1e3Smatthias.ringwald if (channel) { 1013e7ff783cSmatthias.ringwald channel->state = L2CAP_STATE_WILL_SEND_DISCONNECT_REQUEST; 1014f62db1e3Smatthias.ringwald } 10152cd0be45Smatthias.ringwald // process 10162cd0be45Smatthias.ringwald l2cap_run(); 101743625864Smatthias.ringwald } 10181e6aba47Smatthias.ringwald 1019afde0c52Smatthias.ringwald static void l2cap_handle_connection_failed_for_addr(bd_addr_t address, uint8_t status){ 1020665d90f2SMatthias Ringwald btstack_linked_list_iterator_t it; 1021665d90f2SMatthias Ringwald btstack_linked_list_iterator_init(&it, &l2cap_channels); 1022665d90f2SMatthias Ringwald while (btstack_linked_list_iterator_has_next(&it)){ 1023665d90f2SMatthias Ringwald l2cap_channel_t * channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it); 1024058e3d6bSMatthias Ringwald if ( bd_addr_cmp( channel->address, address) != 0) continue; 1025c22aecc9S[email protected] // channel for this address found 1026c22aecc9S[email protected] switch (channel->state){ 1027c22aecc9S[email protected] case L2CAP_STATE_WAIT_CONNECTION_COMPLETE: 1028c22aecc9S[email protected] case L2CAP_STATE_WILL_SEND_CREATE_CONNECTION: 1029afde0c52Smatthias.ringwald // failure, forward error code 1030afde0c52Smatthias.ringwald l2cap_emit_channel_opened(channel, status); 1031afde0c52Smatthias.ringwald // discard channel 10329dcb2fb2S[email protected] l2cap_stop_rtx(channel); 1033665d90f2SMatthias Ringwald btstack_linked_list_iterator_remove(&it); 1034d3a9df87Smatthias.ringwald btstack_memory_l2cap_channel_free(channel); 1035c22aecc9S[email protected] break; 1036c22aecc9S[email protected] default: 1037c22aecc9S[email protected] break; 1038afde0c52Smatthias.ringwald } 1039afde0c52Smatthias.ringwald } 1040afde0c52Smatthias.ringwald } 1041afde0c52Smatthias.ringwald 1042afde0c52Smatthias.ringwald static void l2cap_handle_connection_success_for_addr(bd_addr_t address, hci_con_handle_t handle){ 1043665d90f2SMatthias Ringwald btstack_linked_list_iterator_t it; 1044665d90f2SMatthias Ringwald btstack_linked_list_iterator_init(&it, &l2cap_channels); 1045665d90f2SMatthias Ringwald while (btstack_linked_list_iterator_has_next(&it)){ 1046665d90f2SMatthias Ringwald l2cap_channel_t * channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it); 1047058e3d6bSMatthias Ringwald if ( ! bd_addr_cmp( channel->address, address) ){ 10482df5dadcS[email protected] l2cap_handle_connection_complete(handle, channel); 1049afde0c52Smatthias.ringwald } 1050afde0c52Smatthias.ringwald } 10516fdcc387Smatthias.ringwald // process 10526fdcc387Smatthias.ringwald l2cap_run(); 1053afde0c52Smatthias.ringwald } 105409e9d05bSMatthias Ringwald #endif 1055b448a0e7Smatthias.ringwald 105633c40538SMatthias Ringwald static void l2cap_notify_channel_can_send(void){ 105709e9d05bSMatthias Ringwald 105809e9d05bSMatthias Ringwald #ifdef ENABLE_CLASSIC 105933c40538SMatthias Ringwald btstack_linked_list_iterator_t it; 106033c40538SMatthias Ringwald btstack_linked_list_iterator_init(&it, &l2cap_channels); 106133c40538SMatthias Ringwald while (btstack_linked_list_iterator_has_next(&it)){ 106233c40538SMatthias Ringwald l2cap_channel_t * channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it); 106333c40538SMatthias Ringwald if (!channel->waiting_for_can_send_now) continue; 1064fc64f94aSMatthias Ringwald if (!hci_can_send_acl_packet_now(channel->con_handle)) continue; 106533c40538SMatthias Ringwald channel->waiting_for_can_send_now = 0; 106634e7e577SMatthias Ringwald l2cap_emit_can_send_now(channel->packet_handler, channel->local_cid); 106733c40538SMatthias Ringwald } 106809e9d05bSMatthias Ringwald #endif 106944276248SMatthias Ringwald 10702125de09SMatthias Ringwald int i; 10712125de09SMatthias Ringwald for (i=0;i<L2CAP_FIXED_CHANNEL_TABLE_SIZE;i++){ 1072773c4106SMatthias Ringwald if (!fixed_channels[i].callback) continue; 10732125de09SMatthias Ringwald if (!fixed_channels[i].waiting_for_can_send_now) continue; 107435454696SMatthias Ringwald int can_send = 0; 107534e7e577SMatthias Ringwald if (l2cap_fixed_channel_table_index_is_le(i)){ 107635454696SMatthias Ringwald #ifdef ENABLE_BLE 107734e7e577SMatthias Ringwald can_send = hci_can_send_acl_le_packet_now(); 107835454696SMatthias Ringwald #endif 107934e7e577SMatthias Ringwald } else { 108035454696SMatthias Ringwald #ifdef ENABLE_CLASSIC 108134e7e577SMatthias Ringwald can_send = hci_can_send_acl_classic_packet_now(); 108235454696SMatthias Ringwald #endif 108334e7e577SMatthias Ringwald } 108434e7e577SMatthias Ringwald if (!can_send) continue; 108534e7e577SMatthias Ringwald fixed_channels[i].waiting_for_can_send_now = 0; 108634e7e577SMatthias Ringwald l2cap_emit_can_send_now(fixed_channels[i].callback, l2cap_fixed_channel_table_channel_id_for_index(i)); 10872125de09SMatthias Ringwald } 108833c40538SMatthias Ringwald } 108933c40538SMatthias Ringwald 1090d9a7306aSMatthias Ringwald static void l2cap_hci_event_handler(uint8_t packet_type, uint16_t cid, uint8_t *packet, uint16_t size){ 1091afde0c52Smatthias.ringwald 10929ec2630cSMatthias Ringwald UNUSED(packet_type); 10939ec2630cSMatthias Ringwald UNUSED(cid); 10949ec2630cSMatthias Ringwald UNUSED(size); 10959ec2630cSMatthias Ringwald 1096afde0c52Smatthias.ringwald bd_addr_t address; 1097afde0c52Smatthias.ringwald hci_con_handle_t handle; 10982d00edd4Smatthias.ringwald int hci_con_used; 109909e9d05bSMatthias Ringwald btstack_linked_list_iterator_t it; 110009e9d05bSMatthias Ringwald 110109e9d05bSMatthias Ringwald // avoid unused warnings 1102f3963406SMatthias Ringwald UNUSED(address); 1103f3963406SMatthias Ringwald UNUSED(hci_con_used); 1104f3963406SMatthias Ringwald UNUSED(it); 1105f22209dfSMatthias Ringwald UNUSED(handle); 1106afde0c52Smatthias.ringwald 11070e2df43fSMatthias Ringwald switch(hci_event_packet_get_type(packet)){ 1108afde0c52Smatthias.ringwald 110909e9d05bSMatthias Ringwald // Notify channel packet handler if they can send now 111009e9d05bSMatthias Ringwald case HCI_EVENT_TRANSPORT_PACKET_SENT: 111109e9d05bSMatthias Ringwald case HCI_EVENT_NUMBER_OF_COMPLETED_PACKETS: 111209e9d05bSMatthias Ringwald l2cap_run(); // try sending signaling packets first 111309e9d05bSMatthias Ringwald l2cap_notify_channel_can_send(); 111409e9d05bSMatthias Ringwald break; 111509e9d05bSMatthias Ringwald 111609e9d05bSMatthias Ringwald case HCI_EVENT_COMMAND_STATUS: 111709e9d05bSMatthias Ringwald l2cap_run(); // try sending signaling packets first 111809e9d05bSMatthias Ringwald break; 111909e9d05bSMatthias Ringwald 112009e9d05bSMatthias Ringwald #ifdef ENABLE_CLASSIC 1121afde0c52Smatthias.ringwald // handle connection complete events 1122afde0c52Smatthias.ringwald case HCI_EVENT_CONNECTION_COMPLETE: 1123724d70a2SMatthias Ringwald reverse_bd_addr(&packet[5], address); 1124afde0c52Smatthias.ringwald if (packet[2] == 0){ 1125f8fbdce0SMatthias Ringwald handle = little_endian_read_16(packet, 3); 1126afde0c52Smatthias.ringwald l2cap_handle_connection_success_for_addr(address, handle); 1127afde0c52Smatthias.ringwald } else { 1128afde0c52Smatthias.ringwald l2cap_handle_connection_failed_for_addr(address, packet[2]); 1129afde0c52Smatthias.ringwald } 1130afde0c52Smatthias.ringwald break; 1131afde0c52Smatthias.ringwald 1132afde0c52Smatthias.ringwald // handle successful create connection cancel command 1133afde0c52Smatthias.ringwald case HCI_EVENT_COMMAND_COMPLETE: 1134073bd0faSMatthias Ringwald if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_create_connection_cancel)) { 1135afde0c52Smatthias.ringwald if (packet[5] == 0){ 1136724d70a2SMatthias Ringwald reverse_bd_addr(&packet[6], address); 1137afde0c52Smatthias.ringwald // CONNECTION TERMINATED BY LOCAL HOST (0X16) 1138afde0c52Smatthias.ringwald l2cap_handle_connection_failed_for_addr(address, 0x16); 113903cfbabcSmatthias.ringwald } 11401e6aba47Smatthias.ringwald } 114139d59809Smatthias.ringwald l2cap_run(); // try sending signaling packets first 114239d59809Smatthias.ringwald break; 114309e9d05bSMatthias Ringwald #endif 114427a923d0Smatthias.ringwald 11451e6aba47Smatthias.ringwald // handle disconnection complete events 1146afde0c52Smatthias.ringwald case HCI_EVENT_DISCONNECTION_COMPLETE: 1147c22aecc9S[email protected] // send l2cap disconnect events for all channels on this handle and free them 114809e9d05bSMatthias Ringwald #ifdef ENABLE_CLASSIC 1149d0662982SMatthias Ringwald handle = little_endian_read_16(packet, 3); 1150665d90f2SMatthias Ringwald btstack_linked_list_iterator_init(&it, &l2cap_channels); 1151665d90f2SMatthias Ringwald while (btstack_linked_list_iterator_has_next(&it)){ 1152665d90f2SMatthias Ringwald l2cap_channel_t * channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it); 1153fc64f94aSMatthias Ringwald if (channel->con_handle != handle) continue; 115415ec09bbSmatthias.ringwald l2cap_emit_channel_closed(channel); 11559dcb2fb2S[email protected] l2cap_stop_rtx(channel); 1156665d90f2SMatthias Ringwald btstack_linked_list_iterator_remove(&it); 1157d3a9df87Smatthias.ringwald btstack_memory_l2cap_channel_free(channel); 115827a923d0Smatthias.ringwald } 115909e9d05bSMatthias Ringwald #endif 1160a3dc965aSMatthias Ringwald #ifdef ENABLE_LE_DATA_CHANNELS 1161d0662982SMatthias Ringwald handle = little_endian_read_16(packet, 3); 1162991fea48SMatthias Ringwald btstack_linked_list_iterator_init(&it, &l2cap_le_channels); 1163991fea48SMatthias Ringwald while (btstack_linked_list_iterator_has_next(&it)){ 1164991fea48SMatthias Ringwald l2cap_channel_t * channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it); 1165991fea48SMatthias Ringwald if (channel->con_handle != handle) continue; 1166991fea48SMatthias Ringwald l2cap_emit_channel_closed(channel); 1167991fea48SMatthias Ringwald btstack_linked_list_iterator_remove(&it); 1168991fea48SMatthias Ringwald btstack_memory_l2cap_channel_free(channel); 1169991fea48SMatthias Ringwald } 1170991fea48SMatthias Ringwald #endif 1171afde0c52Smatthias.ringwald break; 1172fcadd0caSmatthias.ringwald 1173ee091cf1Smatthias.ringwald // HCI Connection Timeouts 117409e9d05bSMatthias Ringwald #ifdef ENABLE_CLASSIC 1175afde0c52Smatthias.ringwald case L2CAP_EVENT_TIMEOUT_CHECK: 1176f8fbdce0SMatthias Ringwald handle = little_endian_read_16(packet, 2); 1177bd04d84aSMatthias Ringwald if (gap_get_connection_type(handle) != GAP_CONNECTION_ACL) break; 117880ca58a0Smatthias.ringwald if (hci_authentication_active_for_handle(handle)) break; 11792d00edd4Smatthias.ringwald hci_con_used = 0; 1180665d90f2SMatthias Ringwald btstack_linked_list_iterator_init(&it, &l2cap_channels); 1181665d90f2SMatthias Ringwald while (btstack_linked_list_iterator_has_next(&it)){ 1182665d90f2SMatthias Ringwald l2cap_channel_t * channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it); 1183fc64f94aSMatthias Ringwald if (channel->con_handle != handle) continue; 11842d00edd4Smatthias.ringwald hci_con_used = 1; 1185c22aecc9S[email protected] break; 1186ee091cf1Smatthias.ringwald } 11872d00edd4Smatthias.ringwald if (hci_con_used) break; 1188d94d3cafS[email protected] if (!hci_can_send_command_packet_now()) break; 11899edc8742Smatthias.ringwald hci_send_cmd(&hci_disconnect, handle, 0x13); // remote closed connection 1190afde0c52Smatthias.ringwald break; 1191ee091cf1Smatthias.ringwald 1192df3354fcS[email protected] case HCI_EVENT_READ_REMOTE_SUPPORTED_FEATURES_COMPLETE: 1193f8fbdce0SMatthias Ringwald handle = little_endian_read_16(packet, 3); 1194665d90f2SMatthias Ringwald btstack_linked_list_iterator_init(&it, &l2cap_channels); 1195665d90f2SMatthias Ringwald while (btstack_linked_list_iterator_has_next(&it)){ 1196665d90f2SMatthias Ringwald l2cap_channel_t * channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it); 1197fc64f94aSMatthias Ringwald if (channel->con_handle != handle) continue; 11982df5dadcS[email protected] l2cap_handle_remote_supported_features_received(channel); 1199df3354fcS[email protected] break; 1200df3354fcS[email protected] } 1201c22aecc9S[email protected] break; 1202df3354fcS[email protected] 12035611a760SMatthias Ringwald case GAP_EVENT_SECURITY_LEVEL: 1204f8fbdce0SMatthias Ringwald handle = little_endian_read_16(packet, 2); 1205bd63148eS[email protected] log_info("l2cap - security level update"); 1206665d90f2SMatthias Ringwald btstack_linked_list_iterator_init(&it, &l2cap_channels); 1207665d90f2SMatthias Ringwald while (btstack_linked_list_iterator_has_next(&it)){ 1208665d90f2SMatthias Ringwald l2cap_channel_t * channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it); 1209fc64f94aSMatthias Ringwald if (channel->con_handle != handle) continue; 12105533f01eS[email protected] 1211bd63148eS[email protected] log_info("l2cap - state %u", channel->state); 1212bd63148eS[email protected] 1213e569dfd9SMatthias Ringwald gap_security_level_t actual_level = (gap_security_level_t) packet[4]; 12145533f01eS[email protected] gap_security_level_t required_level = channel->required_security_level; 12155533f01eS[email protected] 1216df3354fcS[email protected] switch (channel->state){ 1217df3354fcS[email protected] case L2CAP_STATE_WAIT_INCOMING_SECURITY_LEVEL_UPDATE: 12185533f01eS[email protected] if (actual_level >= required_level){ 1219f85a9399S[email protected] channel->state = L2CAP_STATE_WAIT_CLIENT_ACCEPT_OR_REJECT; 122044276248SMatthias Ringwald l2cap_emit_incoming_connection(channel); 12211eb2563eS[email protected] } else { 1222775ecc36SMatthias Ringwald channel->reason = 0x0003; // security block 12231eb2563eS[email protected] channel->state = L2CAP_STATE_WILL_SEND_CONNECTION_RESPONSE_DECLINE; 12241eb2563eS[email protected] } 1225df3354fcS[email protected] break; 1226df3354fcS[email protected] 1227df3354fcS[email protected] case L2CAP_STATE_WAIT_OUTGOING_SECURITY_LEVEL_UPDATE: 12285533f01eS[email protected] if (actual_level >= required_level){ 1229df3354fcS[email protected] channel->state = L2CAP_STATE_WILL_SEND_CONNECTION_REQUEST; 1230df3354fcS[email protected] } else { 1231df3354fcS[email protected] // disconnnect, authentication not good enough 1232df3354fcS[email protected] hci_disconnect_security_block(handle); 1233df3354fcS[email protected] } 1234df3354fcS[email protected] break; 1235df3354fcS[email protected] 1236df3354fcS[email protected] default: 1237df3354fcS[email protected] break; 1238df3354fcS[email protected] } 1239f85a9399S[email protected] } 1240f85a9399S[email protected] break; 124109e9d05bSMatthias Ringwald #endif 1242f85a9399S[email protected] 1243afde0c52Smatthias.ringwald default: 1244afde0c52Smatthias.ringwald break; 1245afde0c52Smatthias.ringwald } 1246afde0c52Smatthias.ringwald 1247bd63148eS[email protected] l2cap_run(); 12481e6aba47Smatthias.ringwald } 12491e6aba47Smatthias.ringwald 1250e74c5f58SMatthias Ringwald static void l2cap_register_signaling_response(hci_con_handle_t handle, uint8_t code, uint8_t sig_id, uint16_t cid, uint16_t data){ 12514cf56b4aSmatthias.ringwald // Vol 3, Part A, 4.3: "The DCID and SCID fields shall be ignored when the result field indi- cates the connection was refused." 12522b360848Smatthias.ringwald if (signaling_responses_pending < NR_PENDING_SIGNALING_RESPONSES) { 12532b360848Smatthias.ringwald signaling_responses[signaling_responses_pending].handle = handle; 12542b360848Smatthias.ringwald signaling_responses[signaling_responses_pending].code = code; 12552b360848Smatthias.ringwald signaling_responses[signaling_responses_pending].sig_id = sig_id; 1256e74c5f58SMatthias Ringwald signaling_responses[signaling_responses_pending].cid = cid; 12572b360848Smatthias.ringwald signaling_responses[signaling_responses_pending].data = data; 12582b360848Smatthias.ringwald signaling_responses_pending++; 12592b360848Smatthias.ringwald l2cap_run(); 12602b360848Smatthias.ringwald } 12612b360848Smatthias.ringwald } 12622b360848Smatthias.ringwald 126309e9d05bSMatthias Ringwald #ifdef ENABLE_CLASSIC 126409e9d05bSMatthias Ringwald static void l2cap_handle_disconnect_request(l2cap_channel_t *channel, uint16_t identifier){ 126509e9d05bSMatthias Ringwald channel->remote_sig_id = identifier; 126609e9d05bSMatthias Ringwald channel->state = L2CAP_STATE_WILL_SEND_DISCONNECT_RESPONSE; 126709e9d05bSMatthias Ringwald l2cap_run(); 126809e9d05bSMatthias Ringwald } 126909e9d05bSMatthias Ringwald 1270b35f641cSmatthias.ringwald static void l2cap_handle_connection_request(hci_con_handle_t handle, uint8_t sig_id, uint16_t psm, uint16_t source_cid){ 1271645658c9Smatthias.ringwald 12729da54300S[email protected] // log_info("l2cap_handle_connection_request for handle %u, psm %u cid 0x%02x", handle, psm, source_cid); 1273645658c9Smatthias.ringwald l2cap_service_t *service = l2cap_get_service(psm); 1274645658c9Smatthias.ringwald if (!service) { 1275645658c9Smatthias.ringwald // 0x0002 PSM not supported 1276e74c5f58SMatthias Ringwald l2cap_register_signaling_response(handle, CONNECTION_REQUEST, sig_id, source_cid, 0x0002); 1277645658c9Smatthias.ringwald return; 1278645658c9Smatthias.ringwald } 1279645658c9Smatthias.ringwald 12805061f3afS[email protected] hci_connection_t * hci_connection = hci_connection_for_handle( handle ); 1281645658c9Smatthias.ringwald if (!hci_connection) { 12822b360848Smatthias.ringwald // 12839da54300S[email protected] log_error("no hci_connection for handle %u", handle); 1284645658c9Smatthias.ringwald return; 1285645658c9Smatthias.ringwald } 12862bd8b7e7S[email protected] 1287645658c9Smatthias.ringwald // alloc structure 12889da54300S[email protected] // log_info("l2cap_handle_connection_request register channel"); 1289da144af5SMatthias Ringwald l2cap_channel_t * channel = l2cap_create_channel_entry(service->packet_handler, hci_connection->address, BD_ADDR_TYPE_CLASSIC, 1290da144af5SMatthias Ringwald psm, service->mtu, service->required_security_level); 12912b360848Smatthias.ringwald if (!channel){ 12922b360848Smatthias.ringwald // 0x0004 No resources available 1293e74c5f58SMatthias Ringwald l2cap_register_signaling_response(handle, CONNECTION_REQUEST, sig_id, source_cid, 0x0004); 12942b360848Smatthias.ringwald return; 12952b360848Smatthias.ringwald } 1296da144af5SMatthias Ringwald 1297fc64f94aSMatthias Ringwald channel->con_handle = handle; 1298b35f641cSmatthias.ringwald channel->remote_cid = source_cid; 1299b1988dceSmatthias.ringwald channel->remote_sig_id = sig_id; 1300645658c9Smatthias.ringwald 1301f53da564S[email protected] // limit local mtu to max acl packet length - l2cap header 13022985cb84Smatthias.ringwald if (channel->local_mtu > l2cap_max_mtu()) { 13032985cb84Smatthias.ringwald channel->local_mtu = l2cap_max_mtu(); 13049775e25bSmatthias.ringwald } 13059775e25bSmatthias.ringwald 1306645658c9Smatthias.ringwald // set initial state 1307df3354fcS[email protected] channel->state = L2CAP_STATE_WAIT_INCOMING_SECURITY_LEVEL_UPDATE; 1308a24785d0SMatthias Ringwald channel->state_var = (L2CAP_CHANNEL_STATE_VAR) (L2CAP_CHANNEL_STATE_VAR_SEND_CONN_RESP_PEND | L2CAP_CHANNEL_STATE_VAR_INCOMING); 1309e405ae81Smatthias.ringwald 1310645658c9Smatthias.ringwald // add to connections list 1311665d90f2SMatthias Ringwald btstack_linked_list_add(&l2cap_channels, (btstack_linked_item_t *) channel); 1312645658c9Smatthias.ringwald 1313f85a9399S[email protected] // assert security requirements 13141eb2563eS[email protected] gap_request_security_level(handle, channel->required_security_level); 1315e405ae81Smatthias.ringwald } 1316645658c9Smatthias.ringwald 1317ce8f182eSMatthias Ringwald void l2cap_accept_connection(uint16_t local_cid){ 1318e0abb8e7S[email protected] log_info("L2CAP_ACCEPT_CONNECTION local_cid 0x%x", local_cid); 1319b35f641cSmatthias.ringwald l2cap_channel_t * channel = l2cap_get_channel_for_local_cid(local_cid); 1320e405ae81Smatthias.ringwald if (!channel) { 1321ce8f182eSMatthias Ringwald log_error("l2cap_accept_connection called but local_cid 0x%x not found", local_cid); 1322e405ae81Smatthias.ringwald return; 1323e405ae81Smatthias.ringwald } 1324e405ae81Smatthias.ringwald 1325552d92a1Smatthias.ringwald channel->state = L2CAP_STATE_WILL_SEND_CONNECTION_RESPONSE_ACCEPT; 1326e405ae81Smatthias.ringwald 1327552d92a1Smatthias.ringwald // process 1328552d92a1Smatthias.ringwald l2cap_run(); 1329e405ae81Smatthias.ringwald } 1330645658c9Smatthias.ringwald 13317ef6a7bbSMatthias Ringwald void l2cap_decline_connection(uint16_t local_cid){ 13327ef6a7bbSMatthias Ringwald log_info("L2CAP_DECLINE_CONNECTION local_cid 0x%x", local_cid); 1333b35f641cSmatthias.ringwald l2cap_channel_t * channel = l2cap_get_channel_for_local_cid( local_cid); 1334e405ae81Smatthias.ringwald if (!channel) { 1335ce8f182eSMatthias Ringwald log_error( "l2cap_decline_connection called but local_cid 0x%x not found", local_cid); 1336e405ae81Smatthias.ringwald return; 1337e405ae81Smatthias.ringwald } 1338e7ff783cSmatthias.ringwald channel->state = L2CAP_STATE_WILL_SEND_CONNECTION_RESPONSE_DECLINE; 13397ef6a7bbSMatthias Ringwald channel->reason = 0x04; // no resources available 1340e7ff783cSmatthias.ringwald l2cap_run(); 1341645658c9Smatthias.ringwald } 1342645658c9Smatthias.ringwald 13437f02f414SMatthias Ringwald static void l2cap_signaling_handle_configure_request(l2cap_channel_t *channel, uint8_t *command){ 1344b1988dceSmatthias.ringwald 1345b1988dceSmatthias.ringwald channel->remote_sig_id = command[L2CAP_SIGNALING_COMMAND_SIGID_OFFSET]; 1346b1988dceSmatthias.ringwald 1347f8fbdce0SMatthias Ringwald uint16_t flags = little_endian_read_16(command, 6); 134863a7246aSmatthias.ringwald if (flags & 1) { 134963a7246aSmatthias.ringwald channelStateVarSetFlag(channel, L2CAP_CHANNEL_STATE_VAR_SEND_CONF_RSP_CONT); 135063a7246aSmatthias.ringwald } 135163a7246aSmatthias.ringwald 13522784b77dSmatthias.ringwald // accept the other's configuration options 1353f8fbdce0SMatthias Ringwald uint16_t end_pos = 4 + little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_LENGTH_OFFSET); 13543de7c0caSmatthias.ringwald uint16_t pos = 8; 13553de7c0caSmatthias.ringwald while (pos < end_pos){ 135663a7246aSmatthias.ringwald uint8_t option_hint = command[pos] >> 7; 135763a7246aSmatthias.ringwald uint8_t option_type = command[pos] & 0x7f; 135863a7246aSmatthias.ringwald log_info("l2cap cid %u, hint %u, type %u", channel->local_cid, option_hint, option_type); 135963a7246aSmatthias.ringwald pos++; 13601dc511deSmatthias.ringwald uint8_t length = command[pos++]; 13611dc511deSmatthias.ringwald // MTU { type(8): 1, len(8):2, MTU(16) } 136263a7246aSmatthias.ringwald if (option_type == 1 && length == 2){ 1363f8fbdce0SMatthias Ringwald channel->remote_mtu = little_endian_read_16(command, pos); 13649da54300S[email protected] // log_info("l2cap cid 0x%02x, remote mtu %u", channel->local_cid, channel->remote_mtu); 136563a7246aSmatthias.ringwald channelStateVarSetFlag(channel, L2CAP_CHANNEL_STATE_VAR_SEND_CONF_RSP_MTU); 136663a7246aSmatthias.ringwald } 13670fe7a9d0S[email protected] // Flush timeout { type(8):2, len(8): 2, Flush Timeout(16)} 13680fe7a9d0S[email protected] if (option_type == 2 && length == 2){ 1369f8fbdce0SMatthias Ringwald channel->flush_timeout = little_endian_read_16(command, pos); 13700fe7a9d0S[email protected] } 137163a7246aSmatthias.ringwald // check for unknown options 137263a7246aSmatthias.ringwald if (option_hint == 0 && (option_type == 0 || option_type >= 0x07)){ 1373c177a91cS[email protected] log_info("l2cap cid %u, unknown options", channel->local_cid); 137463a7246aSmatthias.ringwald channelStateVarSetFlag(channel, L2CAP_CHANNEL_STATE_VAR_SEND_CONF_RSP_INVALID); 13751dc511deSmatthias.ringwald } 13761dc511deSmatthias.ringwald pos += length; 13771dc511deSmatthias.ringwald } 13782784b77dSmatthias.ringwald } 13792784b77dSmatthias.ringwald 1380fa8473a4Smatthias.ringwald static int l2cap_channel_ready_for_open(l2cap_channel_t *channel){ 13819da54300S[email protected] // log_info("l2cap_channel_ready_for_open 0x%02x", channel->state_var); 138273cf2b3dSmatthias.ringwald if ((channel->state_var & L2CAP_CHANNEL_STATE_VAR_RCVD_CONF_RSP) == 0) return 0; 138373cf2b3dSmatthias.ringwald if ((channel->state_var & L2CAP_CHANNEL_STATE_VAR_SENT_CONF_RSP) == 0) return 0; 1384019f9b43SMatthias Ringwald // addition check that fixes re-entrance issue causing l2cap event channel opened twice 1385019f9b43SMatthias Ringwald if (channel->state == L2CAP_STATE_OPEN) return 0; 1386fa8473a4Smatthias.ringwald return 1; 1387fa8473a4Smatthias.ringwald } 1388fa8473a4Smatthias.ringwald 1389fa8473a4Smatthias.ringwald 13907f02f414SMatthias Ringwald static void l2cap_signaling_handler_channel(l2cap_channel_t *channel, uint8_t *command){ 13911e6aba47Smatthias.ringwald 139200d93d79Smatthias.ringwald uint8_t code = command[L2CAP_SIGNALING_COMMAND_CODE_OFFSET]; 139300d93d79Smatthias.ringwald uint8_t identifier = command[L2CAP_SIGNALING_COMMAND_SIGID_OFFSET]; 139438e5900eSmatthias.ringwald uint16_t result = 0; 13951e6aba47Smatthias.ringwald 13969da54300S[email protected] log_info("L2CAP signaling handler code %u, state %u", code, channel->state); 1397b35f641cSmatthias.ringwald 13989a011532Smatthias.ringwald // handle DISCONNECT REQUESTS seperately 13999a011532Smatthias.ringwald if (code == DISCONNECTION_REQUEST){ 14009a011532Smatthias.ringwald switch (channel->state){ 1401fa8473a4Smatthias.ringwald case L2CAP_STATE_CONFIG: 14029a011532Smatthias.ringwald case L2CAP_STATE_OPEN: 14032b83fb7dSmatthias.ringwald case L2CAP_STATE_WILL_SEND_DISCONNECT_REQUEST: 14049a011532Smatthias.ringwald case L2CAP_STATE_WAIT_DISCONNECT: 14059a011532Smatthias.ringwald l2cap_handle_disconnect_request(channel, identifier); 14069a011532Smatthias.ringwald break; 14079a011532Smatthias.ringwald 14089a011532Smatthias.ringwald default: 14099a011532Smatthias.ringwald // ignore in other states 14109a011532Smatthias.ringwald break; 14119a011532Smatthias.ringwald } 14129a011532Smatthias.ringwald return; 14139a011532Smatthias.ringwald } 14149a011532Smatthias.ringwald 141556081214Smatthias.ringwald // @STATEMACHINE(l2cap) 14161e6aba47Smatthias.ringwald switch (channel->state) { 14171e6aba47Smatthias.ringwald 14181e6aba47Smatthias.ringwald case L2CAP_STATE_WAIT_CONNECT_RSP: 14191e6aba47Smatthias.ringwald switch (code){ 14201e6aba47Smatthias.ringwald case CONNECTION_RESPONSE: 14215932bd7cS[email protected] l2cap_stop_rtx(channel); 1422f8fbdce0SMatthias Ringwald result = little_endian_read_16 (command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET+4); 142338e5900eSmatthias.ringwald switch (result) { 142438e5900eSmatthias.ringwald case 0: 1425169f8b28Smatthias.ringwald // successful connection 1426f8fbdce0SMatthias Ringwald channel->remote_cid = little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET); 1427fa8473a4Smatthias.ringwald channel->state = L2CAP_STATE_CONFIG; 142828ca2b46S[email protected] channelStateVarSetFlag(channel, L2CAP_CHANNEL_STATE_VAR_SEND_CONF_REQ); 142938e5900eSmatthias.ringwald break; 143038e5900eSmatthias.ringwald case 1: 14315932bd7cS[email protected] // connection pending. get some coffee, but start the ERTX 14325932bd7cS[email protected] l2cap_start_ertx(channel); 143338e5900eSmatthias.ringwald break; 143438e5900eSmatthias.ringwald default: 1435eb920dbeSmatthias.ringwald // channel closed 1436eb920dbeSmatthias.ringwald channel->state = L2CAP_STATE_CLOSED; 1437f32b992eSmatthias.ringwald // map l2cap connection response result to BTstack status enumeration 143838e5900eSmatthias.ringwald l2cap_emit_channel_opened(channel, L2CAP_CONNECTION_RESPONSE_RESULT_SUCCESSFUL + result); 1439eb920dbeSmatthias.ringwald 1440eb920dbeSmatthias.ringwald // drop link key if security block 1441eb920dbeSmatthias.ringwald if (L2CAP_CONNECTION_RESPONSE_RESULT_SUCCESSFUL + result == L2CAP_CONNECTION_RESPONSE_RESULT_REFUSED_SECURITY){ 144215a95bd5SMatthias Ringwald gap_drop_link_key_for_bd_addr(channel->address); 1443eb920dbeSmatthias.ringwald } 1444eb920dbeSmatthias.ringwald 1445eb920dbeSmatthias.ringwald // discard channel 1446665d90f2SMatthias Ringwald btstack_linked_list_remove(&l2cap_channels, (btstack_linked_item_t *) channel); 1447d3a9df87Smatthias.ringwald btstack_memory_l2cap_channel_free(channel); 144838e5900eSmatthias.ringwald break; 14491e6aba47Smatthias.ringwald } 14501e6aba47Smatthias.ringwald break; 145138e5900eSmatthias.ringwald 145238e5900eSmatthias.ringwald default: 14531e6aba47Smatthias.ringwald //@TODO: implement other signaling packets 145438e5900eSmatthias.ringwald break; 14551e6aba47Smatthias.ringwald } 14561e6aba47Smatthias.ringwald break; 14571e6aba47Smatthias.ringwald 1458fa8473a4Smatthias.ringwald case L2CAP_STATE_CONFIG: 1459f8fbdce0SMatthias Ringwald result = little_endian_read_16 (command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET+4); 1460ae280e73Smatthias.ringwald switch (code) { 1461ae280e73Smatthias.ringwald case CONFIGURE_REQUEST: 146228ca2b46S[email protected] channelStateVarSetFlag(channel, L2CAP_CHANNEL_STATE_VAR_SEND_CONF_RSP); 1463ae280e73Smatthias.ringwald l2cap_signaling_handle_configure_request(channel, command); 146463a7246aSmatthias.ringwald if (!(channel->state_var & L2CAP_CHANNEL_STATE_VAR_SEND_CONF_RSP_CONT)){ 146563a7246aSmatthias.ringwald // only done if continuation not set 146663a7246aSmatthias.ringwald channelStateVarSetFlag(channel, L2CAP_CHANNEL_STATE_VAR_RCVD_CONF_REQ); 146763a7246aSmatthias.ringwald } 1468ae280e73Smatthias.ringwald break; 14691e6aba47Smatthias.ringwald case CONFIGURE_RESPONSE: 14705932bd7cS[email protected] l2cap_stop_rtx(channel); 14715932bd7cS[email protected] switch (result){ 14725932bd7cS[email protected] case 0: // success 14735932bd7cS[email protected] channelStateVarSetFlag(channel, L2CAP_CHANNEL_STATE_VAR_RCVD_CONF_RSP); 14745932bd7cS[email protected] break; 14755932bd7cS[email protected] case 4: // pending 14765932bd7cS[email protected] l2cap_start_ertx(channel); 14775932bd7cS[email protected] break; 14785932bd7cS[email protected] default: 1479fe9d8984S[email protected] // retry on negative result 1480fe9d8984S[email protected] channelStateVarSetFlag(channel, L2CAP_CHANNEL_STATE_VAR_SEND_CONF_REQ); 1481fe9d8984S[email protected] break; 1482fe9d8984S[email protected] } 14835a67bd4aSmatthias.ringwald break; 14845a67bd4aSmatthias.ringwald default: 14855a67bd4aSmatthias.ringwald break; 14861e6aba47Smatthias.ringwald } 1487fa8473a4Smatthias.ringwald if (l2cap_channel_ready_for_open(channel)){ 1488fa8473a4Smatthias.ringwald // for open: 14895a67bd4aSmatthias.ringwald channel->state = L2CAP_STATE_OPEN; 1490fa8473a4Smatthias.ringwald l2cap_emit_channel_opened(channel, 0); 1491c8e4258aSmatthias.ringwald } 1492c8e4258aSmatthias.ringwald break; 1493f62db1e3Smatthias.ringwald 1494f62db1e3Smatthias.ringwald case L2CAP_STATE_WAIT_DISCONNECT: 1495f62db1e3Smatthias.ringwald switch (code) { 1496f62db1e3Smatthias.ringwald case DISCONNECTION_RESPONSE: 149727a923d0Smatthias.ringwald l2cap_finialize_channel_close(channel); 149827a923d0Smatthias.ringwald break; 14995a67bd4aSmatthias.ringwald default: 15005a67bd4aSmatthias.ringwald //@TODO: implement other signaling packets 15015a67bd4aSmatthias.ringwald break; 150227a923d0Smatthias.ringwald } 150327a923d0Smatthias.ringwald break; 150484836b65Smatthias.ringwald 150584836b65Smatthias.ringwald case L2CAP_STATE_CLOSED: 150684836b65Smatthias.ringwald // @TODO handle incoming requests 150784836b65Smatthias.ringwald break; 150884836b65Smatthias.ringwald 150984836b65Smatthias.ringwald case L2CAP_STATE_OPEN: 151084836b65Smatthias.ringwald //@TODO: implement other signaling packets, e.g. re-configure 151184836b65Smatthias.ringwald break; 151210642e45Smatthias.ringwald default: 151310642e45Smatthias.ringwald break; 151427a923d0Smatthias.ringwald } 15159da54300S[email protected] // log_info("new state %u", channel->state); 151627a923d0Smatthias.ringwald } 151727a923d0Smatthias.ringwald 151800d93d79Smatthias.ringwald 15197f02f414SMatthias Ringwald static void l2cap_signaling_handler_dispatch( hci_con_handle_t handle, uint8_t * command){ 152000d93d79Smatthias.ringwald 152100d93d79Smatthias.ringwald // get code, signalind identifier and command len 152200d93d79Smatthias.ringwald uint8_t code = command[L2CAP_SIGNALING_COMMAND_CODE_OFFSET]; 152300d93d79Smatthias.ringwald uint8_t sig_id = command[L2CAP_SIGNALING_COMMAND_SIGID_OFFSET]; 152400d93d79Smatthias.ringwald 152500d93d79Smatthias.ringwald // not for a particular channel, and not CONNECTION_REQUEST, ECHO_[REQUEST|RESPONSE], INFORMATION_REQUEST 152600d93d79Smatthias.ringwald if (code < 1 || code == ECHO_RESPONSE || code > INFORMATION_REQUEST){ 1527e74c5f58SMatthias Ringwald l2cap_register_signaling_response(handle, COMMAND_REJECT, sig_id, 0, L2CAP_REJ_CMD_UNKNOWN); 152800d93d79Smatthias.ringwald return; 152900d93d79Smatthias.ringwald } 153000d93d79Smatthias.ringwald 153100d93d79Smatthias.ringwald // general commands without an assigned channel 153200d93d79Smatthias.ringwald switch(code) { 153300d93d79Smatthias.ringwald 153400d93d79Smatthias.ringwald case CONNECTION_REQUEST: { 1535f8fbdce0SMatthias Ringwald uint16_t psm = little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET); 1536f8fbdce0SMatthias Ringwald uint16_t source_cid = little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET+2); 153700d93d79Smatthias.ringwald l2cap_handle_connection_request(handle, sig_id, psm, source_cid); 15382b83fb7dSmatthias.ringwald return; 153900d93d79Smatthias.ringwald } 154000d93d79Smatthias.ringwald 15412b360848Smatthias.ringwald case ECHO_REQUEST: 1542e74c5f58SMatthias Ringwald l2cap_register_signaling_response(handle, code, sig_id, 0, 0); 15432b83fb7dSmatthias.ringwald return; 154400d93d79Smatthias.ringwald 154500d93d79Smatthias.ringwald case INFORMATION_REQUEST: { 1546f8fbdce0SMatthias Ringwald uint16_t infoType = little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET); 1547e74c5f58SMatthias Ringwald l2cap_register_signaling_response(handle, code, sig_id, 0, infoType); 15482b83fb7dSmatthias.ringwald return; 154900d93d79Smatthias.ringwald } 155000d93d79Smatthias.ringwald 155100d93d79Smatthias.ringwald default: 155200d93d79Smatthias.ringwald break; 155300d93d79Smatthias.ringwald } 155400d93d79Smatthias.ringwald 155500d93d79Smatthias.ringwald 155600d93d79Smatthias.ringwald // Get potential destination CID 1557f8fbdce0SMatthias Ringwald uint16_t dest_cid = little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET); 155800d93d79Smatthias.ringwald 155900d93d79Smatthias.ringwald // Find channel for this sig_id and connection handle 1560665d90f2SMatthias Ringwald btstack_linked_list_iterator_t it; 1561665d90f2SMatthias Ringwald btstack_linked_list_iterator_init(&it, &l2cap_channels); 1562665d90f2SMatthias Ringwald while (btstack_linked_list_iterator_has_next(&it)){ 1563665d90f2SMatthias Ringwald l2cap_channel_t * channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it); 1564fc64f94aSMatthias Ringwald if (channel->con_handle != handle) continue; 156500d93d79Smatthias.ringwald if (code & 1) { 1566b1988dceSmatthias.ringwald // match odd commands (responses) by previous signaling identifier 1567b1988dceSmatthias.ringwald if (channel->local_sig_id == sig_id) { 156800d93d79Smatthias.ringwald l2cap_signaling_handler_channel(channel, command); 15694e32727eSmatthias.ringwald break; 157000d93d79Smatthias.ringwald } 157100d93d79Smatthias.ringwald } else { 1572b1988dceSmatthias.ringwald // match even commands (requests) by local channel id 157300d93d79Smatthias.ringwald if (channel->local_cid == dest_cid) { 157400d93d79Smatthias.ringwald l2cap_signaling_handler_channel(channel, command); 15754e32727eSmatthias.ringwald break; 157600d93d79Smatthias.ringwald } 157700d93d79Smatthias.ringwald } 157800d93d79Smatthias.ringwald } 157900d93d79Smatthias.ringwald } 158009e9d05bSMatthias Ringwald #endif 158100d93d79Smatthias.ringwald 1582e7d0c9aaSMatthias Ringwald #ifdef ENABLE_BLE 158309e9d05bSMatthias Ringwald 158409e9d05bSMatthias Ringwald static void l2cap_emit_connection_parameter_update_response(hci_con_handle_t con_handle, uint16_t result){ 158509e9d05bSMatthias Ringwald uint8_t event[6]; 158609e9d05bSMatthias Ringwald event[0] = L2CAP_EVENT_CONNECTION_PARAMETER_UPDATE_RESPONSE; 158709e9d05bSMatthias Ringwald event[1] = 4; 158809e9d05bSMatthias Ringwald little_endian_store_16(event, 2, con_handle); 158909e9d05bSMatthias Ringwald little_endian_store_16(event, 4, result); 159009e9d05bSMatthias Ringwald hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event)); 159109e9d05bSMatthias Ringwald if (!l2cap_event_packet_handler) return; 159209e9d05bSMatthias Ringwald (*l2cap_event_packet_handler)(HCI_EVENT_PACKET, 0, event, sizeof(event)); 159309e9d05bSMatthias Ringwald } 159409e9d05bSMatthias Ringwald 1595c48b2a2cSMatthias Ringwald // @returns valid 1596c48b2a2cSMatthias Ringwald static int l2cap_le_signaling_handler_dispatch(hci_con_handle_t handle, uint8_t * command, uint8_t sig_id){ 1597e7d0c9aaSMatthias Ringwald hci_connection_t * connection; 1598c48b2a2cSMatthias Ringwald uint16_t result; 1599c48b2a2cSMatthias Ringwald uint8_t event[10]; 160083fd9c76SMatthias Ringwald 1601cab29d48SMatthias Ringwald #ifdef ENABLE_LE_DATA_CHANNELS 1602a3dc965aSMatthias Ringwald btstack_linked_list_iterator_t it; 1603a3dc965aSMatthias Ringwald l2cap_channel_t * channel; 1604a3dc965aSMatthias Ringwald uint16_t local_cid; 160583fd9c76SMatthias Ringwald uint16_t le_psm; 160663f0ac45SMatthias Ringwald uint16_t new_credits; 160763f0ac45SMatthias Ringwald uint16_t credits_before; 1608e7d0c9aaSMatthias Ringwald l2cap_service_t * service; 160911cae19eSMilanka Ringwald uint16_t source_cid; 161083fd9c76SMatthias Ringwald #endif 161100d93d79Smatthias.ringwald 16121b8b8d05SMatthias Ringwald uint8_t code = command[L2CAP_SIGNALING_COMMAND_CODE_OFFSET]; 161323017473SMatthias Ringwald log_info("l2cap_le_signaling_handler_dispatch: command 0x%02x, sig id %u", code, sig_id); 16141b8b8d05SMatthias Ringwald 16151b8b8d05SMatthias Ringwald switch (code){ 161600d93d79Smatthias.ringwald 1617c48b2a2cSMatthias Ringwald case CONNECTION_PARAMETER_UPDATE_RESPONSE: 1618c48b2a2cSMatthias Ringwald result = little_endian_read_16(command, 4); 1619ccf076adS[email protected] l2cap_emit_connection_parameter_update_response(handle, result); 1620ccf076adS[email protected] break; 1621da886c03S[email protected] 1622c48b2a2cSMatthias Ringwald case CONNECTION_PARAMETER_UPDATE_REQUEST: 1623e7d0c9aaSMatthias Ringwald connection = hci_connection_for_handle(handle); 1624da886c03S[email protected] if (connection){ 16256d91fb6cSMatthias Ringwald if (connection->role != HCI_ROLE_MASTER){ 16266d91fb6cSMatthias Ringwald // reject command without notifying upper layer when not in master role 1627c48b2a2cSMatthias Ringwald return 0; 16286d91fb6cSMatthias Ringwald } 1629da886c03S[email protected] int update_parameter = 1; 1630a4c06b28SMatthias Ringwald le_connection_parameter_range_t existing_range; 16314ced4e8cSMatthias Ringwald gap_get_connection_parameter_range(&existing_range); 1632c48b2a2cSMatthias Ringwald uint16_t le_conn_interval_min = little_endian_read_16(command,8); 1633c48b2a2cSMatthias Ringwald uint16_t le_conn_interval_max = little_endian_read_16(command,10); 1634c48b2a2cSMatthias Ringwald uint16_t le_conn_latency = little_endian_read_16(command,12); 1635c48b2a2cSMatthias Ringwald uint16_t le_supervision_timeout = little_endian_read_16(command,14); 1636da886c03S[email protected] 1637da886c03S[email protected] if (le_conn_interval_min < existing_range.le_conn_interval_min) update_parameter = 0; 1638da886c03S[email protected] if (le_conn_interval_max > existing_range.le_conn_interval_max) update_parameter = 0; 1639da886c03S[email protected] 1640da886c03S[email protected] if (le_conn_latency < existing_range.le_conn_latency_min) update_parameter = 0; 1641da886c03S[email protected] if (le_conn_latency > existing_range.le_conn_latency_max) update_parameter = 0; 1642da886c03S[email protected] 1643da886c03S[email protected] if (le_supervision_timeout < existing_range.le_supervision_timeout_min) update_parameter = 0; 1644da886c03S[email protected] if (le_supervision_timeout > existing_range.le_supervision_timeout_max) update_parameter = 0; 1645da886c03S[email protected] 1646da886c03S[email protected] if (update_parameter){ 1647da886c03S[email protected] connection->le_con_parameter_update_state = CON_PARAMETER_UPDATE_SEND_RESPONSE; 1648da886c03S[email protected] connection->le_conn_interval_min = le_conn_interval_min; 1649da886c03S[email protected] connection->le_conn_interval_max = le_conn_interval_max; 1650da886c03S[email protected] connection->le_conn_latency = le_conn_latency; 1651da886c03S[email protected] connection->le_supervision_timeout = le_supervision_timeout; 1652da886c03S[email protected] } else { 1653da886c03S[email protected] connection->le_con_parameter_update_state = CON_PARAMETER_UPDATE_DENY; 1654da886c03S[email protected] } 1655c48b2a2cSMatthias Ringwald connection->le_con_param_update_identifier = sig_id; 1656da886c03S[email protected] } 1657da886c03S[email protected] 165833c40538SMatthias Ringwald if (!l2cap_event_packet_handler) break; 1659c48b2a2cSMatthias Ringwald 1660c48b2a2cSMatthias Ringwald event[0] = L2CAP_EVENT_CONNECTION_PARAMETER_UPDATE_REQUEST; 1661c48b2a2cSMatthias Ringwald event[1] = 8; 1662c48b2a2cSMatthias Ringwald memcpy(&event[2], &command[4], 8); 1663c48b2a2cSMatthias Ringwald hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event)); 166433c40538SMatthias Ringwald (*l2cap_event_packet_handler)( HCI_EVENT_PACKET, 0, event, sizeof(event)); 1665ccf076adS[email protected] break; 1666c48b2a2cSMatthias Ringwald 1667a3dc965aSMatthias Ringwald #ifdef ENABLE_LE_DATA_CHANNELS 1668a3dc965aSMatthias Ringwald 166963f0ac45SMatthias Ringwald case COMMAND_REJECT: 167063f0ac45SMatthias Ringwald // Find channel for this sig_id and connection handle 167163f0ac45SMatthias Ringwald channel = NULL; 167263f0ac45SMatthias Ringwald btstack_linked_list_iterator_init(&it, &l2cap_le_channels); 167363f0ac45SMatthias Ringwald while (btstack_linked_list_iterator_has_next(&it)){ 167463f0ac45SMatthias Ringwald l2cap_channel_t * a_channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it); 167563f0ac45SMatthias Ringwald if (a_channel->con_handle != handle) continue; 167663f0ac45SMatthias Ringwald if (a_channel->local_sig_id != sig_id) continue; 167763f0ac45SMatthias Ringwald channel = a_channel; 167863f0ac45SMatthias Ringwald break; 167963f0ac45SMatthias Ringwald } 168063f0ac45SMatthias Ringwald if (!channel) break; 168163f0ac45SMatthias Ringwald 168263f0ac45SMatthias Ringwald // if received while waiting for le connection response, assume legacy device 168363f0ac45SMatthias Ringwald if (channel->state == L2CAP_STATE_WAIT_LE_CONNECTION_RESPONSE){ 168463f0ac45SMatthias Ringwald channel->state = L2CAP_STATE_CLOSED; 168563f0ac45SMatthias Ringwald // no official value for this, use: Connection refused – LE_PSM not supported - 0x0002 168644276248SMatthias Ringwald l2cap_emit_le_channel_opened(channel, 0x0002); 168763f0ac45SMatthias Ringwald 168863f0ac45SMatthias Ringwald // discard channel 168963f0ac45SMatthias Ringwald btstack_linked_list_remove(&l2cap_le_channels, (btstack_linked_item_t *) channel); 169063f0ac45SMatthias Ringwald btstack_memory_l2cap_channel_free(channel); 169163f0ac45SMatthias Ringwald break; 169263f0ac45SMatthias Ringwald } 169363f0ac45SMatthias Ringwald break; 169463f0ac45SMatthias Ringwald 1695e7d0c9aaSMatthias Ringwald case LE_CREDIT_BASED_CONNECTION_REQUEST: 1696e7d0c9aaSMatthias Ringwald 1697e7d0c9aaSMatthias Ringwald // get hci connection, bail if not found (must not happen) 1698e7d0c9aaSMatthias Ringwald connection = hci_connection_for_handle(handle); 1699e7d0c9aaSMatthias Ringwald if (!connection) return 0; 1700e7d0c9aaSMatthias Ringwald 1701e7d0c9aaSMatthias Ringwald // check if service registered 1702e7d0c9aaSMatthias Ringwald le_psm = little_endian_read_16(command, 4); 1703e7d0c9aaSMatthias Ringwald service = l2cap_le_get_service(le_psm); 170411cae19eSMilanka Ringwald source_cid = little_endian_read_16(command, 6); 1705e7d0c9aaSMatthias Ringwald 1706e7d0c9aaSMatthias Ringwald if (service){ 1707e7d0c9aaSMatthias Ringwald if (source_cid < 0x40){ 1708e7d0c9aaSMatthias Ringwald // 0x0009 Connection refused - Invalid Source CID 1709e74c5f58SMatthias Ringwald l2cap_register_signaling_response(handle, LE_CREDIT_BASED_CONNECTION_REQUEST, sig_id, source_cid, 0x0009); 1710e7d0c9aaSMatthias Ringwald return 1; 1711e7d0c9aaSMatthias Ringwald } 1712e7d0c9aaSMatthias Ringwald 1713e7d0c9aaSMatthias Ringwald // go through list of channels for this ACL connection and check if we get a match 1714e7d0c9aaSMatthias Ringwald btstack_linked_list_iterator_init(&it, &l2cap_le_channels); 1715e7d0c9aaSMatthias Ringwald while (btstack_linked_list_iterator_has_next(&it)){ 17161b8b8d05SMatthias Ringwald l2cap_channel_t * a_channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it); 17171b8b8d05SMatthias Ringwald if (a_channel->con_handle != handle) continue; 17181b8b8d05SMatthias Ringwald if (a_channel->remote_cid != source_cid) continue; 1719e7d0c9aaSMatthias Ringwald // 0x000a Connection refused - Source CID already allocated 1720e74c5f58SMatthias Ringwald l2cap_register_signaling_response(handle, LE_CREDIT_BASED_CONNECTION_REQUEST, sig_id, source_cid, 0x000a); 1721e7d0c9aaSMatthias Ringwald return 1; 1722e7d0c9aaSMatthias Ringwald } 1723e7d0c9aaSMatthias Ringwald 172483fd9c76SMatthias Ringwald // security: check encryption 172583fd9c76SMatthias Ringwald if (service->required_security_level >= LEVEL_2){ 172683fd9c76SMatthias Ringwald if (sm_encryption_key_size(handle) == 0){ 172783fd9c76SMatthias Ringwald // 0x0008 Connection refused - insufficient encryption 1728e74c5f58SMatthias Ringwald l2cap_register_signaling_response(handle, LE_CREDIT_BASED_CONNECTION_REQUEST, sig_id, source_cid, 0x0008); 172983fd9c76SMatthias Ringwald return 1; 173083fd9c76SMatthias Ringwald } 173183fd9c76SMatthias Ringwald // anything less than 16 byte key size is insufficient 173283fd9c76SMatthias Ringwald if (sm_encryption_key_size(handle) < 16){ 173383fd9c76SMatthias Ringwald // 0x0007 Connection refused – insufficient encryption key size 1734e74c5f58SMatthias Ringwald l2cap_register_signaling_response(handle, LE_CREDIT_BASED_CONNECTION_REQUEST, sig_id, source_cid, 0x0007); 173583fd9c76SMatthias Ringwald return 1; 173683fd9c76SMatthias Ringwald } 173783fd9c76SMatthias Ringwald } 173883fd9c76SMatthias Ringwald 173983fd9c76SMatthias Ringwald // security: check authencation 174083fd9c76SMatthias Ringwald if (service->required_security_level >= LEVEL_3){ 174183fd9c76SMatthias Ringwald if (!sm_authenticated(handle)){ 174283fd9c76SMatthias Ringwald // 0x0005 Connection refused – insufficient authentication 1743e74c5f58SMatthias Ringwald l2cap_register_signaling_response(handle, LE_CREDIT_BASED_CONNECTION_REQUEST, sig_id, source_cid, 0x0005); 174483fd9c76SMatthias Ringwald return 1; 174583fd9c76SMatthias Ringwald } 174683fd9c76SMatthias Ringwald } 174783fd9c76SMatthias Ringwald 174883fd9c76SMatthias Ringwald // security: check authorization 174983fd9c76SMatthias Ringwald if (service->required_security_level >= LEVEL_4){ 175083fd9c76SMatthias Ringwald if (sm_authorization_state(handle) != AUTHORIZATION_GRANTED){ 175183fd9c76SMatthias Ringwald // 0x0006 Connection refused – insufficient authorization 1752e74c5f58SMatthias Ringwald l2cap_register_signaling_response(handle, LE_CREDIT_BASED_CONNECTION_REQUEST, sig_id, source_cid, 0x0006); 175383fd9c76SMatthias Ringwald return 1; 175483fd9c76SMatthias Ringwald } 175583fd9c76SMatthias Ringwald } 1756e7d0c9aaSMatthias Ringwald 1757e7d0c9aaSMatthias Ringwald // allocate channel 17581b8b8d05SMatthias Ringwald channel = l2cap_create_channel_entry(service->packet_handler, connection->address, 1759e7d0c9aaSMatthias Ringwald BD_ADDR_TYPE_LE_RANDOM, le_psm, service->mtu, service->required_security_level); 1760e7d0c9aaSMatthias Ringwald if (!channel){ 1761e7d0c9aaSMatthias Ringwald // 0x0004 Connection refused – no resources available 1762e74c5f58SMatthias Ringwald l2cap_register_signaling_response(handle, LE_CREDIT_BASED_CONNECTION_REQUEST, sig_id, source_cid, 0x0004); 1763e7d0c9aaSMatthias Ringwald return 1; 1764e7d0c9aaSMatthias Ringwald } 1765e7d0c9aaSMatthias Ringwald 1766e7d0c9aaSMatthias Ringwald channel->con_handle = handle; 1767e7d0c9aaSMatthias Ringwald channel->remote_cid = source_cid; 1768e7d0c9aaSMatthias Ringwald channel->remote_sig_id = sig_id; 17697f107edaSMatthias Ringwald channel->remote_mtu = little_endian_read_16(command, 8); 17707f107edaSMatthias Ringwald channel->remote_mps = little_endian_read_16(command, 10); 17717f107edaSMatthias Ringwald channel->credits_outgoing = little_endian_read_16(command, 12); 1772e7d0c9aaSMatthias Ringwald 1773e7d0c9aaSMatthias Ringwald // set initial state 1774e7d0c9aaSMatthias Ringwald channel->state = L2CAP_STATE_WAIT_CLIENT_ACCEPT_OR_REJECT; 1775c99bb618SMatthias Ringwald channel->state_var |= L2CAP_CHANNEL_STATE_VAR_INCOMING; 1776e7d0c9aaSMatthias Ringwald 1777e7d0c9aaSMatthias Ringwald // add to connections list 1778e7d0c9aaSMatthias Ringwald btstack_linked_list_add(&l2cap_le_channels, (btstack_linked_item_t *) channel); 1779e7d0c9aaSMatthias Ringwald 1780e7d0c9aaSMatthias Ringwald // post connection request event 178144276248SMatthias Ringwald l2cap_emit_le_incoming_connection(channel); 1782e7d0c9aaSMatthias Ringwald 1783e7d0c9aaSMatthias Ringwald } else { 1784e7d0c9aaSMatthias Ringwald // Connection refused – LE_PSM not supported 1785e74c5f58SMatthias Ringwald l2cap_register_signaling_response(handle, LE_CREDIT_BASED_CONNECTION_REQUEST, sig_id, source_cid, 0x0002); 1786e7d0c9aaSMatthias Ringwald } 1787e7d0c9aaSMatthias Ringwald break; 17881b8b8d05SMatthias Ringwald 17891b8b8d05SMatthias Ringwald case LE_CREDIT_BASED_CONNECTION_RESPONSE: 17901b8b8d05SMatthias Ringwald // Find channel for this sig_id and connection handle 17911b8b8d05SMatthias Ringwald channel = NULL; 17921b8b8d05SMatthias Ringwald btstack_linked_list_iterator_init(&it, &l2cap_le_channels); 17931b8b8d05SMatthias Ringwald while (btstack_linked_list_iterator_has_next(&it)){ 17941b8b8d05SMatthias Ringwald l2cap_channel_t * a_channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it); 17951b8b8d05SMatthias Ringwald if (a_channel->con_handle != handle) continue; 17961b8b8d05SMatthias Ringwald if (a_channel->local_sig_id != sig_id) continue; 17971b8b8d05SMatthias Ringwald channel = a_channel; 17981b8b8d05SMatthias Ringwald break; 17991b8b8d05SMatthias Ringwald } 18001b8b8d05SMatthias Ringwald if (!channel) break; 18011b8b8d05SMatthias Ringwald 18021b8b8d05SMatthias Ringwald // cid + 0 18031b8b8d05SMatthias Ringwald result = little_endian_read_16 (command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET+8); 18041b8b8d05SMatthias Ringwald if (result){ 18051b8b8d05SMatthias Ringwald channel->state = L2CAP_STATE_CLOSED; 18061b8b8d05SMatthias Ringwald // map l2cap connection response result to BTstack status enumeration 180744276248SMatthias Ringwald l2cap_emit_le_channel_opened(channel, result); 18081b8b8d05SMatthias Ringwald 18091b8b8d05SMatthias Ringwald // discard channel 181063f0ac45SMatthias Ringwald btstack_linked_list_remove(&l2cap_le_channels, (btstack_linked_item_t *) channel); 18111b8b8d05SMatthias Ringwald btstack_memory_l2cap_channel_free(channel); 18121b8b8d05SMatthias Ringwald break; 18131b8b8d05SMatthias Ringwald } 18141b8b8d05SMatthias Ringwald 18151b8b8d05SMatthias Ringwald // success 18161b8b8d05SMatthias Ringwald channel->remote_cid = little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET + 0); 18171b8b8d05SMatthias Ringwald channel->remote_mtu = little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET + 2); 18181b8b8d05SMatthias Ringwald channel->remote_mps = little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET + 4); 18191b8b8d05SMatthias Ringwald channel->credits_outgoing = little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET + 6); 18201b8b8d05SMatthias Ringwald channel->state = L2CAP_STATE_OPEN; 182144276248SMatthias Ringwald l2cap_emit_le_channel_opened(channel, result); 18221b8b8d05SMatthias Ringwald break; 18231b8b8d05SMatthias Ringwald 182485aeef60SMatthias Ringwald case LE_FLOW_CONTROL_CREDIT: 182585aeef60SMatthias Ringwald // find channel 182685aeef60SMatthias Ringwald local_cid = little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET + 0); 182785aeef60SMatthias Ringwald channel = l2cap_le_get_channel_for_local_cid(local_cid); 182863f0ac45SMatthias Ringwald if (!channel) { 182963f0ac45SMatthias Ringwald log_error("l2cap: no channel for cid 0x%02x", local_cid); 183063f0ac45SMatthias Ringwald break; 183163f0ac45SMatthias Ringwald } 183263f0ac45SMatthias Ringwald new_credits = little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET + 2); 183363f0ac45SMatthias Ringwald credits_before = channel->credits_outgoing; 183463f0ac45SMatthias Ringwald channel->credits_outgoing += new_credits; 183563f0ac45SMatthias Ringwald // check for credit overrun 183663f0ac45SMatthias Ringwald if (credits_before > channel->credits_outgoing){ 183763f0ac45SMatthias Ringwald log_error("l2cap: new credits caused overrrun for cid 0x%02x, disconnecting", local_cid); 183863f0ac45SMatthias Ringwald channel->state = L2CAP_STATE_WILL_SEND_DISCONNECT_REQUEST; 183963f0ac45SMatthias Ringwald break; 184063f0ac45SMatthias Ringwald } 184163f0ac45SMatthias Ringwald log_info("l2cap: %u credits for 0x%02x, now %u", new_credits, local_cid, channel->credits_outgoing); 184285aeef60SMatthias Ringwald break; 184385aeef60SMatthias Ringwald 1844828a7f7aSMatthias Ringwald case DISCONNECTION_REQUEST: 1845828a7f7aSMatthias Ringwald // find channel 1846828a7f7aSMatthias Ringwald local_cid = little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET + 0); 1847828a7f7aSMatthias Ringwald channel = l2cap_le_get_channel_for_local_cid(local_cid); 184863f34e00SMatthias Ringwald if (!channel) { 184963f34e00SMatthias Ringwald log_error("l2cap: no channel for cid 0x%02x", local_cid); 185063f34e00SMatthias Ringwald break; 185163f34e00SMatthias Ringwald } 1852828a7f7aSMatthias Ringwald channel->remote_sig_id = sig_id; 1853828a7f7aSMatthias Ringwald channel->state = L2CAP_STATE_WILL_SEND_DISCONNECT_RESPONSE; 1854828a7f7aSMatthias Ringwald break; 1855828a7f7aSMatthias Ringwald 1856a3dc965aSMatthias Ringwald #endif 1857a3dc965aSMatthias Ringwald 185863f0ac45SMatthias Ringwald case DISCONNECTION_RESPONSE: 185963f0ac45SMatthias Ringwald break; 186063f0ac45SMatthias Ringwald 1861c48b2a2cSMatthias Ringwald default: 1862c48b2a2cSMatthias Ringwald // command unknown -> reject command 1863c48b2a2cSMatthias Ringwald return 0; 1864ccf076adS[email protected] } 1865c48b2a2cSMatthias Ringwald return 1; 1866c48b2a2cSMatthias Ringwald } 1867e7d0c9aaSMatthias Ringwald #endif 1868c48b2a2cSMatthias Ringwald 1869c48b2a2cSMatthias Ringwald static void l2cap_acl_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size ){ 18709ec2630cSMatthias Ringwald UNUSED(packet_type); 18719ec2630cSMatthias Ringwald UNUSED(channel); 1872c48b2a2cSMatthias Ringwald 187309e9d05bSMatthias Ringwald l2cap_channel_t * l2cap_channel; 1874f3963406SMatthias Ringwald UNUSED(l2cap_channel); 187509e9d05bSMatthias Ringwald 1876c48b2a2cSMatthias Ringwald // Get Channel ID 1877c48b2a2cSMatthias Ringwald uint16_t channel_id = READ_L2CAP_CHANNEL_ID(packet); 1878c48b2a2cSMatthias Ringwald hci_con_handle_t handle = READ_ACL_CONNECTION_HANDLE(packet); 1879c48b2a2cSMatthias Ringwald 1880c48b2a2cSMatthias Ringwald switch (channel_id) { 1881c48b2a2cSMatthias Ringwald 188209e9d05bSMatthias Ringwald #ifdef ENABLE_CLASSIC 1883c48b2a2cSMatthias Ringwald case L2CAP_CID_SIGNALING: { 1884c48b2a2cSMatthias Ringwald uint16_t command_offset = 8; 1885c48b2a2cSMatthias Ringwald while (command_offset < size) { 1886c48b2a2cSMatthias Ringwald // handle signaling commands 1887c48b2a2cSMatthias Ringwald l2cap_signaling_handler_dispatch(handle, &packet[command_offset]); 1888c48b2a2cSMatthias Ringwald 1889c48b2a2cSMatthias Ringwald // increment command_offset 1890c48b2a2cSMatthias Ringwald command_offset += L2CAP_SIGNALING_COMMAND_DATA_OFFSET + little_endian_read_16(packet, command_offset + L2CAP_SIGNALING_COMMAND_LENGTH_OFFSET); 1891c48b2a2cSMatthias Ringwald } 1892c48b2a2cSMatthias Ringwald break; 1893c48b2a2cSMatthias Ringwald } 189409e9d05bSMatthias Ringwald #endif 1895c48b2a2cSMatthias Ringwald 1896e7d0c9aaSMatthias Ringwald #ifdef ENABLE_BLE 1897e7d0c9aaSMatthias Ringwald case L2CAP_CID_SIGNALING_LE: { 1898e7d0c9aaSMatthias Ringwald uint16_t sig_id = packet[COMPLETE_L2CAP_HEADER + 1]; 1899e7d0c9aaSMatthias Ringwald int valid = l2cap_le_signaling_handler_dispatch(handle, &packet[COMPLETE_L2CAP_HEADER], sig_id); 1900c48b2a2cSMatthias Ringwald if (!valid){ 1901e74c5f58SMatthias Ringwald l2cap_register_signaling_response(handle, COMMAND_REJECT_LE, sig_id, 0, L2CAP_REJ_CMD_UNKNOWN); 1902ccf076adS[email protected] } 1903ccf076adS[email protected] break; 1904e7d0c9aaSMatthias Ringwald } 1905e7d0c9aaSMatthias Ringwald #endif 1906c48b2a2cSMatthias Ringwald 1907c48b2a2cSMatthias Ringwald case L2CAP_CID_ATTRIBUTE_PROTOCOL: 1908c48b2a2cSMatthias Ringwald if (fixed_channels[L2CAP_FIXED_CHANNEL_TABLE_INDEX_ATTRIBUTE_PROTOCOL].callback) { 1909c48b2a2cSMatthias Ringwald (*fixed_channels[L2CAP_FIXED_CHANNEL_TABLE_INDEX_ATTRIBUTE_PROTOCOL].callback)(ATT_DATA_PACKET, handle, &packet[COMPLETE_L2CAP_HEADER], size-COMPLETE_L2CAP_HEADER); 1910ccf076adS[email protected] } 1911c48b2a2cSMatthias Ringwald break; 1912c48b2a2cSMatthias Ringwald 1913c48b2a2cSMatthias Ringwald case L2CAP_CID_SECURITY_MANAGER_PROTOCOL: 1914c48b2a2cSMatthias Ringwald if (fixed_channels[L2CAP_FIXED_CHANNEL_TABLE_INDEX_SECURITY_MANAGER_PROTOCOL].callback) { 1915c48b2a2cSMatthias Ringwald (*fixed_channels[L2CAP_FIXED_CHANNEL_TABLE_INDEX_SECURITY_MANAGER_PROTOCOL].callback)(SM_DATA_PACKET, handle, &packet[COMPLETE_L2CAP_HEADER], size-COMPLETE_L2CAP_HEADER); 1916c48b2a2cSMatthias Ringwald } 1917c48b2a2cSMatthias Ringwald break; 1918c48b2a2cSMatthias Ringwald 1919c48b2a2cSMatthias Ringwald case L2CAP_CID_CONNECTIONLESS_CHANNEL: 1920c48b2a2cSMatthias Ringwald if (fixed_channels[L2CAP_FIXED_CHANNEL_TABLE_INDEX_CONNECTIONLESS_CHANNEL].callback) { 1921c48b2a2cSMatthias Ringwald (*fixed_channels[L2CAP_FIXED_CHANNEL_TABLE_INDEX_CONNECTIONLESS_CHANNEL].callback)(UCD_DATA_PACKET, handle, &packet[COMPLETE_L2CAP_HEADER], size-COMPLETE_L2CAP_HEADER); 1922c48b2a2cSMatthias Ringwald } 1923c48b2a2cSMatthias Ringwald break; 19241bbc0b23S[email protected] 192509e9d05bSMatthias Ringwald default: 192609e9d05bSMatthias Ringwald #ifdef ENABLE_CLASSIC 192700d93d79Smatthias.ringwald // Find channel for this channel_id and connection handle 192864e11ca9SMatthias Ringwald l2cap_channel = l2cap_get_channel_for_local_cid(channel_id); 1929d1fd2a88SMatthias Ringwald if (l2cap_channel) { 19303d50b4baSMatthias Ringwald l2cap_dispatch_to_channel(l2cap_channel, L2CAP_DATA_PACKET, &packet[COMPLETE_L2CAP_HEADER], size-COMPLETE_L2CAP_HEADER); 193100d93d79Smatthias.ringwald } 193209e9d05bSMatthias Ringwald #endif 1933a3dc965aSMatthias Ringwald #ifdef ENABLE_LE_DATA_CHANNELS 193464e11ca9SMatthias Ringwald l2cap_channel = l2cap_le_get_channel_for_local_cid(channel_id); 193564e11ca9SMatthias Ringwald if (l2cap_channel) { 193685aeef60SMatthias Ringwald // credit counting 193785aeef60SMatthias Ringwald if (l2cap_channel->credits_incoming == 0){ 193885aeef60SMatthias Ringwald log_error("LE Data Channel packet received but no incoming credits"); 193985aeef60SMatthias Ringwald l2cap_channel->state = L2CAP_STATE_WILL_SEND_DISCONNECT_REQUEST; 194085aeef60SMatthias Ringwald break; 194185aeef60SMatthias Ringwald } 194285aeef60SMatthias Ringwald l2cap_channel->credits_incoming--; 194385aeef60SMatthias Ringwald 194485aeef60SMatthias Ringwald // automatic credits 194585aeef60SMatthias Ringwald if (l2cap_channel->credits_incoming < L2CAP_LE_DATA_CHANNELS_AUTOMATIC_CREDITS_WATERMARK && l2cap_channel->automatic_credits){ 194685aeef60SMatthias Ringwald l2cap_channel->new_credits_incoming = L2CAP_LE_DATA_CHANNELS_AUTOMATIC_CREDITS_INCREMENT; 194785aeef60SMatthias Ringwald } 194885aeef60SMatthias Ringwald 1949cd529728SMatthias Ringwald // first fragment 1950cd529728SMatthias Ringwald uint16_t pos = 0; 1951cd529728SMatthias Ringwald if (!l2cap_channel->receive_sdu_len){ 1952cd529728SMatthias Ringwald l2cap_channel->receive_sdu_len = little_endian_read_16(packet, COMPLETE_L2CAP_HEADER); 1953cd529728SMatthias Ringwald l2cap_channel->receive_sdu_pos = 0; 1954cd529728SMatthias Ringwald pos += 2; 1955cd529728SMatthias Ringwald size -= 2; 1956cd529728SMatthias Ringwald } 1957cd529728SMatthias Ringwald memcpy(&l2cap_channel->receive_sdu_buffer[l2cap_channel->receive_sdu_pos], &packet[COMPLETE_L2CAP_HEADER+pos], size-COMPLETE_L2CAP_HEADER); 1958cd529728SMatthias Ringwald l2cap_channel->receive_sdu_pos += size - COMPLETE_L2CAP_HEADER; 1959cd529728SMatthias Ringwald // done? 196063f0ac45SMatthias Ringwald log_info("le packet pos %u, len %u", l2cap_channel->receive_sdu_pos, l2cap_channel->receive_sdu_len); 1961cd529728SMatthias Ringwald if (l2cap_channel->receive_sdu_pos >= l2cap_channel->receive_sdu_len){ 1962cd529728SMatthias Ringwald l2cap_dispatch_to_channel(l2cap_channel, L2CAP_DATA_PACKET, l2cap_channel->receive_sdu_buffer, l2cap_channel->receive_sdu_len); 1963cd529728SMatthias Ringwald l2cap_channel->receive_sdu_len = 0; 1964cd529728SMatthias Ringwald } 196563f0ac45SMatthias Ringwald } else { 196663f0ac45SMatthias Ringwald log_error("LE Data Channel packet received but no channel found for cid 0x%02x", channel_id); 196764e11ca9SMatthias Ringwald } 196864e11ca9SMatthias Ringwald #endif 19695652b5ffS[email protected] break; 19705652b5ffS[email protected] } 197100d93d79Smatthias.ringwald 19721eb2563eS[email protected] l2cap_run(); 19732718e2e7Smatthias.ringwald } 197400d93d79Smatthias.ringwald 197509e9d05bSMatthias Ringwald // Bluetooth 4.0 - allows to register handler for Attribute Protocol and Security Manager Protocol 197609e9d05bSMatthias Ringwald void l2cap_register_fixed_channel(btstack_packet_handler_t the_packet_handler, uint16_t channel_id) { 197709e9d05bSMatthias Ringwald int index = l2cap_fixed_channel_table_index_for_channel_id(channel_id); 197809e9d05bSMatthias Ringwald if (index < 0) return; 197909e9d05bSMatthias Ringwald fixed_channels[index].callback = the_packet_handler; 198009e9d05bSMatthias Ringwald } 198109e9d05bSMatthias Ringwald 198209e9d05bSMatthias Ringwald #ifdef ENABLE_CLASSIC 198315ec09bbSmatthias.ringwald // finalize closed channel - l2cap_handle_disconnect_request & DISCONNECTION_RESPONSE 198427a923d0Smatthias.ringwald void l2cap_finialize_channel_close(l2cap_channel_t * channel){ 1985f62db1e3Smatthias.ringwald channel->state = L2CAP_STATE_CLOSED; 1986f62db1e3Smatthias.ringwald l2cap_emit_channel_closed(channel); 1987f62db1e3Smatthias.ringwald // discard channel 19889dcb2fb2S[email protected] l2cap_stop_rtx(channel); 1989665d90f2SMatthias Ringwald btstack_linked_list_remove(&l2cap_channels, (btstack_linked_item_t *) channel); 1990d3a9df87Smatthias.ringwald btstack_memory_l2cap_channel_free(channel); 1991c8e4258aSmatthias.ringwald } 19921e6aba47Smatthias.ringwald 19938f2a52f4SMatthias Ringwald static l2cap_service_t * l2cap_get_service_internal(btstack_linked_list_t * services, uint16_t psm){ 1994665d90f2SMatthias Ringwald btstack_linked_list_iterator_t it; 1995665d90f2SMatthias Ringwald btstack_linked_list_iterator_init(&it, services); 1996665d90f2SMatthias Ringwald while (btstack_linked_list_iterator_has_next(&it)){ 1997665d90f2SMatthias Ringwald l2cap_service_t * service = (l2cap_service_t *) btstack_linked_list_iterator_next(&it); 19989d9bbc01Smatthias.ringwald if ( service->psm == psm){ 19999d9bbc01Smatthias.ringwald return service; 20009d9bbc01Smatthias.ringwald }; 20019d9bbc01Smatthias.ringwald } 20029d9bbc01Smatthias.ringwald return NULL; 20039d9bbc01Smatthias.ringwald } 20049d9bbc01Smatthias.ringwald 20057192e786SMatthias Ringwald static inline l2cap_service_t * l2cap_get_service(uint16_t psm){ 20067192e786SMatthias Ringwald return l2cap_get_service_internal(&l2cap_services, psm); 20077192e786SMatthias Ringwald } 20087192e786SMatthias Ringwald 2009e0abb8e7S[email protected] 2010be2053a6SMatthias Ringwald uint8_t l2cap_register_service(btstack_packet_handler_t service_packet_handler, uint16_t psm, uint16_t mtu, gap_security_level_t security_level){ 2011be2053a6SMatthias Ringwald 2012be2053a6SMatthias Ringwald log_info("L2CAP_REGISTER_SERVICE psm 0x%x mtu %u", psm, mtu); 2013e0abb8e7S[email protected] 20144bb582b6Smatthias.ringwald // check for alread registered psm 20159d9bbc01Smatthias.ringwald l2cap_service_t *service = l2cap_get_service(psm); 2016277abc2cSmatthias.ringwald if (service) { 2017be2053a6SMatthias Ringwald log_error("l2cap_register_service: PSM %u already registered", psm); 2018be2053a6SMatthias Ringwald return L2CAP_SERVICE_ALREADY_REGISTERED; 2019277abc2cSmatthias.ringwald } 20209d9bbc01Smatthias.ringwald 20214bb582b6Smatthias.ringwald // alloc structure 2022bb69aaaeS[email protected] service = btstack_memory_l2cap_service_get(); 2023277abc2cSmatthias.ringwald if (!service) { 2024be2053a6SMatthias Ringwald log_error("l2cap_register_service: no memory for l2cap_service_t"); 2025be2053a6SMatthias Ringwald return BTSTACK_MEMORY_ALLOC_FAILED; 2026277abc2cSmatthias.ringwald } 20279d9bbc01Smatthias.ringwald 20289d9bbc01Smatthias.ringwald // fill in 20299d9bbc01Smatthias.ringwald service->psm = psm; 20309d9bbc01Smatthias.ringwald service->mtu = mtu; 203105ae8de3SMatthias Ringwald service->packet_handler = service_packet_handler; 2032df3354fcS[email protected] service->required_security_level = security_level; 20339d9bbc01Smatthias.ringwald 20349d9bbc01Smatthias.ringwald // add to services list 2035665d90f2SMatthias Ringwald btstack_linked_list_add(&l2cap_services, (btstack_linked_item_t *) service); 2036c0e866bfSmatthias.ringwald 2037c0e866bfSmatthias.ringwald // enable page scan 203815a95bd5SMatthias Ringwald gap_connectable_control(1); 20395842b6d9Smatthias.ringwald 2040be2053a6SMatthias Ringwald return 0; 20419d9bbc01Smatthias.ringwald } 20429d9bbc01Smatthias.ringwald 20437e8856ebSMatthias Ringwald uint8_t l2cap_unregister_service(uint16_t psm){ 2044e0abb8e7S[email protected] 2045e0abb8e7S[email protected] log_info("L2CAP_UNREGISTER_SERVICE psm 0x%x", psm); 2046e0abb8e7S[email protected] 20479d9bbc01Smatthias.ringwald l2cap_service_t *service = l2cap_get_service(psm); 20487e8856ebSMatthias Ringwald if (!service) return L2CAP_SERVICE_DOES_NOT_EXIST; 2049665d90f2SMatthias Ringwald btstack_linked_list_remove(&l2cap_services, (btstack_linked_item_t *) service); 2050d3a9df87Smatthias.ringwald btstack_memory_l2cap_service_free(service); 2051c0e866bfSmatthias.ringwald 2052c0e866bfSmatthias.ringwald // disable page scan when no services registered 20537e8856ebSMatthias Ringwald if (btstack_linked_list_empty(&l2cap_services)) { 205415a95bd5SMatthias Ringwald gap_connectable_control(0); 20559d9bbc01Smatthias.ringwald } 20567e8856ebSMatthias Ringwald return 0; 20577e8856ebSMatthias Ringwald } 205809e9d05bSMatthias Ringwald #endif 20599d9bbc01Smatthias.ringwald 20607192e786SMatthias Ringwald 2061cab29d48SMatthias Ringwald #ifdef ENABLE_LE_DATA_CHANNELS 206283fd9c76SMatthias Ringwald 206357be49d6SMatthias Ringwald static void l2cap_le_notify_channel_can_send(l2cap_channel_t *channel){ 206457be49d6SMatthias Ringwald if (!channel->waiting_for_can_send_now) return; 206557be49d6SMatthias Ringwald if (channel->send_sdu_buffer) return; 206657be49d6SMatthias Ringwald channel->waiting_for_can_send_now = 0; 206757be49d6SMatthias Ringwald log_info("L2CAP_EVENT_CHANNEL_LE_CAN_SEND_NOW local_cid 0x%x", channel->local_cid); 206857be49d6SMatthias Ringwald l2cap_emit_simple_event_with_cid(channel, L2CAP_EVENT_LE_CAN_SEND_NOW); 206957be49d6SMatthias Ringwald } 207057be49d6SMatthias Ringwald 207157be49d6SMatthias Ringwald // 1BH2222 207257be49d6SMatthias Ringwald static void l2cap_emit_le_incoming_connection(l2cap_channel_t *channel) { 207357be49d6SMatthias Ringwald log_info("L2CAP_EVENT_LE_INCOMING_CONNECTION addr_type %u, addr %s handle 0x%x psm 0x%x local_cid 0x%x remote_cid 0x%x, remote_mtu %u", 207457be49d6SMatthias Ringwald channel->address_type, bd_addr_to_str(channel->address), channel->con_handle, channel->psm, channel->local_cid, channel->remote_cid, channel->remote_mtu); 207557be49d6SMatthias Ringwald uint8_t event[19]; 207657be49d6SMatthias Ringwald event[0] = L2CAP_EVENT_LE_INCOMING_CONNECTION; 207757be49d6SMatthias Ringwald event[1] = sizeof(event) - 2; 207857be49d6SMatthias Ringwald event[2] = channel->address_type; 207957be49d6SMatthias Ringwald reverse_bd_addr(channel->address, &event[3]); 208057be49d6SMatthias Ringwald little_endian_store_16(event, 9, channel->con_handle); 208157be49d6SMatthias Ringwald little_endian_store_16(event, 11, channel->psm); 208257be49d6SMatthias Ringwald little_endian_store_16(event, 13, channel->local_cid); 208357be49d6SMatthias Ringwald little_endian_store_16(event, 15, channel->remote_cid); 208457be49d6SMatthias Ringwald little_endian_store_16(event, 17, channel->remote_mtu); 208557be49d6SMatthias Ringwald hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event)); 208657be49d6SMatthias Ringwald l2cap_dispatch_to_channel(channel, HCI_EVENT_PACKET, event, sizeof(event)); 208757be49d6SMatthias Ringwald } 208857be49d6SMatthias Ringwald // 11BH22222 208957be49d6SMatthias Ringwald static void l2cap_emit_le_channel_opened(l2cap_channel_t *channel, uint8_t status) { 209057be49d6SMatthias Ringwald log_info("L2CAP_EVENT_LE_CHANNEL_OPENED status 0x%x addr_type %u addr %s handle 0x%x psm 0x%x local_cid 0x%x remote_cid 0x%x local_mtu %u, remote_mtu %u", 209157be49d6SMatthias Ringwald status, channel->address_type, bd_addr_to_str(channel->address), channel->con_handle, channel->psm, 209257be49d6SMatthias Ringwald channel->local_cid, channel->remote_cid, channel->local_mtu, channel->remote_mtu); 2093c99bb618SMatthias Ringwald uint8_t event[23]; 209457be49d6SMatthias Ringwald event[0] = L2CAP_EVENT_LE_CHANNEL_OPENED; 209557be49d6SMatthias Ringwald event[1] = sizeof(event) - 2; 209657be49d6SMatthias Ringwald event[2] = status; 209757be49d6SMatthias Ringwald event[3] = channel->address_type; 209857be49d6SMatthias Ringwald reverse_bd_addr(channel->address, &event[4]); 209957be49d6SMatthias Ringwald little_endian_store_16(event, 10, channel->con_handle); 2100c99bb618SMatthias Ringwald event[12] = channel->state_var & L2CAP_CHANNEL_STATE_VAR_INCOMING ? 1 : 0; 2101c99bb618SMatthias Ringwald little_endian_store_16(event, 13, channel->psm); 2102c99bb618SMatthias Ringwald little_endian_store_16(event, 15, channel->local_cid); 2103c99bb618SMatthias Ringwald little_endian_store_16(event, 17, channel->remote_cid); 2104c99bb618SMatthias Ringwald little_endian_store_16(event, 19, channel->local_mtu); 2105c99bb618SMatthias Ringwald little_endian_store_16(event, 21, channel->remote_mtu); 210657be49d6SMatthias Ringwald hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event)); 210757be49d6SMatthias Ringwald l2cap_dispatch_to_channel(channel, HCI_EVENT_PACKET, event, sizeof(event)); 210857be49d6SMatthias Ringwald } 210957be49d6SMatthias Ringwald 211057be49d6SMatthias Ringwald static l2cap_channel_t * l2cap_le_get_channel_for_local_cid(uint16_t local_cid){ 211157be49d6SMatthias Ringwald btstack_linked_list_iterator_t it; 211257be49d6SMatthias Ringwald btstack_linked_list_iterator_init(&it, &l2cap_le_channels); 211357be49d6SMatthias Ringwald while (btstack_linked_list_iterator_has_next(&it)){ 211457be49d6SMatthias Ringwald l2cap_channel_t * channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it); 211557be49d6SMatthias Ringwald if ( channel->local_cid == local_cid) { 211657be49d6SMatthias Ringwald return channel; 211757be49d6SMatthias Ringwald } 211857be49d6SMatthias Ringwald } 211957be49d6SMatthias Ringwald return NULL; 212057be49d6SMatthias Ringwald } 212157be49d6SMatthias Ringwald 212257be49d6SMatthias Ringwald // finalize closed channel - l2cap_handle_disconnect_request & DISCONNECTION_RESPONSE 212357be49d6SMatthias Ringwald void l2cap_le_finialize_channel_close(l2cap_channel_t * channel){ 212457be49d6SMatthias Ringwald channel->state = L2CAP_STATE_CLOSED; 212557be49d6SMatthias Ringwald l2cap_emit_simple_event_with_cid(channel, L2CAP_EVENT_CHANNEL_CLOSED); 212657be49d6SMatthias Ringwald // discard channel 212757be49d6SMatthias Ringwald btstack_linked_list_remove(&l2cap_le_channels, (btstack_linked_item_t *) channel); 212857be49d6SMatthias Ringwald btstack_memory_l2cap_channel_free(channel); 212957be49d6SMatthias Ringwald } 213057be49d6SMatthias Ringwald 2131e7d0c9aaSMatthias Ringwald static inline l2cap_service_t * l2cap_le_get_service(uint16_t le_psm){ 2132e7d0c9aaSMatthias Ringwald return l2cap_get_service_internal(&l2cap_le_services, le_psm); 21337192e786SMatthias Ringwald } 2134efedfb4cSMatthias Ringwald 2135da144af5SMatthias Ringwald uint8_t l2cap_le_register_service(btstack_packet_handler_t packet_handler, uint16_t psm, gap_security_level_t security_level){ 21367192e786SMatthias Ringwald 2137da144af5SMatthias Ringwald log_info("L2CAP_LE_REGISTER_SERVICE psm 0x%x", psm); 21387192e786SMatthias Ringwald 21397192e786SMatthias Ringwald // check for alread registered psm 21407192e786SMatthias Ringwald l2cap_service_t *service = l2cap_le_get_service(psm); 21417192e786SMatthias Ringwald if (service) { 2142da144af5SMatthias Ringwald return L2CAP_SERVICE_ALREADY_REGISTERED; 21437192e786SMatthias Ringwald } 21447192e786SMatthias Ringwald 21457192e786SMatthias Ringwald // alloc structure 21467192e786SMatthias Ringwald service = btstack_memory_l2cap_service_get(); 21477192e786SMatthias Ringwald if (!service) { 21487192e786SMatthias Ringwald log_error("l2cap_register_service_internal: no memory for l2cap_service_t"); 2149da144af5SMatthias Ringwald return BTSTACK_MEMORY_ALLOC_FAILED; 21507192e786SMatthias Ringwald } 21517192e786SMatthias Ringwald 21527192e786SMatthias Ringwald // fill in 21537192e786SMatthias Ringwald service->psm = psm; 2154da144af5SMatthias Ringwald service->mtu = 0; 21557192e786SMatthias Ringwald service->packet_handler = packet_handler; 21567192e786SMatthias Ringwald service->required_security_level = security_level; 21577192e786SMatthias Ringwald 21587192e786SMatthias Ringwald // add to services list 2159665d90f2SMatthias Ringwald btstack_linked_list_add(&l2cap_le_services, (btstack_linked_item_t *) service); 21607192e786SMatthias Ringwald 21617192e786SMatthias Ringwald // done 2162da144af5SMatthias Ringwald return 0; 21637192e786SMatthias Ringwald } 21647192e786SMatthias Ringwald 2165da144af5SMatthias Ringwald uint8_t l2cap_le_unregister_service(uint16_t psm) { 21667192e786SMatthias Ringwald log_info("L2CAP_LE_UNREGISTER_SERVICE psm 0x%x", psm); 21677192e786SMatthias Ringwald l2cap_service_t *service = l2cap_le_get_service(psm); 21689367f9b0SMatthias Ringwald if (!service) return L2CAP_SERVICE_DOES_NOT_EXIST; 2169da144af5SMatthias Ringwald 2170665d90f2SMatthias Ringwald btstack_linked_list_remove(&l2cap_le_services, (btstack_linked_item_t *) service); 21717192e786SMatthias Ringwald btstack_memory_l2cap_service_free(service); 2172da144af5SMatthias Ringwald return 0; 21737192e786SMatthias Ringwald } 2174da144af5SMatthias Ringwald 2175da144af5SMatthias Ringwald uint8_t l2cap_le_accept_connection(uint16_t local_cid, uint8_t * receive_sdu_buffer, uint16_t mtu, uint16_t initial_credits){ 2176e7d0c9aaSMatthias Ringwald // get channel 2177e7d0c9aaSMatthias Ringwald l2cap_channel_t * channel = l2cap_le_get_channel_for_local_cid(local_cid); 2178e7d0c9aaSMatthias Ringwald if (!channel) return L2CAP_LOCAL_CID_DOES_NOT_EXIST; 2179e7d0c9aaSMatthias Ringwald 2180e7d0c9aaSMatthias Ringwald // validate state 2181e7d0c9aaSMatthias Ringwald if (channel->state != L2CAP_STATE_WAIT_CLIENT_ACCEPT_OR_REJECT){ 2182e7d0c9aaSMatthias Ringwald return ERROR_CODE_COMMAND_DISALLOWED; 2183e7d0c9aaSMatthias Ringwald } 2184e7d0c9aaSMatthias Ringwald 2185efedfb4cSMatthias Ringwald // set state accept connection 218623017473SMatthias Ringwald channel->state = L2CAP_STATE_WILL_SEND_LE_CONNECTION_RESPONSE_ACCEPT; 218723017473SMatthias Ringwald channel->receive_sdu_buffer = receive_sdu_buffer; 218823017473SMatthias Ringwald channel->local_mtu = mtu; 218985aeef60SMatthias Ringwald channel->new_credits_incoming = initial_credits; 219085aeef60SMatthias Ringwald channel->automatic_credits = initial_credits == L2CAP_LE_AUTOMATIC_CREDITS; 219185aeef60SMatthias Ringwald 219285aeef60SMatthias Ringwald // test 219363f0ac45SMatthias Ringwald // channel->new_credits_incoming = 1; 2194e7d0c9aaSMatthias Ringwald 2195e7d0c9aaSMatthias Ringwald // go 2196e7d0c9aaSMatthias Ringwald l2cap_run(); 2197da144af5SMatthias Ringwald return 0; 2198da144af5SMatthias Ringwald } 2199da144af5SMatthias Ringwald 2200da144af5SMatthias Ringwald /** 2201da144af5SMatthias Ringwald * @brief Deny incoming LE Data Channel connection due to resource constraints 2202da144af5SMatthias Ringwald * @param local_cid L2CAP LE Data Channel Identifier 2203da144af5SMatthias Ringwald */ 2204da144af5SMatthias Ringwald 2205da144af5SMatthias Ringwald uint8_t l2cap_le_decline_connection(uint16_t local_cid){ 2206e7d0c9aaSMatthias Ringwald // get channel 2207e7d0c9aaSMatthias Ringwald l2cap_channel_t * channel = l2cap_le_get_channel_for_local_cid(local_cid); 2208e7d0c9aaSMatthias Ringwald if (!channel) return L2CAP_LOCAL_CID_DOES_NOT_EXIST; 2209e7d0c9aaSMatthias Ringwald 2210e7d0c9aaSMatthias Ringwald // validate state 2211e7d0c9aaSMatthias Ringwald if (channel->state != L2CAP_STATE_WAIT_CLIENT_ACCEPT_OR_REJECT){ 2212e7d0c9aaSMatthias Ringwald return ERROR_CODE_COMMAND_DISALLOWED; 2213e7d0c9aaSMatthias Ringwald } 2214e7d0c9aaSMatthias Ringwald 2215efedfb4cSMatthias Ringwald // set state decline connection 2216e7d0c9aaSMatthias Ringwald channel->state = L2CAP_STATE_WILL_SEND_LE_CONNECTION_RESPONSE_DECLINE; 2217e7d0c9aaSMatthias Ringwald channel->reason = 0x04; // no resources available 2218e7d0c9aaSMatthias Ringwald l2cap_run(); 2219da144af5SMatthias Ringwald return 0; 2220da144af5SMatthias Ringwald } 2221da144af5SMatthias Ringwald 22227dafa750SMatthias Ringwald uint8_t l2cap_le_create_channel(btstack_packet_handler_t packet_handler, hci_con_handle_t con_handle, 2223da144af5SMatthias Ringwald uint16_t psm, uint8_t * receive_sdu_buffer, uint16_t mtu, uint16_t initial_credits, gap_security_level_t security_level, 2224efedfb4cSMatthias Ringwald uint16_t * out_local_cid) { 2225efedfb4cSMatthias Ringwald 22267dafa750SMatthias Ringwald log_info("L2CAP_LE_CREATE_CHANNEL handle 0x%04x psm 0x%x mtu %u", con_handle, psm, mtu); 2227da144af5SMatthias Ringwald 22287dafa750SMatthias Ringwald 22297dafa750SMatthias Ringwald hci_connection_t * connection = hci_connection_for_handle(con_handle); 22307dafa750SMatthias Ringwald if (!connection) { 22317dafa750SMatthias Ringwald log_error("no hci_connection for handle 0x%04x", con_handle); 22327dafa750SMatthias Ringwald return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; 22337dafa750SMatthias Ringwald } 22347dafa750SMatthias Ringwald 22357dafa750SMatthias Ringwald l2cap_channel_t * channel = l2cap_create_channel_entry(packet_handler, connection->address, connection->address_type, psm, mtu, security_level); 2236da144af5SMatthias Ringwald if (!channel) { 2237da144af5SMatthias Ringwald return BTSTACK_MEMORY_ALLOC_FAILED; 2238da144af5SMatthias Ringwald } 2239e7d0c9aaSMatthias Ringwald log_info("l2cap_le_create_channel %p", channel); 2240da144af5SMatthias Ringwald 2241da144af5SMatthias Ringwald // store local_cid 2242da144af5SMatthias Ringwald if (out_local_cid){ 2243da144af5SMatthias Ringwald *out_local_cid = channel->local_cid; 2244da144af5SMatthias Ringwald } 2245da144af5SMatthias Ringwald 22467dafa750SMatthias Ringwald // provide buffer 22477dafa750SMatthias Ringwald channel->con_handle = con_handle; 2248cd529728SMatthias Ringwald channel->receive_sdu_buffer = receive_sdu_buffer; 22497dafa750SMatthias Ringwald channel->state = L2CAP_STATE_WILL_SEND_LE_CONNECTION_REQUEST; 225085aeef60SMatthias Ringwald channel->new_credits_incoming = initial_credits; 225185aeef60SMatthias Ringwald channel->automatic_credits = initial_credits == L2CAP_LE_AUTOMATIC_CREDITS; 225285aeef60SMatthias Ringwald 2253efedfb4cSMatthias Ringwald // add to connections list 2254efedfb4cSMatthias Ringwald btstack_linked_list_add(&l2cap_le_channels, (btstack_linked_item_t *) channel); 2255efedfb4cSMatthias Ringwald 22567dafa750SMatthias Ringwald // go 225763f0ac45SMatthias Ringwald l2cap_run(); 2258da144af5SMatthias Ringwald return 0; 2259da144af5SMatthias Ringwald } 2260da144af5SMatthias Ringwald 2261da144af5SMatthias Ringwald /** 2262da144af5SMatthias Ringwald * @brief Provide credtis for LE Data Channel 2263da144af5SMatthias Ringwald * @param local_cid L2CAP LE Data Channel Identifier 2264da144af5SMatthias Ringwald * @param credits Number additional credits for peer 2265da144af5SMatthias Ringwald */ 226664e11ca9SMatthias Ringwald uint8_t l2cap_le_provide_credits(uint16_t local_cid, uint16_t credits){ 226763f0ac45SMatthias Ringwald 226863f0ac45SMatthias Ringwald l2cap_channel_t * channel = l2cap_le_get_channel_for_local_cid(local_cid); 226963f0ac45SMatthias Ringwald if (!channel) { 227063f0ac45SMatthias Ringwald log_error("l2cap_le_provide_credits no channel for cid 0x%02x", local_cid); 227163f0ac45SMatthias Ringwald return L2CAP_LOCAL_CID_DOES_NOT_EXIST; 227263f0ac45SMatthias Ringwald } 227363f0ac45SMatthias Ringwald 2274efedfb4cSMatthias Ringwald // check state 227563f0ac45SMatthias Ringwald if (channel->state != L2CAP_STATE_OPEN){ 227663f0ac45SMatthias Ringwald log_error("l2cap_le_provide_credits but channel 0x%02x not open yet", local_cid); 227763f0ac45SMatthias Ringwald } 227863f0ac45SMatthias Ringwald 227963f0ac45SMatthias Ringwald // assert incoming credits + credits <= 0xffff 228063f0ac45SMatthias Ringwald uint32_t total_credits = channel->credits_incoming; 228163f0ac45SMatthias Ringwald total_credits += channel->new_credits_incoming; 228263f0ac45SMatthias Ringwald total_credits += credits; 228363f0ac45SMatthias Ringwald if (total_credits > 0xffff){ 228463f0ac45SMatthias Ringwald log_error("l2cap_le_provide_credits overrun: current %u, scheduled %u, additional %u", channel->credits_incoming, 228563f0ac45SMatthias Ringwald channel->new_credits_incoming, credits); 228663f0ac45SMatthias Ringwald } 228763f0ac45SMatthias Ringwald 2288efedfb4cSMatthias Ringwald // set credits_granted 228963f0ac45SMatthias Ringwald channel->new_credits_incoming += credits; 229063f0ac45SMatthias Ringwald 229163f0ac45SMatthias Ringwald // go 229263f0ac45SMatthias Ringwald l2cap_run(); 2293da144af5SMatthias Ringwald return 0; 2294da144af5SMatthias Ringwald } 2295da144af5SMatthias Ringwald 2296da144af5SMatthias Ringwald /** 2297da144af5SMatthias Ringwald * @brief Check if outgoing buffer is available and that there's space on the Bluetooth module 2298da144af5SMatthias Ringwald * @param local_cid L2CAP LE Data Channel Identifier 2299da144af5SMatthias Ringwald */ 230064e11ca9SMatthias Ringwald int l2cap_le_can_send_now(uint16_t local_cid){ 230144276248SMatthias Ringwald l2cap_channel_t * channel = l2cap_le_get_channel_for_local_cid(local_cid); 230244276248SMatthias Ringwald if (!channel) { 230344276248SMatthias Ringwald log_error("l2cap_le_provide_credits no channel for cid 0x%02x", local_cid); 2304da144af5SMatthias Ringwald return 0; 2305da144af5SMatthias Ringwald } 2306da144af5SMatthias Ringwald 230744276248SMatthias Ringwald // check state 230844276248SMatthias Ringwald if (channel->state != L2CAP_STATE_OPEN) return 0; 230944276248SMatthias Ringwald 231044276248SMatthias Ringwald // check queue 231144276248SMatthias Ringwald if (channel->send_sdu_buffer) return 0; 231244276248SMatthias Ringwald 231344276248SMatthias Ringwald // fine, go ahead 231444276248SMatthias Ringwald return 1; 231544276248SMatthias Ringwald } 231644276248SMatthias Ringwald 2317da144af5SMatthias Ringwald /** 2318da144af5SMatthias Ringwald * @brief Request emission of L2CAP_EVENT_CAN_SEND_NOW as soon as possible 2319da144af5SMatthias Ringwald * @note L2CAP_EVENT_CAN_SEND_NOW might be emitted during call to this function 2320da144af5SMatthias Ringwald * so packet handler should be ready to handle it 2321da144af5SMatthias Ringwald * @param local_cid L2CAP LE Data Channel Identifier 2322da144af5SMatthias Ringwald */ 232364e11ca9SMatthias Ringwald uint8_t l2cap_le_request_can_send_now_event(uint16_t local_cid){ 232444276248SMatthias Ringwald l2cap_channel_t * channel = l2cap_le_get_channel_for_local_cid(local_cid); 232544276248SMatthias Ringwald if (!channel) { 232644276248SMatthias Ringwald log_error("l2cap_le_request_can_send_now_event no channel for cid 0x%02x", local_cid); 232744276248SMatthias Ringwald return 0; 232844276248SMatthias Ringwald } 232944276248SMatthias Ringwald channel->waiting_for_can_send_now = 1; 233044276248SMatthias Ringwald l2cap_le_notify_channel_can_send(channel); 2331da144af5SMatthias Ringwald return 0; 2332da144af5SMatthias Ringwald } 2333da144af5SMatthias Ringwald 2334da144af5SMatthias Ringwald /** 2335da144af5SMatthias Ringwald * @brief Send data via LE Data Channel 2336da144af5SMatthias Ringwald * @note Since data larger then the maximum PDU needs to be segmented into multiple PDUs, data needs to stay valid until ... event 2337da144af5SMatthias Ringwald * @param local_cid L2CAP LE Data Channel Identifier 2338da144af5SMatthias Ringwald * @param data data to send 2339da144af5SMatthias Ringwald * @param size data size 2340da144af5SMatthias Ringwald */ 234164e11ca9SMatthias Ringwald uint8_t l2cap_le_send_data(uint16_t local_cid, uint8_t * data, uint16_t len){ 234264e11ca9SMatthias Ringwald 234364e11ca9SMatthias Ringwald l2cap_channel_t * channel = l2cap_le_get_channel_for_local_cid(local_cid); 234464e11ca9SMatthias Ringwald if (!channel) { 234564e11ca9SMatthias Ringwald log_error("l2cap_send no channel for cid 0x%02x", local_cid); 2346828a7f7aSMatthias Ringwald return L2CAP_LOCAL_CID_DOES_NOT_EXIST; 234764e11ca9SMatthias Ringwald } 234864e11ca9SMatthias Ringwald 234964e11ca9SMatthias Ringwald if (len > channel->remote_mtu){ 235064e11ca9SMatthias Ringwald log_error("l2cap_send cid 0x%02x, data length exceeds remote MTU.", local_cid); 235164e11ca9SMatthias Ringwald return L2CAP_DATA_LEN_EXCEEDS_REMOTE_MTU; 235264e11ca9SMatthias Ringwald } 235364e11ca9SMatthias Ringwald 23547f107edaSMatthias Ringwald if (channel->send_sdu_buffer){ 235564e11ca9SMatthias Ringwald log_info("l2cap_send cid 0x%02x, cannot send", local_cid); 235664e11ca9SMatthias Ringwald return BTSTACK_ACL_BUFFERS_FULL; 235764e11ca9SMatthias Ringwald } 235864e11ca9SMatthias Ringwald 23597f107edaSMatthias Ringwald channel->send_sdu_buffer = data; 23607f107edaSMatthias Ringwald channel->send_sdu_len = len; 23617f107edaSMatthias Ringwald channel->send_sdu_pos = 0; 236264e11ca9SMatthias Ringwald 23637f107edaSMatthias Ringwald l2cap_run(); 23647f107edaSMatthias Ringwald return 0; 2365da144af5SMatthias Ringwald } 2366da144af5SMatthias Ringwald 2367da144af5SMatthias Ringwald /** 2368da144af5SMatthias Ringwald * @brief Disconnect from LE Data Channel 2369da144af5SMatthias Ringwald * @param local_cid L2CAP LE Data Channel Identifier 2370da144af5SMatthias Ringwald */ 2371828a7f7aSMatthias Ringwald uint8_t l2cap_le_disconnect(uint16_t local_cid) 2372da144af5SMatthias Ringwald { 2373828a7f7aSMatthias Ringwald l2cap_channel_t * channel = l2cap_le_get_channel_for_local_cid(local_cid); 2374828a7f7aSMatthias Ringwald if (!channel) { 2375828a7f7aSMatthias Ringwald log_error("l2cap_send no channel for cid 0x%02x", local_cid); 2376828a7f7aSMatthias Ringwald return L2CAP_LOCAL_CID_DOES_NOT_EXIST; 2377828a7f7aSMatthias Ringwald } 2378828a7f7aSMatthias Ringwald 2379828a7f7aSMatthias Ringwald channel->state = L2CAP_STATE_WILL_SEND_DISCONNECT_REQUEST; 2380828a7f7aSMatthias Ringwald l2cap_run(); 2381da144af5SMatthias Ringwald return 0; 2382da144af5SMatthias Ringwald } 2383da144af5SMatthias Ringwald 23847f02f414SMatthias Ringwald #endif 2385