xref: /btstack/src/l2cap.c (revision c99bb61874f3ec820ad68993c8f50e4de7fb77fe)
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 
381713bceaSmatthias.ringwald /*
3943625864Smatthias.ringwald  *  l2cap.c
4043625864Smatthias.ringwald  *
4143625864Smatthias.ringwald  *  Logical Link Control and Adaption Protocl (L2CAP)
4243625864Smatthias.ringwald  *
4343625864Smatthias.ringwald  *  Created by Matthias Ringwald on 5/16/09.
4443625864Smatthias.ringwald  */
4543625864Smatthias.ringwald 
4643625864Smatthias.ringwald #include "l2cap.h"
47645658c9Smatthias.ringwald #include "hci.h"
482b3c6c9bSmatthias.ringwald #include "hci_dump.h"
4916ece135SMatthias Ringwald #include "btstack_debug.h"
500e2df43fSMatthias Ringwald #include "btstack_event.h"
51d3a9df87Smatthias.ringwald #include "btstack_memory.h"
5243625864Smatthias.ringwald 
53cab29d48SMatthias Ringwald #ifdef ENABLE_LE_DATA_CHANNELS
5483fd9c76SMatthias Ringwald #include "ble/sm.h"
5583fd9c76SMatthias Ringwald #endif
5683fd9c76SMatthias Ringwald 
5743625864Smatthias.ringwald #include <stdarg.h>
5843625864Smatthias.ringwald #include <string.h>
5943625864Smatthias.ringwald 
6043625864Smatthias.ringwald #include <stdio.h>
6143625864Smatthias.ringwald 
624c744e21Smatthias.ringwald // nr of buffered acl packets in outgoing queue to get max performance
634c744e21Smatthias.ringwald #define NR_BUFFERED_ACL_PACKETS 3
644c744e21Smatthias.ringwald 
6539bda6d5Smatthias.ringwald // used to cache l2cap rejects, echo, and informational requests
66e16a9cacSmatthias.ringwald #define NR_PENDING_SIGNALING_RESPONSES 3
6739bda6d5Smatthias.ringwald 
6885aeef60SMatthias Ringwald // nr of credits provided to remote if credits fall below watermark
6985aeef60SMatthias Ringwald #define L2CAP_LE_DATA_CHANNELS_AUTOMATIC_CREDITS_WATERMARK 5
7085aeef60SMatthias Ringwald #define L2CAP_LE_DATA_CHANNELS_AUTOMATIC_CREDITS_INCREMENT 5
7185aeef60SMatthias Ringwald 
7200d93d79Smatthias.ringwald // offsets for L2CAP SIGNALING COMMANDS
7300d93d79Smatthias.ringwald #define L2CAP_SIGNALING_COMMAND_CODE_OFFSET   0
7400d93d79Smatthias.ringwald #define L2CAP_SIGNALING_COMMAND_SIGID_OFFSET  1
7500d93d79Smatthias.ringwald #define L2CAP_SIGNALING_COMMAND_LENGTH_OFFSET 2
7600d93d79Smatthias.ringwald #define L2CAP_SIGNALING_COMMAND_DATA_OFFSET   4
7700d93d79Smatthias.ringwald 
785628cf69SMatthias Ringwald // internal table
795628cf69SMatthias Ringwald #define L2CAP_FIXED_CHANNEL_TABLE_INDEX_ATTRIBUTE_PROTOCOL 0
805628cf69SMatthias Ringwald #define L2CAP_FIXED_CHANNEL_TABLE_INDEX_SECURITY_MANAGER_PROTOCOL  1
815628cf69SMatthias Ringwald #define L2CAP_FIXED_CHANNEL_TABLE_INDEX_CONNECTIONLESS_CHANNEL 2
825628cf69SMatthias Ringwald #define L2CAP_FIXED_CHANNEL_TABLE_SIZE (L2CAP_FIXED_CHANNEL_TABLE_INDEX_CONNECTIONLESS_CHANNEL+1)
835628cf69SMatthias Ringwald 
8433c40538SMatthias Ringwald // prototypes
8533c40538SMatthias Ringwald static void l2cap_finialize_channel_close(l2cap_channel_t *channel);
8633c40538SMatthias Ringwald static inline l2cap_service_t * l2cap_get_service(uint16_t psm);
8733c40538SMatthias Ringwald static void l2cap_emit_channel_opened(l2cap_channel_t *channel, uint8_t status);
8834e7e577SMatthias Ringwald static void l2cap_emit_can_send_now(btstack_packet_handler_t packet_handler, uint16_t channel);
8933c40538SMatthias Ringwald static void l2cap_emit_channel_closed(l2cap_channel_t *channel);
9044276248SMatthias Ringwald static void l2cap_emit_incoming_connection(l2cap_channel_t *channel);
9133c40538SMatthias Ringwald static int  l2cap_channel_ready_for_open(l2cap_channel_t *channel);
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);
9557be49d6SMatthias Ringwald 
96cab29d48SMatthias Ringwald #ifdef ENABLE_LE_DATA_CHANNELS
9757be49d6SMatthias Ringwald static void l2cap_emit_le_channel_opened(l2cap_channel_t *channel, uint8_t status);
9857be49d6SMatthias Ringwald static void l2cap_emit_le_incoming_connection(l2cap_channel_t *channel);
9957be49d6SMatthias Ringwald static l2cap_channel_t * l2cap_le_get_channel_for_local_cid(uint16_t local_cid);
10044276248SMatthias Ringwald static void l2cap_le_notify_channel_can_send(l2cap_channel_t *channel);
101828a7f7aSMatthias Ringwald static void l2cap_le_finialize_channel_close(l2cap_channel_t *channel);
102e7d0c9aaSMatthias Ringwald static inline l2cap_service_t * l2cap_le_get_service(uint16_t psm);
103e7d0c9aaSMatthias Ringwald #endif
10433c40538SMatthias Ringwald 
1055628cf69SMatthias Ringwald typedef struct l2cap_fixed_channel {
1065628cf69SMatthias Ringwald     btstack_packet_handler_t callback;
1072125de09SMatthias Ringwald     uint8_t waiting_for_can_send_now;
1085628cf69SMatthias Ringwald } l2cap_fixed_channel_t;
1095628cf69SMatthias Ringwald 
1105628cf69SMatthias Ringwald static btstack_linked_list_t l2cap_channels;
1115628cf69SMatthias Ringwald static btstack_linked_list_t l2cap_services;
11257be49d6SMatthias Ringwald 
11357be49d6SMatthias Ringwald #ifdef ENABLE_LE_DATA_CHANNELS
1145628cf69SMatthias Ringwald static btstack_linked_list_t l2cap_le_channels;
1155628cf69SMatthias Ringwald static btstack_linked_list_t l2cap_le_services;
11657be49d6SMatthias Ringwald #endif
11739bda6d5Smatthias.ringwald 
11839bda6d5Smatthias.ringwald // used to cache l2cap rejects, echo, and informational requests
1192b83fb7dSmatthias.ringwald static l2cap_signaling_response_t signaling_responses[NR_PENDING_SIGNALING_RESPONSES];
1202b83fb7dSmatthias.ringwald static int signaling_responses_pending;
1212b83fb7dSmatthias.ringwald 
12233c40538SMatthias Ringwald static uint8_t require_security_level2_for_outgoing_sdp;
12333c40538SMatthias Ringwald 
124fb37a842SMatthias Ringwald static btstack_packet_callback_registration_t hci_event_callback_registration;
125fb37a842SMatthias Ringwald 
12633c40538SMatthias Ringwald static btstack_packet_handler_t l2cap_event_packet_handler;
1275628cf69SMatthias Ringwald static l2cap_fixed_channel_t fixed_channels[L2CAP_FIXED_CHANNEL_TABLE_SIZE];
12839bda6d5Smatthias.ringwald 
12934e7e577SMatthias Ringwald static uint16_t l2cap_fixed_channel_table_channel_id_for_index(int index){
13034e7e577SMatthias Ringwald     switch (index){
13134e7e577SMatthias Ringwald         case L2CAP_FIXED_CHANNEL_TABLE_INDEX_ATTRIBUTE_PROTOCOL:
13234e7e577SMatthias Ringwald             return L2CAP_CID_ATTRIBUTE_PROTOCOL;
13334e7e577SMatthias Ringwald         case L2CAP_FIXED_CHANNEL_TABLE_INDEX_SECURITY_MANAGER_PROTOCOL:
13434e7e577SMatthias Ringwald             return L2CAP_CID_SECURITY_MANAGER_PROTOCOL;
13534e7e577SMatthias Ringwald         case L2CAP_FIXED_CHANNEL_TABLE_INDEX_CONNECTIONLESS_CHANNEL:
13634e7e577SMatthias Ringwald             return L2CAP_CID_CONNECTIONLESS_CHANNEL;
13734e7e577SMatthias Ringwald         default:
13834e7e577SMatthias Ringwald             return 0;
13934e7e577SMatthias Ringwald     }
14034e7e577SMatthias Ringwald }
1415628cf69SMatthias Ringwald static int l2cap_fixed_channel_table_index_for_channel_id(uint16_t channel_id){
1425628cf69SMatthias Ringwald     switch (channel_id){
1435628cf69SMatthias Ringwald         case L2CAP_CID_ATTRIBUTE_PROTOCOL:
1445628cf69SMatthias Ringwald             return L2CAP_FIXED_CHANNEL_TABLE_INDEX_ATTRIBUTE_PROTOCOL;
1455628cf69SMatthias Ringwald         case L2CAP_CID_SECURITY_MANAGER_PROTOCOL:
1465628cf69SMatthias Ringwald             return  L2CAP_FIXED_CHANNEL_TABLE_INDEX_SECURITY_MANAGER_PROTOCOL;
1475628cf69SMatthias Ringwald         case L2CAP_CID_CONNECTIONLESS_CHANNEL:
1485628cf69SMatthias Ringwald             return  L2CAP_FIXED_CHANNEL_TABLE_INDEX_CONNECTIONLESS_CHANNEL;
1495628cf69SMatthias Ringwald         default:
1505628cf69SMatthias Ringwald             return -1;
1515628cf69SMatthias Ringwald         }
1525628cf69SMatthias Ringwald }
15339bda6d5Smatthias.ringwald 
15434e7e577SMatthias Ringwald static int l2cap_fixed_channel_table_index_is_le(int index){
15534e7e577SMatthias Ringwald     if (index == L2CAP_CID_CONNECTIONLESS_CHANNEL) return 0;
15634e7e577SMatthias Ringwald     return 1;
15734e7e577SMatthias Ringwald }
15834e7e577SMatthias Ringwald 
15971de195eSMatthias Ringwald void l2cap_init(void){
1602b83fb7dSmatthias.ringwald     signaling_responses_pending = 0;
161808a48abSmatthias.ringwald 
162f5454fc6Smatthias.ringwald     l2cap_channels = NULL;
163f5454fc6Smatthias.ringwald     l2cap_services = NULL;
1647192e786SMatthias Ringwald     l2cap_le_services = NULL;
1657192e786SMatthias Ringwald     l2cap_le_channels = NULL;
166f5454fc6Smatthias.ringwald 
16733c40538SMatthias Ringwald     l2cap_event_packet_handler = NULL;
1685628cf69SMatthias Ringwald     memset(fixed_channels, 0, sizeof(fixed_channels));
169f5454fc6Smatthias.ringwald 
170ac301f95S[email protected]     require_security_level2_for_outgoing_sdp = 0;
171ac301f95S[email protected] 
172fcadd0caSmatthias.ringwald     //
1732718e2e7Smatthias.ringwald     // register callback with HCI
174fcadd0caSmatthias.ringwald     //
175d9a7306aSMatthias Ringwald     hci_event_callback_registration.callback = &l2cap_hci_event_handler;
176fb37a842SMatthias Ringwald     hci_add_event_handler(&hci_event_callback_registration);
177fb37a842SMatthias Ringwald 
178d9a7306aSMatthias Ringwald     hci_register_acl_packet_handler(&l2cap_acl_handler);
179fb37a842SMatthias Ringwald 
18015a95bd5SMatthias Ringwald     gap_connectable_control(0); // no services yet
181fcadd0caSmatthias.ringwald }
182fcadd0caSmatthias.ringwald 
183ffbf8201SMatthias Ringwald void l2cap_register_packet_handler(void (*handler)(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size)){
18433c40538SMatthias Ringwald     l2cap_event_packet_handler = handler;
1851e6aba47Smatthias.ringwald }
1861e6aba47Smatthias.ringwald 
18717a9b554SMatthias Ringwald static void l2cap_dispatch_to_channel(l2cap_channel_t *channel, uint8_t type, uint8_t * data, uint16_t size){
18858de5610Smatthias.ringwald     (* (channel->packet_handler))(type, channel->local_cid, data, size);
18958de5610Smatthias.ringwald }
19058de5610Smatthias.ringwald 
19144276248SMatthias Ringwald static void l2cap_emit_simple_event_with_cid(l2cap_channel_t * channel, uint8_t event_code){
19244276248SMatthias Ringwald     uint8_t event[4];
19344276248SMatthias Ringwald     event[0] = event_code;
19444276248SMatthias Ringwald     event[1] = sizeof(event) - 2;
19544276248SMatthias Ringwald     little_endian_store_16(event, 2, channel->local_cid);
19644276248SMatthias Ringwald     hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event));
19744276248SMatthias Ringwald     l2cap_dispatch_to_channel(channel, HCI_EVENT_PACKET, event, sizeof(event));
19844276248SMatthias Ringwald }
19944276248SMatthias Ringwald 
20058de5610Smatthias.ringwald void l2cap_emit_channel_opened(l2cap_channel_t *channel, uint8_t status) {
201c9dc710bS[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",
202fc64f94aSMatthias Ringwald              status, bd_addr_to_str(channel->address), channel->con_handle, channel->psm,
203c9dc710bS[email protected]              channel->local_cid, channel->remote_cid, channel->local_mtu, channel->remote_mtu, channel->flush_timeout);
204c9dc710bS[email protected]     uint8_t event[23];
20558de5610Smatthias.ringwald     event[0] = L2CAP_EVENT_CHANNEL_OPENED;
20658de5610Smatthias.ringwald     event[1] = sizeof(event) - 2;
20758de5610Smatthias.ringwald     event[2] = status;
208724d70a2SMatthias Ringwald     reverse_bd_addr(channel->address, &event[3]);
209fc64f94aSMatthias Ringwald     little_endian_store_16(event,  9, channel->con_handle);
210f8fbdce0SMatthias Ringwald     little_endian_store_16(event, 11, channel->psm);
211f8fbdce0SMatthias Ringwald     little_endian_store_16(event, 13, channel->local_cid);
212f8fbdce0SMatthias Ringwald     little_endian_store_16(event, 15, channel->remote_cid);
213f8fbdce0SMatthias Ringwald     little_endian_store_16(event, 17, channel->local_mtu);
214f8fbdce0SMatthias Ringwald     little_endian_store_16(event, 19, channel->remote_mtu);
215f8fbdce0SMatthias Ringwald     little_endian_store_16(event, 21, channel->flush_timeout);
21658de5610Smatthias.ringwald     hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event));
21717a9b554SMatthias Ringwald     l2cap_dispatch_to_channel(channel, HCI_EVENT_PACKET, event, sizeof(event));
21858de5610Smatthias.ringwald }
21958de5610Smatthias.ringwald 
22044276248SMatthias Ringwald static void l2cap_emit_channel_closed(l2cap_channel_t *channel) {
221e0abb8e7S[email protected]     log_info("L2CAP_EVENT_CHANNEL_CLOSED local_cid 0x%x", channel->local_cid);
22244276248SMatthias Ringwald     l2cap_emit_simple_event_with_cid(channel, L2CAP_EVENT_CHANNEL_CLOSED);
22358de5610Smatthias.ringwald }
22458de5610Smatthias.ringwald 
22544276248SMatthias Ringwald 
22644276248SMatthias Ringwald static void l2cap_emit_can_send_now(btstack_packet_handler_t packet_handler, uint16_t channel) {
22744276248SMatthias Ringwald     log_info("L2CAP_EVENT_CHANNEL_CAN_SEND_NOW local_cid 0x%x", channel);
22844276248SMatthias Ringwald     uint8_t event[4];
22944276248SMatthias Ringwald     event[0] = L2CAP_EVENT_CAN_SEND_NOW;
23044276248SMatthias Ringwald     event[1] = sizeof(event) - 2;
23144276248SMatthias Ringwald     little_endian_store_16(event, 2, channel);
23244276248SMatthias Ringwald     hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event));
23344276248SMatthias Ringwald     packet_handler(HCI_EVENT_PACKET, channel, event, sizeof(event));
23444276248SMatthias Ringwald }
23544276248SMatthias Ringwald 
23644276248SMatthias Ringwald static void l2cap_emit_incoming_connection(l2cap_channel_t *channel) {
237e0abb8e7S[email protected]     log_info("L2CAP_EVENT_INCOMING_CONNECTION addr %s handle 0x%x psm 0x%x local_cid 0x%x remote_cid 0x%x",
238fc64f94aSMatthias Ringwald              bd_addr_to_str(channel->address), channel->con_handle,  channel->psm, channel->local_cid, channel->remote_cid);
23958de5610Smatthias.ringwald     uint8_t event[16];
24058de5610Smatthias.ringwald     event[0] = L2CAP_EVENT_INCOMING_CONNECTION;
24158de5610Smatthias.ringwald     event[1] = sizeof(event) - 2;
242724d70a2SMatthias Ringwald     reverse_bd_addr(channel->address, &event[2]);
243fc64f94aSMatthias Ringwald     little_endian_store_16(event,  8, channel->con_handle);
244f8fbdce0SMatthias Ringwald     little_endian_store_16(event, 10, channel->psm);
245f8fbdce0SMatthias Ringwald     little_endian_store_16(event, 12, channel->local_cid);
246f8fbdce0SMatthias Ringwald     little_endian_store_16(event, 14, channel->remote_cid);
24758de5610Smatthias.ringwald     hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event));
24817a9b554SMatthias Ringwald     l2cap_dispatch_to_channel(channel, HCI_EVENT_PACKET, event, sizeof(event));
2490af41d30Smatthias.ringwald }
250808a48abSmatthias.ringwald 
251fc64f94aSMatthias Ringwald static void l2cap_emit_connection_parameter_update_response(hci_con_handle_t con_handle, uint16_t result){
252ccf076adS[email protected]     uint8_t event[6];
253ccf076adS[email protected]     event[0] = L2CAP_EVENT_CONNECTION_PARAMETER_UPDATE_RESPONSE;
254ccf076adS[email protected]     event[1] = 4;
255fc64f94aSMatthias Ringwald     little_endian_store_16(event, 2, con_handle);
256f8fbdce0SMatthias Ringwald     little_endian_store_16(event, 4, result);
257ccf076adS[email protected]     hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event));
25833c40538SMatthias Ringwald     if (!l2cap_event_packet_handler) return;
25933c40538SMatthias Ringwald     (*l2cap_event_packet_handler)(HCI_EVENT_PACKET, 0, event, sizeof(event));
260ccf076adS[email protected] }
261ccf076adS[email protected] 
2627f02f414SMatthias Ringwald static l2cap_channel_t * l2cap_get_channel_for_local_cid(uint16_t local_cid){
263665d90f2SMatthias Ringwald     btstack_linked_list_iterator_t it;
264665d90f2SMatthias Ringwald     btstack_linked_list_iterator_init(&it, &l2cap_channels);
265665d90f2SMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
266665d90f2SMatthias Ringwald         l2cap_channel_t * channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it);
267b35f641cSmatthias.ringwald         if ( channel->local_cid == local_cid) {
268f62db1e3Smatthias.ringwald             return channel;
269f62db1e3Smatthias.ringwald         }
270f62db1e3Smatthias.ringwald     }
271f62db1e3Smatthias.ringwald     return NULL;
272f62db1e3Smatthias.ringwald }
273f62db1e3Smatthias.ringwald 
2740b9d7e78SMatthias Ringwald ///
2750b9d7e78SMatthias Ringwald 
27630725612SMatthias Ringwald void l2cap_request_can_send_now_event(uint16_t local_cid){
27730725612SMatthias Ringwald     l2cap_channel_t *channel = l2cap_get_channel_for_local_cid(local_cid);
27830725612SMatthias Ringwald     if (!channel) return;
27930725612SMatthias Ringwald     channel->waiting_for_can_send_now = 1;
28030725612SMatthias Ringwald     l2cap_notify_channel_can_send();
28130725612SMatthias Ringwald }
28230725612SMatthias Ringwald 
2830b9d7e78SMatthias Ringwald void l2cap_request_can_send_fix_channel_now_event(hci_con_handle_t con_handle, uint16_t channel_id){
2840b9d7e78SMatthias Ringwald     int index = l2cap_fixed_channel_table_index_for_channel_id(channel_id);
2850b9d7e78SMatthias Ringwald     if (index < 0) return;
2860b9d7e78SMatthias Ringwald     fixed_channels[index].waiting_for_can_send_now = 1;
2870b9d7e78SMatthias Ringwald     l2cap_notify_channel_can_send();
2880b9d7e78SMatthias Ringwald }
2890b9d7e78SMatthias Ringwald 
2900b9d7e78SMatthias Ringwald ///
2910b9d7e78SMatthias Ringwald 
2926b1fde37Smatthias.ringwald int  l2cap_can_send_packet_now(uint16_t local_cid){
2936b1fde37Smatthias.ringwald     l2cap_channel_t *channel = l2cap_get_channel_for_local_cid(local_cid);
2946b1fde37Smatthias.ringwald     if (!channel) return 0;
2950b9d7e78SMatthias Ringwald     return hci_can_send_acl_packet_now(channel->con_handle);
2967856fb31S[email protected] }
2977856fb31S[email protected] 
29883e7cdd9SMatthias Ringwald int  l2cap_can_send_prepared_packet_now(uint16_t local_cid){
29983e7cdd9SMatthias Ringwald     l2cap_channel_t *channel = l2cap_get_channel_for_local_cid(local_cid);
30083e7cdd9SMatthias Ringwald     if (!channel) return 0;
3010b9d7e78SMatthias Ringwald     return hci_can_send_prepared_acl_packet_now(channel->con_handle);
30283e7cdd9SMatthias Ringwald }
30383e7cdd9SMatthias Ringwald 
304fc64f94aSMatthias Ringwald int  l2cap_can_send_fixed_channel_packet_now(hci_con_handle_t con_handle, uint16_t channel_id){
3050b9d7e78SMatthias Ringwald     return hci_can_send_acl_packet_now(con_handle);
3062125de09SMatthias Ringwald }
3070b9d7e78SMatthias Ringwald 
3080b9d7e78SMatthias Ringwald ///
3093cab4fcaS[email protected] 
31096cbd662Smatthias.ringwald uint16_t l2cap_get_remote_mtu_for_local_cid(uint16_t local_cid){
31196cbd662Smatthias.ringwald     l2cap_channel_t * channel = l2cap_get_channel_for_local_cid(local_cid);
31296cbd662Smatthias.ringwald     if (channel) {
31396cbd662Smatthias.ringwald         return channel->remote_mtu;
31496cbd662Smatthias.ringwald     }
31596cbd662Smatthias.ringwald     return 0;
31696cbd662Smatthias.ringwald }
31796cbd662Smatthias.ringwald 
318ec820d77SMatthias Ringwald static l2cap_channel_t * l2cap_channel_for_rtx_timer(btstack_timer_source_t * ts){
319665d90f2SMatthias Ringwald     btstack_linked_list_iterator_t it;
320665d90f2SMatthias Ringwald     btstack_linked_list_iterator_init(&it, &l2cap_channels);
321665d90f2SMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
322665d90f2SMatthias Ringwald         l2cap_channel_t * channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it);
3235932bd7cS[email protected]         if ( &channel->rtx == ts) {
3245932bd7cS[email protected]             return channel;
3255932bd7cS[email protected]         }
3265932bd7cS[email protected]     }
3275932bd7cS[email protected]     return NULL;
3285932bd7cS[email protected] }
3295932bd7cS[email protected] 
330ec820d77SMatthias Ringwald static void l2cap_rtx_timeout(btstack_timer_source_t * ts){
3315932bd7cS[email protected]     l2cap_channel_t * channel = l2cap_channel_for_rtx_timer(ts);
33295d2c8f4SMatthias Ringwald     if (!channel) return;
3335932bd7cS[email protected] 
3345932bd7cS[email protected]     log_info("l2cap_rtx_timeout for local cid 0x%02x", channel->local_cid);
3355932bd7cS[email protected] 
3365932bd7cS[email protected]     // "When terminating the channel, it is not necessary to send a L2CAP_DisconnectReq
3375932bd7cS[email protected]     //  and enter WAIT_DISCONNECT state. Channels can be transitioned directly to the CLOSED state."
3385932bd7cS[email protected]     // notify client
3395932bd7cS[email protected]     l2cap_emit_channel_opened(channel, L2CAP_CONNECTION_RESPONSE_RESULT_RTX_TIMEOUT);
3405932bd7cS[email protected] 
3415932bd7cS[email protected]     // discard channel
3429dcb2fb2S[email protected]     // no need to stop timer here, it is removed from list during timer callback
343665d90f2SMatthias Ringwald     btstack_linked_list_remove(&l2cap_channels, (btstack_linked_item_t *) channel);
3445932bd7cS[email protected]     btstack_memory_l2cap_channel_free(channel);
3455932bd7cS[email protected] }
3465932bd7cS[email protected] 
3475932bd7cS[email protected] static void l2cap_stop_rtx(l2cap_channel_t * channel){
3485932bd7cS[email protected]     log_info("l2cap_stop_rtx for local cid 0x%02x", channel->local_cid);
349528a4a3bSMatthias Ringwald     btstack_run_loop_remove_timer(&channel->rtx);
3505932bd7cS[email protected] }
3515932bd7cS[email protected] 
3525932bd7cS[email protected] static void l2cap_start_rtx(l2cap_channel_t * channel){
3535932bd7cS[email protected]     l2cap_stop_rtx(channel);
354cb0ff06bS[email protected]     log_info("l2cap_start_rtx for local cid 0x%02x", channel->local_cid);
355528a4a3bSMatthias Ringwald     btstack_run_loop_set_timer_handler(&channel->rtx, l2cap_rtx_timeout);
356528a4a3bSMatthias Ringwald     btstack_run_loop_set_timer(&channel->rtx, L2CAP_RTX_TIMEOUT_MS);
357528a4a3bSMatthias Ringwald     btstack_run_loop_add_timer(&channel->rtx);
3585932bd7cS[email protected] }
3595932bd7cS[email protected] 
3605932bd7cS[email protected] static void l2cap_start_ertx(l2cap_channel_t * channel){
3615932bd7cS[email protected]     log_info("l2cap_start_ertx for local cid 0x%02x", channel->local_cid);
3625932bd7cS[email protected]     l2cap_stop_rtx(channel);
363528a4a3bSMatthias Ringwald     btstack_run_loop_set_timer_handler(&channel->rtx, l2cap_rtx_timeout);
364528a4a3bSMatthias Ringwald     btstack_run_loop_set_timer(&channel->rtx, L2CAP_ERTX_TIMEOUT_MS);
365528a4a3bSMatthias Ringwald     btstack_run_loop_add_timer(&channel->rtx);
3665932bd7cS[email protected] }
3675932bd7cS[email protected] 
36871de195eSMatthias Ringwald void l2cap_require_security_level_2_for_outgoing_sdp(void){
369ac301f95S[email protected]     require_security_level2_for_outgoing_sdp = 1;
370ac301f95S[email protected] }
371ac301f95S[email protected] 
372df3354fcS[email protected] static int l2cap_security_level_0_allowed_for_PSM(uint16_t psm){
373ac301f95S[email protected]     return (psm == PSM_SDP) && (!require_security_level2_for_outgoing_sdp);
374df3354fcS[email protected] }
3755932bd7cS[email protected] 
3767f02f414SMatthias Ringwald static int l2cap_send_signaling_packet(hci_con_handle_t handle, L2CAP_SIGNALING_COMMANDS cmd, uint8_t identifier, ...){
377b1d43497Smatthias.ringwald 
378a35252c8S[email protected]     if (!hci_can_send_acl_packet_now(handle)){
3799da54300S[email protected]         log_info("l2cap_send_signaling_packet, cannot send");
380b1d43497Smatthias.ringwald         return BTSTACK_ACL_BUFFERS_FULL;
381b1d43497Smatthias.ringwald     }
382b1d43497Smatthias.ringwald 
3839da54300S[email protected]     // log_info("l2cap_send_signaling_packet type %u", cmd);
3842a373862S[email protected]     hci_reserve_packet_buffer();
385facf93fdS[email protected]     uint8_t *acl_buffer = hci_get_outgoing_packet_buffer();
38658de5610Smatthias.ringwald     va_list argptr;
38758de5610Smatthias.ringwald     va_start(argptr, identifier);
38870efece1S[email protected]     uint16_t len = l2cap_create_signaling_classic(acl_buffer, handle, cmd, identifier, argptr);
38958de5610Smatthias.ringwald     va_end(argptr);
3909da54300S[email protected]     // log_info("l2cap_send_signaling_packet con %u!", handle);
391826f7347S[email protected]     return hci_send_acl_packet_buffer(len);
39258de5610Smatthias.ringwald }
39358de5610Smatthias.ringwald 
394a9a4c409SMatthias Ringwald #ifdef ENABLE_BLE
3957f02f414SMatthias Ringwald static int l2cap_send_le_signaling_packet(hci_con_handle_t handle, L2CAP_SIGNALING_COMMANDS cmd, uint8_t identifier, ...){
39670efece1S[email protected] 
397a35252c8S[email protected]     if (!hci_can_send_acl_packet_now(handle)){
3989da54300S[email protected]         log_info("l2cap_send_signaling_packet, cannot send");
39970efece1S[email protected]         return BTSTACK_ACL_BUFFERS_FULL;
40070efece1S[email protected]     }
40170efece1S[email protected] 
4029da54300S[email protected]     // log_info("l2cap_send_signaling_packet type %u", cmd);
4032a373862S[email protected]     hci_reserve_packet_buffer();
404facf93fdS[email protected]     uint8_t *acl_buffer = hci_get_outgoing_packet_buffer();
40570efece1S[email protected]     va_list argptr;
40670efece1S[email protected]     va_start(argptr, identifier);
40770efece1S[email protected]     uint16_t len = l2cap_create_signaling_le(acl_buffer, handle, cmd, identifier, argptr);
40870efece1S[email protected]     va_end(argptr);
4099da54300S[email protected]     // log_info("l2cap_send_signaling_packet con %u!", handle);
410826f7347S[email protected]     return hci_send_acl_packet_buffer(len);
41170efece1S[email protected] }
41270efece1S[email protected] #endif
41370efece1S[email protected] 
414b1d43497Smatthias.ringwald uint8_t *l2cap_get_outgoing_buffer(void){
415facf93fdS[email protected]     return hci_get_outgoing_packet_buffer() + COMPLETE_L2CAP_HEADER; // 8 bytes
416b1d43497Smatthias.ringwald }
4176218e6f1Smatthias.ringwald 
4186b4af23dS[email protected] int l2cap_reserve_packet_buffer(void){
4196b4af23dS[email protected]     return hci_reserve_packet_buffer();
4206b4af23dS[email protected] }
4216b4af23dS[email protected] 
42268a0fcf7S[email protected] void l2cap_release_packet_buffer(void){
42368a0fcf7S[email protected]     hci_release_packet_buffer();
42468a0fcf7S[email protected] }
42568a0fcf7S[email protected] 
4267f107edaSMatthias Ringwald static void l2cap_setup_header(uint8_t * acl_buffer, hci_con_handle_t con_handle, uint16_t remote_cid, uint16_t len){
4277f107edaSMatthias Ringwald 
4287f107edaSMatthias Ringwald     int pb = hci_non_flushable_packet_boundary_flag_supported() ? 0x00 : 0x02;
4297f107edaSMatthias Ringwald 
4307f107edaSMatthias Ringwald     // 0 - Connection handle : PB=pb : BC=00
4317f107edaSMatthias Ringwald     little_endian_store_16(acl_buffer, 0, con_handle | (pb << 12) | (0 << 14));
4327f107edaSMatthias Ringwald     // 2 - ACL length
4337f107edaSMatthias Ringwald     little_endian_store_16(acl_buffer, 2,  len + 4);
4347f107edaSMatthias Ringwald     // 4 - L2CAP packet length
4357f107edaSMatthias Ringwald     little_endian_store_16(acl_buffer, 4,  len + 0);
4367f107edaSMatthias Ringwald     // 6 - L2CAP channel DEST
4377f107edaSMatthias Ringwald     little_endian_store_16(acl_buffer, 6,  remote_cid);
4387f107edaSMatthias Ringwald }
43968a0fcf7S[email protected] 
440b1d43497Smatthias.ringwald int l2cap_send_prepared(uint16_t local_cid, uint16_t len){
441b1d43497Smatthias.ringwald 
442c8b9416aS[email protected]     if (!hci_is_packet_buffer_reserved()){
443c8b9416aS[email protected]         log_error("l2cap_send_prepared called without reserving packet first");
444c8b9416aS[email protected]         return BTSTACK_ACL_BUFFERS_FULL;
445c8b9416aS[email protected]     }
446c8b9416aS[email protected] 
44758de5610Smatthias.ringwald     l2cap_channel_t * channel = l2cap_get_channel_for_local_cid(local_cid);
448b1d43497Smatthias.ringwald     if (!channel) {
4499da54300S[email protected]         log_error("l2cap_send_prepared no channel for cid 0x%02x", local_cid);
450b1d43497Smatthias.ringwald         return -1;   // TODO: define error
4516218e6f1Smatthias.ringwald     }
4526218e6f1Smatthias.ringwald 
453fc64f94aSMatthias Ringwald     if (!hci_can_send_prepared_acl_packet_now(channel->con_handle)){
4549da54300S[email protected]         log_info("l2cap_send_prepared cid 0x%02x, cannot send", local_cid);
455a35252c8S[email protected]         return BTSTACK_ACL_BUFFERS_FULL;
456a35252c8S[email protected]     }
457a35252c8S[email protected] 
458fc64f94aSMatthias Ringwald     log_debug("l2cap_send_prepared cid 0x%02x, handle %u, 1 credit used", local_cid, channel->con_handle);
459b1d43497Smatthias.ringwald 
460facf93fdS[email protected]     uint8_t *acl_buffer = hci_get_outgoing_packet_buffer();
4617f107edaSMatthias Ringwald     l2cap_setup_header(acl_buffer, channel->con_handle, channel->remote_cid, len);
46258de5610Smatthias.ringwald     // send
4637f107edaSMatthias Ringwald     return hci_send_acl_packet_buffer(len+8);
46458de5610Smatthias.ringwald }
46558de5610Smatthias.ringwald 
466fc64f94aSMatthias Ringwald int l2cap_send_prepared_connectionless(hci_con_handle_t con_handle, uint16_t cid, uint16_t len){
4672149f12eSmatthias.ringwald 
468c8b9416aS[email protected]     if (!hci_is_packet_buffer_reserved()){
469c8b9416aS[email protected]         log_error("l2cap_send_prepared_connectionless called without reserving packet first");
4702149f12eSmatthias.ringwald         return BTSTACK_ACL_BUFFERS_FULL;
4712149f12eSmatthias.ringwald     }
4722149f12eSmatthias.ringwald 
473fc64f94aSMatthias Ringwald     if (!hci_can_send_prepared_acl_packet_now(con_handle)){
474fc64f94aSMatthias Ringwald         log_info("l2cap_send_prepared_connectionless handle 0x%02x, cid 0x%02x, cannot send", con_handle, cid);
475c8b9416aS[email protected]         return BTSTACK_ACL_BUFFERS_FULL;
476c8b9416aS[email protected]     }
477c8b9416aS[email protected] 
478fc64f94aSMatthias Ringwald     log_debug("l2cap_send_prepared_connectionless handle %u, cid 0x%02x", con_handle, cid);
4792149f12eSmatthias.ringwald 
480facf93fdS[email protected]     uint8_t *acl_buffer = hci_get_outgoing_packet_buffer();
4817f107edaSMatthias Ringwald     l2cap_setup_header(acl_buffer, con_handle, cid, len);
4822149f12eSmatthias.ringwald     // send
4837f107edaSMatthias Ringwald     return hci_send_acl_packet_buffer(len+8);
4842149f12eSmatthias.ringwald }
4852149f12eSmatthias.ringwald 
486ce8f182eSMatthias Ringwald int l2cap_send(uint16_t local_cid, uint8_t *data, uint16_t len){
487b1d43497Smatthias.ringwald 
488a35252c8S[email protected]     l2cap_channel_t * channel = l2cap_get_channel_for_local_cid(local_cid);
489a35252c8S[email protected]     if (!channel) {
490ce8f182eSMatthias Ringwald         log_error("l2cap_send no channel for cid 0x%02x", local_cid);
491a35252c8S[email protected]         return -1;   // TODO: define error
492a35252c8S[email protected]     }
493a35252c8S[email protected] 
494f0efaa57S[email protected]     if (len > channel->remote_mtu){
495ce8f182eSMatthias Ringwald         log_error("l2cap_send cid 0x%02x, data length exceeds remote MTU.", local_cid);
496f0efaa57S[email protected]         return L2CAP_DATA_LEN_EXCEEDS_REMOTE_MTU;
497f0efaa57S[email protected]     }
498f0efaa57S[email protected] 
499fc64f94aSMatthias Ringwald     if (!hci_can_send_acl_packet_now(channel->con_handle)){
500ce8f182eSMatthias Ringwald         log_info("l2cap_send cid 0x%02x, cannot send", local_cid);
501b1d43497Smatthias.ringwald         return BTSTACK_ACL_BUFFERS_FULL;
502b1d43497Smatthias.ringwald     }
503b1d43497Smatthias.ringwald 
5042a373862S[email protected]     hci_reserve_packet_buffer();
505facf93fdS[email protected]     uint8_t *acl_buffer = hci_get_outgoing_packet_buffer();
506b1d43497Smatthias.ringwald 
507b1d43497Smatthias.ringwald     memcpy(&acl_buffer[8], data, len);
508b1d43497Smatthias.ringwald 
509b1d43497Smatthias.ringwald     return l2cap_send_prepared(local_cid, len);
510b1d43497Smatthias.ringwald }
511b1d43497Smatthias.ringwald 
512fc64f94aSMatthias Ringwald int l2cap_send_connectionless(hci_con_handle_t con_handle, uint16_t cid, uint8_t *data, uint16_t len){
5132149f12eSmatthias.ringwald 
514fc64f94aSMatthias Ringwald     if (!hci_can_send_acl_packet_now(con_handle)){
515ce8f182eSMatthias Ringwald         log_info("l2cap_send cid 0x%02x, cannot send", cid);
5162149f12eSmatthias.ringwald         return BTSTACK_ACL_BUFFERS_FULL;
5172149f12eSmatthias.ringwald     }
5182149f12eSmatthias.ringwald 
5192a373862S[email protected]     hci_reserve_packet_buffer();
520facf93fdS[email protected]     uint8_t *acl_buffer = hci_get_outgoing_packet_buffer();
5212149f12eSmatthias.ringwald 
5222149f12eSmatthias.ringwald     memcpy(&acl_buffer[8], data, len);
5232149f12eSmatthias.ringwald 
524fc64f94aSMatthias Ringwald     return l2cap_send_prepared_connectionless(con_handle, cid, len);
5252149f12eSmatthias.ringwald }
5262149f12eSmatthias.ringwald 
527fc64f94aSMatthias Ringwald int l2cap_send_echo_request(hci_con_handle_t con_handle, uint8_t *data, uint16_t len){
528fc64f94aSMatthias Ringwald     return l2cap_send_signaling_packet(con_handle, ECHO_REQUEST, 0x77, len, data);
5290e37e417S[email protected] }
5300e37e417S[email protected] 
53128ca2b46S[email protected] static inline void channelStateVarSetFlag(l2cap_channel_t *channel, L2CAP_CHANNEL_STATE_VAR flag){
53228ca2b46S[email protected]     channel->state_var = (L2CAP_CHANNEL_STATE_VAR) (channel->state_var | flag);
53328ca2b46S[email protected] }
53428ca2b46S[email protected] 
53528ca2b46S[email protected] static inline void channelStateVarClearFlag(l2cap_channel_t *channel, L2CAP_CHANNEL_STATE_VAR flag){
53628ca2b46S[email protected]     channel->state_var = (L2CAP_CHANNEL_STATE_VAR) (channel->state_var & ~flag);
53728ca2b46S[email protected] }
53828ca2b46S[email protected] 
53928ca2b46S[email protected] 
540b1d43497Smatthias.ringwald 
5418158c421Smatthias.ringwald // MARK: L2CAP_RUN
5422cd0be45Smatthias.ringwald // process outstanding signaling tasks
5437f02f414SMatthias Ringwald static void l2cap_run(void){
5442b83fb7dSmatthias.ringwald 
54522c29ab4SMatthias Ringwald     // log_info("l2cap_run: entered");
54622c29ab4SMatthias Ringwald 
5472b83fb7dSmatthias.ringwald     // check pending signaling responses
5482b83fb7dSmatthias.ringwald     while (signaling_responses_pending){
5492b83fb7dSmatthias.ringwald 
5502b83fb7dSmatthias.ringwald         hci_con_handle_t handle = signaling_responses[0].handle;
551a35252c8S[email protected] 
552a35252c8S[email protected]         if (!hci_can_send_acl_packet_now(handle)) break;
553a35252c8S[email protected] 
5542b83fb7dSmatthias.ringwald         uint8_t  sig_id = signaling_responses[0].sig_id;
5552b360848Smatthias.ringwald         uint16_t infoType = signaling_responses[0].data;    // INFORMATION_REQUEST
55663a7246aSmatthias.ringwald         uint16_t result   = signaling_responses[0].data;    // CONNECTION_REQUEST, COMMAND_REJECT
557f53da564S[email protected]         uint8_t  response_code = signaling_responses[0].code;
5582b83fb7dSmatthias.ringwald 
559f53da564S[email protected]         // remove first item before sending (to avoid sending response mutliple times)
560f53da564S[email protected]         signaling_responses_pending--;
561f53da564S[email protected]         int i;
562f53da564S[email protected]         for (i=0; i < signaling_responses_pending; i++){
563f53da564S[email protected]             memcpy(&signaling_responses[i], &signaling_responses[i+1], sizeof(l2cap_signaling_response_t));
564f53da564S[email protected]         }
565f53da564S[email protected] 
566f53da564S[email protected]         switch (response_code){
5672b360848Smatthias.ringwald             case CONNECTION_REQUEST:
5682b360848Smatthias.ringwald                 l2cap_send_signaling_packet(handle, CONNECTION_RESPONSE, sig_id, 0, 0, result, 0);
5692bd8b7e7S[email protected]                 // also disconnect if result is 0x0003 - security blocked
5704d816277S[email protected]                 if (result == 0x0003){
5712bd8b7e7S[email protected]                     hci_disconnect_security_block(handle);
5724d816277S[email protected]                 }
5732b360848Smatthias.ringwald                 break;
5742b83fb7dSmatthias.ringwald             case ECHO_REQUEST:
5752b83fb7dSmatthias.ringwald                 l2cap_send_signaling_packet(handle, ECHO_RESPONSE, sig_id, 0, NULL);
5762b83fb7dSmatthias.ringwald                 break;
5772b83fb7dSmatthias.ringwald             case INFORMATION_REQUEST:
5783b0484b3S[email protected]                 switch (infoType){
5793b0484b3S[email protected]                     case 1: { // Connectionless MTU
5803b0484b3S[email protected]                         uint16_t connectionless_mtu = hci_max_acl_data_packet_length();
5813b0484b3S[email protected]                         l2cap_send_signaling_packet(handle, INFORMATION_RESPONSE, sig_id, infoType, 0, sizeof(connectionless_mtu), &connectionless_mtu);
5823b0484b3S[email protected]                         break;
5833b0484b3S[email protected]                     }
5843b0484b3S[email protected]                     case 2: { // Extended Features Supported
585462e630dS[email protected]                         // extended features request supported, features: fixed channels, unicast connectionless data reception
586462e630dS[email protected]                         uint32_t features = 0x280;
5873b0484b3S[email protected]                         l2cap_send_signaling_packet(handle, INFORMATION_RESPONSE, sig_id, infoType, 0, sizeof(features), &features);
5883b0484b3S[email protected]                         break;
5893b0484b3S[email protected]                     }
5903b0484b3S[email protected]                     case 3: { // Fixed Channels Supported
5913b0484b3S[email protected]                         uint8_t map[8];
5923b0484b3S[email protected]                         memset(map, 0, 8);
593288636a2SMatthias Ringwald                         map[0] = 0x06;  // L2CAP Signaling Channel (0x02) + Connectionless reception (0x04)
5943b0484b3S[email protected]                         l2cap_send_signaling_packet(handle, INFORMATION_RESPONSE, sig_id, infoType, 0, sizeof(map), &map);
5953b0484b3S[email protected]                         break;
5963b0484b3S[email protected]                     }
5973b0484b3S[email protected]                     default:
5982b83fb7dSmatthias.ringwald                         // all other types are not supported
5992b83fb7dSmatthias.ringwald                         l2cap_send_signaling_packet(handle, INFORMATION_RESPONSE, sig_id, infoType, 1, 0, NULL);
6003b0484b3S[email protected]                         break;
6012b83fb7dSmatthias.ringwald                 }
6022b83fb7dSmatthias.ringwald                 break;
60363a7246aSmatthias.ringwald             case COMMAND_REJECT:
6045ca8d57bS[email protected]                 l2cap_send_signaling_packet(handle, COMMAND_REJECT, sig_id, result, 0, NULL);
60563f0ac45SMatthias Ringwald                 break;
606a9a4c409SMatthias Ringwald #ifdef ENABLE_BLE
60763f0ac45SMatthias Ringwald             case LE_CREDIT_BASED_CONNECTION_REQUEST:
60863f0ac45SMatthias Ringwald                 l2cap_send_le_signaling_packet(handle, LE_CREDIT_BASED_CONNECTION_RESPONSE, sig_id, 0, 0, 0, 0, result);
60963f0ac45SMatthias Ringwald                 break;
61070efece1S[email protected]             case COMMAND_REJECT_LE:
61170efece1S[email protected]                 l2cap_send_le_signaling_packet(handle, COMMAND_REJECT, sig_id, result, 0, NULL);
61263a7246aSmatthias.ringwald                 break;
61370efece1S[email protected] #endif
6142b83fb7dSmatthias.ringwald             default:
6152b83fb7dSmatthias.ringwald                 // should not happen
6162b83fb7dSmatthias.ringwald                 break;
6172b83fb7dSmatthias.ringwald         }
6182b83fb7dSmatthias.ringwald     }
6192b83fb7dSmatthias.ringwald 
620ae280e73Smatthias.ringwald     uint8_t  config_options[4];
621665d90f2SMatthias Ringwald     btstack_linked_list_iterator_t it;
622665d90f2SMatthias Ringwald     btstack_linked_list_iterator_init(&it, &l2cap_channels);
623665d90f2SMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
624baf94f06S[email protected] 
625665d90f2SMatthias Ringwald         l2cap_channel_t * channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it);
62622c29ab4SMatthias Ringwald         // log_info("l2cap_run: channel %p, state %u, var 0x%02x", channel, channel->state, channel->state_var);
6272cd0be45Smatthias.ringwald         switch (channel->state){
6282cd0be45Smatthias.ringwald 
629df3354fcS[email protected]             case L2CAP_STATE_WAIT_INCOMING_SECURITY_LEVEL_UPDATE:
630ad671560S[email protected]             case L2CAP_STATE_WAIT_CLIENT_ACCEPT_OR_REJECT:
631fc64f94aSMatthias Ringwald                 if (!hci_can_send_acl_packet_now(channel->con_handle)) break;
632a00031e2S[email protected]                 if (channel->state_var & L2CAP_CHANNEL_STATE_VAR_SEND_CONN_RESP_PEND) {
633ad671560S[email protected]                     channelStateVarClearFlag(channel, L2CAP_CHANNEL_STATE_VAR_SEND_CONN_RESP_PEND);
634fc64f94aSMatthias Ringwald                     l2cap_send_signaling_packet(channel->con_handle, CONNECTION_RESPONSE, channel->remote_sig_id, channel->local_cid, channel->remote_cid, 1, 0);
635ad671560S[email protected]                 }
636ad671560S[email protected]                 break;
637ad671560S[email protected] 
63802b22dc4Smatthias.ringwald             case L2CAP_STATE_WILL_SEND_CREATE_CONNECTION:
639baf94f06S[email protected]                 if (!hci_can_send_command_packet_now()) break;
64064472d52Smatthias.ringwald                 // send connection request - set state first
64164472d52Smatthias.ringwald                 channel->state = L2CAP_STATE_WAIT_CONNECTION_COMPLETE;
64202b22dc4Smatthias.ringwald                 // BD_ADDR, Packet_Type, Page_Scan_Repetition_Mode, Reserved, Clock_Offset, Allow_Role_Switch
6438f8108aaSmatthias.ringwald                 hci_send_cmd(&hci_create_connection, channel->address, hci_usable_acl_packet_types(), 0, 0, 0, 1);
64402b22dc4Smatthias.ringwald                 break;
64502b22dc4Smatthias.ringwald 
646e7ff783cSmatthias.ringwald             case L2CAP_STATE_WILL_SEND_CONNECTION_RESPONSE_DECLINE:
647fc64f94aSMatthias Ringwald                 if (!hci_can_send_acl_packet_now(channel->con_handle)) break;
64822c29ab4SMatthias Ringwald                 channel->state = L2CAP_STATE_INVALID;
649fc64f94aSMatthias Ringwald                 l2cap_send_signaling_packet(channel->con_handle, CONNECTION_RESPONSE, channel->remote_sig_id, channel->local_cid, channel->remote_cid, channel->reason, 0);
650e7ff783cSmatthias.ringwald                 // discard channel - l2cap_finialize_channel_close without sending l2cap close event
6519dcb2fb2S[email protected]                 l2cap_stop_rtx(channel);
652665d90f2SMatthias Ringwald                 btstack_linked_list_iterator_remove(&it);
653d3a9df87Smatthias.ringwald                 btstack_memory_l2cap_channel_free(channel);
654e7ff783cSmatthias.ringwald                 break;
655e7ff783cSmatthias.ringwald 
656552d92a1Smatthias.ringwald             case L2CAP_STATE_WILL_SEND_CONNECTION_RESPONSE_ACCEPT:
657fc64f94aSMatthias Ringwald                 if (!hci_can_send_acl_packet_now(channel->con_handle)) break;
658fa8473a4Smatthias.ringwald                 channel->state = L2CAP_STATE_CONFIG;
65928ca2b46S[email protected]                 channelStateVarSetFlag(channel, L2CAP_CHANNEL_STATE_VAR_SEND_CONF_REQ);
660fc64f94aSMatthias Ringwald                 l2cap_send_signaling_packet(channel->con_handle, CONNECTION_RESPONSE, channel->remote_sig_id, channel->local_cid, channel->remote_cid, 0, 0);
661552d92a1Smatthias.ringwald                 break;
662552d92a1Smatthias.ringwald 
6636fdcc387Smatthias.ringwald             case L2CAP_STATE_WILL_SEND_CONNECTION_REQUEST:
664fc64f94aSMatthias Ringwald                 if (!hci_can_send_acl_packet_now(channel->con_handle)) break;
6656fdcc387Smatthias.ringwald                 // success, start l2cap handshake
666b1988dceSmatthias.ringwald                 channel->local_sig_id = l2cap_next_sig_id();
6676fdcc387Smatthias.ringwald                 channel->state = L2CAP_STATE_WAIT_CONNECT_RSP;
668fc64f94aSMatthias Ringwald                 l2cap_send_signaling_packet( channel->con_handle, CONNECTION_REQUEST, channel->local_sig_id, channel->psm, channel->local_cid);
6695932bd7cS[email protected]                 l2cap_start_rtx(channel);
6706fdcc387Smatthias.ringwald                 break;
6716fdcc387Smatthias.ringwald 
672fa8473a4Smatthias.ringwald             case L2CAP_STATE_CONFIG:
673fc64f94aSMatthias Ringwald                 if (!hci_can_send_acl_packet_now(channel->con_handle)) break;
67473cf2b3dSmatthias.ringwald                 if (channel->state_var & L2CAP_CHANNEL_STATE_VAR_SEND_CONF_RSP){
67563a7246aSmatthias.ringwald                     uint16_t flags = 0;
67628ca2b46S[email protected]                     channelStateVarClearFlag(channel, L2CAP_CHANNEL_STATE_VAR_SEND_CONF_RSP);
67763a7246aSmatthias.ringwald                     if (channel->state_var & L2CAP_CHANNEL_STATE_VAR_SEND_CONF_RSP_CONT) {
67863a7246aSmatthias.ringwald                         flags = 1;
67963a7246aSmatthias.ringwald                     } else {
68028ca2b46S[email protected]                         channelStateVarSetFlag(channel, L2CAP_CHANNEL_STATE_VAR_SENT_CONF_RSP);
68163a7246aSmatthias.ringwald                     }
68263a7246aSmatthias.ringwald                     if (channel->state_var & L2CAP_CHANNEL_STATE_VAR_SEND_CONF_RSP_INVALID){
683fc64f94aSMatthias 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);
68463a7246aSmatthias.ringwald                     } else if (channel->state_var & L2CAP_CHANNEL_STATE_VAR_SEND_CONF_RSP_MTU){
68563a7246aSmatthias.ringwald                         config_options[0] = 1; // MTU
68663a7246aSmatthias.ringwald                         config_options[1] = 2; // len param
687f8fbdce0SMatthias Ringwald                         little_endian_store_16( (uint8_t*)&config_options, 2, channel->remote_mtu);
688fc64f94aSMatthias Ringwald                         l2cap_send_signaling_packet(channel->con_handle, CONFIGURE_RESPONSE, channel->remote_sig_id, channel->remote_cid, flags, 0, 4, &config_options);
68963a7246aSmatthias.ringwald                         channelStateVarClearFlag(channel,L2CAP_CHANNEL_STATE_VAR_SEND_CONF_RSP_MTU);
69063a7246aSmatthias.ringwald                     } else {
691fc64f94aSMatthias Ringwald                         l2cap_send_signaling_packet(channel->con_handle, CONFIGURE_RESPONSE, channel->remote_sig_id, channel->remote_cid, flags, 0, 0, NULL);
69263a7246aSmatthias.ringwald                     }
69363a7246aSmatthias.ringwald                     channelStateVarClearFlag(channel, L2CAP_CHANNEL_STATE_VAR_SEND_CONF_RSP_CONT);
694fa8473a4Smatthias.ringwald                 }
69573cf2b3dSmatthias.ringwald                 else if (channel->state_var & L2CAP_CHANNEL_STATE_VAR_SEND_CONF_REQ){
69628ca2b46S[email protected]                     channelStateVarClearFlag(channel, L2CAP_CHANNEL_STATE_VAR_SEND_CONF_REQ);
69728ca2b46S[email protected]                     channelStateVarSetFlag(channel, L2CAP_CHANNEL_STATE_VAR_SENT_CONF_REQ);
698b1988dceSmatthias.ringwald                     channel->local_sig_id = l2cap_next_sig_id();
699ae280e73Smatthias.ringwald                     config_options[0] = 1; // MTU
700ae280e73Smatthias.ringwald                     config_options[1] = 2; // len param
701f8fbdce0SMatthias Ringwald                     little_endian_store_16( (uint8_t*)&config_options, 2, channel->local_mtu);
702fc64f94aSMatthias Ringwald                     l2cap_send_signaling_packet(channel->con_handle, CONFIGURE_REQUEST, channel->local_sig_id, channel->remote_cid, 0, 4, &config_options);
7035932bd7cS[email protected]                     l2cap_start_rtx(channel);
704fa8473a4Smatthias.ringwald                 }
705fa8473a4Smatthias.ringwald                 if (l2cap_channel_ready_for_open(channel)){
706552d92a1Smatthias.ringwald                     channel->state = L2CAP_STATE_OPEN;
707552d92a1Smatthias.ringwald                     l2cap_emit_channel_opened(channel, 0);  // success
708fa8473a4Smatthias.ringwald                 }
709552d92a1Smatthias.ringwald                 break;
710552d92a1Smatthias.ringwald 
711e7ff783cSmatthias.ringwald             case L2CAP_STATE_WILL_SEND_DISCONNECT_RESPONSE:
712fc64f94aSMatthias Ringwald                 if (!hci_can_send_acl_packet_now(channel->con_handle)) break;
71322c29ab4SMatthias Ringwald                 channel->state = L2CAP_STATE_INVALID;
714fc64f94aSMatthias Ringwald                 l2cap_send_signaling_packet( channel->con_handle, DISCONNECTION_RESPONSE, channel->remote_sig_id, channel->local_cid, channel->remote_cid);
7155932bd7cS[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 :)
716756102d3Smatthias.ringwald                 l2cap_finialize_channel_close(channel);  // -- remove from list
717e7ff783cSmatthias.ringwald                 break;
718e7ff783cSmatthias.ringwald 
719e7ff783cSmatthias.ringwald             case L2CAP_STATE_WILL_SEND_DISCONNECT_REQUEST:
720fc64f94aSMatthias Ringwald                 if (!hci_can_send_acl_packet_now(channel->con_handle)) break;
721b1988dceSmatthias.ringwald                 channel->local_sig_id = l2cap_next_sig_id();
7222cd0be45Smatthias.ringwald                 channel->state = L2CAP_STATE_WAIT_DISCONNECT;
723fc64f94aSMatthias Ringwald                 l2cap_send_signaling_packet( channel->con_handle, DISCONNECTION_REQUEST, channel->local_sig_id, channel->remote_cid, channel->local_cid);
7242cd0be45Smatthias.ringwald                 break;
7252cd0be45Smatthias.ringwald             default:
7262cd0be45Smatthias.ringwald                 break;
7272cd0be45Smatthias.ringwald         }
7282cd0be45Smatthias.ringwald     }
729da886c03S[email protected] 
730a9a4c409SMatthias Ringwald #ifdef ENABLE_BLE
731cab29d48SMatthias Ringwald #ifdef ENABLE_LE_DATA_CHANNELS
732efedfb4cSMatthias Ringwald     btstack_linked_list_iterator_init(&it, &l2cap_le_channels);
733efedfb4cSMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
7347f107edaSMatthias Ringwald         uint8_t  * acl_buffer;
7357f107edaSMatthias Ringwald         uint8_t  * l2cap_payload;
7367f107edaSMatthias Ringwald         uint16_t pos;
7377f107edaSMatthias Ringwald         uint16_t payload_size;
738efedfb4cSMatthias Ringwald         l2cap_channel_t * channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it);
739efedfb4cSMatthias Ringwald         // log_info("l2cap_run: channel %p, state %u, var 0x%02x", channel, channel->state, channel->state_var);
740efedfb4cSMatthias Ringwald         switch (channel->state){
7415cb87675SMatthias Ringwald             case L2CAP_STATE_WILL_SEND_LE_CONNECTION_REQUEST:
7425cb87675SMatthias Ringwald                 if (!hci_can_send_acl_packet_now(channel->con_handle)) break;
7435cb87675SMatthias Ringwald                 channel->state = L2CAP_STATE_WAIT_LE_CONNECTION_RESPONSE;
7445cb87675SMatthias Ringwald                 // le psm, source cid, mtu, mps, initial credits
7451b8b8d05SMatthias Ringwald                 channel->local_sig_id = l2cap_next_sig_id();
74663f0ac45SMatthias Ringwald                 channel->credits_incoming =  channel->new_credits_incoming;
74763f0ac45SMatthias Ringwald                 channel->new_credits_incoming = 0;
74863f0ac45SMatthias 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);
7495cb87675SMatthias Ringwald                 break;
75023017473SMatthias Ringwald             case L2CAP_STATE_WILL_SEND_LE_CONNECTION_RESPONSE_ACCEPT:
75123017473SMatthias Ringwald                 if (!hci_can_send_acl_packet_now(channel->con_handle)) break;
75223017473SMatthias Ringwald                 // TODO: support larger MPS
75323017473SMatthias Ringwald                 channel->state = L2CAP_STATE_OPEN;
75463f0ac45SMatthias Ringwald                 channel->credits_incoming =  channel->new_credits_incoming;
75563f0ac45SMatthias Ringwald                 channel->new_credits_incoming = 0;
75663f0ac45SMatthias 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);
75764e11ca9SMatthias Ringwald                 // notify client
75844276248SMatthias Ringwald                 l2cap_emit_le_channel_opened(channel, 0);
75923017473SMatthias Ringwald                 break;
760e7d0c9aaSMatthias Ringwald             case L2CAP_STATE_WILL_SEND_LE_CONNECTION_RESPONSE_DECLINE:
761e7d0c9aaSMatthias Ringwald                 if (!hci_can_send_acl_packet_now(channel->con_handle)) break;
762e7d0c9aaSMatthias Ringwald                 channel->state = L2CAP_STATE_INVALID;
76363f0ac45SMatthias Ringwald                 l2cap_send_le_signaling_packet(channel->con_handle, LE_CREDIT_BASED_CONNECTION_RESPONSE, channel->remote_sig_id, 0, 0, 0, 0, channel->reason);
764e7d0c9aaSMatthias Ringwald                 // discard channel - l2cap_finialize_channel_close without sending l2cap close event
765e7d0c9aaSMatthias Ringwald                 l2cap_stop_rtx(channel);
766e7d0c9aaSMatthias Ringwald                 btstack_linked_list_iterator_remove(&it);
767e7d0c9aaSMatthias Ringwald                 btstack_memory_l2cap_channel_free(channel);
768e7d0c9aaSMatthias Ringwald                 break;
7697f107edaSMatthias Ringwald             case L2CAP_STATE_OPEN:
77085aeef60SMatthias Ringwald                 if (!hci_can_send_acl_packet_now(channel->con_handle)) break;
77185aeef60SMatthias Ringwald 
77285aeef60SMatthias Ringwald                 // send credits
77385aeef60SMatthias Ringwald                 if (channel->new_credits_incoming){
77485aeef60SMatthias Ringwald                     log_info("l2cap: sending %u credits", channel->new_credits_incoming);
77585aeef60SMatthias Ringwald                     channel->local_sig_id = l2cap_next_sig_id();
77685aeef60SMatthias Ringwald                     uint16_t new_credits = channel->new_credits_incoming;
77785aeef60SMatthias Ringwald                     channel->new_credits_incoming = 0;
77885aeef60SMatthias Ringwald                     channel->credits_incoming += new_credits;
77985aeef60SMatthias Ringwald                     l2cap_send_le_signaling_packet(channel->con_handle, LE_FLOW_CONTROL_CREDIT, channel->local_sig_id, channel->remote_cid, new_credits);
78085aeef60SMatthias Ringwald                     break;
78185aeef60SMatthias Ringwald                 }
78285aeef60SMatthias Ringwald 
78385aeef60SMatthias Ringwald                 // send data
7847f107edaSMatthias Ringwald                 if (!channel->send_sdu_buffer) break;
7857f107edaSMatthias Ringwald                 if (!channel->credits_outgoing) break;
78685aeef60SMatthias Ringwald 
7877f107edaSMatthias Ringwald                 // send part of SDU
7887f107edaSMatthias Ringwald                 hci_reserve_packet_buffer();
7897f107edaSMatthias Ringwald                 acl_buffer = hci_get_outgoing_packet_buffer();
7907f107edaSMatthias Ringwald                 l2cap_payload = acl_buffer + 8;
7917f107edaSMatthias Ringwald                 pos = 0;
7927f107edaSMatthias Ringwald                 if (!channel->send_sdu_pos){
7937f107edaSMatthias Ringwald                     // store SDU len
7947f107edaSMatthias Ringwald                     channel->send_sdu_pos += 2;
7957f107edaSMatthias Ringwald                     little_endian_store_16(l2cap_payload, pos, channel->send_sdu_len);
7967f107edaSMatthias Ringwald                     pos += 2;
7977f107edaSMatthias Ringwald                 }
7987f107edaSMatthias Ringwald                 payload_size = btstack_min(channel->send_sdu_len + 2 - channel->send_sdu_pos, channel->remote_mps - pos);
79985aeef60SMatthias Ringwald                 log_info("len %u, pos %u => payload %u, credits %u", channel->send_sdu_len, channel->send_sdu_pos, payload_size, channel->credits_outgoing);
8007f107edaSMatthias Ringwald                 memcpy(&l2cap_payload[pos], &channel->send_sdu_buffer[channel->send_sdu_pos-2], payload_size); // -2 for virtual SDU len
8017f107edaSMatthias Ringwald                 pos += payload_size;
8027f107edaSMatthias Ringwald                 channel->send_sdu_pos += payload_size;
80363f0ac45SMatthias Ringwald                 l2cap_setup_header(acl_buffer, channel->con_handle, channel->remote_cid, pos);
8047f107edaSMatthias Ringwald                 // done
8057f107edaSMatthias Ringwald 
80685aeef60SMatthias Ringwald                 channel->credits_outgoing--;
8077f107edaSMatthias Ringwald 
8087f107edaSMatthias Ringwald                 if (channel->send_sdu_pos >= channel->send_sdu_len + 2){
8097f107edaSMatthias Ringwald                     channel->send_sdu_buffer = NULL;
81044276248SMatthias Ringwald                     // send done event
81144276248SMatthias Ringwald                     l2cap_emit_simple_event_with_cid(channel, L2CAP_EVENT_LE_PACKET_SENT);
81244276248SMatthias Ringwald                     // inform about can send now
81344276248SMatthias Ringwald                     l2cap_le_notify_channel_can_send(channel);
8147f107edaSMatthias Ringwald                 }
8157f107edaSMatthias Ringwald                 hci_send_acl_packet_buffer(8 + pos);
8167f107edaSMatthias Ringwald                 break;
817828a7f7aSMatthias Ringwald             case L2CAP_STATE_WILL_SEND_DISCONNECT_REQUEST:
818828a7f7aSMatthias Ringwald                 if (!hci_can_send_acl_packet_now(channel->con_handle)) break;
819828a7f7aSMatthias Ringwald                 channel->local_sig_id = l2cap_next_sig_id();
820828a7f7aSMatthias Ringwald                 channel->state = L2CAP_STATE_WAIT_DISCONNECT;
821828a7f7aSMatthias Ringwald                 l2cap_send_le_signaling_packet( channel->con_handle, DISCONNECTION_REQUEST, channel->local_sig_id, channel->remote_cid, channel->local_cid);
822828a7f7aSMatthias Ringwald                 break;
823828a7f7aSMatthias Ringwald             case L2CAP_STATE_WILL_SEND_DISCONNECT_RESPONSE:
824828a7f7aSMatthias Ringwald                 if (!hci_can_send_acl_packet_now(channel->con_handle)) break;
825828a7f7aSMatthias Ringwald                 channel->state = L2CAP_STATE_INVALID;
826828a7f7aSMatthias Ringwald                 l2cap_send_le_signaling_packet( channel->con_handle, DISCONNECTION_RESPONSE, channel->remote_sig_id, channel->local_cid, channel->remote_cid);
827828a7f7aSMatthias Ringwald                 l2cap_le_finialize_channel_close(channel);  // -- remove from list
828828a7f7aSMatthias Ringwald                 break;
829efedfb4cSMatthias Ringwald             default:
830efedfb4cSMatthias Ringwald                 break;
831efedfb4cSMatthias Ringwald         }
832efedfb4cSMatthias Ringwald     }
833efedfb4cSMatthias Ringwald 
834da886c03S[email protected]     // send l2cap con paramter update if necessary
835da886c03S[email protected]     hci_connections_get_iterator(&it);
836665d90f2SMatthias Ringwald     while(btstack_linked_list_iterator_has_next(&it)){
837665d90f2SMatthias Ringwald         hci_connection_t * connection = (hci_connection_t *) btstack_linked_list_iterator_next(&it);
8385d14fa8fSMatthias Ringwald         if (connection->address_type != BD_ADDR_TYPE_LE_PUBLIC && connection->address_type != BD_ADDR_TYPE_LE_RANDOM) continue;
839b68d7bc3SMatthias Ringwald         if (!hci_can_send_acl_packet_now(connection->con_handle)) continue;
840da886c03S[email protected]         switch (connection->le_con_parameter_update_state){
841b68d7bc3SMatthias Ringwald             case CON_PARAMETER_UPDATE_SEND_REQUEST:
842b68d7bc3SMatthias Ringwald                 connection->le_con_parameter_update_state = CON_PARAMETER_UPDATE_NONE;
843b68d7bc3SMatthias Ringwald                 l2cap_send_le_signaling_packet(connection->con_handle, CONNECTION_PARAMETER_UPDATE_REQUEST, connection->le_con_param_update_identifier,
844b68d7bc3SMatthias Ringwald                                                connection->le_conn_interval_min, connection->le_conn_interval_max, connection->le_conn_latency, connection->le_supervision_timeout);
845b68d7bc3SMatthias Ringwald                 break;
846da886c03S[email protected]             case CON_PARAMETER_UPDATE_SEND_RESPONSE:
847b68d7bc3SMatthias Ringwald                 connection->le_con_parameter_update_state = CON_PARAMETER_UPDATE_CHANGE_HCI_CON_PARAMETERS;
848b68d7bc3SMatthias Ringwald                 l2cap_send_le_signaling_packet(connection->con_handle, CONNECTION_PARAMETER_UPDATE_RESPONSE, connection->le_con_param_update_identifier, 0);
849da886c03S[email protected]                 break;
850da886c03S[email protected]             case CON_PARAMETER_UPDATE_DENY:
851b68d7bc3SMatthias Ringwald                 connection->le_con_parameter_update_state = CON_PARAMETER_UPDATE_NONE;
852b68d7bc3SMatthias Ringwald                 l2cap_send_le_signaling_packet(connection->con_handle, CONNECTION_PARAMETER_UPDATE_RESPONSE, connection->le_con_param_update_identifier, 1);
853da886c03S[email protected]                 break;
854da886c03S[email protected]             default:
855da886c03S[email protected]                 break;
856da886c03S[email protected]         }
857da886c03S[email protected]     }
8584d7157c3S[email protected] #endif
859cab29d48SMatthias Ringwald #endif
860da886c03S[email protected] 
86122c29ab4SMatthias Ringwald     // log_info("l2cap_run: exit");
8622cd0be45Smatthias.ringwald }
8632cd0be45Smatthias.ringwald 
8644aa9e837Smatthias.ringwald uint16_t l2cap_max_mtu(void){
8654ff786cfS[email protected]     return HCI_ACL_PAYLOAD_SIZE - L2CAP_HEADER_SIZE;
866fa8c92f6Smatthias.ringwald }
867fa8c92f6Smatthias.ringwald 
86871de195eSMatthias Ringwald uint16_t l2cap_max_le_mtu(void){
8694ff786cfS[email protected]     return l2cap_max_mtu();
870e5e1518dS[email protected] }
871e5e1518dS[email protected] 
872fc64f94aSMatthias Ringwald static void l2cap_handle_connection_complete(hci_con_handle_t con_handle, l2cap_channel_t * channel){
8732df5dadcS[email protected]     if (channel->state == L2CAP_STATE_WAIT_CONNECTION_COMPLETE || channel->state == L2CAP_STATE_WILL_SEND_CREATE_CONNECTION) {
8745533f01eS[email protected]         log_info("l2cap_handle_connection_complete expected state");
8752df5dadcS[email protected]         // success, start l2cap handshake
876fc64f94aSMatthias Ringwald         channel->con_handle = con_handle;
8772df5dadcS[email protected]         // check remote SSP feature first
8782df5dadcS[email protected]         channel->state = L2CAP_STATE_WAIT_REMOTE_SUPPORTED_FEATURES;
8792df5dadcS[email protected]     }
8802df5dadcS[email protected] }
8812df5dadcS[email protected] 
8822df5dadcS[email protected] static void l2cap_handle_remote_supported_features_received(l2cap_channel_t * channel){
8832df5dadcS[email protected]     if (channel->state != L2CAP_STATE_WAIT_REMOTE_SUPPORTED_FEATURES) return;
8842df5dadcS[email protected] 
8852df5dadcS[email protected]     // we have been waiting for remote supported features, if both support SSP,
886ac301f95S[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));
887fc64f94aSMatthias Ringwald     if (gap_ssp_supported_on_both_sides(channel->con_handle) && !l2cap_security_level_0_allowed_for_PSM(channel->psm)){
8882df5dadcS[email protected]         // request security level 2
8892df5dadcS[email protected]         channel->state = L2CAP_STATE_WAIT_OUTGOING_SECURITY_LEVEL_UPDATE;
890fc64f94aSMatthias Ringwald         gap_request_security_level(channel->con_handle, LEVEL_2);
8912df5dadcS[email protected]         return;
8922df5dadcS[email protected]     }
8932df5dadcS[email protected]     // fine, go ahead
8942df5dadcS[email protected]     channel->state = L2CAP_STATE_WILL_SEND_CONNECTION_REQUEST;
8952df5dadcS[email protected] }
8962df5dadcS[email protected] 
897da144af5SMatthias 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,
898da144af5SMatthias Ringwald     uint16_t psm, uint16_t local_mtu, gap_security_level_t security_level){
899da144af5SMatthias Ringwald 
900da144af5SMatthias Ringwald     l2cap_channel_t * channel = btstack_memory_l2cap_channel_get();
901da144af5SMatthias Ringwald     if (!channel) {
902da144af5SMatthias Ringwald         return NULL;
903da144af5SMatthias Ringwald     }
904da144af5SMatthias Ringwald 
905da144af5SMatthias Ringwald      // Init memory (make valgrind happy)
906da144af5SMatthias Ringwald     memset(channel, 0, sizeof(l2cap_channel_t));
907da144af5SMatthias Ringwald 
908da144af5SMatthias Ringwald     // fill in
909da144af5SMatthias Ringwald     channel->packet_handler = packet_handler;
910da144af5SMatthias Ringwald     bd_addr_copy(channel->address, address);
911da144af5SMatthias Ringwald     channel->address_type = address_type;
912da144af5SMatthias Ringwald     channel->psm = psm;
913da144af5SMatthias Ringwald     channel->local_mtu  = local_mtu;
914da144af5SMatthias Ringwald     channel->remote_mtu = L2CAP_MINIMAL_MTU;
915da144af5SMatthias Ringwald     channel->required_security_level = security_level;
916da144af5SMatthias Ringwald 
917da144af5SMatthias Ringwald     //
918da144af5SMatthias Ringwald     channel->local_cid = l2cap_next_local_cid();
919da144af5SMatthias Ringwald     channel->con_handle = 0;
920da144af5SMatthias Ringwald 
921da144af5SMatthias Ringwald     // set initial state
922da144af5SMatthias Ringwald     channel->state = L2CAP_STATE_WILL_SEND_CREATE_CONNECTION;
923da144af5SMatthias Ringwald     channel->state_var = L2CAP_CHANNEL_STATE_VAR_NONE;
924da144af5SMatthias Ringwald     channel->remote_sig_id = L2CAP_SIG_ID_INVALID;
925da144af5SMatthias Ringwald     channel->local_sig_id = L2CAP_SIG_ID_INVALID;
926da144af5SMatthias Ringwald     return channel;
927da144af5SMatthias Ringwald }
928da144af5SMatthias Ringwald 
9299077cb15SMatthias Ringwald /**
9309077cb15SMatthias Ringwald  * @brief Creates L2CAP channel to the PSM of a remote device with baseband address. A new baseband connection will be initiated if necessary.
9319077cb15SMatthias Ringwald  * @param packet_handler
9329077cb15SMatthias Ringwald  * @param address
9339077cb15SMatthias Ringwald  * @param psm
9349077cb15SMatthias Ringwald  * @param mtu
9359077cb15SMatthias Ringwald  * @param local_cid
9369077cb15SMatthias Ringwald  */
9379077cb15SMatthias Ringwald 
938da144af5SMatthias 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){
939da144af5SMatthias Ringwald     log_info("L2CAP_CREATE_CHANNEL addr %s psm 0x%x mtu %u", bd_addr_to_str(address), psm, local_mtu);
940da144af5SMatthias Ringwald 
941da144af5SMatthias Ringwald     if (local_mtu > l2cap_max_mtu()) {
942da144af5SMatthias Ringwald         local_mtu = l2cap_max_mtu();
943da144af5SMatthias Ringwald     }
944da144af5SMatthias Ringwald 
945da144af5SMatthias Ringwald     l2cap_channel_t * channel = l2cap_create_channel_entry(channel_packet_handler, address, BD_ADDR_TYPE_CLASSIC, psm, local_mtu, LEVEL_0);
946fc64f94aSMatthias Ringwald     if (!channel) {
9479077cb15SMatthias Ringwald         return BTSTACK_MEMORY_ALLOC_FAILED;
9489077cb15SMatthias Ringwald     }
9499077cb15SMatthias Ringwald 
9509077cb15SMatthias Ringwald     // add to connections list
951fc64f94aSMatthias Ringwald     btstack_linked_list_add(&l2cap_channels, (btstack_linked_item_t *) channel);
9529077cb15SMatthias Ringwald 
9539077cb15SMatthias Ringwald     // store local_cid
9549077cb15SMatthias Ringwald     if (out_local_cid){
955fc64f94aSMatthias Ringwald        *out_local_cid = channel->local_cid;
9569077cb15SMatthias Ringwald     }
9579077cb15SMatthias Ringwald 
9589077cb15SMatthias Ringwald     // check if hci connection is already usable
9599077cb15SMatthias Ringwald     hci_connection_t * conn = hci_connection_for_bd_addr_and_type(address, BD_ADDR_TYPE_CLASSIC);
9609077cb15SMatthias Ringwald     if (conn){
961add0254bSMatthias Ringwald         log_info("l2cap_create_channel, hci connection already exists");
962fc64f94aSMatthias Ringwald         l2cap_handle_connection_complete(conn->con_handle, channel);
9639077cb15SMatthias Ringwald         // check if remote supported fearures are already received
9649077cb15SMatthias Ringwald         if (conn->bonding_flags & BONDING_RECEIVED_REMOTE_FEATURES) {
965fc64f94aSMatthias Ringwald             l2cap_handle_remote_supported_features_received(channel);
9669077cb15SMatthias Ringwald         }
9679077cb15SMatthias Ringwald     }
9689077cb15SMatthias Ringwald 
9699077cb15SMatthias Ringwald     l2cap_run();
9709077cb15SMatthias Ringwald 
9719077cb15SMatthias Ringwald     return 0;
9729077cb15SMatthias Ringwald }
9739077cb15SMatthias Ringwald 
974ce8f182eSMatthias Ringwald void
975ce8f182eSMatthias Ringwald l2cap_disconnect(uint16_t local_cid, uint8_t reason){
976e0abb8e7S[email protected]     log_info("L2CAP_DISCONNECT local_cid 0x%x reason 0x%x", local_cid, reason);
977b35f641cSmatthias.ringwald     // find channel for local_cid
978b35f641cSmatthias.ringwald     l2cap_channel_t * channel = l2cap_get_channel_for_local_cid(local_cid);
979f62db1e3Smatthias.ringwald     if (channel) {
980e7ff783cSmatthias.ringwald         channel->state = L2CAP_STATE_WILL_SEND_DISCONNECT_REQUEST;
981f62db1e3Smatthias.ringwald     }
9822cd0be45Smatthias.ringwald     // process
9832cd0be45Smatthias.ringwald     l2cap_run();
98443625864Smatthias.ringwald }
9851e6aba47Smatthias.ringwald 
986afde0c52Smatthias.ringwald static void l2cap_handle_connection_failed_for_addr(bd_addr_t address, uint8_t status){
987665d90f2SMatthias Ringwald     btstack_linked_list_iterator_t it;
988665d90f2SMatthias Ringwald     btstack_linked_list_iterator_init(&it, &l2cap_channels);
989665d90f2SMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
990665d90f2SMatthias Ringwald         l2cap_channel_t * channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it);
991058e3d6bSMatthias Ringwald         if ( bd_addr_cmp( channel->address, address) != 0) continue;
992c22aecc9S[email protected]         // channel for this address found
993c22aecc9S[email protected]         switch (channel->state){
994c22aecc9S[email protected]             case L2CAP_STATE_WAIT_CONNECTION_COMPLETE:
995c22aecc9S[email protected]             case L2CAP_STATE_WILL_SEND_CREATE_CONNECTION:
996afde0c52Smatthias.ringwald                 // failure, forward error code
997afde0c52Smatthias.ringwald                 l2cap_emit_channel_opened(channel, status);
998afde0c52Smatthias.ringwald                 // discard channel
9999dcb2fb2S[email protected]                 l2cap_stop_rtx(channel);
1000665d90f2SMatthias Ringwald                 btstack_linked_list_iterator_remove(&it);
1001d3a9df87Smatthias.ringwald                 btstack_memory_l2cap_channel_free(channel);
1002c22aecc9S[email protected]                 break;
1003c22aecc9S[email protected]             default:
1004c22aecc9S[email protected]                 break;
1005afde0c52Smatthias.ringwald         }
1006afde0c52Smatthias.ringwald     }
1007afde0c52Smatthias.ringwald }
1008afde0c52Smatthias.ringwald 
1009afde0c52Smatthias.ringwald static void l2cap_handle_connection_success_for_addr(bd_addr_t address, hci_con_handle_t handle){
1010665d90f2SMatthias Ringwald     btstack_linked_list_iterator_t it;
1011665d90f2SMatthias Ringwald     btstack_linked_list_iterator_init(&it, &l2cap_channels);
1012665d90f2SMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
1013665d90f2SMatthias Ringwald         l2cap_channel_t * channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it);
1014058e3d6bSMatthias Ringwald         if ( ! bd_addr_cmp( channel->address, address) ){
10152df5dadcS[email protected]             l2cap_handle_connection_complete(handle, channel);
1016afde0c52Smatthias.ringwald         }
1017afde0c52Smatthias.ringwald     }
10186fdcc387Smatthias.ringwald     // process
10196fdcc387Smatthias.ringwald     l2cap_run();
1020afde0c52Smatthias.ringwald }
1021b448a0e7Smatthias.ringwald 
102233c40538SMatthias Ringwald static void l2cap_notify_channel_can_send(void){
102333c40538SMatthias Ringwald     btstack_linked_list_iterator_t it;
102433c40538SMatthias Ringwald     btstack_linked_list_iterator_init(&it, &l2cap_channels);
102533c40538SMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
102633c40538SMatthias Ringwald         l2cap_channel_t * channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it);
102733c40538SMatthias Ringwald         if (!channel->waiting_for_can_send_now) continue;
1028fc64f94aSMatthias Ringwald         if (!hci_can_send_acl_packet_now(channel->con_handle)) continue;
102933c40538SMatthias Ringwald         channel->waiting_for_can_send_now = 0;
103034e7e577SMatthias Ringwald         l2cap_emit_can_send_now(channel->packet_handler, channel->local_cid);
103133c40538SMatthias Ringwald     }
10322125de09SMatthias Ringwald 
103344276248SMatthias Ringwald 
10342125de09SMatthias Ringwald     int i;
10352125de09SMatthias Ringwald     for (i=0;i<L2CAP_FIXED_CHANNEL_TABLE_SIZE;i++){
1036773c4106SMatthias Ringwald         if (!fixed_channels[i].callback) continue;
10372125de09SMatthias Ringwald         if (!fixed_channels[i].waiting_for_can_send_now) continue;
103834e7e577SMatthias Ringwald         int can_send;
103934e7e577SMatthias Ringwald         if (l2cap_fixed_channel_table_index_is_le(i)){
104034e7e577SMatthias Ringwald             can_send = hci_can_send_acl_le_packet_now();
104134e7e577SMatthias Ringwald         } else {
104234e7e577SMatthias Ringwald             can_send = hci_can_send_acl_classic_packet_now();
104334e7e577SMatthias Ringwald         }
104434e7e577SMatthias Ringwald         if (!can_send) continue;
104534e7e577SMatthias Ringwald         fixed_channels[i].waiting_for_can_send_now = 0;
104634e7e577SMatthias Ringwald         l2cap_emit_can_send_now(fixed_channels[i].callback, l2cap_fixed_channel_table_channel_id_for_index(i));
10472125de09SMatthias Ringwald     }
104833c40538SMatthias Ringwald }
104933c40538SMatthias Ringwald 
1050d9a7306aSMatthias Ringwald static void l2cap_hci_event_handler(uint8_t packet_type, uint16_t cid, uint8_t *packet, uint16_t size){
1051afde0c52Smatthias.ringwald 
1052afde0c52Smatthias.ringwald     bd_addr_t address;
1053afde0c52Smatthias.ringwald     hci_con_handle_t handle;
1054665d90f2SMatthias Ringwald     btstack_linked_list_iterator_t it;
10552d00edd4Smatthias.ringwald     int hci_con_used;
1056afde0c52Smatthias.ringwald 
10570e2df43fSMatthias Ringwald     switch(hci_event_packet_get_type(packet)){
1058afde0c52Smatthias.ringwald 
1059afde0c52Smatthias.ringwald         // handle connection complete events
1060afde0c52Smatthias.ringwald         case HCI_EVENT_CONNECTION_COMPLETE:
1061724d70a2SMatthias Ringwald             reverse_bd_addr(&packet[5], address);
1062afde0c52Smatthias.ringwald             if (packet[2] == 0){
1063f8fbdce0SMatthias Ringwald                 handle = little_endian_read_16(packet, 3);
1064afde0c52Smatthias.ringwald                 l2cap_handle_connection_success_for_addr(address, handle);
1065afde0c52Smatthias.ringwald             } else {
1066afde0c52Smatthias.ringwald                 l2cap_handle_connection_failed_for_addr(address, packet[2]);
1067afde0c52Smatthias.ringwald             }
1068afde0c52Smatthias.ringwald             break;
1069afde0c52Smatthias.ringwald 
1070afde0c52Smatthias.ringwald         // handle successful create connection cancel command
1071afde0c52Smatthias.ringwald         case HCI_EVENT_COMMAND_COMPLETE:
1072073bd0faSMatthias Ringwald             if (HCI_EVENT_IS_COMMAND_COMPLETE(packet, hci_create_connection_cancel)) {
1073afde0c52Smatthias.ringwald                 if (packet[5] == 0){
1074724d70a2SMatthias Ringwald                     reverse_bd_addr(&packet[6], address);
1075afde0c52Smatthias.ringwald                     // CONNECTION TERMINATED BY LOCAL HOST (0X16)
1076afde0c52Smatthias.ringwald                     l2cap_handle_connection_failed_for_addr(address, 0x16);
107703cfbabcSmatthias.ringwald                 }
10781e6aba47Smatthias.ringwald             }
107939d59809Smatthias.ringwald             l2cap_run();    // try sending signaling packets first
108039d59809Smatthias.ringwald             break;
108139d59809Smatthias.ringwald 
108239d59809Smatthias.ringwald         case HCI_EVENT_COMMAND_STATUS:
108339d59809Smatthias.ringwald             l2cap_run();    // try sending signaling packets first
1084afde0c52Smatthias.ringwald             break;
108527a923d0Smatthias.ringwald 
10861e6aba47Smatthias.ringwald         // handle disconnection complete events
1087afde0c52Smatthias.ringwald         case HCI_EVENT_DISCONNECTION_COMPLETE:
1088c22aecc9S[email protected]             // send l2cap disconnect events for all channels on this handle and free them
1089f8fbdce0SMatthias Ringwald             handle = little_endian_read_16(packet, 3);
1090665d90f2SMatthias Ringwald             btstack_linked_list_iterator_init(&it, &l2cap_channels);
1091665d90f2SMatthias Ringwald             while (btstack_linked_list_iterator_has_next(&it)){
1092665d90f2SMatthias Ringwald                 l2cap_channel_t * channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it);
1093fc64f94aSMatthias Ringwald                 if (channel->con_handle != handle) continue;
109415ec09bbSmatthias.ringwald                 l2cap_emit_channel_closed(channel);
10959dcb2fb2S[email protected]                 l2cap_stop_rtx(channel);
1096665d90f2SMatthias Ringwald                 btstack_linked_list_iterator_remove(&it);
1097d3a9df87Smatthias.ringwald                 btstack_memory_l2cap_channel_free(channel);
109827a923d0Smatthias.ringwald             }
1099991fea48SMatthias Ringwald #ifdef ENABLE_BLE
1100991fea48SMatthias Ringwald             btstack_linked_list_iterator_init(&it, &l2cap_le_channels);
1101991fea48SMatthias Ringwald             while (btstack_linked_list_iterator_has_next(&it)){
1102991fea48SMatthias Ringwald                 l2cap_channel_t * channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it);
1103991fea48SMatthias Ringwald                 if (channel->con_handle != handle) continue;
1104991fea48SMatthias Ringwald                 l2cap_emit_channel_closed(channel);
1105991fea48SMatthias Ringwald                 btstack_linked_list_iterator_remove(&it);
1106991fea48SMatthias Ringwald                 btstack_memory_l2cap_channel_free(channel);
1107991fea48SMatthias Ringwald             }
1108991fea48SMatthias Ringwald #endif
1109afde0c52Smatthias.ringwald             break;
1110fcadd0caSmatthias.ringwald 
111133c40538SMatthias Ringwald         // Notify channel packet handler if they can send now
111263fa3374SMatthias Ringwald         case HCI_EVENT_TRANSPORT_PACKET_SENT:
11136218e6f1Smatthias.ringwald         case HCI_EVENT_NUMBER_OF_COMPLETED_PACKETS:
111402b22dc4Smatthias.ringwald             l2cap_run();    // try sending signaling packets first
111533c40538SMatthias Ringwald             l2cap_notify_channel_can_send();
11166218e6f1Smatthias.ringwald             break;
11176218e6f1Smatthias.ringwald 
1118ee091cf1Smatthias.ringwald         // HCI Connection Timeouts
1119afde0c52Smatthias.ringwald         case L2CAP_EVENT_TIMEOUT_CHECK:
1120f8fbdce0SMatthias Ringwald             handle = little_endian_read_16(packet, 2);
1121bd04d84aSMatthias Ringwald             if (gap_get_connection_type(handle) != GAP_CONNECTION_ACL) break;
112280ca58a0Smatthias.ringwald             if (hci_authentication_active_for_handle(handle)) break;
11232d00edd4Smatthias.ringwald             hci_con_used = 0;
1124665d90f2SMatthias Ringwald             btstack_linked_list_iterator_init(&it, &l2cap_channels);
1125665d90f2SMatthias Ringwald             while (btstack_linked_list_iterator_has_next(&it)){
1126665d90f2SMatthias Ringwald                 l2cap_channel_t * channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it);
1127fc64f94aSMatthias Ringwald                 if (channel->con_handle != handle) continue;
11282d00edd4Smatthias.ringwald                 hci_con_used = 1;
1129c22aecc9S[email protected]                 break;
1130ee091cf1Smatthias.ringwald             }
11312d00edd4Smatthias.ringwald             if (hci_con_used) break;
1132d94d3cafS[email protected]             if (!hci_can_send_command_packet_now()) break;
11339edc8742Smatthias.ringwald             hci_send_cmd(&hci_disconnect, handle, 0x13); // remote closed connection
1134afde0c52Smatthias.ringwald             break;
1135ee091cf1Smatthias.ringwald 
1136df3354fcS[email protected]         case HCI_EVENT_READ_REMOTE_SUPPORTED_FEATURES_COMPLETE:
1137f8fbdce0SMatthias Ringwald             handle = little_endian_read_16(packet, 3);
1138665d90f2SMatthias Ringwald             btstack_linked_list_iterator_init(&it, &l2cap_channels);
1139665d90f2SMatthias Ringwald             while (btstack_linked_list_iterator_has_next(&it)){
1140665d90f2SMatthias Ringwald                 l2cap_channel_t * channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it);
1141fc64f94aSMatthias Ringwald                 if (channel->con_handle != handle) continue;
11422df5dadcS[email protected]                 l2cap_handle_remote_supported_features_received(channel);
1143df3354fcS[email protected]                 break;
1144df3354fcS[email protected]             }
1145c22aecc9S[email protected]             break;
1146df3354fcS[email protected] 
11475611a760SMatthias Ringwald         case GAP_EVENT_SECURITY_LEVEL:
1148f8fbdce0SMatthias Ringwald             handle = little_endian_read_16(packet, 2);
1149bd63148eS[email protected]             log_info("l2cap - security level update");
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;
11545533f01eS[email protected] 
1155bd63148eS[email protected]                 log_info("l2cap - state %u", channel->state);
1156bd63148eS[email protected] 
1157e569dfd9SMatthias Ringwald                 gap_security_level_t actual_level = (gap_security_level_t) packet[4];
11585533f01eS[email protected]                 gap_security_level_t required_level = channel->required_security_level;
11595533f01eS[email protected] 
1160df3354fcS[email protected]                 switch (channel->state){
1161df3354fcS[email protected]                     case L2CAP_STATE_WAIT_INCOMING_SECURITY_LEVEL_UPDATE:
11625533f01eS[email protected]                         if (actual_level >= required_level){
1163f85a9399S[email protected]                             channel->state = L2CAP_STATE_WAIT_CLIENT_ACCEPT_OR_REJECT;
116444276248SMatthias Ringwald                             l2cap_emit_incoming_connection(channel);
11651eb2563eS[email protected]                         } else {
1166775ecc36SMatthias Ringwald                             channel->reason = 0x0003; // security block
11671eb2563eS[email protected]                             channel->state = L2CAP_STATE_WILL_SEND_CONNECTION_RESPONSE_DECLINE;
11681eb2563eS[email protected]                         }
1169df3354fcS[email protected]                         break;
1170df3354fcS[email protected] 
1171df3354fcS[email protected]                     case L2CAP_STATE_WAIT_OUTGOING_SECURITY_LEVEL_UPDATE:
11725533f01eS[email protected]                         if (actual_level >= required_level){
1173df3354fcS[email protected]                             channel->state = L2CAP_STATE_WILL_SEND_CONNECTION_REQUEST;
1174df3354fcS[email protected]                         } else {
1175df3354fcS[email protected]                             // disconnnect, authentication not good enough
1176df3354fcS[email protected]                             hci_disconnect_security_block(handle);
1177df3354fcS[email protected]                         }
1178df3354fcS[email protected]                         break;
1179df3354fcS[email protected] 
1180df3354fcS[email protected]                     default:
1181df3354fcS[email protected]                         break;
1182df3354fcS[email protected]                 }
1183f85a9399S[email protected]             }
1184f85a9399S[email protected]             break;
1185f85a9399S[email protected] 
1186afde0c52Smatthias.ringwald         default:
1187afde0c52Smatthias.ringwald             break;
1188afde0c52Smatthias.ringwald     }
1189afde0c52Smatthias.ringwald 
1190bd63148eS[email protected]     l2cap_run();
11911e6aba47Smatthias.ringwald }
11921e6aba47Smatthias.ringwald 
1193afde0c52Smatthias.ringwald static void l2cap_handle_disconnect_request(l2cap_channel_t *channel, uint16_t identifier){
1194b1988dceSmatthias.ringwald     channel->remote_sig_id = identifier;
1195e7ff783cSmatthias.ringwald     channel->state = L2CAP_STATE_WILL_SEND_DISCONNECT_RESPONSE;
1196e7ff783cSmatthias.ringwald     l2cap_run();
119784836b65Smatthias.ringwald }
119884836b65Smatthias.ringwald 
11992b360848Smatthias.ringwald static void l2cap_register_signaling_response(hci_con_handle_t handle, uint8_t code, uint8_t sig_id, uint16_t data){
12004cf56b4aSmatthias.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."
12012b360848Smatthias.ringwald     if (signaling_responses_pending < NR_PENDING_SIGNALING_RESPONSES) {
12022b360848Smatthias.ringwald         signaling_responses[signaling_responses_pending].handle = handle;
12032b360848Smatthias.ringwald         signaling_responses[signaling_responses_pending].code = code;
12042b360848Smatthias.ringwald         signaling_responses[signaling_responses_pending].sig_id = sig_id;
12052b360848Smatthias.ringwald         signaling_responses[signaling_responses_pending].data = data;
12062b360848Smatthias.ringwald         signaling_responses_pending++;
12072b360848Smatthias.ringwald         l2cap_run();
12082b360848Smatthias.ringwald     }
12092b360848Smatthias.ringwald }
12102b360848Smatthias.ringwald 
1211b35f641cSmatthias.ringwald static void l2cap_handle_connection_request(hci_con_handle_t handle, uint8_t sig_id, uint16_t psm, uint16_t source_cid){
1212645658c9Smatthias.ringwald 
12139da54300S[email protected]     // log_info("l2cap_handle_connection_request for handle %u, psm %u cid 0x%02x", handle, psm, source_cid);
1214645658c9Smatthias.ringwald     l2cap_service_t *service = l2cap_get_service(psm);
1215645658c9Smatthias.ringwald     if (!service) {
1216645658c9Smatthias.ringwald         // 0x0002 PSM not supported
12172b360848Smatthias.ringwald         l2cap_register_signaling_response(handle, CONNECTION_REQUEST, sig_id, 0x0002);
1218645658c9Smatthias.ringwald         return;
1219645658c9Smatthias.ringwald     }
1220645658c9Smatthias.ringwald 
12215061f3afS[email protected]     hci_connection_t * hci_connection = hci_connection_for_handle( handle );
1222645658c9Smatthias.ringwald     if (!hci_connection) {
12232b360848Smatthias.ringwald         //
12249da54300S[email protected]         log_error("no hci_connection for handle %u", handle);
1225645658c9Smatthias.ringwald         return;
1226645658c9Smatthias.ringwald     }
12272bd8b7e7S[email protected] 
1228645658c9Smatthias.ringwald     // alloc structure
12299da54300S[email protected]     // log_info("l2cap_handle_connection_request register channel");
1230da144af5SMatthias Ringwald     l2cap_channel_t * channel = l2cap_create_channel_entry(service->packet_handler, hci_connection->address, BD_ADDR_TYPE_CLASSIC,
1231da144af5SMatthias Ringwald     psm, service->mtu, service->required_security_level);
12322b360848Smatthias.ringwald     if (!channel){
12332b360848Smatthias.ringwald         // 0x0004 No resources available
12342b360848Smatthias.ringwald         l2cap_register_signaling_response(handle, CONNECTION_REQUEST, sig_id, 0x0004);
12352b360848Smatthias.ringwald         return;
12362b360848Smatthias.ringwald     }
1237da144af5SMatthias Ringwald 
1238fc64f94aSMatthias Ringwald     channel->con_handle = handle;
1239b35f641cSmatthias.ringwald     channel->remote_cid = source_cid;
1240b1988dceSmatthias.ringwald     channel->remote_sig_id = sig_id;
1241645658c9Smatthias.ringwald 
1242f53da564S[email protected]     // limit local mtu to max acl packet length - l2cap header
12432985cb84Smatthias.ringwald     if (channel->local_mtu > l2cap_max_mtu()) {
12442985cb84Smatthias.ringwald         channel->local_mtu = l2cap_max_mtu();
12459775e25bSmatthias.ringwald     }
12469775e25bSmatthias.ringwald 
1247645658c9Smatthias.ringwald     // set initial state
1248df3354fcS[email protected]     channel->state =     L2CAP_STATE_WAIT_INCOMING_SECURITY_LEVEL_UPDATE;
1249ad671560S[email protected]     channel->state_var = L2CAP_CHANNEL_STATE_VAR_SEND_CONN_RESP_PEND;
1250e405ae81Smatthias.ringwald 
1251645658c9Smatthias.ringwald     // add to connections list
1252665d90f2SMatthias Ringwald     btstack_linked_list_add(&l2cap_channels, (btstack_linked_item_t *) channel);
1253645658c9Smatthias.ringwald 
1254f85a9399S[email protected]     // assert security requirements
12551eb2563eS[email protected]     gap_request_security_level(handle, channel->required_security_level);
1256e405ae81Smatthias.ringwald }
1257645658c9Smatthias.ringwald 
1258ce8f182eSMatthias Ringwald void l2cap_accept_connection(uint16_t local_cid){
1259e0abb8e7S[email protected]     log_info("L2CAP_ACCEPT_CONNECTION local_cid 0x%x", local_cid);
1260b35f641cSmatthias.ringwald     l2cap_channel_t * channel = l2cap_get_channel_for_local_cid(local_cid);
1261e405ae81Smatthias.ringwald     if (!channel) {
1262ce8f182eSMatthias Ringwald         log_error("l2cap_accept_connection called but local_cid 0x%x not found", local_cid);
1263e405ae81Smatthias.ringwald         return;
1264e405ae81Smatthias.ringwald     }
1265e405ae81Smatthias.ringwald 
1266552d92a1Smatthias.ringwald     channel->state = L2CAP_STATE_WILL_SEND_CONNECTION_RESPONSE_ACCEPT;
1267e405ae81Smatthias.ringwald 
1268552d92a1Smatthias.ringwald     // process
1269552d92a1Smatthias.ringwald     l2cap_run();
1270e405ae81Smatthias.ringwald }
1271645658c9Smatthias.ringwald 
12727ef6a7bbSMatthias Ringwald void l2cap_decline_connection(uint16_t local_cid){
12737ef6a7bbSMatthias Ringwald     log_info("L2CAP_DECLINE_CONNECTION local_cid 0x%x", local_cid);
1274b35f641cSmatthias.ringwald     l2cap_channel_t * channel = l2cap_get_channel_for_local_cid( local_cid);
1275e405ae81Smatthias.ringwald     if (!channel) {
1276ce8f182eSMatthias Ringwald         log_error( "l2cap_decline_connection called but local_cid 0x%x not found", local_cid);
1277e405ae81Smatthias.ringwald         return;
1278e405ae81Smatthias.ringwald     }
1279e7ff783cSmatthias.ringwald     channel->state  = L2CAP_STATE_WILL_SEND_CONNECTION_RESPONSE_DECLINE;
12807ef6a7bbSMatthias Ringwald     channel->reason = 0x04; // no resources available
1281e7ff783cSmatthias.ringwald     l2cap_run();
1282645658c9Smatthias.ringwald }
1283645658c9Smatthias.ringwald 
12847f02f414SMatthias Ringwald static void l2cap_signaling_handle_configure_request(l2cap_channel_t *channel, uint8_t *command){
1285b1988dceSmatthias.ringwald 
1286b1988dceSmatthias.ringwald     channel->remote_sig_id = command[L2CAP_SIGNALING_COMMAND_SIGID_OFFSET];
1287b1988dceSmatthias.ringwald 
1288f8fbdce0SMatthias Ringwald     uint16_t flags = little_endian_read_16(command, 6);
128963a7246aSmatthias.ringwald     if (flags & 1) {
129063a7246aSmatthias.ringwald         channelStateVarSetFlag(channel, L2CAP_CHANNEL_STATE_VAR_SEND_CONF_RSP_CONT);
129163a7246aSmatthias.ringwald     }
129263a7246aSmatthias.ringwald 
12932784b77dSmatthias.ringwald     // accept the other's configuration options
1294f8fbdce0SMatthias Ringwald     uint16_t end_pos = 4 + little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_LENGTH_OFFSET);
12953de7c0caSmatthias.ringwald     uint16_t pos     = 8;
12963de7c0caSmatthias.ringwald     while (pos < end_pos){
129763a7246aSmatthias.ringwald         uint8_t option_hint = command[pos] >> 7;
129863a7246aSmatthias.ringwald         uint8_t option_type = command[pos] & 0x7f;
129963a7246aSmatthias.ringwald         log_info("l2cap cid %u, hint %u, type %u", channel->local_cid, option_hint, option_type);
130063a7246aSmatthias.ringwald         pos++;
13011dc511deSmatthias.ringwald         uint8_t length = command[pos++];
13021dc511deSmatthias.ringwald         // MTU { type(8): 1, len(8):2, MTU(16) }
130363a7246aSmatthias.ringwald         if (option_type == 1 && length == 2){
1304f8fbdce0SMatthias Ringwald             channel->remote_mtu = little_endian_read_16(command, pos);
13059da54300S[email protected]             // log_info("l2cap cid 0x%02x, remote mtu %u", channel->local_cid, channel->remote_mtu);
130663a7246aSmatthias.ringwald             channelStateVarSetFlag(channel, L2CAP_CHANNEL_STATE_VAR_SEND_CONF_RSP_MTU);
130763a7246aSmatthias.ringwald         }
13080fe7a9d0S[email protected]         // Flush timeout { type(8):2, len(8): 2, Flush Timeout(16)}
13090fe7a9d0S[email protected]         if (option_type == 2 && length == 2){
1310f8fbdce0SMatthias Ringwald             channel->flush_timeout = little_endian_read_16(command, pos);
13110fe7a9d0S[email protected]         }
131263a7246aSmatthias.ringwald         // check for unknown options
131363a7246aSmatthias.ringwald         if (option_hint == 0 && (option_type == 0 || option_type >= 0x07)){
1314c177a91cS[email protected]             log_info("l2cap cid %u, unknown options", channel->local_cid);
131563a7246aSmatthias.ringwald             channelStateVarSetFlag(channel, L2CAP_CHANNEL_STATE_VAR_SEND_CONF_RSP_INVALID);
13161dc511deSmatthias.ringwald         }
13171dc511deSmatthias.ringwald         pos += length;
13181dc511deSmatthias.ringwald     }
13192784b77dSmatthias.ringwald }
13202784b77dSmatthias.ringwald 
1321fa8473a4Smatthias.ringwald static int l2cap_channel_ready_for_open(l2cap_channel_t *channel){
13229da54300S[email protected]     // log_info("l2cap_channel_ready_for_open 0x%02x", channel->state_var);
132373cf2b3dSmatthias.ringwald     if ((channel->state_var & L2CAP_CHANNEL_STATE_VAR_RCVD_CONF_RSP) == 0) return 0;
132473cf2b3dSmatthias.ringwald     if ((channel->state_var & L2CAP_CHANNEL_STATE_VAR_SENT_CONF_RSP) == 0) return 0;
1325019f9b43SMatthias Ringwald     // addition check that fixes re-entrance issue causing l2cap event channel opened twice
1326019f9b43SMatthias Ringwald     if (channel->state == L2CAP_STATE_OPEN) return 0;
1327fa8473a4Smatthias.ringwald     return 1;
1328fa8473a4Smatthias.ringwald }
1329fa8473a4Smatthias.ringwald 
1330fa8473a4Smatthias.ringwald 
13317f02f414SMatthias Ringwald static void l2cap_signaling_handler_channel(l2cap_channel_t *channel, uint8_t *command){
13321e6aba47Smatthias.ringwald 
133300d93d79Smatthias.ringwald     uint8_t  code       = command[L2CAP_SIGNALING_COMMAND_CODE_OFFSET];
133400d93d79Smatthias.ringwald     uint8_t  identifier = command[L2CAP_SIGNALING_COMMAND_SIGID_OFFSET];
133538e5900eSmatthias.ringwald     uint16_t result = 0;
13361e6aba47Smatthias.ringwald 
13379da54300S[email protected]     log_info("L2CAP signaling handler code %u, state %u", code, channel->state);
1338b35f641cSmatthias.ringwald 
13399a011532Smatthias.ringwald     // handle DISCONNECT REQUESTS seperately
13409a011532Smatthias.ringwald     if (code == DISCONNECTION_REQUEST){
13419a011532Smatthias.ringwald         switch (channel->state){
1342fa8473a4Smatthias.ringwald             case L2CAP_STATE_CONFIG:
13439a011532Smatthias.ringwald             case L2CAP_STATE_OPEN:
13442b83fb7dSmatthias.ringwald             case L2CAP_STATE_WILL_SEND_DISCONNECT_REQUEST:
13459a011532Smatthias.ringwald             case L2CAP_STATE_WAIT_DISCONNECT:
13469a011532Smatthias.ringwald                 l2cap_handle_disconnect_request(channel, identifier);
13479a011532Smatthias.ringwald                 break;
13489a011532Smatthias.ringwald 
13499a011532Smatthias.ringwald             default:
13509a011532Smatthias.ringwald                 // ignore in other states
13519a011532Smatthias.ringwald                 break;
13529a011532Smatthias.ringwald         }
13539a011532Smatthias.ringwald         return;
13549a011532Smatthias.ringwald     }
13559a011532Smatthias.ringwald 
135656081214Smatthias.ringwald     // @STATEMACHINE(l2cap)
13571e6aba47Smatthias.ringwald     switch (channel->state) {
13581e6aba47Smatthias.ringwald 
13591e6aba47Smatthias.ringwald         case L2CAP_STATE_WAIT_CONNECT_RSP:
13601e6aba47Smatthias.ringwald             switch (code){
13611e6aba47Smatthias.ringwald                 case CONNECTION_RESPONSE:
13625932bd7cS[email protected]                     l2cap_stop_rtx(channel);
1363f8fbdce0SMatthias Ringwald                     result = little_endian_read_16 (command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET+4);
136438e5900eSmatthias.ringwald                     switch (result) {
136538e5900eSmatthias.ringwald                         case 0:
1366169f8b28Smatthias.ringwald                             // successful connection
1367f8fbdce0SMatthias Ringwald                             channel->remote_cid = little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET);
1368fa8473a4Smatthias.ringwald                             channel->state = L2CAP_STATE_CONFIG;
136928ca2b46S[email protected]                             channelStateVarSetFlag(channel, L2CAP_CHANNEL_STATE_VAR_SEND_CONF_REQ);
137038e5900eSmatthias.ringwald                             break;
137138e5900eSmatthias.ringwald                         case 1:
13725932bd7cS[email protected]                             // connection pending. get some coffee, but start the ERTX
13735932bd7cS[email protected]                             l2cap_start_ertx(channel);
137438e5900eSmatthias.ringwald                             break;
137538e5900eSmatthias.ringwald                         default:
1376eb920dbeSmatthias.ringwald                             // channel closed
1377eb920dbeSmatthias.ringwald                             channel->state = L2CAP_STATE_CLOSED;
1378f32b992eSmatthias.ringwald                             // map l2cap connection response result to BTstack status enumeration
137938e5900eSmatthias.ringwald                             l2cap_emit_channel_opened(channel, L2CAP_CONNECTION_RESPONSE_RESULT_SUCCESSFUL + result);
1380eb920dbeSmatthias.ringwald 
1381eb920dbeSmatthias.ringwald                             // drop link key if security block
1382eb920dbeSmatthias.ringwald                             if (L2CAP_CONNECTION_RESPONSE_RESULT_SUCCESSFUL + result == L2CAP_CONNECTION_RESPONSE_RESULT_REFUSED_SECURITY){
138315a95bd5SMatthias Ringwald                                 gap_drop_link_key_for_bd_addr(channel->address);
1384eb920dbeSmatthias.ringwald                             }
1385eb920dbeSmatthias.ringwald 
1386eb920dbeSmatthias.ringwald                             // discard channel
1387665d90f2SMatthias Ringwald                             btstack_linked_list_remove(&l2cap_channels, (btstack_linked_item_t *) channel);
1388d3a9df87Smatthias.ringwald                             btstack_memory_l2cap_channel_free(channel);
138938e5900eSmatthias.ringwald                             break;
13901e6aba47Smatthias.ringwald                     }
13911e6aba47Smatthias.ringwald                     break;
139238e5900eSmatthias.ringwald 
139338e5900eSmatthias.ringwald                 default:
13941e6aba47Smatthias.ringwald                     //@TODO: implement other signaling packets
139538e5900eSmatthias.ringwald                     break;
13961e6aba47Smatthias.ringwald             }
13971e6aba47Smatthias.ringwald             break;
13981e6aba47Smatthias.ringwald 
1399fa8473a4Smatthias.ringwald         case L2CAP_STATE_CONFIG:
1400f8fbdce0SMatthias Ringwald             result = little_endian_read_16 (command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET+4);
1401ae280e73Smatthias.ringwald             switch (code) {
1402ae280e73Smatthias.ringwald                 case CONFIGURE_REQUEST:
140328ca2b46S[email protected]                     channelStateVarSetFlag(channel, L2CAP_CHANNEL_STATE_VAR_SEND_CONF_RSP);
1404ae280e73Smatthias.ringwald                     l2cap_signaling_handle_configure_request(channel, command);
140563a7246aSmatthias.ringwald                     if (!(channel->state_var & L2CAP_CHANNEL_STATE_VAR_SEND_CONF_RSP_CONT)){
140663a7246aSmatthias.ringwald                         // only done if continuation not set
140763a7246aSmatthias.ringwald                         channelStateVarSetFlag(channel, L2CAP_CHANNEL_STATE_VAR_RCVD_CONF_REQ);
140863a7246aSmatthias.ringwald                     }
1409ae280e73Smatthias.ringwald                     break;
14101e6aba47Smatthias.ringwald                 case CONFIGURE_RESPONSE:
14115932bd7cS[email protected]                     l2cap_stop_rtx(channel);
14125932bd7cS[email protected]                     switch (result){
14135932bd7cS[email protected]                         case 0: // success
14145932bd7cS[email protected]                             channelStateVarSetFlag(channel, L2CAP_CHANNEL_STATE_VAR_RCVD_CONF_RSP);
14155932bd7cS[email protected]                             break;
14165932bd7cS[email protected]                         case 4: // pending
14175932bd7cS[email protected]                             l2cap_start_ertx(channel);
14185932bd7cS[email protected]                             break;
14195932bd7cS[email protected]                         default:
1420fe9d8984S[email protected]                             // retry on negative result
1421fe9d8984S[email protected]                             channelStateVarSetFlag(channel, L2CAP_CHANNEL_STATE_VAR_SEND_CONF_REQ);
1422fe9d8984S[email protected]                             break;
1423fe9d8984S[email protected]                     }
14245a67bd4aSmatthias.ringwald                     break;
14255a67bd4aSmatthias.ringwald                 default:
14265a67bd4aSmatthias.ringwald                     break;
14271e6aba47Smatthias.ringwald             }
1428fa8473a4Smatthias.ringwald             if (l2cap_channel_ready_for_open(channel)){
1429fa8473a4Smatthias.ringwald                 // for open:
14305a67bd4aSmatthias.ringwald                 channel->state = L2CAP_STATE_OPEN;
1431fa8473a4Smatthias.ringwald                 l2cap_emit_channel_opened(channel, 0);
1432c8e4258aSmatthias.ringwald             }
1433c8e4258aSmatthias.ringwald             break;
1434f62db1e3Smatthias.ringwald 
1435f62db1e3Smatthias.ringwald         case L2CAP_STATE_WAIT_DISCONNECT:
1436f62db1e3Smatthias.ringwald             switch (code) {
1437f62db1e3Smatthias.ringwald                 case DISCONNECTION_RESPONSE:
143827a923d0Smatthias.ringwald                     l2cap_finialize_channel_close(channel);
143927a923d0Smatthias.ringwald                     break;
14405a67bd4aSmatthias.ringwald                 default:
14415a67bd4aSmatthias.ringwald                     //@TODO: implement other signaling packets
14425a67bd4aSmatthias.ringwald                     break;
144327a923d0Smatthias.ringwald             }
144427a923d0Smatthias.ringwald             break;
144584836b65Smatthias.ringwald 
144684836b65Smatthias.ringwald         case L2CAP_STATE_CLOSED:
144784836b65Smatthias.ringwald             // @TODO handle incoming requests
144884836b65Smatthias.ringwald             break;
144984836b65Smatthias.ringwald 
145084836b65Smatthias.ringwald         case L2CAP_STATE_OPEN:
145184836b65Smatthias.ringwald             //@TODO: implement other signaling packets, e.g. re-configure
145284836b65Smatthias.ringwald             break;
145310642e45Smatthias.ringwald         default:
145410642e45Smatthias.ringwald             break;
145527a923d0Smatthias.ringwald     }
14569da54300S[email protected]     // log_info("new state %u", channel->state);
145727a923d0Smatthias.ringwald }
145827a923d0Smatthias.ringwald 
145900d93d79Smatthias.ringwald 
14607f02f414SMatthias Ringwald static void l2cap_signaling_handler_dispatch( hci_con_handle_t handle, uint8_t * command){
146100d93d79Smatthias.ringwald 
146200d93d79Smatthias.ringwald     // get code, signalind identifier and command len
146300d93d79Smatthias.ringwald     uint8_t code   = command[L2CAP_SIGNALING_COMMAND_CODE_OFFSET];
146400d93d79Smatthias.ringwald     uint8_t sig_id = command[L2CAP_SIGNALING_COMMAND_SIGID_OFFSET];
146500d93d79Smatthias.ringwald 
146600d93d79Smatthias.ringwald     // not for a particular channel, and not CONNECTION_REQUEST, ECHO_[REQUEST|RESPONSE], INFORMATION_REQUEST
146700d93d79Smatthias.ringwald     if (code < 1 || code == ECHO_RESPONSE || code > INFORMATION_REQUEST){
146863a7246aSmatthias.ringwald         l2cap_register_signaling_response(handle, COMMAND_REJECT, sig_id, L2CAP_REJ_CMD_UNKNOWN);
146900d93d79Smatthias.ringwald         return;
147000d93d79Smatthias.ringwald     }
147100d93d79Smatthias.ringwald 
147200d93d79Smatthias.ringwald     // general commands without an assigned channel
147300d93d79Smatthias.ringwald     switch(code) {
147400d93d79Smatthias.ringwald 
147500d93d79Smatthias.ringwald         case CONNECTION_REQUEST: {
1476f8fbdce0SMatthias Ringwald             uint16_t psm =        little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET);
1477f8fbdce0SMatthias Ringwald             uint16_t source_cid = little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET+2);
147800d93d79Smatthias.ringwald             l2cap_handle_connection_request(handle, sig_id, psm, source_cid);
14792b83fb7dSmatthias.ringwald             return;
148000d93d79Smatthias.ringwald         }
148100d93d79Smatthias.ringwald 
14822b360848Smatthias.ringwald         case ECHO_REQUEST:
14832b360848Smatthias.ringwald             l2cap_register_signaling_response(handle, code, sig_id, 0);
14842b83fb7dSmatthias.ringwald             return;
148500d93d79Smatthias.ringwald 
148600d93d79Smatthias.ringwald         case INFORMATION_REQUEST: {
1487f8fbdce0SMatthias Ringwald             uint16_t infoType = little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET);
14882b360848Smatthias.ringwald             l2cap_register_signaling_response(handle, code, sig_id, infoType);
14892b83fb7dSmatthias.ringwald             return;
149000d93d79Smatthias.ringwald         }
149100d93d79Smatthias.ringwald 
149200d93d79Smatthias.ringwald         default:
149300d93d79Smatthias.ringwald             break;
149400d93d79Smatthias.ringwald     }
149500d93d79Smatthias.ringwald 
149600d93d79Smatthias.ringwald 
149700d93d79Smatthias.ringwald     // Get potential destination CID
1498f8fbdce0SMatthias Ringwald     uint16_t dest_cid = little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET);
149900d93d79Smatthias.ringwald 
150000d93d79Smatthias.ringwald     // Find channel for this sig_id and connection handle
1501665d90f2SMatthias Ringwald     btstack_linked_list_iterator_t it;
1502665d90f2SMatthias Ringwald     btstack_linked_list_iterator_init(&it, &l2cap_channels);
1503665d90f2SMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
1504665d90f2SMatthias Ringwald         l2cap_channel_t * channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it);
1505fc64f94aSMatthias Ringwald         if (channel->con_handle != handle) continue;
150600d93d79Smatthias.ringwald         if (code & 1) {
1507b1988dceSmatthias.ringwald             // match odd commands (responses) by previous signaling identifier
1508b1988dceSmatthias.ringwald             if (channel->local_sig_id == sig_id) {
150900d93d79Smatthias.ringwald                 l2cap_signaling_handler_channel(channel, command);
15104e32727eSmatthias.ringwald                 break;
151100d93d79Smatthias.ringwald             }
151200d93d79Smatthias.ringwald         } else {
1513b1988dceSmatthias.ringwald             // match even commands (requests) by local channel id
151400d93d79Smatthias.ringwald             if (channel->local_cid == dest_cid) {
151500d93d79Smatthias.ringwald                 l2cap_signaling_handler_channel(channel, command);
15164e32727eSmatthias.ringwald                 break;
151700d93d79Smatthias.ringwald             }
151800d93d79Smatthias.ringwald         }
151900d93d79Smatthias.ringwald     }
152000d93d79Smatthias.ringwald }
152100d93d79Smatthias.ringwald 
1522e7d0c9aaSMatthias Ringwald #ifdef ENABLE_BLE
1523c48b2a2cSMatthias Ringwald // @returns valid
1524c48b2a2cSMatthias Ringwald static int l2cap_le_signaling_handler_dispatch(hci_con_handle_t handle, uint8_t * command, uint8_t sig_id){
1525e7d0c9aaSMatthias Ringwald     hci_connection_t * connection;
1526c48b2a2cSMatthias Ringwald     uint16_t result;
1527c48b2a2cSMatthias Ringwald     uint8_t  event[10];
1528828a7f7aSMatthias Ringwald     uint16_t local_cid;
152983fd9c76SMatthias Ringwald     l2cap_channel_t * channel;
153083fd9c76SMatthias Ringwald     btstack_linked_list_iterator_t it;
153183fd9c76SMatthias Ringwald 
1532cab29d48SMatthias Ringwald #ifdef ENABLE_LE_DATA_CHANNELS
153383fd9c76SMatthias Ringwald     uint16_t le_psm;
153463f0ac45SMatthias Ringwald     uint16_t new_credits;
153563f0ac45SMatthias Ringwald     uint16_t credits_before;
1536e7d0c9aaSMatthias Ringwald     l2cap_service_t * service;
153783fd9c76SMatthias Ringwald #endif
153800d93d79Smatthias.ringwald 
15391b8b8d05SMatthias Ringwald     uint8_t code   = command[L2CAP_SIGNALING_COMMAND_CODE_OFFSET];
154023017473SMatthias Ringwald     log_info("l2cap_le_signaling_handler_dispatch: command 0x%02x, sig id %u", code, sig_id);
15411b8b8d05SMatthias Ringwald 
15421b8b8d05SMatthias Ringwald     switch (code){
154300d93d79Smatthias.ringwald 
1544c48b2a2cSMatthias Ringwald         case CONNECTION_PARAMETER_UPDATE_RESPONSE:
1545c48b2a2cSMatthias Ringwald             result = little_endian_read_16(command, 4);
1546ccf076adS[email protected]             l2cap_emit_connection_parameter_update_response(handle, result);
1547ccf076adS[email protected]             break;
1548da886c03S[email protected] 
1549c48b2a2cSMatthias Ringwald         case CONNECTION_PARAMETER_UPDATE_REQUEST:
1550e7d0c9aaSMatthias Ringwald             connection = hci_connection_for_handle(handle);
1551da886c03S[email protected]             if (connection){
15526d91fb6cSMatthias Ringwald                 if (connection->role != HCI_ROLE_MASTER){
15536d91fb6cSMatthias Ringwald                     // reject command without notifying upper layer when not in master role
1554c48b2a2cSMatthias Ringwald                     return 0;
15556d91fb6cSMatthias Ringwald                 }
1556da886c03S[email protected]                 int update_parameter = 1;
1557a4c06b28SMatthias Ringwald                 le_connection_parameter_range_t existing_range;
15584ced4e8cSMatthias Ringwald                 gap_get_connection_parameter_range(&existing_range);
1559c48b2a2cSMatthias Ringwald                 uint16_t le_conn_interval_min = little_endian_read_16(command,8);
1560c48b2a2cSMatthias Ringwald                 uint16_t le_conn_interval_max = little_endian_read_16(command,10);
1561c48b2a2cSMatthias Ringwald                 uint16_t le_conn_latency = little_endian_read_16(command,12);
1562c48b2a2cSMatthias Ringwald                 uint16_t le_supervision_timeout = little_endian_read_16(command,14);
1563da886c03S[email protected] 
1564da886c03S[email protected]                 if (le_conn_interval_min < existing_range.le_conn_interval_min) update_parameter = 0;
1565da886c03S[email protected]                 if (le_conn_interval_max > existing_range.le_conn_interval_max) update_parameter = 0;
1566da886c03S[email protected] 
1567da886c03S[email protected]                 if (le_conn_latency < existing_range.le_conn_latency_min) update_parameter = 0;
1568da886c03S[email protected]                 if (le_conn_latency > existing_range.le_conn_latency_max) update_parameter = 0;
1569da886c03S[email protected] 
1570da886c03S[email protected]                 if (le_supervision_timeout < existing_range.le_supervision_timeout_min) update_parameter = 0;
1571da886c03S[email protected]                 if (le_supervision_timeout > existing_range.le_supervision_timeout_max) update_parameter = 0;
1572da886c03S[email protected] 
1573da886c03S[email protected]                 if (update_parameter){
1574da886c03S[email protected]                     connection->le_con_parameter_update_state = CON_PARAMETER_UPDATE_SEND_RESPONSE;
1575da886c03S[email protected]                     connection->le_conn_interval_min = le_conn_interval_min;
1576da886c03S[email protected]                     connection->le_conn_interval_max = le_conn_interval_max;
1577da886c03S[email protected]                     connection->le_conn_latency = le_conn_latency;
1578da886c03S[email protected]                     connection->le_supervision_timeout = le_supervision_timeout;
1579da886c03S[email protected]                 } else {
1580da886c03S[email protected]                     connection->le_con_parameter_update_state = CON_PARAMETER_UPDATE_DENY;
1581da886c03S[email protected]                 }
1582c48b2a2cSMatthias Ringwald                 connection->le_con_param_update_identifier = sig_id;
1583da886c03S[email protected]             }
1584da886c03S[email protected] 
158533c40538SMatthias Ringwald             if (!l2cap_event_packet_handler) break;
1586c48b2a2cSMatthias Ringwald 
1587c48b2a2cSMatthias Ringwald             event[0] = L2CAP_EVENT_CONNECTION_PARAMETER_UPDATE_REQUEST;
1588c48b2a2cSMatthias Ringwald             event[1] = 8;
1589c48b2a2cSMatthias Ringwald             memcpy(&event[2], &command[4], 8);
1590c48b2a2cSMatthias Ringwald             hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event));
159133c40538SMatthias Ringwald             (*l2cap_event_packet_handler)( HCI_EVENT_PACKET, 0, event, sizeof(event));
1592ccf076adS[email protected]             break;
1593c48b2a2cSMatthias Ringwald 
159463f0ac45SMatthias Ringwald         case COMMAND_REJECT:
159563f0ac45SMatthias Ringwald             // Find channel for this sig_id and connection handle
159663f0ac45SMatthias Ringwald             channel = NULL;
159763f0ac45SMatthias Ringwald             btstack_linked_list_iterator_init(&it, &l2cap_le_channels);
159863f0ac45SMatthias Ringwald             while (btstack_linked_list_iterator_has_next(&it)){
159963f0ac45SMatthias Ringwald                 l2cap_channel_t * a_channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it);
160063f0ac45SMatthias Ringwald                 if (a_channel->con_handle   != handle) continue;
160163f0ac45SMatthias Ringwald                 if (a_channel->local_sig_id != sig_id) continue;
160263f0ac45SMatthias Ringwald                 channel = a_channel;
160363f0ac45SMatthias Ringwald                 break;
160463f0ac45SMatthias Ringwald             }
160563f0ac45SMatthias Ringwald             if (!channel) break;
160663f0ac45SMatthias Ringwald 
160763f0ac45SMatthias Ringwald             // if received while waiting for le connection response, assume legacy device
160863f0ac45SMatthias Ringwald             if (channel->state == L2CAP_STATE_WAIT_LE_CONNECTION_RESPONSE){
160963f0ac45SMatthias Ringwald                 channel->state = L2CAP_STATE_CLOSED;
161063f0ac45SMatthias Ringwald                 // no official value for this, use: Connection refused – LE_PSM not supported - 0x0002
161144276248SMatthias Ringwald                 l2cap_emit_le_channel_opened(channel, 0x0002);
161263f0ac45SMatthias Ringwald 
161363f0ac45SMatthias Ringwald                 // discard channel
161463f0ac45SMatthias Ringwald                 btstack_linked_list_remove(&l2cap_le_channels, (btstack_linked_item_t *) channel);
161563f0ac45SMatthias Ringwald                 btstack_memory_l2cap_channel_free(channel);
161663f0ac45SMatthias Ringwald                 break;
161763f0ac45SMatthias Ringwald             }
161863f0ac45SMatthias Ringwald             break;
161963f0ac45SMatthias Ringwald 
1620cab29d48SMatthias Ringwald #ifdef ENABLE_LE_DATA_CHANNELS
1621e7d0c9aaSMatthias Ringwald         case LE_CREDIT_BASED_CONNECTION_REQUEST:
1622e7d0c9aaSMatthias Ringwald 
1623e7d0c9aaSMatthias Ringwald             // get hci connection, bail if not found (must not happen)
1624e7d0c9aaSMatthias Ringwald             connection = hci_connection_for_handle(handle);
1625e7d0c9aaSMatthias Ringwald             if (!connection) return 0;
1626e7d0c9aaSMatthias Ringwald 
1627e7d0c9aaSMatthias Ringwald             // check if service registered
1628e7d0c9aaSMatthias Ringwald             le_psm  = little_endian_read_16(command, 4);
1629e7d0c9aaSMatthias Ringwald             service = l2cap_le_get_service(le_psm);
1630e7d0c9aaSMatthias Ringwald 
1631e7d0c9aaSMatthias Ringwald             if (service){
1632e7d0c9aaSMatthias Ringwald 
1633e7d0c9aaSMatthias Ringwald                 uint16_t source_cid = little_endian_read_16(command, 6);
1634e7d0c9aaSMatthias Ringwald                 if (source_cid < 0x40){
1635e7d0c9aaSMatthias Ringwald                     // 0x0009 Connection refused - Invalid Source CID
1636e7d0c9aaSMatthias Ringwald                     l2cap_register_signaling_response(handle, LE_CREDIT_BASED_CONNECTION_REQUEST, sig_id, 0x0009);
1637e7d0c9aaSMatthias Ringwald                     return 1;
1638e7d0c9aaSMatthias Ringwald                 }
1639e7d0c9aaSMatthias Ringwald 
1640e7d0c9aaSMatthias Ringwald                 // go through list of channels for this ACL connection and check if we get a match
1641e7d0c9aaSMatthias Ringwald                 btstack_linked_list_iterator_init(&it, &l2cap_le_channels);
1642e7d0c9aaSMatthias Ringwald                 while (btstack_linked_list_iterator_has_next(&it)){
16431b8b8d05SMatthias Ringwald                     l2cap_channel_t * a_channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it);
16441b8b8d05SMatthias Ringwald                     if (a_channel->con_handle != handle) continue;
16451b8b8d05SMatthias Ringwald                     if (a_channel->remote_cid != source_cid) continue;
1646e7d0c9aaSMatthias Ringwald                     // 0x000a Connection refused - Source CID already allocated
1647e7d0c9aaSMatthias Ringwald                     l2cap_register_signaling_response(handle, LE_CREDIT_BASED_CONNECTION_REQUEST, sig_id, 0x000a);
1648e7d0c9aaSMatthias Ringwald                     return 1;
1649e7d0c9aaSMatthias Ringwald                 }
1650e7d0c9aaSMatthias Ringwald 
165183fd9c76SMatthias Ringwald                 // security: check encryption
165283fd9c76SMatthias Ringwald                 if (service->required_security_level >= LEVEL_2){
165383fd9c76SMatthias Ringwald                     if (sm_encryption_key_size(handle) == 0){
165483fd9c76SMatthias Ringwald                         // 0x0008 Connection refused - insufficient encryption
165583fd9c76SMatthias Ringwald                         l2cap_register_signaling_response(handle, LE_CREDIT_BASED_CONNECTION_REQUEST, sig_id, 0x0008);
165683fd9c76SMatthias Ringwald                         return 1;
165783fd9c76SMatthias Ringwald                     }
165883fd9c76SMatthias Ringwald                     // anything less than 16 byte key size is insufficient
165983fd9c76SMatthias Ringwald                     if (sm_encryption_key_size(handle) < 16){
166083fd9c76SMatthias Ringwald                         // 0x0007 Connection refused – insufficient encryption key size
166183fd9c76SMatthias Ringwald                         l2cap_register_signaling_response(handle, LE_CREDIT_BASED_CONNECTION_REQUEST, sig_id, 0x0007);
166283fd9c76SMatthias Ringwald                         return 1;
166383fd9c76SMatthias Ringwald                     }
166483fd9c76SMatthias Ringwald                 }
166583fd9c76SMatthias Ringwald 
166683fd9c76SMatthias Ringwald                 // security: check authencation
166783fd9c76SMatthias Ringwald                 if (service->required_security_level >= LEVEL_3){
166883fd9c76SMatthias Ringwald                     if (!sm_authenticated(handle)){
166983fd9c76SMatthias Ringwald                         // 0x0005 Connection refused – insufficient authentication
167083fd9c76SMatthias Ringwald                         l2cap_register_signaling_response(handle, LE_CREDIT_BASED_CONNECTION_REQUEST, sig_id, 0x0005);
167183fd9c76SMatthias Ringwald                         return 1;
167283fd9c76SMatthias Ringwald                     }
167383fd9c76SMatthias Ringwald                 }
167483fd9c76SMatthias Ringwald 
167583fd9c76SMatthias Ringwald                 // security: check authorization
167683fd9c76SMatthias Ringwald                 if (service->required_security_level >= LEVEL_4){
167783fd9c76SMatthias Ringwald                     if (sm_authorization_state(handle) != AUTHORIZATION_GRANTED){
167883fd9c76SMatthias Ringwald                         // 0x0006 Connection refused – insufficient authorization
167983fd9c76SMatthias Ringwald                         l2cap_register_signaling_response(handle, LE_CREDIT_BASED_CONNECTION_REQUEST, sig_id, 0x0006);
168083fd9c76SMatthias Ringwald                         return 1;
168183fd9c76SMatthias Ringwald                     }
168283fd9c76SMatthias Ringwald                 }
1683e7d0c9aaSMatthias Ringwald 
1684e7d0c9aaSMatthias Ringwald                 // allocate channel
16851b8b8d05SMatthias Ringwald                 channel = l2cap_create_channel_entry(service->packet_handler, connection->address,
1686e7d0c9aaSMatthias Ringwald                     BD_ADDR_TYPE_LE_RANDOM, le_psm, service->mtu, service->required_security_level);
1687e7d0c9aaSMatthias Ringwald                 if (!channel){
1688e7d0c9aaSMatthias Ringwald                     // 0x0004 Connection refused – no resources available
1689e7d0c9aaSMatthias Ringwald                     l2cap_register_signaling_response(handle, LE_CREDIT_BASED_CONNECTION_REQUEST, sig_id, 0x0004);
1690e7d0c9aaSMatthias Ringwald                     return 1;
1691e7d0c9aaSMatthias Ringwald                 }
1692e7d0c9aaSMatthias Ringwald 
1693e7d0c9aaSMatthias Ringwald                 channel->con_handle = handle;
1694e7d0c9aaSMatthias Ringwald                 channel->remote_cid = source_cid;
1695e7d0c9aaSMatthias Ringwald                 channel->remote_sig_id = sig_id;
16967f107edaSMatthias Ringwald                 channel->remote_mtu = little_endian_read_16(command, 8);
16977f107edaSMatthias Ringwald                 channel->remote_mps = little_endian_read_16(command, 10);
16987f107edaSMatthias Ringwald                 channel->credits_outgoing = little_endian_read_16(command, 12);
1699e7d0c9aaSMatthias Ringwald 
1700e7d0c9aaSMatthias Ringwald                 // set initial state
1701e7d0c9aaSMatthias Ringwald                 channel->state      = L2CAP_STATE_WAIT_CLIENT_ACCEPT_OR_REJECT;
1702*c99bb618SMatthias Ringwald                 channel->state_var |= L2CAP_CHANNEL_STATE_VAR_INCOMING;
1703e7d0c9aaSMatthias Ringwald 
1704e7d0c9aaSMatthias Ringwald                 // add to connections list
1705e7d0c9aaSMatthias Ringwald                 btstack_linked_list_add(&l2cap_le_channels, (btstack_linked_item_t *) channel);
1706e7d0c9aaSMatthias Ringwald 
1707e7d0c9aaSMatthias Ringwald                 // post connection request event
170844276248SMatthias Ringwald                 l2cap_emit_le_incoming_connection(channel);
1709e7d0c9aaSMatthias Ringwald 
1710e7d0c9aaSMatthias Ringwald             } else {
1711e7d0c9aaSMatthias Ringwald                 // Connection refused – LE_PSM not supported
1712e7d0c9aaSMatthias Ringwald                 l2cap_register_signaling_response(handle, LE_CREDIT_BASED_CONNECTION_REQUEST, sig_id, 0x0002);
1713e7d0c9aaSMatthias Ringwald             }
1714e7d0c9aaSMatthias Ringwald             break;
17151b8b8d05SMatthias Ringwald 
17161b8b8d05SMatthias Ringwald         case LE_CREDIT_BASED_CONNECTION_RESPONSE:
17171b8b8d05SMatthias Ringwald             // Find channel for this sig_id and connection handle
17181b8b8d05SMatthias Ringwald             channel = NULL;
17191b8b8d05SMatthias Ringwald             btstack_linked_list_iterator_init(&it, &l2cap_le_channels);
17201b8b8d05SMatthias Ringwald             while (btstack_linked_list_iterator_has_next(&it)){
17211b8b8d05SMatthias Ringwald                 l2cap_channel_t * a_channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it);
17221b8b8d05SMatthias Ringwald                 if (a_channel->con_handle   != handle) continue;
17231b8b8d05SMatthias Ringwald                 if (a_channel->local_sig_id != sig_id) continue;
17241b8b8d05SMatthias Ringwald                 channel = a_channel;
17251b8b8d05SMatthias Ringwald                 break;
17261b8b8d05SMatthias Ringwald             }
17271b8b8d05SMatthias Ringwald             if (!channel) break;
17281b8b8d05SMatthias Ringwald 
17291b8b8d05SMatthias Ringwald             // cid + 0
17301b8b8d05SMatthias Ringwald             result = little_endian_read_16 (command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET+8);
17311b8b8d05SMatthias Ringwald             if (result){
17321b8b8d05SMatthias Ringwald                 channel->state = L2CAP_STATE_CLOSED;
17331b8b8d05SMatthias Ringwald                 // map l2cap connection response result to BTstack status enumeration
173444276248SMatthias Ringwald                 l2cap_emit_le_channel_opened(channel, result);
17351b8b8d05SMatthias Ringwald 
17361b8b8d05SMatthias Ringwald                 // discard channel
173763f0ac45SMatthias Ringwald                 btstack_linked_list_remove(&l2cap_le_channels, (btstack_linked_item_t *) channel);
17381b8b8d05SMatthias Ringwald                 btstack_memory_l2cap_channel_free(channel);
17391b8b8d05SMatthias Ringwald                 break;
17401b8b8d05SMatthias Ringwald             }
17411b8b8d05SMatthias Ringwald 
17421b8b8d05SMatthias Ringwald             // success
17431b8b8d05SMatthias Ringwald             channel->remote_cid = little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET + 0);
17441b8b8d05SMatthias Ringwald             channel->remote_mtu = little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET + 2);
17451b8b8d05SMatthias Ringwald             channel->remote_mps = little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET + 4);
17461b8b8d05SMatthias Ringwald             channel->credits_outgoing = little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET + 6);
17471b8b8d05SMatthias Ringwald             channel->state = L2CAP_STATE_OPEN;
174844276248SMatthias Ringwald             l2cap_emit_le_channel_opened(channel, result);
17491b8b8d05SMatthias Ringwald             break;
17501b8b8d05SMatthias Ringwald 
175185aeef60SMatthias Ringwald         case LE_FLOW_CONTROL_CREDIT:
175285aeef60SMatthias Ringwald             // find channel
175385aeef60SMatthias Ringwald             local_cid = little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET + 0);
175485aeef60SMatthias Ringwald             channel = l2cap_le_get_channel_for_local_cid(local_cid);
175563f0ac45SMatthias Ringwald             if (!channel) {
175663f0ac45SMatthias Ringwald                 log_error("l2cap: no channel for cid 0x%02x", local_cid);
175763f0ac45SMatthias Ringwald                 break;
175863f0ac45SMatthias Ringwald             }
175963f0ac45SMatthias Ringwald             new_credits = little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET + 2);
176063f0ac45SMatthias Ringwald             credits_before = channel->credits_outgoing;
176163f0ac45SMatthias Ringwald             channel->credits_outgoing += new_credits;
176263f0ac45SMatthias Ringwald             // check for credit overrun
176363f0ac45SMatthias Ringwald             if (credits_before > channel->credits_outgoing){
176463f0ac45SMatthias Ringwald                 log_error("l2cap: new credits caused overrrun for cid 0x%02x, disconnecting", local_cid);
176563f0ac45SMatthias Ringwald                 channel->state = L2CAP_STATE_WILL_SEND_DISCONNECT_REQUEST;
176663f0ac45SMatthias Ringwald                 break;
176763f0ac45SMatthias Ringwald             }
176863f0ac45SMatthias Ringwald             log_info("l2cap: %u credits for 0x%02x, now %u", new_credits, local_cid, channel->credits_outgoing);
176985aeef60SMatthias Ringwald             break;
177083fd9c76SMatthias Ringwald #endif
177185aeef60SMatthias Ringwald 
1772828a7f7aSMatthias Ringwald         case DISCONNECTION_REQUEST:
1773828a7f7aSMatthias Ringwald             // find channel
1774828a7f7aSMatthias Ringwald             local_cid = little_endian_read_16(command, L2CAP_SIGNALING_COMMAND_DATA_OFFSET + 0);
1775828a7f7aSMatthias Ringwald             channel = l2cap_le_get_channel_for_local_cid(local_cid);
177663f34e00SMatthias Ringwald             if (!channel) {
177763f34e00SMatthias Ringwald                 log_error("l2cap: no channel for cid 0x%02x", local_cid);
177863f34e00SMatthias Ringwald                 break;
177963f34e00SMatthias Ringwald             }
1780828a7f7aSMatthias Ringwald             channel->remote_sig_id = sig_id;
1781828a7f7aSMatthias Ringwald             channel->state = L2CAP_STATE_WILL_SEND_DISCONNECT_RESPONSE;
1782828a7f7aSMatthias Ringwald             break;
1783828a7f7aSMatthias Ringwald 
178463f0ac45SMatthias Ringwald         case DISCONNECTION_RESPONSE:
178563f0ac45SMatthias Ringwald             break;
178663f0ac45SMatthias Ringwald 
1787c48b2a2cSMatthias Ringwald         default:
1788c48b2a2cSMatthias Ringwald             // command unknown -> reject command
1789c48b2a2cSMatthias Ringwald             return 0;
1790ccf076adS[email protected]     }
1791c48b2a2cSMatthias Ringwald     return 1;
1792c48b2a2cSMatthias Ringwald }
1793e7d0c9aaSMatthias Ringwald #endif
1794c48b2a2cSMatthias Ringwald 
1795c48b2a2cSMatthias Ringwald static void l2cap_acl_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size ){
1796c48b2a2cSMatthias Ringwald 
1797c48b2a2cSMatthias Ringwald     // Get Channel ID
1798c48b2a2cSMatthias Ringwald     uint16_t channel_id = READ_L2CAP_CHANNEL_ID(packet);
1799c48b2a2cSMatthias Ringwald     hci_con_handle_t handle = READ_ACL_CONNECTION_HANDLE(packet);
1800c48b2a2cSMatthias Ringwald 
1801c48b2a2cSMatthias Ringwald     switch (channel_id) {
1802c48b2a2cSMatthias Ringwald 
1803c48b2a2cSMatthias Ringwald         case L2CAP_CID_SIGNALING: {
1804c48b2a2cSMatthias Ringwald             uint16_t command_offset = 8;
1805c48b2a2cSMatthias Ringwald             while (command_offset < size) {
1806c48b2a2cSMatthias Ringwald                 // handle signaling commands
1807c48b2a2cSMatthias Ringwald                 l2cap_signaling_handler_dispatch(handle, &packet[command_offset]);
1808c48b2a2cSMatthias Ringwald 
1809c48b2a2cSMatthias Ringwald                 // increment command_offset
1810c48b2a2cSMatthias Ringwald                 command_offset += L2CAP_SIGNALING_COMMAND_DATA_OFFSET + little_endian_read_16(packet, command_offset + L2CAP_SIGNALING_COMMAND_LENGTH_OFFSET);
1811c48b2a2cSMatthias Ringwald             }
1812c48b2a2cSMatthias Ringwald             break;
1813c48b2a2cSMatthias Ringwald         }
1814c48b2a2cSMatthias Ringwald 
1815e7d0c9aaSMatthias Ringwald #ifdef ENABLE_BLE
1816e7d0c9aaSMatthias Ringwald         case L2CAP_CID_SIGNALING_LE: {
1817e7d0c9aaSMatthias Ringwald             uint16_t sig_id = packet[COMPLETE_L2CAP_HEADER + 1];
1818e7d0c9aaSMatthias Ringwald             int      valid  = l2cap_le_signaling_handler_dispatch(handle, &packet[COMPLETE_L2CAP_HEADER], sig_id);
1819c48b2a2cSMatthias Ringwald             if (!valid){
18201bbc0b23S[email protected]                 l2cap_register_signaling_response(handle, COMMAND_REJECT_LE, sig_id, L2CAP_REJ_CMD_UNKNOWN);
1821ccf076adS[email protected]             }
1822ccf076adS[email protected]             break;
1823e7d0c9aaSMatthias Ringwald         }
1824e7d0c9aaSMatthias Ringwald #endif
1825c48b2a2cSMatthias Ringwald 
1826c48b2a2cSMatthias Ringwald         case L2CAP_CID_ATTRIBUTE_PROTOCOL:
1827c48b2a2cSMatthias Ringwald             if (fixed_channels[L2CAP_FIXED_CHANNEL_TABLE_INDEX_ATTRIBUTE_PROTOCOL].callback) {
1828c48b2a2cSMatthias Ringwald                 (*fixed_channels[L2CAP_FIXED_CHANNEL_TABLE_INDEX_ATTRIBUTE_PROTOCOL].callback)(ATT_DATA_PACKET, handle, &packet[COMPLETE_L2CAP_HEADER], size-COMPLETE_L2CAP_HEADER);
1829ccf076adS[email protected]             }
1830c48b2a2cSMatthias Ringwald             break;
1831c48b2a2cSMatthias Ringwald 
1832c48b2a2cSMatthias Ringwald         case L2CAP_CID_SECURITY_MANAGER_PROTOCOL:
1833c48b2a2cSMatthias Ringwald             if (fixed_channels[L2CAP_FIXED_CHANNEL_TABLE_INDEX_SECURITY_MANAGER_PROTOCOL].callback) {
1834c48b2a2cSMatthias Ringwald                 (*fixed_channels[L2CAP_FIXED_CHANNEL_TABLE_INDEX_SECURITY_MANAGER_PROTOCOL].callback)(SM_DATA_PACKET, handle, &packet[COMPLETE_L2CAP_HEADER], size-COMPLETE_L2CAP_HEADER);
1835c48b2a2cSMatthias Ringwald             }
1836c48b2a2cSMatthias Ringwald             break;
1837c48b2a2cSMatthias Ringwald 
1838c48b2a2cSMatthias Ringwald         case L2CAP_CID_CONNECTIONLESS_CHANNEL:
1839c48b2a2cSMatthias Ringwald             if (fixed_channels[L2CAP_FIXED_CHANNEL_TABLE_INDEX_CONNECTIONLESS_CHANNEL].callback) {
1840c48b2a2cSMatthias Ringwald                 (*fixed_channels[L2CAP_FIXED_CHANNEL_TABLE_INDEX_CONNECTIONLESS_CHANNEL].callback)(UCD_DATA_PACKET, handle, &packet[COMPLETE_L2CAP_HEADER], size-COMPLETE_L2CAP_HEADER);
1841c48b2a2cSMatthias Ringwald             }
1842c48b2a2cSMatthias Ringwald             break;
18431bbc0b23S[email protected] 
18445652b5ffS[email protected]         default: {
184500d93d79Smatthias.ringwald             // Find channel for this channel_id and connection handle
184664e11ca9SMatthias Ringwald             l2cap_channel_t * l2cap_channel;
184764e11ca9SMatthias Ringwald             l2cap_channel = l2cap_get_channel_for_local_cid(channel_id);
1848d1fd2a88SMatthias Ringwald             if (l2cap_channel) {
18493d50b4baSMatthias Ringwald                 l2cap_dispatch_to_channel(l2cap_channel, L2CAP_DATA_PACKET, &packet[COMPLETE_L2CAP_HEADER], size-COMPLETE_L2CAP_HEADER);
185000d93d79Smatthias.ringwald             }
185164e11ca9SMatthias Ringwald #ifdef ENABLE_BLE
185264e11ca9SMatthias Ringwald             l2cap_channel = l2cap_le_get_channel_for_local_cid(channel_id);
185364e11ca9SMatthias Ringwald             if (l2cap_channel) {
185485aeef60SMatthias Ringwald                 // credit counting
185585aeef60SMatthias Ringwald                 if (l2cap_channel->credits_incoming == 0){
185685aeef60SMatthias Ringwald                     log_error("LE Data Channel packet received but no incoming credits");
185785aeef60SMatthias Ringwald                     l2cap_channel->state = L2CAP_STATE_WILL_SEND_DISCONNECT_REQUEST;
185885aeef60SMatthias Ringwald                     break;
185985aeef60SMatthias Ringwald                 }
186085aeef60SMatthias Ringwald                 l2cap_channel->credits_incoming--;
186185aeef60SMatthias Ringwald 
186285aeef60SMatthias Ringwald                 // automatic credits
186385aeef60SMatthias Ringwald                 if (l2cap_channel->credits_incoming < L2CAP_LE_DATA_CHANNELS_AUTOMATIC_CREDITS_WATERMARK && l2cap_channel->automatic_credits){
186485aeef60SMatthias Ringwald                     l2cap_channel->new_credits_incoming = L2CAP_LE_DATA_CHANNELS_AUTOMATIC_CREDITS_INCREMENT;
186585aeef60SMatthias Ringwald                 }
186685aeef60SMatthias Ringwald 
1867cd529728SMatthias Ringwald                 // first fragment
1868cd529728SMatthias Ringwald                 uint16_t pos = 0;
1869cd529728SMatthias Ringwald                 if (!l2cap_channel->receive_sdu_len){
1870cd529728SMatthias Ringwald                     l2cap_channel->receive_sdu_len = little_endian_read_16(packet, COMPLETE_L2CAP_HEADER);
1871cd529728SMatthias Ringwald                     l2cap_channel->receive_sdu_pos = 0;
1872cd529728SMatthias Ringwald                     pos  += 2;
1873cd529728SMatthias Ringwald                     size -= 2;
1874cd529728SMatthias Ringwald                 }
1875cd529728SMatthias Ringwald                 memcpy(&l2cap_channel->receive_sdu_buffer[l2cap_channel->receive_sdu_pos], &packet[COMPLETE_L2CAP_HEADER+pos], size-COMPLETE_L2CAP_HEADER);
1876cd529728SMatthias Ringwald                 l2cap_channel->receive_sdu_pos += size - COMPLETE_L2CAP_HEADER;
1877cd529728SMatthias Ringwald                 // done?
187863f0ac45SMatthias Ringwald                 log_info("le packet pos %u, len %u", l2cap_channel->receive_sdu_pos, l2cap_channel->receive_sdu_len);
1879cd529728SMatthias Ringwald                 if (l2cap_channel->receive_sdu_pos >= l2cap_channel->receive_sdu_len){
1880cd529728SMatthias Ringwald                     l2cap_dispatch_to_channel(l2cap_channel, L2CAP_DATA_PACKET, l2cap_channel->receive_sdu_buffer, l2cap_channel->receive_sdu_len);
1881cd529728SMatthias Ringwald                     l2cap_channel->receive_sdu_len = 0;
1882cd529728SMatthias Ringwald                 }
188363f0ac45SMatthias Ringwald             } else {
188463f0ac45SMatthias Ringwald                 log_error("LE Data Channel packet received but no channel found for cid 0x%02x", channel_id);
188564e11ca9SMatthias Ringwald             }
188664e11ca9SMatthias Ringwald #endif
18875652b5ffS[email protected]             break;
18885652b5ffS[email protected]         }
18895652b5ffS[email protected]     }
189000d93d79Smatthias.ringwald 
18911eb2563eS[email protected]     l2cap_run();
18922718e2e7Smatthias.ringwald }
189300d93d79Smatthias.ringwald 
189415ec09bbSmatthias.ringwald // finalize closed channel - l2cap_handle_disconnect_request & DISCONNECTION_RESPONSE
189527a923d0Smatthias.ringwald void l2cap_finialize_channel_close(l2cap_channel_t * channel){
1896f62db1e3Smatthias.ringwald     channel->state = L2CAP_STATE_CLOSED;
1897f62db1e3Smatthias.ringwald     l2cap_emit_channel_closed(channel);
1898f62db1e3Smatthias.ringwald     // discard channel
18999dcb2fb2S[email protected]     l2cap_stop_rtx(channel);
1900665d90f2SMatthias Ringwald     btstack_linked_list_remove(&l2cap_channels, (btstack_linked_item_t *) channel);
1901d3a9df87Smatthias.ringwald     btstack_memory_l2cap_channel_free(channel);
1902c8e4258aSmatthias.ringwald }
19031e6aba47Smatthias.ringwald 
19048f2a52f4SMatthias Ringwald static l2cap_service_t * l2cap_get_service_internal(btstack_linked_list_t * services, uint16_t psm){
1905665d90f2SMatthias Ringwald     btstack_linked_list_iterator_t it;
1906665d90f2SMatthias Ringwald     btstack_linked_list_iterator_init(&it, services);
1907665d90f2SMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
1908665d90f2SMatthias Ringwald         l2cap_service_t * service = (l2cap_service_t *) btstack_linked_list_iterator_next(&it);
19099d9bbc01Smatthias.ringwald         if ( service->psm == psm){
19109d9bbc01Smatthias.ringwald             return service;
19119d9bbc01Smatthias.ringwald         };
19129d9bbc01Smatthias.ringwald     }
19139d9bbc01Smatthias.ringwald     return NULL;
19149d9bbc01Smatthias.ringwald }
19159d9bbc01Smatthias.ringwald 
19167192e786SMatthias Ringwald static inline l2cap_service_t * l2cap_get_service(uint16_t psm){
19177192e786SMatthias Ringwald     return l2cap_get_service_internal(&l2cap_services, psm);
19187192e786SMatthias Ringwald }
19197192e786SMatthias Ringwald 
1920e0abb8e7S[email protected] 
1921be2053a6SMatthias 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){
1922be2053a6SMatthias Ringwald 
1923be2053a6SMatthias Ringwald     log_info("L2CAP_REGISTER_SERVICE psm 0x%x mtu %u", psm, mtu);
1924e0abb8e7S[email protected] 
19254bb582b6Smatthias.ringwald     // check for alread registered psm
19269d9bbc01Smatthias.ringwald     l2cap_service_t *service = l2cap_get_service(psm);
1927277abc2cSmatthias.ringwald     if (service) {
1928be2053a6SMatthias Ringwald         log_error("l2cap_register_service: PSM %u already registered", psm);
1929be2053a6SMatthias Ringwald         return L2CAP_SERVICE_ALREADY_REGISTERED;
1930277abc2cSmatthias.ringwald     }
19319d9bbc01Smatthias.ringwald 
19324bb582b6Smatthias.ringwald     // alloc structure
1933bb69aaaeS[email protected]     service = btstack_memory_l2cap_service_get();
1934277abc2cSmatthias.ringwald     if (!service) {
1935be2053a6SMatthias Ringwald         log_error("l2cap_register_service: no memory for l2cap_service_t");
1936be2053a6SMatthias Ringwald         return BTSTACK_MEMORY_ALLOC_FAILED;
1937277abc2cSmatthias.ringwald     }
19389d9bbc01Smatthias.ringwald 
19399d9bbc01Smatthias.ringwald     // fill in
19409d9bbc01Smatthias.ringwald     service->psm = psm;
19419d9bbc01Smatthias.ringwald     service->mtu = mtu;
194205ae8de3SMatthias Ringwald     service->packet_handler = service_packet_handler;
1943df3354fcS[email protected]     service->required_security_level = security_level;
19449d9bbc01Smatthias.ringwald 
19459d9bbc01Smatthias.ringwald     // add to services list
1946665d90f2SMatthias Ringwald     btstack_linked_list_add(&l2cap_services, (btstack_linked_item_t *) service);
1947c0e866bfSmatthias.ringwald 
1948c0e866bfSmatthias.ringwald     // enable page scan
194915a95bd5SMatthias Ringwald     gap_connectable_control(1);
19505842b6d9Smatthias.ringwald 
1951be2053a6SMatthias Ringwald     return 0;
19529d9bbc01Smatthias.ringwald }
19539d9bbc01Smatthias.ringwald 
19547e8856ebSMatthias Ringwald uint8_t l2cap_unregister_service(uint16_t psm){
1955e0abb8e7S[email protected] 
1956e0abb8e7S[email protected]     log_info("L2CAP_UNREGISTER_SERVICE psm 0x%x", psm);
1957e0abb8e7S[email protected] 
19589d9bbc01Smatthias.ringwald     l2cap_service_t *service = l2cap_get_service(psm);
19597e8856ebSMatthias Ringwald     if (!service) return L2CAP_SERVICE_DOES_NOT_EXIST;
1960665d90f2SMatthias Ringwald     btstack_linked_list_remove(&l2cap_services, (btstack_linked_item_t *) service);
1961d3a9df87Smatthias.ringwald     btstack_memory_l2cap_service_free(service);
1962c0e866bfSmatthias.ringwald 
1963c0e866bfSmatthias.ringwald     // disable page scan when no services registered
19647e8856ebSMatthias Ringwald     if (btstack_linked_list_empty(&l2cap_services)) {
196515a95bd5SMatthias Ringwald         gap_connectable_control(0);
19669d9bbc01Smatthias.ringwald     }
19677e8856ebSMatthias Ringwald     return 0;
19687e8856ebSMatthias Ringwald }
19699d9bbc01Smatthias.ringwald 
19705652b5ffS[email protected] // Bluetooth 4.0 - allows to register handler for Attribute Protocol and Security Manager Protocol
197105ae8de3SMatthias Ringwald void l2cap_register_fixed_channel(btstack_packet_handler_t the_packet_handler, uint16_t channel_id) {
19725628cf69SMatthias Ringwald     int index = l2cap_fixed_channel_table_index_for_channel_id(channel_id);
19735628cf69SMatthias Ringwald     if (index < 0) return;
19745628cf69SMatthias Ringwald     fixed_channels[index].callback = the_packet_handler;
19755652b5ffS[email protected] }
19765652b5ffS[email protected] 
1977a9a4c409SMatthias Ringwald #ifdef ENABLE_BLE
19787192e786SMatthias Ringwald 
1979cab29d48SMatthias Ringwald #ifdef ENABLE_LE_DATA_CHANNELS
198083fd9c76SMatthias Ringwald 
198157be49d6SMatthias Ringwald static void l2cap_le_notify_channel_can_send(l2cap_channel_t *channel){
198257be49d6SMatthias Ringwald     if (!channel->waiting_for_can_send_now) return;
198357be49d6SMatthias Ringwald     if (channel->send_sdu_buffer) return;
198457be49d6SMatthias Ringwald     channel->waiting_for_can_send_now = 0;
198557be49d6SMatthias Ringwald     log_info("L2CAP_EVENT_CHANNEL_LE_CAN_SEND_NOW local_cid 0x%x", channel->local_cid);
198657be49d6SMatthias Ringwald     l2cap_emit_simple_event_with_cid(channel, L2CAP_EVENT_LE_CAN_SEND_NOW);
198757be49d6SMatthias Ringwald }
198857be49d6SMatthias Ringwald 
198957be49d6SMatthias Ringwald // 1BH2222
199057be49d6SMatthias Ringwald static void l2cap_emit_le_incoming_connection(l2cap_channel_t *channel) {
199157be49d6SMatthias 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",
199257be49d6SMatthias Ringwald              channel->address_type, bd_addr_to_str(channel->address), channel->con_handle,  channel->psm, channel->local_cid, channel->remote_cid, channel->remote_mtu);
199357be49d6SMatthias Ringwald     uint8_t event[19];
199457be49d6SMatthias Ringwald     event[0] = L2CAP_EVENT_LE_INCOMING_CONNECTION;
199557be49d6SMatthias Ringwald     event[1] = sizeof(event) - 2;
199657be49d6SMatthias Ringwald     event[2] = channel->address_type;
199757be49d6SMatthias Ringwald     reverse_bd_addr(channel->address, &event[3]);
199857be49d6SMatthias Ringwald     little_endian_store_16(event,  9, channel->con_handle);
199957be49d6SMatthias Ringwald     little_endian_store_16(event, 11, channel->psm);
200057be49d6SMatthias Ringwald     little_endian_store_16(event, 13, channel->local_cid);
200157be49d6SMatthias Ringwald     little_endian_store_16(event, 15, channel->remote_cid);
200257be49d6SMatthias Ringwald     little_endian_store_16(event, 17, channel->remote_mtu);
200357be49d6SMatthias Ringwald     hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event));
200457be49d6SMatthias Ringwald     l2cap_dispatch_to_channel(channel, HCI_EVENT_PACKET, event, sizeof(event));
200557be49d6SMatthias Ringwald }
200657be49d6SMatthias Ringwald // 11BH22222
200757be49d6SMatthias Ringwald static void l2cap_emit_le_channel_opened(l2cap_channel_t *channel, uint8_t status) {
200857be49d6SMatthias 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",
200957be49d6SMatthias Ringwald              status, channel->address_type, bd_addr_to_str(channel->address), channel->con_handle, channel->psm,
201057be49d6SMatthias Ringwald              channel->local_cid, channel->remote_cid, channel->local_mtu, channel->remote_mtu);
2011*c99bb618SMatthias Ringwald     uint8_t event[23];
201257be49d6SMatthias Ringwald     event[0] = L2CAP_EVENT_LE_CHANNEL_OPENED;
201357be49d6SMatthias Ringwald     event[1] = sizeof(event) - 2;
201457be49d6SMatthias Ringwald     event[2] = status;
201557be49d6SMatthias Ringwald     event[3] = channel->address_type;
201657be49d6SMatthias Ringwald     reverse_bd_addr(channel->address, &event[4]);
201757be49d6SMatthias Ringwald     little_endian_store_16(event, 10, channel->con_handle);
2018*c99bb618SMatthias Ringwald     event[12] = channel->state_var & L2CAP_CHANNEL_STATE_VAR_INCOMING ? 1 : 0;
2019*c99bb618SMatthias Ringwald     little_endian_store_16(event, 13, channel->psm);
2020*c99bb618SMatthias Ringwald     little_endian_store_16(event, 15, channel->local_cid);
2021*c99bb618SMatthias Ringwald     little_endian_store_16(event, 17, channel->remote_cid);
2022*c99bb618SMatthias Ringwald     little_endian_store_16(event, 19, channel->local_mtu);
2023*c99bb618SMatthias Ringwald     little_endian_store_16(event, 21, channel->remote_mtu);
202457be49d6SMatthias Ringwald     hci_dump_packet( HCI_EVENT_PACKET, 0, event, sizeof(event));
202557be49d6SMatthias Ringwald     l2cap_dispatch_to_channel(channel, HCI_EVENT_PACKET, event, sizeof(event));
202657be49d6SMatthias Ringwald }
202757be49d6SMatthias Ringwald 
202857be49d6SMatthias Ringwald static l2cap_channel_t * l2cap_le_get_channel_for_local_cid(uint16_t local_cid){
202957be49d6SMatthias Ringwald     btstack_linked_list_iterator_t it;
203057be49d6SMatthias Ringwald     btstack_linked_list_iterator_init(&it, &l2cap_le_channels);
203157be49d6SMatthias Ringwald     while (btstack_linked_list_iterator_has_next(&it)){
203257be49d6SMatthias Ringwald         l2cap_channel_t * channel = (l2cap_channel_t *) btstack_linked_list_iterator_next(&it);
203357be49d6SMatthias Ringwald         if ( channel->local_cid == local_cid) {
203457be49d6SMatthias Ringwald             return channel;
203557be49d6SMatthias Ringwald         }
203657be49d6SMatthias Ringwald     }
203757be49d6SMatthias Ringwald     return NULL;
203857be49d6SMatthias Ringwald }
203957be49d6SMatthias Ringwald 
204057be49d6SMatthias Ringwald // finalize closed channel - l2cap_handle_disconnect_request & DISCONNECTION_RESPONSE
204157be49d6SMatthias Ringwald void l2cap_le_finialize_channel_close(l2cap_channel_t * channel){
204257be49d6SMatthias Ringwald     channel->state = L2CAP_STATE_CLOSED;
204357be49d6SMatthias Ringwald     l2cap_emit_simple_event_with_cid(channel, L2CAP_EVENT_CHANNEL_CLOSED);
204457be49d6SMatthias Ringwald     // discard channel
204557be49d6SMatthias Ringwald     btstack_linked_list_remove(&l2cap_le_channels, (btstack_linked_item_t *) channel);
204657be49d6SMatthias Ringwald     btstack_memory_l2cap_channel_free(channel);
204757be49d6SMatthias Ringwald }
204857be49d6SMatthias Ringwald 
2049e7d0c9aaSMatthias Ringwald static inline l2cap_service_t * l2cap_le_get_service(uint16_t le_psm){
2050e7d0c9aaSMatthias Ringwald     return l2cap_get_service_internal(&l2cap_le_services, le_psm);
20517192e786SMatthias Ringwald }
2052efedfb4cSMatthias Ringwald 
2053da144af5SMatthias Ringwald uint8_t l2cap_le_register_service(btstack_packet_handler_t packet_handler, uint16_t psm, gap_security_level_t security_level){
20547192e786SMatthias Ringwald 
2055da144af5SMatthias Ringwald     log_info("L2CAP_LE_REGISTER_SERVICE psm 0x%x", psm);
20567192e786SMatthias Ringwald 
20577192e786SMatthias Ringwald     // check for alread registered psm
20587192e786SMatthias Ringwald     l2cap_service_t *service = l2cap_le_get_service(psm);
20597192e786SMatthias Ringwald     if (service) {
2060da144af5SMatthias Ringwald         return L2CAP_SERVICE_ALREADY_REGISTERED;
20617192e786SMatthias Ringwald     }
20627192e786SMatthias Ringwald 
20637192e786SMatthias Ringwald     // alloc structure
20647192e786SMatthias Ringwald     service = btstack_memory_l2cap_service_get();
20657192e786SMatthias Ringwald     if (!service) {
20667192e786SMatthias Ringwald         log_error("l2cap_register_service_internal: no memory for l2cap_service_t");
2067da144af5SMatthias Ringwald         return BTSTACK_MEMORY_ALLOC_FAILED;
20687192e786SMatthias Ringwald     }
20697192e786SMatthias Ringwald 
20707192e786SMatthias Ringwald     // fill in
20717192e786SMatthias Ringwald     service->psm = psm;
2072da144af5SMatthias Ringwald     service->mtu = 0;
20737192e786SMatthias Ringwald     service->packet_handler = packet_handler;
20747192e786SMatthias Ringwald     service->required_security_level = security_level;
20757192e786SMatthias Ringwald 
20767192e786SMatthias Ringwald     // add to services list
2077665d90f2SMatthias Ringwald     btstack_linked_list_add(&l2cap_le_services, (btstack_linked_item_t *) service);
20787192e786SMatthias Ringwald 
20797192e786SMatthias Ringwald     // done
2080da144af5SMatthias Ringwald     return 0;
20817192e786SMatthias Ringwald }
20827192e786SMatthias Ringwald 
2083da144af5SMatthias Ringwald uint8_t l2cap_le_unregister_service(uint16_t psm) {
20847192e786SMatthias Ringwald     log_info("L2CAP_LE_UNREGISTER_SERVICE psm 0x%x", psm);
20857192e786SMatthias Ringwald     l2cap_service_t *service = l2cap_le_get_service(psm);
20869367f9b0SMatthias Ringwald     if (!service) return L2CAP_SERVICE_DOES_NOT_EXIST;
2087da144af5SMatthias Ringwald 
2088665d90f2SMatthias Ringwald     btstack_linked_list_remove(&l2cap_le_services, (btstack_linked_item_t *) service);
20897192e786SMatthias Ringwald     btstack_memory_l2cap_service_free(service);
2090da144af5SMatthias Ringwald     return 0;
20917192e786SMatthias Ringwald }
2092da144af5SMatthias Ringwald 
2093da144af5SMatthias Ringwald uint8_t l2cap_le_accept_connection(uint16_t local_cid, uint8_t * receive_sdu_buffer, uint16_t mtu, uint16_t initial_credits){
2094e7d0c9aaSMatthias Ringwald     // get channel
2095e7d0c9aaSMatthias Ringwald     l2cap_channel_t * channel = l2cap_le_get_channel_for_local_cid(local_cid);
2096e7d0c9aaSMatthias Ringwald     if (!channel) return L2CAP_LOCAL_CID_DOES_NOT_EXIST;
2097e7d0c9aaSMatthias Ringwald 
2098e7d0c9aaSMatthias Ringwald     // validate state
2099e7d0c9aaSMatthias Ringwald     if (channel->state != L2CAP_STATE_WAIT_CLIENT_ACCEPT_OR_REJECT){
2100e7d0c9aaSMatthias Ringwald         return ERROR_CODE_COMMAND_DISALLOWED;
2101e7d0c9aaSMatthias Ringwald     }
2102e7d0c9aaSMatthias Ringwald 
2103efedfb4cSMatthias Ringwald     // set state accept connection
210423017473SMatthias Ringwald     channel->state = L2CAP_STATE_WILL_SEND_LE_CONNECTION_RESPONSE_ACCEPT;
210523017473SMatthias Ringwald     channel->receive_sdu_buffer = receive_sdu_buffer;
210623017473SMatthias Ringwald     channel->local_mtu = mtu;
210785aeef60SMatthias Ringwald     channel->new_credits_incoming = initial_credits;
210885aeef60SMatthias Ringwald     channel->automatic_credits  = initial_credits == L2CAP_LE_AUTOMATIC_CREDITS;
210985aeef60SMatthias Ringwald 
211085aeef60SMatthias Ringwald     // test
211163f0ac45SMatthias Ringwald     // channel->new_credits_incoming = 1;
2112e7d0c9aaSMatthias Ringwald 
2113e7d0c9aaSMatthias Ringwald     // go
2114e7d0c9aaSMatthias Ringwald     l2cap_run();
2115da144af5SMatthias Ringwald     return 0;
2116da144af5SMatthias Ringwald }
2117da144af5SMatthias Ringwald 
2118da144af5SMatthias Ringwald /**
2119da144af5SMatthias Ringwald  * @brief Deny incoming LE Data Channel connection due to resource constraints
2120da144af5SMatthias Ringwald  * @param local_cid             L2CAP LE Data Channel Identifier
2121da144af5SMatthias Ringwald  */
2122da144af5SMatthias Ringwald 
2123da144af5SMatthias Ringwald uint8_t l2cap_le_decline_connection(uint16_t local_cid){
2124e7d0c9aaSMatthias Ringwald     // get channel
2125e7d0c9aaSMatthias Ringwald     l2cap_channel_t * channel = l2cap_le_get_channel_for_local_cid(local_cid);
2126e7d0c9aaSMatthias Ringwald     if (!channel) return L2CAP_LOCAL_CID_DOES_NOT_EXIST;
2127e7d0c9aaSMatthias Ringwald 
2128e7d0c9aaSMatthias Ringwald     // validate state
2129e7d0c9aaSMatthias Ringwald     if (channel->state != L2CAP_STATE_WAIT_CLIENT_ACCEPT_OR_REJECT){
2130e7d0c9aaSMatthias Ringwald         return ERROR_CODE_COMMAND_DISALLOWED;
2131e7d0c9aaSMatthias Ringwald     }
2132e7d0c9aaSMatthias Ringwald 
2133efedfb4cSMatthias Ringwald     // set state decline connection
2134e7d0c9aaSMatthias Ringwald     channel->state  = L2CAP_STATE_WILL_SEND_LE_CONNECTION_RESPONSE_DECLINE;
2135e7d0c9aaSMatthias Ringwald     channel->reason = 0x04; // no resources available
2136e7d0c9aaSMatthias Ringwald     l2cap_run();
2137da144af5SMatthias Ringwald     return 0;
2138da144af5SMatthias Ringwald }
2139da144af5SMatthias Ringwald 
21407dafa750SMatthias Ringwald uint8_t l2cap_le_create_channel(btstack_packet_handler_t packet_handler, hci_con_handle_t con_handle,
2141da144af5SMatthias Ringwald     uint16_t psm, uint8_t * receive_sdu_buffer, uint16_t mtu, uint16_t initial_credits, gap_security_level_t security_level,
2142efedfb4cSMatthias Ringwald     uint16_t * out_local_cid) {
2143efedfb4cSMatthias Ringwald 
21447dafa750SMatthias Ringwald     log_info("L2CAP_LE_CREATE_CHANNEL handle 0x%04x psm 0x%x mtu %u", con_handle, psm, mtu);
2145da144af5SMatthias Ringwald 
21467dafa750SMatthias Ringwald 
21477dafa750SMatthias Ringwald     hci_connection_t * connection = hci_connection_for_handle(con_handle);
21487dafa750SMatthias Ringwald     if (!connection) {
21497dafa750SMatthias Ringwald         log_error("no hci_connection for handle 0x%04x", con_handle);
21507dafa750SMatthias Ringwald         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
21517dafa750SMatthias Ringwald     }
21527dafa750SMatthias Ringwald 
21537dafa750SMatthias Ringwald     l2cap_channel_t * channel = l2cap_create_channel_entry(packet_handler, connection->address, connection->address_type, psm, mtu, security_level);
2154da144af5SMatthias Ringwald     if (!channel) {
2155da144af5SMatthias Ringwald         return BTSTACK_MEMORY_ALLOC_FAILED;
2156da144af5SMatthias Ringwald     }
2157e7d0c9aaSMatthias Ringwald     log_info("l2cap_le_create_channel %p", channel);
2158da144af5SMatthias Ringwald 
2159da144af5SMatthias Ringwald     // store local_cid
2160da144af5SMatthias Ringwald     if (out_local_cid){
2161da144af5SMatthias Ringwald        *out_local_cid = channel->local_cid;
2162da144af5SMatthias Ringwald     }
2163da144af5SMatthias Ringwald 
21647dafa750SMatthias Ringwald     // provide buffer
21657dafa750SMatthias Ringwald     channel->con_handle = con_handle;
2166cd529728SMatthias Ringwald     channel->receive_sdu_buffer = receive_sdu_buffer;
21677dafa750SMatthias Ringwald     channel->state = L2CAP_STATE_WILL_SEND_LE_CONNECTION_REQUEST;
216885aeef60SMatthias Ringwald     channel->new_credits_incoming = initial_credits;
216985aeef60SMatthias Ringwald     channel->automatic_credits    = initial_credits == L2CAP_LE_AUTOMATIC_CREDITS;
217085aeef60SMatthias Ringwald 
2171efedfb4cSMatthias Ringwald     // add to connections list
2172efedfb4cSMatthias Ringwald     btstack_linked_list_add(&l2cap_le_channels, (btstack_linked_item_t *) channel);
2173efedfb4cSMatthias Ringwald 
21747dafa750SMatthias Ringwald     // go
217563f0ac45SMatthias Ringwald     l2cap_run();
2176da144af5SMatthias Ringwald     return 0;
2177da144af5SMatthias Ringwald }
2178da144af5SMatthias Ringwald 
2179da144af5SMatthias Ringwald /**
2180da144af5SMatthias Ringwald  * @brief Provide credtis for LE Data Channel
2181da144af5SMatthias Ringwald  * @param local_cid             L2CAP LE Data Channel Identifier
2182da144af5SMatthias Ringwald  * @param credits               Number additional credits for peer
2183da144af5SMatthias Ringwald  */
218464e11ca9SMatthias Ringwald uint8_t l2cap_le_provide_credits(uint16_t local_cid, uint16_t credits){
218563f0ac45SMatthias Ringwald 
218663f0ac45SMatthias Ringwald     l2cap_channel_t * channel = l2cap_le_get_channel_for_local_cid(local_cid);
218763f0ac45SMatthias Ringwald     if (!channel) {
218863f0ac45SMatthias Ringwald         log_error("l2cap_le_provide_credits no channel for cid 0x%02x", local_cid);
218963f0ac45SMatthias Ringwald         return L2CAP_LOCAL_CID_DOES_NOT_EXIST;
219063f0ac45SMatthias Ringwald     }
219163f0ac45SMatthias Ringwald 
2192efedfb4cSMatthias Ringwald     // check state
219363f0ac45SMatthias Ringwald     if (channel->state != L2CAP_STATE_OPEN){
219463f0ac45SMatthias Ringwald         log_error("l2cap_le_provide_credits but channel 0x%02x not open yet", local_cid);
219563f0ac45SMatthias Ringwald     }
219663f0ac45SMatthias Ringwald 
219763f0ac45SMatthias Ringwald     // assert incoming credits + credits <= 0xffff
219863f0ac45SMatthias Ringwald     uint32_t total_credits = channel->credits_incoming;
219963f0ac45SMatthias Ringwald     total_credits += channel->new_credits_incoming;
220063f0ac45SMatthias Ringwald     total_credits += credits;
220163f0ac45SMatthias Ringwald     if (total_credits > 0xffff){
220263f0ac45SMatthias Ringwald         log_error("l2cap_le_provide_credits overrun: current %u, scheduled %u, additional %u", channel->credits_incoming,
220363f0ac45SMatthias Ringwald             channel->new_credits_incoming, credits);
220463f0ac45SMatthias Ringwald     }
220563f0ac45SMatthias Ringwald 
2206efedfb4cSMatthias Ringwald     // set credits_granted
220763f0ac45SMatthias Ringwald     channel->new_credits_incoming += credits;
220863f0ac45SMatthias Ringwald 
220963f0ac45SMatthias Ringwald     // go
221063f0ac45SMatthias Ringwald     l2cap_run();
2211da144af5SMatthias Ringwald     return 0;
2212da144af5SMatthias Ringwald }
2213da144af5SMatthias Ringwald 
2214da144af5SMatthias Ringwald /**
2215da144af5SMatthias Ringwald  * @brief Check if outgoing buffer is available and that there's space on the Bluetooth module
2216da144af5SMatthias Ringwald  * @param local_cid             L2CAP LE Data Channel Identifier
2217da144af5SMatthias Ringwald  */
221864e11ca9SMatthias Ringwald int l2cap_le_can_send_now(uint16_t local_cid){
221944276248SMatthias Ringwald     l2cap_channel_t * channel = l2cap_le_get_channel_for_local_cid(local_cid);
222044276248SMatthias Ringwald     if (!channel) {
222144276248SMatthias Ringwald         log_error("l2cap_le_provide_credits no channel for cid 0x%02x", local_cid);
2222da144af5SMatthias Ringwald         return 0;
2223da144af5SMatthias Ringwald     }
2224da144af5SMatthias Ringwald 
222544276248SMatthias Ringwald     // check state
222644276248SMatthias Ringwald     if (channel->state != L2CAP_STATE_OPEN) return 0;
222744276248SMatthias Ringwald 
222844276248SMatthias Ringwald     // check queue
222944276248SMatthias Ringwald     if (channel->send_sdu_buffer) return 0;
223044276248SMatthias Ringwald 
223144276248SMatthias Ringwald     // fine, go ahead
223244276248SMatthias Ringwald     return 1;
223344276248SMatthias Ringwald }
223444276248SMatthias Ringwald 
2235da144af5SMatthias Ringwald /**
2236da144af5SMatthias Ringwald  * @brief Request emission of L2CAP_EVENT_CAN_SEND_NOW as soon as possible
2237da144af5SMatthias Ringwald  * @note L2CAP_EVENT_CAN_SEND_NOW might be emitted during call to this function
2238da144af5SMatthias Ringwald  *       so packet handler should be ready to handle it
2239da144af5SMatthias Ringwald  * @param local_cid             L2CAP LE Data Channel Identifier
2240da144af5SMatthias Ringwald  */
224164e11ca9SMatthias Ringwald uint8_t l2cap_le_request_can_send_now_event(uint16_t local_cid){
224244276248SMatthias Ringwald     l2cap_channel_t * channel = l2cap_le_get_channel_for_local_cid(local_cid);
224344276248SMatthias Ringwald     if (!channel) {
224444276248SMatthias Ringwald         log_error("l2cap_le_request_can_send_now_event no channel for cid 0x%02x", local_cid);
224544276248SMatthias Ringwald         return 0;
224644276248SMatthias Ringwald     }
224744276248SMatthias Ringwald     channel->waiting_for_can_send_now = 1;
224844276248SMatthias Ringwald     l2cap_le_notify_channel_can_send(channel);
2249da144af5SMatthias Ringwald     return 0;
2250da144af5SMatthias Ringwald }
2251da144af5SMatthias Ringwald 
2252da144af5SMatthias Ringwald /**
2253da144af5SMatthias Ringwald  * @brief Send data via LE Data Channel
2254da144af5SMatthias Ringwald  * @note Since data larger then the maximum PDU needs to be segmented into multiple PDUs, data needs to stay valid until ... event
2255da144af5SMatthias Ringwald  * @param local_cid             L2CAP LE Data Channel Identifier
2256da144af5SMatthias Ringwald  * @param data                  data to send
2257da144af5SMatthias Ringwald  * @param size                  data size
2258da144af5SMatthias Ringwald  */
225964e11ca9SMatthias Ringwald uint8_t l2cap_le_send_data(uint16_t local_cid, uint8_t * data, uint16_t len){
226064e11ca9SMatthias Ringwald 
226164e11ca9SMatthias Ringwald     l2cap_channel_t * channel = l2cap_le_get_channel_for_local_cid(local_cid);
226264e11ca9SMatthias Ringwald     if (!channel) {
226364e11ca9SMatthias Ringwald         log_error("l2cap_send no channel for cid 0x%02x", local_cid);
2264828a7f7aSMatthias Ringwald         return L2CAP_LOCAL_CID_DOES_NOT_EXIST;
226564e11ca9SMatthias Ringwald     }
226664e11ca9SMatthias Ringwald 
226764e11ca9SMatthias Ringwald     if (len > channel->remote_mtu){
226864e11ca9SMatthias Ringwald         log_error("l2cap_send cid 0x%02x, data length exceeds remote MTU.", local_cid);
226964e11ca9SMatthias Ringwald         return L2CAP_DATA_LEN_EXCEEDS_REMOTE_MTU;
227064e11ca9SMatthias Ringwald     }
227164e11ca9SMatthias Ringwald 
22727f107edaSMatthias Ringwald     if (channel->send_sdu_buffer){
227364e11ca9SMatthias Ringwald         log_info("l2cap_send cid 0x%02x, cannot send", local_cid);
227464e11ca9SMatthias Ringwald         return BTSTACK_ACL_BUFFERS_FULL;
227564e11ca9SMatthias Ringwald     }
227664e11ca9SMatthias Ringwald 
22777f107edaSMatthias Ringwald     channel->send_sdu_buffer = data;
22787f107edaSMatthias Ringwald     channel->send_sdu_len    = len;
22797f107edaSMatthias Ringwald     channel->send_sdu_pos    = 0;
228064e11ca9SMatthias Ringwald 
22817f107edaSMatthias Ringwald     l2cap_run();
22827f107edaSMatthias Ringwald     return 0;
2283da144af5SMatthias Ringwald }
2284da144af5SMatthias Ringwald 
2285da144af5SMatthias Ringwald /**
2286da144af5SMatthias Ringwald  * @brief Disconnect from LE Data Channel
2287da144af5SMatthias Ringwald  * @param local_cid             L2CAP LE Data Channel Identifier
2288da144af5SMatthias Ringwald  */
2289828a7f7aSMatthias Ringwald uint8_t l2cap_le_disconnect(uint16_t local_cid)
2290da144af5SMatthias Ringwald {
2291828a7f7aSMatthias Ringwald     l2cap_channel_t * channel = l2cap_le_get_channel_for_local_cid(local_cid);
2292828a7f7aSMatthias Ringwald     if (!channel) {
2293828a7f7aSMatthias Ringwald         log_error("l2cap_send no channel for cid 0x%02x", local_cid);
2294828a7f7aSMatthias Ringwald         return L2CAP_LOCAL_CID_DOES_NOT_EXIST;
2295828a7f7aSMatthias Ringwald     }
2296828a7f7aSMatthias Ringwald 
2297828a7f7aSMatthias Ringwald     channel->state = L2CAP_STATE_WILL_SEND_DISCONNECT_REQUEST;
2298828a7f7aSMatthias Ringwald     l2cap_run();
2299da144af5SMatthias Ringwald     return 0;
2300da144af5SMatthias Ringwald }
2301da144af5SMatthias Ringwald 
23027f02f414SMatthias Ringwald #endif
230383fd9c76SMatthias Ringwald 
230483fd9c76SMatthias Ringwald #endif
2305