xref: /btstack/src/l2cap.c (revision d6ed9f9cc019cef4ac8d6e16b5b6bbef02cfc2e2)
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