1 /*
2 * Copyright (C) 2016 BlueKitchen GmbH
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the name of the copyright holders nor the names of
14 * contributors may be used to endorse or promote products derived
15 * from this software without specific prior written permission.
16 * 4. Any redistribution, use, or modification is done solely for
17 * personal benefit and not for any commercial purpose or for
18 * monetary gain.
19 *
20 * THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BLUEKITCHEN
24 * GMBH OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
26 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
27 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
28 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
29 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
30 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 *
33 * Please inquire about commercial licensing options at
34 * [email protected]
35 *
36 */
37
38 #define BTSTACK_FILE__ "avdtp.c"
39
40
41 #include <stdint.h>
42 #include <string.h>
43
44 #include "bluetooth_psm.h"
45 #include "bluetooth_sdp.h"
46 #include "btstack_debug.h"
47 #include "btstack_event.h"
48 #include "btstack_memory.h"
49 #include "classic/avdtp.h"
50 #include "classic/avdtp_util.h"
51 #include "classic/avdtp_acceptor.h"
52 #include "classic/avdtp_initiator.h"
53 #include "classic/avdtp_util.h"
54 #include "classic/sdp_client.h"
55 #include "classic/sdp_util.h"
56
57 // higher layer callbacks
58 static btstack_packet_handler_t avdtp_source_callback;
59 static btstack_packet_handler_t avdtp_sink_callback;
60
61 static void (*avdtp_sink_handle_media_data)(uint8_t local_seid, uint8_t *packet, uint16_t size);
62
63 static uint8_t (*avdtp_sink_media_config_validator)(const avdtp_stream_endpoint_t * stream_endpoint, const uint8_t * event, uint16_t size);
64 static uint8_t (*avdtp_source_media_config_validator)(const avdtp_stream_endpoint_t * stream_endpoint, const uint8_t * event, uint16_t size);
65
66 // sdp query
67 static btstack_context_callback_registration_t avdtp_handle_sdp_client_query_request;
68 static uint16_t avdtp_sdp_query_context_avdtp_cid = 0;
69
70 // registered stream endpoints
71 static btstack_linked_list_t avdtp_stream_endpoints;
72 static uint8_t avdtp_stream_endpoints_id_counter = 0;
73
74 static bool avdtp_l2cap_registered;
75
76 static btstack_linked_list_t avdtp_connections;
77 static uint8_t avdtp_transaction_id_counter = 0;
78
79 static int avdtp_record_id;
80 static uint8_t avdtp_attribute_value[45];
81 static const unsigned int avdtp_attribute_value_buffer_size = sizeof(avdtp_attribute_value);
82
83 static uint16_t avdtp_cid_counter = 0;
84
85 static void avdtp_handle_sdp_client_query_result(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size);
86
87 btstack_packet_handler_t
avdtp_packet_handler_for_stream_endpoint(const avdtp_stream_endpoint_t * stream_endpoint)88 avdtp_packet_handler_for_stream_endpoint(const avdtp_stream_endpoint_t *stream_endpoint) {
89 return (stream_endpoint->sep.type == AVDTP_SOURCE) ? avdtp_source_callback : avdtp_sink_callback;
90 }
91
avdtp_emit_sink_and_source(uint8_t * packet,uint16_t size)92 void avdtp_emit_sink_and_source(uint8_t * packet, uint16_t size){
93 if (avdtp_source_callback != NULL){
94 (*avdtp_source_callback)(HCI_EVENT_PACKET, 0, packet, size);
95 }
96 if (avdtp_sink_callback != NULL){
97 (*avdtp_sink_callback)(HCI_EVENT_PACKET, 0, packet, size);
98 }
99 }
100
avdtp_emit_source(uint8_t * packet,uint16_t size)101 void avdtp_emit_source(uint8_t * packet, uint16_t size){
102 if (avdtp_source_callback != NULL){
103 (*avdtp_source_callback)(HCI_EVENT_PACKET, 0, packet, size);
104 }
105 }
106
avdtp_get_stream_endpoints(void)107 btstack_linked_list_t * avdtp_get_stream_endpoints(void){
108 return &avdtp_stream_endpoints;
109 }
110
avdtp_get_connections(void)111 btstack_linked_list_t * avdtp_get_connections(void){
112 return &avdtp_connections;
113 }
114
avdtp_get_connection_for_bd_addr(bd_addr_t addr)115 avdtp_connection_t * avdtp_get_connection_for_bd_addr(bd_addr_t addr){
116 btstack_linked_list_iterator_t it;
117 btstack_linked_list_iterator_init(&it, &avdtp_connections);
118 while (btstack_linked_list_iterator_has_next(&it)){
119 avdtp_connection_t * connection = (avdtp_connection_t *)btstack_linked_list_iterator_next(&it);
120 if (memcmp(addr, connection->remote_addr, 6) != 0) continue;
121 return connection;
122 }
123 return NULL;
124 }
125
avdtp_get_connection_for_avdtp_cid(uint16_t avdtp_cid)126 avdtp_connection_t * avdtp_get_connection_for_avdtp_cid(uint16_t avdtp_cid){
127 btstack_linked_list_iterator_t it;
128 btstack_linked_list_iterator_init(&it, &avdtp_connections);
129 while (btstack_linked_list_iterator_has_next(&it)){
130 avdtp_connection_t * connection = (avdtp_connection_t *)btstack_linked_list_iterator_next(&it);
131 if (connection->avdtp_cid != avdtp_cid) continue;
132 return connection;
133 }
134 return NULL;
135 }
136
137
avdtp_get_stream_endpoint_for_seid(uint16_t seid)138 avdtp_stream_endpoint_t * avdtp_get_stream_endpoint_for_seid(uint16_t seid){
139 btstack_linked_list_iterator_t it;
140 btstack_linked_list_iterator_init(&it, avdtp_get_stream_endpoints());
141 while (btstack_linked_list_iterator_has_next(&it)){
142 avdtp_stream_endpoint_t * stream_endpoint = (avdtp_stream_endpoint_t *)btstack_linked_list_iterator_next(&it);
143 if (stream_endpoint->sep.seid == seid){
144 return stream_endpoint;
145 }
146 }
147 return NULL;
148 }
149
avdtp_get_source_stream_endpoint_for_media_codec_and_type(avdtp_media_codec_type_t codec_type,avdtp_sep_type_t sep_type)150 avdtp_stream_endpoint_t * avdtp_get_source_stream_endpoint_for_media_codec_and_type(avdtp_media_codec_type_t codec_type, avdtp_sep_type_t sep_type){
151 btstack_linked_list_iterator_t it;
152 btstack_linked_list_iterator_init(&it, avdtp_get_stream_endpoints());
153 while (btstack_linked_list_iterator_has_next(&it)){
154 avdtp_stream_endpoint_t * stream_endpoint = (avdtp_stream_endpoint_t *)btstack_linked_list_iterator_next(&it);
155 if (stream_endpoint->sep.type != sep_type) continue;
156 if (stream_endpoint->sep.media_type != AVDTP_AUDIO) continue;
157 if (stream_endpoint->sep.capabilities.media_codec.media_codec_type != codec_type) continue;
158 if (stream_endpoint->sep.in_use) continue;
159 return stream_endpoint;
160 }
161 return NULL;
162 }
163
avdtp_get_source_stream_endpoint_for_media_codec(avdtp_media_codec_type_t codec_type)164 avdtp_stream_endpoint_t * avdtp_get_source_stream_endpoint_for_media_codec(avdtp_media_codec_type_t codec_type){
165 return avdtp_get_source_stream_endpoint_for_media_codec_and_type(codec_type, AVDTP_SOURCE);
166 }
167
168
avdtp_get_source_stream_endpoint_for_media_codec_other(uint32_t vendor_id,uint16_t codec_id)169 avdtp_stream_endpoint_t * avdtp_get_source_stream_endpoint_for_media_codec_other(uint32_t vendor_id, uint16_t codec_id){
170 btstack_linked_list_iterator_t it;
171 btstack_linked_list_iterator_init(&it, avdtp_get_stream_endpoints());
172 while (btstack_linked_list_iterator_has_next(&it)){
173 avdtp_stream_endpoint_t * stream_endpoint = (avdtp_stream_endpoint_t *)btstack_linked_list_iterator_next(&it);
174 if (stream_endpoint->sep.type != AVDTP_SOURCE) continue;
175 if (stream_endpoint->sep.media_type != AVDTP_AUDIO) continue;
176 if (stream_endpoint->sep.in_use) continue;
177 if (stream_endpoint->sep.capabilities.media_codec.media_codec_type != AVDTP_CODEC_NON_A2DP) continue;
178 if (stream_endpoint->sep.capabilities.media_codec.media_codec_information_len < 6) continue;
179 if (little_endian_read_32(stream_endpoint->sep.capabilities.media_codec.media_codec_information, 0) != vendor_id) continue;
180 if (little_endian_read_16(stream_endpoint->sep.capabilities.media_codec.media_codec_information, 4) != codec_id) continue;
181 return stream_endpoint;
182 }
183 return NULL;
184 }
185
186
avdtp_get_connection_for_l2cap_signaling_cid(uint16_t l2cap_cid)187 avdtp_connection_t * avdtp_get_connection_for_l2cap_signaling_cid(uint16_t l2cap_cid){
188 btstack_linked_list_iterator_t it;
189 btstack_linked_list_iterator_init(&it, &avdtp_connections);
190 while (btstack_linked_list_iterator_has_next(&it)){
191 avdtp_connection_t * connection = (avdtp_connection_t *)btstack_linked_list_iterator_next(&it);
192 if (connection->l2cap_signaling_cid != l2cap_cid) continue;
193 return connection;
194 }
195 return NULL;
196 }
197
avdtp_get_stream_endpoint_for_l2cap_cid(uint16_t l2cap_cid)198 static avdtp_stream_endpoint_t * avdtp_get_stream_endpoint_for_l2cap_cid(uint16_t l2cap_cid){
199 btstack_linked_list_iterator_t it;
200 btstack_linked_list_iterator_init(&it, avdtp_get_stream_endpoints());
201 while (btstack_linked_list_iterator_has_next(&it)){
202 avdtp_stream_endpoint_t * stream_endpoint = (avdtp_stream_endpoint_t *)btstack_linked_list_iterator_next(&it);
203 if (stream_endpoint->l2cap_media_cid == l2cap_cid){
204 return stream_endpoint;
205 }
206 if (stream_endpoint->l2cap_reporting_cid == l2cap_cid){
207 return stream_endpoint;
208 }
209 if (stream_endpoint->l2cap_recovery_cid == l2cap_cid){
210 return stream_endpoint;
211 }
212 }
213 return NULL;
214 }
215
avdtp_get_stream_endpoint_for_signaling_cid(uint16_t l2cap_cid)216 static avdtp_stream_endpoint_t * avdtp_get_stream_endpoint_for_signaling_cid(uint16_t l2cap_cid){
217 btstack_linked_list_iterator_t it;
218 btstack_linked_list_iterator_init(&it, avdtp_get_stream_endpoints());
219 while (btstack_linked_list_iterator_has_next(&it)){
220 avdtp_stream_endpoint_t * stream_endpoint = (avdtp_stream_endpoint_t *)btstack_linked_list_iterator_next(&it);
221 if (stream_endpoint->connection){
222 if (stream_endpoint->connection->l2cap_signaling_cid == l2cap_cid){
223 return stream_endpoint;
224 }
225 }
226 }
227 return NULL;
228 }
229
avdtp_get_next_transaction_label(void)230 uint8_t avdtp_get_next_transaction_label(void){
231 avdtp_transaction_id_counter++;
232 if (avdtp_transaction_id_counter == 16){
233 avdtp_transaction_id_counter = 1;
234 }
235 return avdtp_transaction_id_counter;
236 }
237
avdtp_create_connection(bd_addr_t remote_addr,uint16_t cid)238 static avdtp_connection_t * avdtp_create_connection(bd_addr_t remote_addr, uint16_t cid){
239 avdtp_connection_t * connection = btstack_memory_avdtp_connection_get();
240 if (!connection){
241 log_error("Not enough memory to create connection");
242 return NULL;
243 }
244 connection->state = AVDTP_SIGNALING_CONNECTION_IDLE;
245 connection->initiator_transaction_label = avdtp_get_next_transaction_label();
246 connection->configuration_state = AVDTP_CONFIGURATION_STATE_IDLE;
247 connection->a2dp_source_config_process.discover_seps = false;
248 connection->a2dp_sink_config_process.discover_seps = false;
249 connection->avdtp_cid = cid;
250 (void)memcpy(connection->remote_addr, remote_addr, 6);
251
252 btstack_linked_list_add_tail(&avdtp_connections, (btstack_linked_item_t *) connection);
253 return connection;
254 }
255
avdtp_get_next_cid(void)256 static uint16_t avdtp_get_next_cid(void){
257 if (avdtp_cid_counter == 0xffff) {
258 avdtp_cid_counter = 1;
259 } else {
260 avdtp_cid_counter++;
261 }
262 return avdtp_cid_counter;
263 }
264
265 // Stream Endpoint Identifier are 6-bit
avdtp_get_next_local_seid(void)266 static uint8_t avdtp_get_next_local_seid(void){
267 if (avdtp_stream_endpoints_id_counter >= 0x3f) {
268 avdtp_stream_endpoints_id_counter = 1;
269 } else {
270 avdtp_stream_endpoints_id_counter++;
271 }
272 return avdtp_stream_endpoints_id_counter;
273 }
274
avdtp_get_next_connection_ready_for_sdp_query(void)275 static avdtp_connection_t * avdtp_get_next_connection_ready_for_sdp_query(void){
276 btstack_linked_list_iterator_t it;
277 btstack_linked_list_iterator_init(&it, &avdtp_connections);
278 while (btstack_linked_list_iterator_has_next(&it)){
279 avdtp_connection_t * connection = (avdtp_connection_t *)btstack_linked_list_iterator_next(&it);
280 switch (connection->state){
281 case AVDTP_SIGNALING_W2_SEND_SDP_QUERY_FOR_REMOTE_SOURCE:
282 case AVDTP_SIGNALING_W2_SEND_SDP_QUERY_FOR_REMOTE_SINK:
283 return connection;
284 case AVDTP_SIGNALING_CONNECTION_OPENED:
285 switch (connection->initiator_connection_state ){
286 case AVDTP_SIGNALING_CONNECTION_INITIATOR_W2_SEND_SDP_QUERY_THEN_GET_ALL_CAPABILITIES_FROM_REMOTE_SOURCE:
287 case AVDTP_SIGNALING_CONNECTION_INITIATOR_W2_SEND_SDP_QUERY_THEN_GET_ALL_CAPABILITIES_FROM_REMOTE_SINK:
288 return connection;
289 default:
290 break;
291 }
292 break;
293 default:
294 break;
295 }
296 }
297 return NULL;
298 }
299
avdtp_handle_start_sdp_client_query(void * context)300 static void avdtp_handle_start_sdp_client_query(void * context){
301 UNUSED(context);
302 avdtp_connection_t * connection = avdtp_get_next_connection_ready_for_sdp_query();
303 if (connection != NULL){
304
305 // Get UUID to Query
306 uint16_t uuid;
307 switch (connection->state){
308 case AVDTP_SIGNALING_W2_SEND_SDP_QUERY_FOR_REMOTE_SOURCE:
309 uuid = BLUETOOTH_SERVICE_CLASS_AUDIO_SOURCE;
310 connection->state = AVDTP_SIGNALING_W4_SDP_QUERY_FOR_REMOTE_SOURCE_COMPLETE;
311 break;
312 case AVDTP_SIGNALING_W2_SEND_SDP_QUERY_FOR_REMOTE_SINK:
313 uuid = BLUETOOTH_SERVICE_CLASS_AUDIO_SINK;
314 connection->state = AVDTP_SIGNALING_W4_SDP_QUERY_FOR_REMOTE_SINK_COMPLETE;
315 break;
316 case AVDTP_SIGNALING_CONNECTION_OPENED:
317 switch (connection->initiator_connection_state ){
318 case AVDTP_SIGNALING_CONNECTION_INITIATOR_W2_SEND_SDP_QUERY_THEN_GET_ALL_CAPABILITIES_FROM_REMOTE_SOURCE:
319 uuid = BLUETOOTH_SERVICE_CLASS_AUDIO_SOURCE;
320 connection->initiator_connection_state = AVDTP_SIGNALING_CONNECTION_INITIATOR_W4_SDP_QUERY_COMPLETE_THEN_GET_ALL_CAPABILITIES;
321 break;
322 case AVDTP_SIGNALING_CONNECTION_INITIATOR_W2_SEND_SDP_QUERY_THEN_GET_ALL_CAPABILITIES_FROM_REMOTE_SINK:
323 uuid = BLUETOOTH_SERVICE_CLASS_AUDIO_SINK;
324 connection->initiator_connection_state = AVDTP_SIGNALING_CONNECTION_INITIATOR_W4_SDP_QUERY_COMPLETE_THEN_GET_ALL_CAPABILITIES;
325 break;
326 default:
327 btstack_unreachable();
328 break;
329 }
330 break;
331 default:
332 btstack_unreachable();
333 break;
334 }
335
336 // Start & track query
337 avdtp_sdp_query_context_avdtp_cid = connection->avdtp_cid;
338 avdtp_record_id = -1;
339 sdp_client_query_uuid16(&avdtp_handle_sdp_client_query_result, (uint8_t *) connection->remote_addr, uuid);
340 return;
341 }
342 }
343
avdtp_connect(bd_addr_t remote,avdtp_role_t role,uint16_t * avdtp_cid)344 uint8_t avdtp_connect(bd_addr_t remote, avdtp_role_t role, uint16_t * avdtp_cid){
345 avdtp_connection_t * connection = avdtp_get_connection_for_bd_addr(remote);
346 if (connection){
347 // allow to call avdtp_connect after signaling connection was triggered remotely
348 // @note this also allows to call avdtp_connect again before SLC is complete
349 if (connection->state < AVDTP_SIGNALING_CONNECTION_OPENED){
350 return ERROR_CODE_SUCCESS;
351 } else {
352 return ERROR_CODE_COMMAND_DISALLOWED;
353 }
354 }
355
356 uint16_t cid = avdtp_get_next_cid();
357 if (avdtp_cid != NULL) {
358 *avdtp_cid = cid;
359 }
360
361 connection = avdtp_create_connection(remote, cid);
362 if (!connection) return BTSTACK_MEMORY_ALLOC_FAILED;
363
364 connection->avdtp_cid = cid;
365
366 connection->avdtp_l2cap_psm = 0;
367 connection->avdtp_version = 0;
368 connection->sink_supported = false;
369 connection->source_supported = false;
370
371 switch (role){
372 case AVDTP_ROLE_SOURCE:
373 connection->state = AVDTP_SIGNALING_W2_SEND_SDP_QUERY_FOR_REMOTE_SINK;
374 break;
375 case AVDTP_ROLE_SINK:
376 connection->state = AVDTP_SIGNALING_W2_SEND_SDP_QUERY_FOR_REMOTE_SOURCE;
377 break;
378 default:
379 btstack_assert(false);
380 return ERROR_CODE_COMMAND_DISALLOWED;
381 }
382
383 // ignore ERROR_CODE_COMMAND_DISALLOWED because in that case, we already have requested an SDP callback
384 (void) sdp_client_register_query_callback(&avdtp_handle_sdp_client_query_request);
385 return ERROR_CODE_SUCCESS;
386 }
387
388
avdtp_register_sink_packet_handler(btstack_packet_handler_t callback)389 void avdtp_register_sink_packet_handler(btstack_packet_handler_t callback){
390 btstack_assert(callback != NULL);
391 avdtp_sink_callback = callback;
392 }
393
avdtp_register_source_packet_handler(btstack_packet_handler_t callback)394 void avdtp_register_source_packet_handler(btstack_packet_handler_t callback){
395 btstack_assert(callback != NULL);
396 avdtp_source_callback = callback;
397 }
398
avdtp_register_media_transport_category(avdtp_stream_endpoint_t * stream_endpoint)399 void avdtp_register_media_transport_category(avdtp_stream_endpoint_t * stream_endpoint){
400 if (!stream_endpoint){
401 log_error("Stream endpoint with given seid is not registered.");
402 return;
403 }
404 uint16_t bitmap = store_bit16(stream_endpoint->sep.registered_service_categories, AVDTP_MEDIA_TRANSPORT, 1);
405 stream_endpoint->sep.registered_service_categories = bitmap;
406 }
407
avdtp_register_reporting_category(avdtp_stream_endpoint_t * stream_endpoint)408 void avdtp_register_reporting_category(avdtp_stream_endpoint_t * stream_endpoint){
409 if (!stream_endpoint){
410 log_error("Stream endpoint with given seid is not registered.");
411 return;
412 }
413 uint16_t bitmap = store_bit16(stream_endpoint->sep.registered_service_categories, AVDTP_REPORTING, 1);
414 stream_endpoint->sep.registered_service_categories = bitmap;
415 }
416
avdtp_register_delay_reporting_category(avdtp_stream_endpoint_t * stream_endpoint)417 void avdtp_register_delay_reporting_category(avdtp_stream_endpoint_t * stream_endpoint){
418 if (!stream_endpoint){
419 log_error("Stream endpoint with given seid is not registered.");
420 return;
421 }
422 uint16_t bitmap = store_bit16(stream_endpoint->sep.registered_service_categories, AVDTP_DELAY_REPORTING, 1);
423 stream_endpoint->sep.registered_service_categories = bitmap;
424 }
425
avdtp_register_recovery_category(avdtp_stream_endpoint_t * stream_endpoint,uint8_t maximum_recovery_window_size,uint8_t maximum_number_media_packets)426 void avdtp_register_recovery_category(avdtp_stream_endpoint_t * stream_endpoint, uint8_t maximum_recovery_window_size, uint8_t maximum_number_media_packets){
427 if (!stream_endpoint){
428 log_error("Stream endpoint with given seid is not registered.");
429 return;
430 }
431 uint16_t bitmap = store_bit16(stream_endpoint->sep.registered_service_categories, AVDTP_RECOVERY, 1);
432 stream_endpoint->sep.registered_service_categories = bitmap;
433 stream_endpoint->sep.capabilities.recovery.recovery_type = 0x01; // 0x01 = RFC2733
434 stream_endpoint->sep.capabilities.recovery.maximum_recovery_window_size = maximum_recovery_window_size;
435 stream_endpoint->sep.capabilities.recovery.maximum_number_media_packets = maximum_number_media_packets;
436 }
437
avdtp_register_content_protection_category(avdtp_stream_endpoint_t * stream_endpoint,uint16_t cp_type,const uint8_t * cp_type_value,uint8_t cp_type_value_len)438 void avdtp_register_content_protection_category(avdtp_stream_endpoint_t * stream_endpoint, uint16_t cp_type, const uint8_t * cp_type_value, uint8_t cp_type_value_len){
439 if (!stream_endpoint){
440 log_error("Stream endpoint with given seid is not registered.");
441 return;
442 }
443 uint16_t bitmap = store_bit16(stream_endpoint->sep.registered_service_categories, AVDTP_CONTENT_PROTECTION, 1);
444 stream_endpoint->sep.registered_service_categories = bitmap;
445 stream_endpoint->sep.capabilities.content_protection.cp_type = cp_type;
446 (void)memcpy(stream_endpoint->sep.capabilities.content_protection.cp_type_value,
447 cp_type_value,
448 btstack_min(cp_type_value_len, AVDTP_MAX_CONTENT_PROTECTION_TYPE_VALUE_LEN));
449 stream_endpoint->sep.capabilities.content_protection.cp_type_value_len = btstack_min(cp_type_value_len, AVDTP_MAX_CONTENT_PROTECTION_TYPE_VALUE_LEN);
450 }
451
avdtp_register_header_compression_category(avdtp_stream_endpoint_t * stream_endpoint,uint8_t back_ch,uint8_t media,uint8_t recovery)452 void avdtp_register_header_compression_category(avdtp_stream_endpoint_t * stream_endpoint, uint8_t back_ch, uint8_t media, uint8_t recovery){
453 if (!stream_endpoint){
454 log_error("Stream endpoint with given seid is not registered.");
455 return;
456 }
457 uint16_t bitmap = store_bit16(stream_endpoint->sep.registered_service_categories, AVDTP_HEADER_COMPRESSION, 1);
458 stream_endpoint->sep.registered_service_categories = bitmap;
459 stream_endpoint->sep.capabilities.header_compression.back_ch = back_ch;
460 stream_endpoint->sep.capabilities.header_compression.media = media;
461 stream_endpoint->sep.capabilities.header_compression.recovery = recovery;
462 }
463
avdtp_register_media_codec_category(avdtp_stream_endpoint_t * stream_endpoint,avdtp_media_type_t media_type,avdtp_media_codec_type_t media_codec_type,const uint8_t * media_codec_info,uint16_t media_codec_info_len)464 void avdtp_register_media_codec_category(avdtp_stream_endpoint_t * stream_endpoint, avdtp_media_type_t media_type, avdtp_media_codec_type_t media_codec_type, const uint8_t *media_codec_info, uint16_t media_codec_info_len){
465 if (!stream_endpoint){
466 log_error("Stream endpoint with given seid is not registered.");
467 return;
468 }
469 uint16_t bitmap = store_bit16(stream_endpoint->sep.registered_service_categories, AVDTP_MEDIA_CODEC, 1);
470 stream_endpoint->sep.registered_service_categories = bitmap;
471 stream_endpoint->sep.capabilities.media_codec.media_type = media_type;
472 stream_endpoint->sep.capabilities.media_codec.media_codec_type = media_codec_type;
473 // @todo should be stored in struct as const
474 stream_endpoint->sep.capabilities.media_codec.media_codec_information = (uint8_t*) media_codec_info;
475 stream_endpoint->sep.capabilities.media_codec.media_codec_information_len = media_codec_info_len;
476 }
477
avdtp_register_multiplexing_category(avdtp_stream_endpoint_t * stream_endpoint,uint8_t fragmentation)478 void avdtp_register_multiplexing_category(avdtp_stream_endpoint_t * stream_endpoint, uint8_t fragmentation){
479 if (!stream_endpoint){
480 log_error("Stream endpoint with given seid is not registered.");
481 return;
482 }
483 uint16_t bitmap = store_bit16(stream_endpoint->sep.registered_service_categories, AVDTP_MULTIPLEXING, 1);
484 stream_endpoint->sep.registered_service_categories = bitmap;
485 stream_endpoint->sep.capabilities.multiplexing_mode.fragmentation = fragmentation;
486 }
487
avdtp_register_media_handler(void (* callback)(uint8_t local_seid,uint8_t * packet,uint16_t size))488 void avdtp_register_media_handler(void (*callback)(uint8_t local_seid, uint8_t *packet, uint16_t size)){
489 avdtp_sink_handle_media_data = callback;
490 }
491
avdtp_sink_register_media_config_validator(uint8_t (* callback)(const avdtp_stream_endpoint_t * stream_endpoint,const uint8_t * event,uint16_t size))492 void avdtp_sink_register_media_config_validator(uint8_t (*callback)(const avdtp_stream_endpoint_t * stream_endpoint, const uint8_t * event, uint16_t size)){
493 avdtp_sink_media_config_validator = callback;
494 }
495
avdtp_source_register_media_config_validator(uint8_t (* callback)(const avdtp_stream_endpoint_t * stream_endpoint,const uint8_t * event,uint16_t size))496 void avdtp_source_register_media_config_validator(uint8_t (*callback)(const avdtp_stream_endpoint_t * stream_endpoint, const uint8_t * event, uint16_t size)){
497 avdtp_source_media_config_validator = callback;
498 }
499
avdtp_validate_media_configuration(const avdtp_stream_endpoint_t * stream_endpoint,uint16_t avdtp_cid,uint8_t reconfigure,const adtvp_media_codec_capabilities_t * media_codec)500 uint8_t avdtp_validate_media_configuration(const avdtp_stream_endpoint_t *stream_endpoint, uint16_t avdtp_cid,
501 uint8_t reconfigure, const adtvp_media_codec_capabilities_t *media_codec) {
502 uint8_t (*callback)(const avdtp_stream_endpoint_t * stream_endpoint, const uint8_t * event, uint16_t size);
503 if (stream_endpoint->sep.type == AVDTP_SOURCE){
504 callback = avdtp_source_media_config_validator;
505 } else {
506 callback = avdtp_sink_media_config_validator;
507 }
508 if (callback == NULL) {
509 // config valid
510 return 0;
511 }
512 uint8_t event[AVDTP_MEDIA_CONFIG_OTHER_EVENT_LEN];
513 uint16_t size = avdtp_setup_media_codec_config_event(event, sizeof(event), stream_endpoint, avdtp_cid, reconfigure, media_codec);
514 return (*callback)(stream_endpoint, event, size);
515 }
516
517 /* START: tracking can send now requests per l2cap cid */
avdtp_handle_can_send_now(uint16_t l2cap_cid)518 static void avdtp_handle_can_send_now(uint16_t l2cap_cid) {
519
520 log_debug("avdtp_packet_handler, L2CAP_EVENT_CAN_SEND_NOW l2cap_cid 0x%02x", l2cap_cid);
521
522 // get signaling connection for l2cap cid
523 avdtp_connection_t * connection = avdtp_get_connection_for_l2cap_signaling_cid(l2cap_cid);
524
525 if (connection != NULL) {
526 if (connection->wait_to_send_acceptor) {
527 log_debug("call avdtp_acceptor_stream_config_subsm_run %p", connection);
528 connection->wait_to_send_acceptor = false;
529 avdtp_acceptor_stream_config_subsm_run(connection);
530 } else if (connection->wait_to_send_initiator) {
531 log_debug("call avdtp_initiator_stream_config_subsm_handle_can_send_now_signaling %p", connection);
532 connection->wait_to_send_initiator = false;
533 avdtp_initiator_stream_config_subsm_handle_can_send_now_signaling(connection);
534 }
535 bool more_to_send = connection->wait_to_send_acceptor || connection->wait_to_send_initiator;
536 if (more_to_send){
537 l2cap_request_can_send_now_event(l2cap_cid);
538 }
539 return;
540 }
541
542 // get stream endpoint connection for l2cap cid
543 avdtp_stream_endpoint_t * stream_endpoint = avdtp_get_stream_endpoint_for_l2cap_cid(l2cap_cid);
544 if (stream_endpoint != NULL) {
545 log_debug("call avdtp_initiator_stream_config_subsm_handle_can_send_now_stream_endpoint %p", stream_endpoint);
546 if (stream_endpoint->request_can_send_now) {
547 stream_endpoint->request_can_send_now = false;
548 avdtp_initiator_stream_config_subsm_handle_can_send_now_stream_endpoint(stream_endpoint);
549 }
550 if (stream_endpoint->request_can_send_now){
551 l2cap_request_can_send_now_event(l2cap_cid);
552 }
553 }
554 }
555 /* END: tracking can send now requests per l2cap cid */
556
557
avdtp_create_stream_endpoint(avdtp_sep_type_t sep_type,avdtp_media_type_t media_type)558 avdtp_stream_endpoint_t * avdtp_create_stream_endpoint(avdtp_sep_type_t sep_type, avdtp_media_type_t media_type){
559 avdtp_stream_endpoint_t * stream_endpoint = btstack_memory_avdtp_stream_endpoint_get();
560 if (!stream_endpoint){
561 log_error("Not enough memory to create stream endpoint");
562 return NULL;
563 }
564 stream_endpoint->sep.seid = avdtp_get_next_local_seid();
565 stream_endpoint->sep.media_type = media_type;
566 stream_endpoint->sep.type = sep_type;
567 btstack_linked_list_add(avdtp_get_stream_endpoints(), (btstack_linked_item_t *) stream_endpoint);
568 return stream_endpoint;
569 }
570
avdtp_finalize_stream_endpoint(avdtp_stream_endpoint_t * stream_endpoint)571 void avdtp_finalize_stream_endpoint(avdtp_stream_endpoint_t * stream_endpoint){
572 btstack_linked_list_remove(avdtp_get_stream_endpoints(), (btstack_linked_item_t* ) stream_endpoint);
573 btstack_memory_avdtp_stream_endpoint_free(stream_endpoint);
574 }
575
576 static void
handle_l2cap_data_packet_for_signaling_connection(avdtp_connection_t * connection,uint8_t * packet,uint16_t size)577 handle_l2cap_data_packet_for_signaling_connection(avdtp_connection_t *connection, uint8_t *packet, uint16_t size) {
578 if (size < 2) return;
579
580 uint16_t offset;
581 avdtp_message_type_t message_type = avdtp_get_signaling_message_type(packet);
582 switch (message_type){
583 case AVDTP_CMD_MSG:
584 offset = avdtp_read_signaling_header(&connection->acceptor_signaling_packet, packet, size);
585 if (offset > 0){
586 avdtp_acceptor_stream_config_subsm(connection, packet, size, offset);
587 }
588 break;
589 default:
590 offset = avdtp_read_signaling_header(&connection->initiator_signaling_packet, packet, size);
591 if (offset > 0) {
592 avdtp_initiator_stream_config_subsm(connection, packet, size, offset);
593 }
594 break;
595 }
596 }
597
avdtp_handle_sdp_client_query_attribute_value(avdtp_connection_t * connection,uint8_t * packet)598 static void avdtp_handle_sdp_client_query_attribute_value(avdtp_connection_t * connection, uint8_t *packet){
599 des_iterator_t des_list_it;
600 des_iterator_t prot_it;
601
602 // Handle new SDP record
603 if (sdp_event_query_attribute_byte_get_record_id(packet) != avdtp_record_id) {
604 avdtp_record_id = sdp_event_query_attribute_byte_get_record_id(packet);
605 // log_info("SDP Record: Nr: %d", record_id);
606 }
607
608 if (sdp_event_query_attribute_byte_get_attribute_length(packet) <= avdtp_attribute_value_buffer_size) {
609 avdtp_attribute_value[sdp_event_query_attribute_byte_get_data_offset(packet)] = sdp_event_query_attribute_byte_get_data(packet);
610
611 if ((uint16_t)(sdp_event_query_attribute_byte_get_data_offset(packet)+1) == sdp_event_query_attribute_byte_get_attribute_length(packet)) {
612
613 switch(sdp_event_query_attribute_byte_get_attribute_id(packet)) {
614
615 case BLUETOOTH_ATTRIBUTE_SERVICE_CLASS_ID_LIST:
616 if (de_get_element_type(avdtp_attribute_value) != DE_DES) break;
617 for (des_iterator_init(&des_list_it, avdtp_attribute_value); des_iterator_has_more(&des_list_it); des_iterator_next(&des_list_it)) {
618 uint8_t * element = des_iterator_get_element(&des_list_it);
619 if (de_get_element_type(element) != DE_UUID) continue;
620 uint32_t uuid = de_get_uuid32(element);
621 switch (uuid){
622 case BLUETOOTH_SERVICE_CLASS_AUDIO_SOURCE:
623 connection->source_supported = true;
624 log_info("source_supported");
625 break;
626 case BLUETOOTH_SERVICE_CLASS_AUDIO_SINK:
627 connection->sink_supported = true;
628 log_info("sink_supported");
629 break;
630 default:
631 break;
632 }
633 }
634 break;
635
636 case BLUETOOTH_ATTRIBUTE_PROTOCOL_DESCRIPTOR_LIST:
637 // log_info("SDP Attribute: 0x%04x", sdp_event_query_attribute_byte_get_attribute_id(packet));
638 for (des_iterator_init(&des_list_it, avdtp_attribute_value); des_iterator_has_more(&des_list_it); des_iterator_next(&des_list_it)) {
639 uint8_t *des_element;
640 uint8_t *element;
641 uint32_t uuid;
642
643 if (des_iterator_get_type(&des_list_it) != DE_DES) continue;
644
645 des_element = des_iterator_get_element(&des_list_it);
646 des_iterator_init(&prot_it, des_element);
647 element = des_iterator_get_element(&prot_it);
648
649 if (de_get_element_type(element) != DE_UUID) continue;
650
651 uuid = de_get_uuid32(element);
652 des_iterator_next(&prot_it);
653 // we assume that the even if there are both roles supported, remote device uses the same psm and avdtp version for both
654 switch (uuid){
655 case BLUETOOTH_PROTOCOL_L2CAP:
656 if (!des_iterator_has_more(&prot_it)) continue;
657 de_element_get_uint16(des_iterator_get_element(&prot_it), &connection->avdtp_l2cap_psm);
658 break;
659 case BLUETOOTH_PROTOCOL_AVDTP:
660 if (!des_iterator_has_more(&prot_it)) continue;
661 de_element_get_uint16(des_iterator_get_element(&prot_it), &connection->avdtp_version);
662 log_info("avdtp version 0x%02x", connection->avdtp_version);
663 break;
664 default:
665 break;
666 }
667 }
668 break;
669
670 default:
671 break;
672 }
673 }
674 } else {
675 log_error("SDP attribute value buffer size exceeded: available %d, required %d", avdtp_attribute_value_buffer_size, sdp_event_query_attribute_byte_get_attribute_length(packet));
676 }
677
678 }
679
avdtp_finalize_connection(avdtp_connection_t * connection)680 static void avdtp_finalize_connection(avdtp_connection_t * connection){
681 btstack_run_loop_remove_timer(&connection->retry_timer);
682 btstack_linked_list_remove(&avdtp_connections, (btstack_linked_item_t*) connection);
683 btstack_memory_avdtp_connection_free(connection);
684 }
685
avdtp_handle_sdp_query_failed(avdtp_connection_t * connection,uint8_t status)686 static void avdtp_handle_sdp_query_failed(avdtp_connection_t * connection, uint8_t status){
687 switch (connection->state){
688 case AVDTP_SIGNALING_W4_SDP_QUERY_FOR_REMOTE_SINK_COMPLETE:
689 case AVDTP_SIGNALING_W4_SDP_QUERY_FOR_REMOTE_SOURCE_COMPLETE:
690 avdtp_signaling_emit_connection_established(connection->avdtp_cid, connection->remote_addr, connection->con_handle, status);
691 break;
692
693 case AVDTP_SIGNALING_CONNECTION_OPENED:
694 // SDP query failed: try query that must be supported
695 connection->initiator_connection_state = AVDTP_SIGNALING_CONNECTION_INITIATOR_W2_GET_CAPABILITIES;
696 avdtp_request_can_send_now_initiator(connection);
697 return;
698
699 default:
700 btstack_assert(false);
701 break;
702 }
703 avdtp_finalize_connection(connection);
704 avdtp_sdp_query_context_avdtp_cid = 0;
705 log_info("SDP query failed with status 0x%02x.", status);
706 }
707
avdtp_handle_sdp_query_succeeded(avdtp_connection_t * connection)708 static void avdtp_handle_sdp_query_succeeded(avdtp_connection_t * connection){
709 log_info("avdtp_handle_sdp_query_succeeded: state %d", connection->state);
710
711 switch (connection->state){
712 case AVDTP_SIGNALING_CONNECTION_OPENED:
713 if (connection->avdtp_version < 0x0103){
714 connection->initiator_connection_state = AVDTP_SIGNALING_CONNECTION_INITIATOR_W2_GET_CAPABILITIES;
715 } else {
716 connection->initiator_connection_state = AVDTP_SIGNALING_CONNECTION_INITIATOR_W2_GET_ALL_CAPABILITIES;
717 }
718 avdtp_request_can_send_now_initiator(connection);
719 break;
720 default:
721 connection->state = AVDTP_SIGNALING_CONNECTION_W4_L2CAP_CONNECTED;
722 l2cap_create_channel(avdtp_packet_handler, connection->remote_addr, connection->avdtp_l2cap_psm, AVDTP_L2CAP_MTU, NULL);
723 break;
724 }
725 }
726
avdtp_handle_sdp_client_query_result(uint8_t packet_type,uint16_t channel,uint8_t * packet,uint16_t size)727 static void avdtp_handle_sdp_client_query_result(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
728 UNUSED(packet_type);
729 UNUSED(channel);
730 UNUSED(size);
731
732 avdtp_connection_t * connection = avdtp_get_connection_for_avdtp_cid(avdtp_sdp_query_context_avdtp_cid);
733 if (!connection) {
734 log_error("SDP query, connection with 0x%02x cid not found", avdtp_sdp_query_context_avdtp_cid);
735 return;
736 }
737
738 uint8_t status = ERROR_CODE_SUCCESS;
739 switch (hci_event_packet_get_type(packet)){
740 case SDP_EVENT_QUERY_ATTRIBUTE_VALUE:
741 avdtp_handle_sdp_client_query_attribute_value(connection, packet);
742 return;
743 case SDP_EVENT_QUERY_COMPLETE:
744 status = sdp_event_query_complete_get_status(packet);
745 break;
746 default:
747 btstack_assert(false);
748 return;
749 }
750
751 // query completed with status, validate received information
752 bool handle_query_complete = true;
753 switch (connection->state){
754 case AVDTP_SIGNALING_W4_SDP_QUERY_FOR_REMOTE_SINK_COMPLETE:
755 if (status == ERROR_CODE_SUCCESS) {
756 if (!connection->sink_supported || (connection->avdtp_l2cap_psm == 0)) {
757 status = SDP_SERVICE_NOT_FOUND;
758 }
759 }
760 break;
761 case AVDTP_SIGNALING_W4_SDP_QUERY_FOR_REMOTE_SOURCE_COMPLETE:
762 if (status == ERROR_CODE_SUCCESS) {
763 if (!connection->source_supported || (connection->avdtp_l2cap_psm == 0)) {
764 status = SDP_SERVICE_NOT_FOUND;
765 }
766 }
767 break;
768 case AVDTP_SIGNALING_CONNECTION_OPENED:
769 // without suitable SDP Record, avdtp version v0.0 is assumed
770 break;
771 default:
772 // we must have had an incoming connection in the meantime -> bail out
773 // just trigger next sdp query on complete
774 handle_query_complete = false;
775 break;
776 }
777
778 if (handle_query_complete){
779 if (status == ERROR_CODE_SUCCESS){
780 avdtp_handle_sdp_query_succeeded(connection);
781 } else {
782 avdtp_handle_sdp_query_failed(connection, status);
783 }
784 }
785
786 // register the SDP Query request to check if there is another connection waiting for the query
787 if (avdtp_get_next_connection_ready_for_sdp_query() != NULL){
788 // ignore ERROR_CODE_COMMAND_DISALLOWED because in that case, we already have requested an SDP callback
789 (void) sdp_client_register_query_callback(&avdtp_handle_sdp_client_query_request);
790 }
791 }
792
avdtp_handle_incoming_connection(avdtp_connection_t * connection,bd_addr_t event_addr,hci_con_handle_t con_handle,uint16_t local_cid)793 static avdtp_connection_t * avdtp_handle_incoming_connection(avdtp_connection_t * connection, bd_addr_t event_addr, hci_con_handle_t con_handle, uint16_t local_cid){
794 if (connection == NULL){
795 uint16_t cid = avdtp_get_next_cid();
796 connection = avdtp_create_connection(event_addr, cid);
797 }
798
799 if (connection) {
800 connection->state = AVDTP_SIGNALING_CONNECTION_W4_L2CAP_CONNECTED;
801 connection->l2cap_signaling_cid = local_cid;
802 connection->con_handle = con_handle;
803 btstack_run_loop_remove_timer(&connection->retry_timer);
804 }
805 return connection;
806 }
807
avdtp_retry_timer_timeout_handler(btstack_timer_source_t * timer)808 static void avdtp_retry_timer_timeout_handler(btstack_timer_source_t * timer){
809 uint16_t avdtp_cid = (uint16_t)(uintptr_t) btstack_run_loop_get_timer_context(timer);
810
811 avdtp_connection_t * connection = avdtp_get_connection_for_avdtp_cid(avdtp_cid);
812 if (connection == NULL) return;
813
814 if (connection->state == AVDTP_SIGNALING_CONNECTION_W2_L2CAP_RETRY){
815 connection->state = AVDTP_SIGNALING_CONNECTION_W4_L2CAP_CONNECTED;
816 l2cap_create_channel(&avdtp_packet_handler, connection->remote_addr, connection->avdtp_l2cap_psm, AVDTP_L2CAP_MTU, NULL);
817 }
818 }
819
avdtp_retry_timer_start(avdtp_connection_t * connection)820 static void avdtp_retry_timer_start(avdtp_connection_t * connection){
821 btstack_run_loop_set_timer_handler(&connection->retry_timer, avdtp_retry_timer_timeout_handler);
822 btstack_run_loop_set_timer_context(&connection->retry_timer, (void *)(uintptr_t)connection->avdtp_cid);
823
824 // add some jitter/randomness to reconnect delay
825 uint32_t timeout = 100 + (btstack_run_loop_get_time_ms() & 0x7F);
826 btstack_run_loop_set_timer(&connection->retry_timer, timeout);
827 btstack_run_loop_add_timer(&connection->retry_timer);
828 }
829
avdtp_handle_close_media_channel(avdtp_stream_endpoint_t * stream_endpoint)830 static void avdtp_handle_close_media_channel(avdtp_stream_endpoint_t * stream_endpoint){
831 avdtp_connection_t * connection = stream_endpoint->connection;
832 btstack_assert(connection != NULL);
833 avdtp_streaming_emit_connection_released(stream_endpoint, connection->avdtp_cid, avdtp_local_seid(stream_endpoint));
834 avdtp_reset_stream_endpoint(stream_endpoint);
835 connection->configuration_state = AVDTP_CONFIGURATION_STATE_IDLE;
836 }
837
avdtp_handle_close_recovery_channel(avdtp_stream_endpoint_t * stream_endpoint)838 static void avdtp_handle_close_recovery_channel(avdtp_stream_endpoint_t * stream_endpoint){
839 log_info("L2CAP_EVENT_CHANNEL_CLOSED recovery cid 0x%0x", stream_endpoint->l2cap_recovery_cid);
840 stream_endpoint->l2cap_recovery_cid = 0;
841 }
842
avdtp_handle_close_reporting_channel(avdtp_stream_endpoint_t * stream_endpoint)843 static void avdtp_handle_close_reporting_channel(avdtp_stream_endpoint_t * stream_endpoint){
844 log_info("L2CAP_EVENT_CHANNEL_CLOSED reporting cid 0x%0x", stream_endpoint->l2cap_reporting_cid);
845 stream_endpoint->l2cap_reporting_cid = 0;
846 }
847
848
avdtp_packet_handler(uint8_t packet_type,uint16_t channel,uint8_t * packet,uint16_t size)849 void avdtp_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
850 bd_addr_t event_addr;
851 uint16_t psm;
852 uint16_t local_cid;
853 uint8_t status;
854 uint16_t l2cap_mtu;
855 hci_con_handle_t con_handle;
856
857 bool accept_streaming_connection;
858 bool outoing_signaling_active;
859 bool decline_connection;
860
861 avdtp_stream_endpoint_t * stream_endpoint = NULL;
862 avdtp_connection_t * connection = NULL;
863
864 switch (packet_type) {
865 case L2CAP_DATA_PACKET:
866 connection = avdtp_get_connection_for_l2cap_signaling_cid(channel);
867 if (connection){
868 handle_l2cap_data_packet_for_signaling_connection(connection, packet, size);
869 break;
870 }
871
872 stream_endpoint = avdtp_get_stream_endpoint_for_l2cap_cid(channel);
873 if (!stream_endpoint){
874 if (!connection) break;
875 handle_l2cap_data_packet_for_signaling_connection(connection, packet, size);
876 break;
877 }
878
879 if (stream_endpoint->connection){
880 if (channel == stream_endpoint->connection->l2cap_signaling_cid){
881 handle_l2cap_data_packet_for_signaling_connection(stream_endpoint->connection, packet, size);
882 break;
883 }
884 }
885
886 if (channel == stream_endpoint->l2cap_media_cid){
887 btstack_assert(avdtp_sink_handle_media_data);
888 (*avdtp_sink_handle_media_data)(avdtp_local_seid(stream_endpoint), packet, size);
889 break;
890 }
891
892 if (channel == stream_endpoint->l2cap_reporting_cid){
893 log_info("L2CAP_DATA_PACKET for reporting: NOT IMPLEMENTED");
894 } else if (channel == stream_endpoint->l2cap_recovery_cid){
895 log_info("L2CAP_DATA_PACKET for recovery: NOT IMPLEMENTED");
896 } else {
897 log_error("avdtp packet handler L2CAP_DATA_PACKET: local cid 0x%02x not found", channel);
898 }
899 break;
900
901 case HCI_EVENT_PACKET:
902 switch (hci_event_packet_get_type(packet)) {
903
904 case L2CAP_EVENT_INCOMING_CONNECTION:
905 l2cap_event_incoming_connection_get_address(packet, event_addr);
906 local_cid = l2cap_event_incoming_connection_get_local_cid(packet);
907 con_handle = l2cap_event_incoming_connection_get_handle(packet);
908 outoing_signaling_active = false;
909 accept_streaming_connection = false;
910
911 connection = avdtp_get_connection_for_bd_addr(event_addr);
912 if (connection != NULL){
913 switch (connection->state){
914 case AVDTP_SIGNALING_CONNECTION_W4_L2CAP_DISCONNECTED:
915 case AVDTP_SIGNALING_CONNECTION_W4_L2CAP_CONNECTED:
916 outoing_signaling_active = true;
917 connection->incoming_declined = true;
918 break;
919 case AVDTP_SIGNALING_CONNECTION_OPENED:
920 outoing_signaling_active = true;
921 accept_streaming_connection = true;
922 break;
923 default:
924 break;
925 }
926 }
927 log_info("incoming: %s, outoing_signaling_active %d, accept_streaming_connection %d",
928 bd_addr_to_str(event_addr), outoing_signaling_active, accept_streaming_connection);
929
930 decline_connection = outoing_signaling_active && !accept_streaming_connection;
931 if (outoing_signaling_active == false){
932 connection = avdtp_handle_incoming_connection(connection, event_addr, con_handle, local_cid);
933 if (connection == NULL){
934 decline_connection = true;
935 }
936 } else if (accept_streaming_connection){
937 if ((connection == NULL) || (connection->configuration_state != AVDTP_CONFIGURATION_STATE_REMOTE_CONFIGURED)) {
938 decline_connection = true;
939 } else {
940 // now, we're only dealing with media connections that are created by remote side - we're acceptor here
941 stream_endpoint = avdtp_get_stream_endpoint_for_seid(connection->acceptor_local_seid);
942 if ((stream_endpoint == NULL) || (stream_endpoint->l2cap_media_cid != 0) ) {
943 decline_connection = true;
944 }
945 }
946 }
947
948 if (decline_connection){
949 l2cap_decline_connection(local_cid);
950 } else {
951 l2cap_accept_connection(local_cid);
952 }
953 break;
954
955 case L2CAP_EVENT_CHANNEL_OPENED:
956
957 psm = l2cap_event_channel_opened_get_psm(packet);
958 if (psm != BLUETOOTH_PSM_AVDTP){
959 log_info("Unexpected PSM - Not implemented yet, avdtp sink: L2CAP_EVENT_CHANNEL_OPENED ");
960 return;
961 }
962
963 status = l2cap_event_channel_opened_get_status(packet);
964 // inform about new l2cap connection
965 l2cap_event_channel_opened_get_address(packet, event_addr);
966 local_cid = l2cap_event_channel_opened_get_local_cid(packet);
967 l2cap_mtu = l2cap_event_channel_opened_get_remote_mtu(packet);
968 connection = avdtp_get_connection_for_bd_addr(event_addr);
969 if (connection == NULL){
970 log_info("L2CAP_EVENT_CHANNEL_OPENED: no connection found for %s", bd_addr_to_str(event_addr));
971 break;
972 }
973
974 con_handle = l2cap_event_channel_opened_get_handle(packet);
975
976 switch (connection->state){
977 case AVDTP_SIGNALING_CONNECTION_W4_L2CAP_CONNECTED:
978 switch (status){
979 case ERROR_CODE_SUCCESS:
980 connection->l2cap_signaling_cid = local_cid;
981 connection->incoming_declined = false;
982 connection->l2cap_mtu = l2cap_mtu;
983 connection->con_handle = con_handle;
984 connection->state = AVDTP_SIGNALING_CONNECTION_OPENED;
985 log_info("Connection opened l2cap_signaling_cid 0x%02x, avdtp_cid 0x%02x, con_handle 0x%02x", connection->l2cap_signaling_cid, connection->avdtp_cid, con_handle);
986 avdtp_signaling_emit_connection_established(connection->avdtp_cid, event_addr, con_handle, status);
987 return;
988 case L2CAP_CONNECTION_RESPONSE_RESULT_REFUSED_RESOURCES:
989 if (connection->incoming_declined == true) {
990 log_info("Connection was declined, and the outgoing failed");
991 connection->state = AVDTP_SIGNALING_CONNECTION_W2_L2CAP_RETRY;
992 connection->incoming_declined = false;
993 avdtp_retry_timer_start(connection);
994 return;
995 }
996 break;
997 default:
998 log_info("Connection to %s failed. status code 0x%02x", bd_addr_to_str(event_addr), status);
999 break;
1000 }
1001 avdtp_signaling_emit_connection_established(connection->avdtp_cid, event_addr, con_handle, status);
1002 avdtp_finalize_connection(connection);
1003 break;
1004
1005 case AVDTP_SIGNALING_CONNECTION_OPENED:
1006 stream_endpoint = avdtp_get_stream_endpoint_for_signaling_cid(connection->l2cap_signaling_cid);
1007 if (!stream_endpoint){
1008 log_info("L2CAP_EVENT_CHANNEL_OPENED: stream_endpoint not found for signaling cid 0x%02x", connection->l2cap_signaling_cid);
1009 return;
1010 }
1011 if (status != ERROR_CODE_SUCCESS){
1012 log_info("AVDTP_STREAM_ENDPOINT_OPENED failed with status %d, avdtp cid 0x%02x, l2cap_media_cid 0x%02x, local seid %d, remote seid %d", status, connection->avdtp_cid, stream_endpoint->l2cap_media_cid, avdtp_local_seid(stream_endpoint), avdtp_remote_seid(stream_endpoint));
1013 stream_endpoint->state = AVDTP_STREAM_ENDPOINT_IDLE;
1014 avdtp_streaming_emit_connection_established(stream_endpoint, status);
1015 break;
1016 }
1017 switch (stream_endpoint->state){
1018 case AVDTP_STREAM_ENDPOINT_W4_L2CAP_FOR_MEDIA_CONNECTED:
1019 stream_endpoint->state = AVDTP_STREAM_ENDPOINT_OPENED;
1020 stream_endpoint->l2cap_media_cid = l2cap_event_channel_opened_get_local_cid(packet);
1021 stream_endpoint->media_con_handle = l2cap_event_channel_opened_get_handle(packet);
1022
1023 log_info("AVDTP_STREAM_ENDPOINT_OPENED, avdtp cid 0x%02x, l2cap_media_cid 0x%02x, local seid %d, remote seid %d", connection->avdtp_cid, stream_endpoint->l2cap_media_cid, avdtp_local_seid(stream_endpoint), avdtp_remote_seid(stream_endpoint));
1024 avdtp_streaming_emit_connection_established(stream_endpoint, ERROR_CODE_SUCCESS);
1025 break;
1026 default:
1027 log_info("AVDTP_STREAM_ENDPOINT_OPENED failed - stream endpoint in wrong state %d, avdtp cid 0x%02x, l2cap_media_cid 0x%02x, local seid %d, remote seid %d", stream_endpoint->state, connection->avdtp_cid, stream_endpoint->l2cap_media_cid, avdtp_local_seid(stream_endpoint), avdtp_remote_seid(stream_endpoint));
1028 avdtp_streaming_emit_connection_established(stream_endpoint, ERROR_CODE_COMMAND_DISALLOWED);
1029 break;
1030 }
1031 break;
1032
1033 default:
1034 log_info("L2CAP connection to %s ignored: status code 0x%02x, connection state %d", bd_addr_to_str(event_addr), status, connection->state);
1035 break;
1036 }
1037 break;
1038
1039 case L2CAP_EVENT_CHANNEL_CLOSED:
1040 local_cid = l2cap_event_channel_closed_get_local_cid(packet);
1041 stream_endpoint = avdtp_get_stream_endpoint_for_l2cap_cid(local_cid);
1042 connection = avdtp_get_connection_for_l2cap_signaling_cid(local_cid);
1043
1044 log_info("Received L2CAP_EVENT_CHANNEL_CLOSED, cid 0x%2x, connection %p, stream_endpoint %p", local_cid, connection, stream_endpoint);
1045
1046 if (stream_endpoint){
1047 if (stream_endpoint->l2cap_media_cid == local_cid){
1048 avdtp_handle_close_media_channel(stream_endpoint);
1049 break;
1050 }
1051 if (stream_endpoint->l2cap_recovery_cid == local_cid){
1052 avdtp_handle_close_recovery_channel(stream_endpoint);
1053 break;
1054 }
1055 if (stream_endpoint->l2cap_reporting_cid == local_cid){
1056 avdtp_handle_close_reporting_channel(stream_endpoint);
1057 break;
1058 }
1059 }
1060
1061 if (connection){
1062 // closing signaling channel invalidates all other channels as well
1063 btstack_linked_list_iterator_t it;
1064 btstack_linked_list_iterator_init(&it, avdtp_get_stream_endpoints());
1065 while (btstack_linked_list_iterator_has_next(&it)){
1066 stream_endpoint = (avdtp_stream_endpoint_t *)btstack_linked_list_iterator_next(&it);
1067 if (stream_endpoint->connection == connection){
1068 avdtp_handle_close_recovery_channel(stream_endpoint);
1069 avdtp_handle_close_reporting_channel(stream_endpoint);
1070 avdtp_handle_close_media_channel(stream_endpoint);
1071 avdtp_reset_stream_endpoint(stream_endpoint);
1072 }
1073 }
1074 avdtp_signaling_emit_connection_released(connection->avdtp_cid);
1075 avdtp_finalize_connection(connection);
1076 break;
1077 }
1078 break;
1079
1080 case L2CAP_EVENT_CAN_SEND_NOW:
1081 log_debug("avdtp_packet_handler, L2CAP_EVENT_CAN_SEND_NOW l2cap_cid 0x%02x", channel);
1082 avdtp_handle_can_send_now(channel);
1083 break;
1084 default:
1085 log_info("Unknown HCI event type %02x", hci_event_packet_get_type(packet));
1086 break;
1087 }
1088 break;
1089
1090 default:
1091 // other packet type
1092 break;
1093 }
1094 }
1095
avdtp_disconenct_streamendpoints(const avdtp_connection_t * connection)1096 static void avdtp_disconenct_streamendpoints(const avdtp_connection_t *connection) {
1097 btstack_linked_list_iterator_t it;
1098 btstack_linked_list_iterator_init(&it, avdtp_get_stream_endpoints());
1099 while (btstack_linked_list_iterator_has_next(&it)){
1100 avdtp_stream_endpoint_t * stream_endpoint = (avdtp_stream_endpoint_t *)btstack_linked_list_iterator_next(&it);
1101 if (stream_endpoint->connection != connection) continue;
1102
1103 switch (stream_endpoint->state){
1104 case AVDTP_STREAM_ENDPOINT_OPENED:
1105 case AVDTP_STREAM_ENDPOINT_STREAMING:
1106 stream_endpoint->state = AVDTP_STREAM_ENDPOINT_W4_L2CAP_FOR_MEDIA_DISCONNECTED;
1107 l2cap_disconnect(stream_endpoint->l2cap_media_cid);
1108 break;
1109 default:
1110 break;
1111 }
1112 }
1113 }
1114
avdtp_disconnect(uint16_t avdtp_cid)1115 uint8_t avdtp_disconnect(uint16_t avdtp_cid){
1116 avdtp_connection_t * connection = avdtp_get_connection_for_avdtp_cid(avdtp_cid);
1117 if (!connection) return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1118
1119 switch (connection->state){
1120 case AVDTP_SIGNALING_CONNECTION_OPENED:
1121 avdtp_disconenct_streamendpoints(connection);
1122 connection->state = AVDTP_SIGNALING_CONNECTION_W4_L2CAP_DISCONNECTED;
1123 l2cap_disconnect(connection->l2cap_signaling_cid);
1124 break;
1125 case AVDTP_SIGNALING_CONNECTION_W4_L2CAP_DISCONNECTED:
1126 // stream endpoints closed, wait for disconnected
1127 break;
1128 default:
1129 // connection has not been reported as established yet, report open failed
1130 avdtp_signaling_emit_connection_established(connection->avdtp_cid, connection->remote_addr,
1131 connection->con_handle, ERROR_CODE_UNSPECIFIED_ERROR);
1132 avdtp_finalize_connection(connection);
1133 break;
1134 }
1135 return ERROR_CODE_SUCCESS;
1136 }
1137
1138
1139 #ifdef ENABLE_AVDTP_ACCEPTOR_EXPLICIT_START_STREAM_CONFIRMATION
avdtp_handle_explicit_start_stream_confirmation(uint16_t avdtp_cid,uint8_t local_seid,bool accept_stream_requested)1140 static uint8_t avdtp_handle_explicit_start_stream_confirmation(uint16_t avdtp_cid, uint8_t local_seid, bool accept_stream_requested){
1141 avdtp_connection_t * connection = avdtp_get_connection_for_avdtp_cid(avdtp_cid);
1142 if (!connection){
1143 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1144 }
1145
1146 if (connection->state != AVDTP_SIGNALING_CONNECTION_OPENED) {
1147 log_error("avdtp_media_connect: wrong connection state %d", connection->state);
1148 return ERROR_CODE_COMMAND_DISALLOWED;
1149 }
1150
1151 avdtp_stream_endpoint_t * stream_endpoint = avdtp_get_stream_endpoint_for_seid(local_seid);
1152 if (!stream_endpoint) {
1153 log_error("avdtp_media_connect: no stream_endpoint with seid %d found", local_seid);
1154 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1155 }
1156
1157 if (stream_endpoint->acceptor_config_state != AVDTP_ACCEPTOR_W4_USER_CONFIRM_START_STREAM){
1158 return ERROR_CODE_COMMAND_DISALLOWED;
1159 }
1160
1161 if (accept_stream_requested){
1162 stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_ACCEPT_START_STREAM;
1163 } else {
1164 stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_REJECT_START_STREAM;
1165 }
1166 avdtp_request_can_send_now_acceptor(connection);
1167 return ERROR_CODE_SUCCESS;
1168 }
1169
avdtp_start_stream_accept(uint16_t avdtp_cid,uint8_t local_seid)1170 uint8_t avdtp_start_stream_accept(uint16_t avdtp_cid, uint8_t local_seid){
1171 return avdtp_handle_explicit_start_stream_confirmation(avdtp_cid, local_seid, true);
1172 }
1173
avdtp_start_stream_reject(uint16_t avdtp_cid,uint8_t local_seid)1174 uint8_t avdtp_start_stream_reject(uint16_t avdtp_cid, uint8_t local_seid){
1175 return avdtp_handle_explicit_start_stream_confirmation(avdtp_cid, local_seid, false);
1176 }
1177 #endif
1178
avdtp_open_stream(uint16_t avdtp_cid,uint8_t local_seid,uint8_t remote_seid)1179 uint8_t avdtp_open_stream(uint16_t avdtp_cid, uint8_t local_seid, uint8_t remote_seid){
1180 avdtp_connection_t * connection = avdtp_get_connection_for_avdtp_cid(avdtp_cid);
1181 if (!connection){
1182 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1183 }
1184
1185 if (connection->state != AVDTP_SIGNALING_CONNECTION_OPENED) {
1186 log_error("avdtp_media_connect: wrong connection state %d", connection->state);
1187 return ERROR_CODE_COMMAND_DISALLOWED;
1188 }
1189
1190 avdtp_stream_endpoint_t * stream_endpoint = avdtp_get_stream_endpoint_for_seid(local_seid);
1191 if (!stream_endpoint) {
1192 log_error("avdtp_media_connect: no stream_endpoint with seid %d found", local_seid);
1193 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1194 }
1195
1196 if (stream_endpoint->remote_sep.seid != remote_seid){
1197 log_error("avdtp_media_connect: no remote sep with seid %d registered with the stream endpoint", remote_seid);
1198 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1199 }
1200
1201 if (stream_endpoint->state < AVDTP_STREAM_ENDPOINT_CONFIGURED) return ERROR_CODE_COMMAND_DISALLOWED;
1202
1203 connection->initiator_transaction_label= avdtp_get_next_transaction_label();
1204 connection->initiator_remote_seid = remote_seid;
1205 connection->initiator_local_seid = local_seid;
1206 stream_endpoint->initiator_config_state = AVDTP_INITIATOR_W2_OPEN_STREAM;
1207 stream_endpoint->state = AVDTP_STREAM_ENDPOINT_W2_REQUEST_OPEN_STREAM;
1208 avdtp_request_can_send_now_initiator(connection);
1209 return ERROR_CODE_SUCCESS;
1210 }
1211
avdtp_start_stream(uint16_t avdtp_cid,uint8_t local_seid)1212 uint8_t avdtp_start_stream(uint16_t avdtp_cid, uint8_t local_seid){
1213 avdtp_connection_t * connection = avdtp_get_connection_for_avdtp_cid(avdtp_cid);
1214 if (!connection){
1215 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1216 }
1217
1218 avdtp_stream_endpoint_t * stream_endpoint = avdtp_get_stream_endpoint_for_seid(local_seid);
1219 if (!stream_endpoint) {
1220 log_error("avdtp_start_stream: no stream_endpoint with seid %d found", local_seid);
1221 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1222 }
1223
1224 if (stream_endpoint->l2cap_media_cid == 0){
1225 log_error("avdtp_start_stream: no media connection for stream_endpoint with seid %d found", local_seid);
1226 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1227 }
1228
1229 if (!is_avdtp_remote_seid_registered(stream_endpoint)){
1230 log_error("avdtp_media_connect: no remote sep registered with the stream endpoint");
1231 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1232 }
1233
1234 if (!is_avdtp_remote_seid_registered(stream_endpoint) || stream_endpoint->start_stream == 1){
1235 return ERROR_CODE_COMMAND_DISALLOWED;
1236 }
1237
1238 if (stream_endpoint->start_stream == 1) {
1239 return ERROR_CODE_COMMAND_DISALLOWED;
1240 }
1241
1242 stream_endpoint->start_stream = 1;
1243 connection->initiator_local_seid = local_seid;
1244 connection->initiator_remote_seid = stream_endpoint->remote_sep.seid;
1245 avdtp_request_can_send_now_initiator(connection);
1246 return ERROR_CODE_SUCCESS;
1247 }
1248
avdtp_stop_stream(uint16_t avdtp_cid,uint8_t local_seid)1249 uint8_t avdtp_stop_stream(uint16_t avdtp_cid, uint8_t local_seid){
1250 avdtp_connection_t * connection = avdtp_get_connection_for_avdtp_cid(avdtp_cid);
1251 if (!connection){
1252 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1253 }
1254
1255 avdtp_stream_endpoint_t * stream_endpoint = avdtp_get_stream_endpoint_for_seid(local_seid);
1256 if (!stream_endpoint) {
1257 log_error("avdtp_stop_stream: no stream_endpoint with seid %d found", local_seid);
1258 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1259 }
1260
1261 if (stream_endpoint->l2cap_media_cid == 0){
1262 log_error("avdtp_stop_stream: no media connection for stream_endpoint with seid %d found", local_seid);
1263 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1264 }
1265
1266 if (!is_avdtp_remote_seid_registered(stream_endpoint) || stream_endpoint->close_stream){
1267 return ERROR_CODE_COMMAND_DISALLOWED;
1268 }
1269
1270 if (stream_endpoint->close_stream == 1) {
1271 return ERROR_CODE_COMMAND_DISALLOWED;
1272 }
1273
1274 stream_endpoint->close_stream = 1;
1275 connection->initiator_local_seid = local_seid;
1276 connection->initiator_remote_seid = stream_endpoint->remote_sep.seid;
1277 avdtp_request_can_send_now_initiator(connection);
1278 return ERROR_CODE_SUCCESS;
1279 }
1280
avdtp_abort_stream(uint16_t avdtp_cid,uint8_t local_seid)1281 uint8_t avdtp_abort_stream(uint16_t avdtp_cid, uint8_t local_seid){
1282 avdtp_connection_t * connection = avdtp_get_connection_for_avdtp_cid(avdtp_cid);
1283 if (!connection){
1284 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1285 }
1286
1287 avdtp_stream_endpoint_t * stream_endpoint = avdtp_get_stream_endpoint_for_seid(local_seid);
1288 if (!stream_endpoint) {
1289 log_error("avdtp_abort_stream: no stream_endpoint with seid %d found", local_seid);
1290 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1291 }
1292
1293 if (stream_endpoint->l2cap_media_cid == 0){
1294 log_error("avdtp_abort_stream: no media connection for stream_endpoint with seid %d found", local_seid);
1295 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1296 }
1297
1298 if (!is_avdtp_remote_seid_registered(stream_endpoint) || stream_endpoint->abort_stream){
1299 return ERROR_CODE_COMMAND_DISALLOWED;
1300 }
1301
1302 if (stream_endpoint->abort_stream == 1) {
1303 return ERROR_CODE_COMMAND_DISALLOWED;
1304 }
1305
1306 stream_endpoint->abort_stream = 1;
1307 connection->initiator_local_seid = local_seid;
1308 connection->initiator_remote_seid = stream_endpoint->remote_sep.seid;
1309 avdtp_request_can_send_now_initiator(connection);
1310 return ERROR_CODE_SUCCESS;
1311 }
1312
avdtp_suspend_stream(uint16_t avdtp_cid,uint8_t local_seid)1313 uint8_t avdtp_suspend_stream(uint16_t avdtp_cid, uint8_t local_seid){
1314 avdtp_connection_t * connection = avdtp_get_connection_for_avdtp_cid(avdtp_cid);
1315 if (!connection){
1316 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1317 }
1318 avdtp_stream_endpoint_t * stream_endpoint = avdtp_get_stream_endpoint_for_seid(local_seid);
1319 if (!stream_endpoint) {
1320 log_error("avdtp_suspend_stream: no stream_endpoint with seid %d found", local_seid);
1321 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1322 }
1323
1324 if (stream_endpoint->l2cap_media_cid == 0){
1325 log_error("avdtp_suspend_stream: no media connection for stream_endpoint with seid %d found", local_seid);
1326 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1327 }
1328
1329 if (!is_avdtp_remote_seid_registered(stream_endpoint)){
1330 return ERROR_CODE_COMMAND_DISALLOWED;
1331 }
1332
1333 if (stream_endpoint->state != AVDTP_STREAM_ENDPOINT_STREAMING){
1334 return ERROR_CODE_COMMAND_DISALLOWED;
1335 }
1336
1337 if (stream_endpoint->suspend_stream == 1) {
1338 return ERROR_CODE_COMMAND_DISALLOWED;
1339 }
1340
1341 stream_endpoint->suspend_stream = 1;
1342 connection->initiator_local_seid = local_seid;
1343 connection->initiator_remote_seid = stream_endpoint->remote_sep.seid;
1344 avdtp_request_can_send_now_initiator(connection);
1345 return ERROR_CODE_SUCCESS;
1346 }
1347
avdtp_discover_stream_endpoints(uint16_t avdtp_cid)1348 uint8_t avdtp_discover_stream_endpoints(uint16_t avdtp_cid){
1349 avdtp_connection_t * connection = avdtp_get_connection_for_avdtp_cid(avdtp_cid);
1350 if (!connection){
1351 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1352 }
1353 if ((connection->state != AVDTP_SIGNALING_CONNECTION_OPENED) ||
1354 (connection->initiator_connection_state != AVDTP_SIGNALING_CONNECTION_INITIATOR_IDLE)) {
1355 return ERROR_CODE_COMMAND_DISALLOWED;
1356 }
1357
1358 connection->initiator_transaction_label= avdtp_get_next_transaction_label();
1359 connection->initiator_connection_state = AVDTP_SIGNALING_CONNECTION_INITIATOR_W2_DISCOVER_SEPS;
1360 return avdtp_request_can_send_now_initiator(connection);
1361 }
1362
1363
avdtp_get_capabilities(uint16_t avdtp_cid,uint8_t remote_seid)1364 uint8_t avdtp_get_capabilities(uint16_t avdtp_cid, uint8_t remote_seid){
1365 avdtp_connection_t * connection = avdtp_get_connection_for_avdtp_cid(avdtp_cid);
1366 if (!connection){
1367 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1368 }
1369 if ((connection->state != AVDTP_SIGNALING_CONNECTION_OPENED) ||
1370 (connection->initiator_connection_state != AVDTP_SIGNALING_CONNECTION_INITIATOR_IDLE)) {
1371 return ERROR_CODE_COMMAND_DISALLOWED;
1372 }
1373
1374 connection->initiator_transaction_label= avdtp_get_next_transaction_label();
1375 connection->initiator_connection_state = AVDTP_SIGNALING_CONNECTION_INITIATOR_W2_GET_CAPABILITIES;
1376 connection->initiator_remote_seid = remote_seid;
1377 return avdtp_request_can_send_now_initiator(connection);
1378 }
1379
1380
avdtp_get_all_capabilities(uint16_t avdtp_cid,uint8_t remote_seid,avdtp_role_t role)1381 uint8_t avdtp_get_all_capabilities(uint16_t avdtp_cid, uint8_t remote_seid, avdtp_role_t role) {
1382 avdtp_connection_t * connection = avdtp_get_connection_for_avdtp_cid(avdtp_cid);
1383 if (!connection){
1384 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1385 }
1386 if ((connection->state != AVDTP_SIGNALING_CONNECTION_OPENED) ||
1387 (connection->initiator_connection_state != AVDTP_SIGNALING_CONNECTION_INITIATOR_IDLE)) {
1388 return ERROR_CODE_COMMAND_DISALLOWED;
1389 }
1390
1391 connection->initiator_transaction_label= avdtp_get_next_transaction_label();
1392 connection->initiator_remote_seid = remote_seid;
1393
1394 if (connection->avdtp_version == 0){
1395 switch(role){
1396 case AVDTP_ROLE_SINK:
1397 connection->initiator_connection_state = AVDTP_SIGNALING_CONNECTION_INITIATOR_W2_SEND_SDP_QUERY_THEN_GET_ALL_CAPABILITIES_FROM_REMOTE_SOURCE;
1398 break;
1399 case AVDTP_ROLE_SOURCE:
1400 connection->initiator_connection_state = AVDTP_SIGNALING_CONNECTION_INITIATOR_W2_SEND_SDP_QUERY_THEN_GET_ALL_CAPABILITIES_FROM_REMOTE_SINK;
1401 break;
1402 default:
1403 btstack_unreachable();
1404 break;
1405 }
1406 // ignore ERROR_CODE_COMMAND_DISALLOWED because in that case, we already have requested an SDP callback
1407 (void) sdp_client_register_query_callback(&avdtp_handle_sdp_client_query_request);
1408 return ERROR_CODE_SUCCESS;
1409 } else {
1410 // AVDTP version lower then 1.3 supports only get capabilities command
1411 if (connection->avdtp_version < 0x103){
1412 connection->initiator_connection_state = AVDTP_SIGNALING_CONNECTION_INITIATOR_W2_GET_CAPABILITIES;
1413 } else {
1414 connection->initiator_connection_state = AVDTP_SIGNALING_CONNECTION_INITIATOR_W2_GET_ALL_CAPABILITIES;
1415 }
1416 return avdtp_request_can_send_now_initiator(connection);
1417 }
1418 }
1419
avdtp_get_configuration(uint16_t avdtp_cid,uint8_t remote_seid)1420 uint8_t avdtp_get_configuration(uint16_t avdtp_cid, uint8_t remote_seid){
1421 avdtp_connection_t * connection = avdtp_get_connection_for_avdtp_cid(avdtp_cid);
1422 if (!connection){
1423 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1424 }
1425 if ((connection->state != AVDTP_SIGNALING_CONNECTION_OPENED) ||
1426 (connection->initiator_connection_state != AVDTP_SIGNALING_CONNECTION_INITIATOR_IDLE)) {
1427 return ERROR_CODE_COMMAND_DISALLOWED;
1428 }
1429
1430 connection->initiator_transaction_label= avdtp_get_next_transaction_label();
1431 connection->initiator_connection_state = AVDTP_SIGNALING_CONNECTION_INITIATOR_W2_GET_CONFIGURATION;
1432 connection->initiator_remote_seid = remote_seid;
1433 return avdtp_request_can_send_now_initiator(connection);
1434 }
1435
avdtp_set_configuration(uint16_t avdtp_cid,uint8_t local_seid,uint8_t remote_seid,uint16_t configured_services_bitmap,avdtp_capabilities_t configuration)1436 uint8_t avdtp_set_configuration(uint16_t avdtp_cid, uint8_t local_seid, uint8_t remote_seid, uint16_t configured_services_bitmap, avdtp_capabilities_t configuration){
1437 avdtp_connection_t * connection = avdtp_get_connection_for_avdtp_cid(avdtp_cid);
1438 if (!connection){
1439 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1440 }
1441 if ((connection->state != AVDTP_SIGNALING_CONNECTION_OPENED) ||
1442 (connection->initiator_connection_state != AVDTP_SIGNALING_CONNECTION_INITIATOR_IDLE)) {
1443 log_error("connection in wrong state, %d, initiator state %d", connection->state, connection->initiator_connection_state);
1444 return ERROR_CODE_COMMAND_DISALLOWED;
1445 }
1446 if (connection->configuration_state != AVDTP_CONFIGURATION_STATE_IDLE){
1447 log_info("configuration already started, config state %u", connection->configuration_state);
1448 return ERROR_CODE_COMMAND_DISALLOWED;
1449 }
1450
1451 avdtp_stream_endpoint_t * stream_endpoint = avdtp_get_stream_endpoint_for_seid(local_seid);
1452 if (!stream_endpoint) {
1453 log_error("No initiator stream endpoint for seid %d", local_seid);
1454 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1455 }
1456 if (stream_endpoint->state >= AVDTP_STREAM_ENDPOINT_CONFIGURED){
1457 log_error("Stream endpoint seid %d in wrong state %d", local_seid, stream_endpoint->state);
1458 return ERROR_CODE_COMMAND_DISALLOWED;
1459 }
1460
1461 connection->active_stream_endpoint = (void*) stream_endpoint;
1462 connection->configuration_state = AVDTP_CONFIGURATION_STATE_LOCAL_INITIATED;
1463
1464 connection->initiator_transaction_label= avdtp_get_next_transaction_label();
1465 connection->initiator_remote_seid = remote_seid;
1466 connection->initiator_local_seid = local_seid;
1467 stream_endpoint->remote_configuration_bitmap = configured_services_bitmap;
1468 stream_endpoint->remote_configuration = configuration;
1469 stream_endpoint->initiator_config_state = AVDTP_INITIATOR_W2_SET_CONFIGURATION;
1470
1471 log_debug("SE %p, initiator_config_state: 0x%02x", stream_endpoint, stream_endpoint->initiator_config_state);
1472
1473 return avdtp_request_can_send_now_initiator(connection);
1474 }
1475
avdtp_reconfigure(uint16_t avdtp_cid,uint8_t local_seid,uint8_t remote_seid,uint16_t configured_services_bitmap,avdtp_capabilities_t configuration)1476 uint8_t avdtp_reconfigure(uint16_t avdtp_cid, uint8_t local_seid, uint8_t remote_seid, uint16_t configured_services_bitmap, avdtp_capabilities_t configuration){
1477 avdtp_connection_t * connection = avdtp_get_connection_for_avdtp_cid(avdtp_cid);
1478 if (!connection){
1479 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1480 }
1481 //TODO: if opened only app capabilities, enable reconfigure for not opened
1482 if ((connection->state != AVDTP_SIGNALING_CONNECTION_OPENED) ||
1483 (connection->initiator_connection_state != AVDTP_SIGNALING_CONNECTION_INITIATOR_IDLE)) {
1484 return ERROR_CODE_COMMAND_DISALLOWED;
1485 }
1486
1487 avdtp_stream_endpoint_t * stream_endpoint = avdtp_get_stream_endpoint_for_seid(local_seid);
1488 if (!stream_endpoint) {
1489 log_error("avdtp_reconfigure: no initiator stream endpoint for seid %d", local_seid);
1490 return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1491 }
1492
1493 if (!is_avdtp_remote_seid_registered(stream_endpoint)){
1494 log_error("avdtp_reconfigure: no associated remote sep");
1495 return ERROR_CODE_COMMAND_DISALLOWED;
1496 }
1497
1498 connection->initiator_transaction_label= avdtp_get_next_transaction_label();
1499 connection->initiator_remote_seid = remote_seid;
1500 connection->initiator_local_seid = local_seid;
1501 stream_endpoint->remote_configuration_bitmap = configured_services_bitmap;
1502 stream_endpoint->remote_configuration = configuration;
1503 stream_endpoint->initiator_config_state = AVDTP_INITIATOR_W2_RECONFIGURE_STREAM_WITH_SEID;
1504 return avdtp_request_can_send_now_initiator(connection);
1505 }
1506
avdtp_set_preferred_sampling_frequency(avdtp_stream_endpoint_t * stream_endpoint,uint32_t sampling_frequency)1507 void avdtp_set_preferred_sampling_frequency(avdtp_stream_endpoint_t * stream_endpoint, uint32_t sampling_frequency){
1508 stream_endpoint->preferred_sampling_frequency = sampling_frequency;
1509 }
1510
avdtp_set_preferred_channel_mode(avdtp_stream_endpoint_t * stream_endpoint,uint8_t channel_mode)1511 void avdtp_set_preferred_channel_mode(avdtp_stream_endpoint_t * stream_endpoint, uint8_t channel_mode){
1512 stream_endpoint->preferred_channel_mode = channel_mode;
1513 }
1514
1515
avdtp_choose_sbc_channel_mode(avdtp_stream_endpoint_t * stream_endpoint,uint8_t remote_channel_mode_bitmap)1516 avdtp_channel_mode_t avdtp_choose_sbc_channel_mode(avdtp_stream_endpoint_t * stream_endpoint, uint8_t remote_channel_mode_bitmap){
1517 uint8_t * media_codec = stream_endpoint->sep.capabilities.media_codec.media_codec_information;
1518 uint8_t channel_mode_bitmap = (media_codec[0] & 0x0F) & remote_channel_mode_bitmap;
1519
1520 // use preferred channel mode if possible
1521 if (stream_endpoint->preferred_channel_mode == AVDTP_SBC_JOINT_STEREO){
1522 return AVDTP_CHANNEL_MODE_JOINT_STEREO;
1523 }
1524 if (stream_endpoint->preferred_channel_mode == AVDTP_SBC_STEREO){
1525 return AVDTP_CHANNEL_MODE_STEREO;
1526 }
1527 if (stream_endpoint->preferred_channel_mode == AVDTP_SBC_DUAL_CHANNEL){
1528 return AVDTP_CHANNEL_MODE_DUAL_CHANNEL;
1529 }
1530 if (stream_endpoint->preferred_channel_mode == AVDTP_SBC_MONO){
1531 return AVDTP_CHANNEL_MODE_MONO;
1532 }
1533
1534
1535 if (channel_mode_bitmap & AVDTP_SBC_JOINT_STEREO){
1536 return AVDTP_CHANNEL_MODE_JOINT_STEREO;
1537 } else if (channel_mode_bitmap & AVDTP_SBC_STEREO){
1538 return AVDTP_CHANNEL_MODE_STEREO;
1539 } else if (channel_mode_bitmap & AVDTP_SBC_DUAL_CHANNEL){
1540 return AVDTP_CHANNEL_MODE_DUAL_CHANNEL;
1541 } else if (channel_mode_bitmap & AVDTP_SBC_MONO){
1542 return AVDTP_CHANNEL_MODE_MONO;
1543 }
1544 return AVDTP_CHANNEL_MODE_JOINT_STEREO;
1545 }
1546
avdtp_choose_sbc_allocation_method(avdtp_stream_endpoint_t * stream_endpoint,uint8_t remote_allocation_method_bitmap)1547 avdtp_sbc_allocation_method_t avdtp_choose_sbc_allocation_method(avdtp_stream_endpoint_t * stream_endpoint, uint8_t remote_allocation_method_bitmap){
1548 uint8_t * media_codec = stream_endpoint->sep.capabilities.media_codec.media_codec_information;
1549 uint8_t allocation_method_bitmap = (media_codec[1] & 0x03) & remote_allocation_method_bitmap;
1550
1551 avdtp_sbc_allocation_method_t allocation_method = AVDTP_SBC_ALLOCATION_METHOD_LOUDNESS;
1552 if (allocation_method_bitmap & AVDTP_SBC_ALLOCATION_METHOD_LOUDNESS){
1553 allocation_method = AVDTP_SBC_ALLOCATION_METHOD_LOUDNESS;
1554 } else if (allocation_method_bitmap & AVDTP_SBC_ALLOCATION_METHOD_SNR){
1555 allocation_method = AVDTP_SBC_ALLOCATION_METHOD_SNR;
1556 }
1557 return allocation_method;
1558 }
1559
avdtp_stream_endpoint_seid(avdtp_stream_endpoint_t * stream_endpoint)1560 uint8_t avdtp_stream_endpoint_seid(avdtp_stream_endpoint_t * stream_endpoint){
1561 if (!stream_endpoint) return 0;
1562 return stream_endpoint->sep.seid;
1563 }
1564
avdtp_choose_sbc_subbands(avdtp_stream_endpoint_t * stream_endpoint,uint8_t remote_subbands_bitmap)1565 avdtp_sbc_subbands_t avdtp_choose_sbc_subbands(avdtp_stream_endpoint_t * stream_endpoint, uint8_t remote_subbands_bitmap){
1566 if (!stream_endpoint) return 0;
1567 uint8_t * media_codec = stream_endpoint->sep.capabilities.media_codec.media_codec_information;
1568 uint8_t subbands_bitmap = ((media_codec[1] >> 2) & 0x03) & remote_subbands_bitmap;
1569
1570 avdtp_sbc_subbands_t subbands = AVDTP_SBC_SUBBANDS_8;
1571 if (subbands_bitmap & AVDTP_SBC_SUBBANDS_8){
1572 subbands = AVDTP_SBC_SUBBANDS_8;
1573 } else if (subbands_bitmap & AVDTP_SBC_SUBBANDS_4){
1574 subbands = AVDTP_SBC_SUBBANDS_4;
1575 }
1576 return subbands;
1577 }
1578
avdtp_choose_sbc_block_length(avdtp_stream_endpoint_t * stream_endpoint,uint8_t remote_block_length_bitmap)1579 avdtp_sbc_block_length_t avdtp_choose_sbc_block_length(avdtp_stream_endpoint_t * stream_endpoint, uint8_t remote_block_length_bitmap){
1580 if (!stream_endpoint) return 0;
1581 uint8_t * media_codec = stream_endpoint->sep.capabilities.media_codec.media_codec_information;
1582 uint8_t block_length_bitmap = (media_codec[1] >> 4) & remote_block_length_bitmap;
1583
1584 avdtp_sbc_block_length_t block_length = AVDTP_SBC_BLOCK_LENGTH_16;
1585 if (block_length_bitmap & AVDTP_SBC_BLOCK_LENGTH_16){
1586 block_length = AVDTP_SBC_BLOCK_LENGTH_16;
1587 } else if (block_length_bitmap & AVDTP_SBC_BLOCK_LENGTH_12){
1588 block_length = AVDTP_SBC_BLOCK_LENGTH_12;
1589 } else if (block_length_bitmap & AVDTP_SBC_BLOCK_LENGTH_8){
1590 block_length = AVDTP_SBC_BLOCK_LENGTH_8;
1591 } else if (block_length_bitmap & AVDTP_SBC_BLOCK_LENGTH_4){
1592 block_length = AVDTP_SBC_BLOCK_LENGTH_4;
1593 }
1594 return block_length;
1595 }
1596
avdtp_get_highest_sampling_frequency(uint8_t sampling_frequency_bitmap)1597 uint16_t avdtp_get_highest_sampling_frequency(uint8_t sampling_frequency_bitmap){
1598 if (sampling_frequency_bitmap & AVDTP_SBC_48000){
1599 return 48000;
1600 }
1601 if (sampling_frequency_bitmap & AVDTP_SBC_44100){
1602 return 44100;
1603 }
1604 if (sampling_frequency_bitmap & AVDTP_SBC_32000){
1605 return 32000;
1606 }
1607 if (sampling_frequency_bitmap & AVDTP_SBC_16000){
1608 return 16000;
1609 }
1610 return 0;
1611 }
1612
avdtp_choose_sbc_sampling_frequency(avdtp_stream_endpoint_t * stream_endpoint,uint8_t remote_sampling_frequency_bitmap)1613 uint16_t avdtp_choose_sbc_sampling_frequency(avdtp_stream_endpoint_t * stream_endpoint, uint8_t remote_sampling_frequency_bitmap){
1614 if (!stream_endpoint) return 0;
1615 uint8_t * media_codec = stream_endpoint->sep.capabilities.media_codec.media_codec_information;
1616 uint8_t supported_sampling_frequency_bitmap = (media_codec[0] >> 4) & remote_sampling_frequency_bitmap;
1617
1618 // use preferred sampling frequency if possible
1619 if ((stream_endpoint->preferred_sampling_frequency == 48000) && (supported_sampling_frequency_bitmap & AVDTP_SBC_48000)){
1620 return stream_endpoint->preferred_sampling_frequency;
1621 }
1622 if ((stream_endpoint->preferred_sampling_frequency == 44100) && (supported_sampling_frequency_bitmap & AVDTP_SBC_44100)){
1623 return stream_endpoint->preferred_sampling_frequency;
1624 }
1625 if ((stream_endpoint->preferred_sampling_frequency == 32000) && (supported_sampling_frequency_bitmap & AVDTP_SBC_32000)){
1626 return stream_endpoint->preferred_sampling_frequency;
1627 }
1628 if ((stream_endpoint->preferred_sampling_frequency == 16000) && (supported_sampling_frequency_bitmap & AVDTP_SBC_16000)){
1629 return stream_endpoint->preferred_sampling_frequency;
1630 }
1631
1632 // otherwise, use highest available
1633 uint16_t sampling_frequency = avdtp_get_highest_sampling_frequency(supported_sampling_frequency_bitmap);
1634 if (sampling_frequency != 0){
1635 return sampling_frequency;
1636 } else {
1637 return 44100; // some default
1638 }
1639 }
1640
avdtp_choose_sbc_max_bitpool_value(avdtp_stream_endpoint_t * stream_endpoint,uint8_t remote_max_bitpool_value)1641 uint8_t avdtp_choose_sbc_max_bitpool_value(avdtp_stream_endpoint_t * stream_endpoint, uint8_t remote_max_bitpool_value){
1642 if (!stream_endpoint) return 0;
1643 uint8_t * media_codec = stream_endpoint->sep.capabilities.media_codec.media_codec_information;
1644 return btstack_min(media_codec[3], remote_max_bitpool_value);
1645 }
1646
avdtp_choose_sbc_min_bitpool_value(avdtp_stream_endpoint_t * stream_endpoint,uint8_t remote_min_bitpool_value)1647 uint8_t avdtp_choose_sbc_min_bitpool_value(avdtp_stream_endpoint_t * stream_endpoint, uint8_t remote_min_bitpool_value){
1648 if (!stream_endpoint) return 0;
1649 uint8_t * media_codec = stream_endpoint->sep.capabilities.media_codec.media_codec_information;
1650 return btstack_max(media_codec[2], remote_min_bitpool_value);
1651 }
1652
is_avdtp_remote_seid_registered(avdtp_stream_endpoint_t * stream_endpoint)1653 uint8_t is_avdtp_remote_seid_registered(avdtp_stream_endpoint_t * stream_endpoint){
1654 if (!stream_endpoint) return 0;
1655 if (stream_endpoint->remote_sep.seid == 0) return 0;
1656 if (stream_endpoint->remote_sep.seid > 0x3E) return 0;
1657 return 1;
1658 }
1659
avdtp_init(void)1660 void avdtp_init(void){
1661 if (!avdtp_l2cap_registered){
1662 avdtp_handle_sdp_client_query_request.callback = &avdtp_handle_start_sdp_client_query;
1663 avdtp_l2cap_registered = true;
1664 l2cap_register_service(&avdtp_packet_handler, BLUETOOTH_PSM_AVDTP, AVDTP_L2CAP_MTU, gap_get_security_level());
1665 }
1666 }
1667
avdtp_deinit(void)1668 void avdtp_deinit(void){
1669 avdtp_sink_handle_media_data = NULL;
1670 avdtp_sink_media_config_validator = NULL;
1671 avdtp_source_media_config_validator = NULL;
1672 avdtp_source_callback = NULL;
1673 avdtp_sink_callback = NULL;
1674
1675 avdtp_sdp_query_context_avdtp_cid = 0;
1676
1677 avdtp_stream_endpoints = NULL;
1678 avdtp_stream_endpoints_id_counter = 0;
1679
1680 avdtp_l2cap_registered = false;
1681
1682 avdtp_connections = NULL;
1683 avdtp_transaction_id_counter = 0;
1684
1685 avdtp_record_id = 0;
1686 avdtp_cid_counter = 0;
1687 }
1688
1689 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
1690 #define FUZZ_CID 0x44
1691 #define FUZZ_CON_HANDLE 0x0001
1692 static bd_addr_t remote_addr = { 0x33, 0x33, 0x33, 0x33, 0x33, 0x33 };
avdtp_init_fuzz(void)1693 void avdtp_init_fuzz(void){
1694 // setup avdtp connections for cid
1695 avdtp_connection_t * connection = avdtp_create_connection(remote_addr, FUZZ_CID);
1696 connection->state = AVDTP_SIGNALING_CONNECTION_OPENED;
1697 connection->l2cap_signaling_cid = FUZZ_CID;
1698 connection->con_handle = FUZZ_CON_HANDLE;
1699 }
avdtp_packet_handler_fuzz(uint8_t * packet,uint16_t size)1700 void avdtp_packet_handler_fuzz(uint8_t *packet, uint16_t size){
1701 avdtp_packet_handler(L2CAP_DATA_PACKET, FUZZ_CID, packet, size);
1702 }
1703 #endif