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_initiator.c"
39
40 #include <stdint.h>
41 #include <string.h>
42
43 #include "bluetooth_psm.h"
44 #include "bluetooth_sdp.h"
45 #include "btstack_debug.h"
46 #include "btstack_event.h"
47 #include "l2cap.h"
48 #include "classic/avdtp.h"
49 #include "classic/avdtp_util.h"
50 #include "classic/avdtp_initiator.h"
51
avdtp_initiator_send_signaling_cmd(uint16_t cid,avdtp_signal_identifier_t identifier,uint8_t transaction_label)52 static int avdtp_initiator_send_signaling_cmd(uint16_t cid, avdtp_signal_identifier_t identifier, uint8_t transaction_label){
53 uint8_t command[2];
54 command[0] = avdtp_header(transaction_label, AVDTP_SINGLE_PACKET, AVDTP_CMD_MSG);
55 command[1] = (uint8_t)identifier;
56 return l2cap_send(cid, command, sizeof(command));
57 }
58
avdtp_initiator_send_signaling_cmd_with_seid(uint16_t cid,avdtp_signal_identifier_t identifier,uint8_t transaction_label,uint8_t sep_id)59 static int avdtp_initiator_send_signaling_cmd_with_seid(uint16_t cid, avdtp_signal_identifier_t identifier, uint8_t transaction_label, uint8_t sep_id){
60 uint8_t command[3];
61 command[0] = avdtp_header(transaction_label, AVDTP_SINGLE_PACKET, AVDTP_CMD_MSG);
62 command[1] = (uint8_t)identifier;
63 command[2] = sep_id << 2;
64 return l2cap_send(cid, command, sizeof(command));
65 }
66
avdtp_initiator_send_signaling_cmd_delay_report(uint16_t cid,uint8_t transaction_label,uint8_t sep_id,uint16_t delay_ms)67 static int avdtp_initiator_send_signaling_cmd_delay_report(uint16_t cid, uint8_t transaction_label, uint8_t sep_id, uint16_t delay_ms){
68 uint8_t command[5];
69 command[0] = avdtp_header(transaction_label, AVDTP_SINGLE_PACKET, AVDTP_CMD_MSG);
70 command[1] = AVDTP_SI_DELAYREPORT;
71 command[2] = sep_id << 2;
72 big_endian_store_16(command, 3, delay_ms);
73 return l2cap_send(cid, command, sizeof(command));
74 }
75
avdtp_initiator_stream_config_subsm(avdtp_connection_t * connection,uint8_t * packet,uint16_t size,int offset)76 void avdtp_initiator_stream_config_subsm(avdtp_connection_t *connection, uint8_t *packet, uint16_t size, int offset) {
77 // int status = 0;
78 avdtp_stream_endpoint_t * stream_endpoint = NULL;
79 avdtp_stream_endpoint_t * stream_endpoint_for_event = NULL;
80
81 avdtp_sep_t sep;
82 if (connection->initiator_connection_state == AVDTP_SIGNALING_CONNECTION_INITIATOR_W4_ANSWER) {
83 connection->initiator_connection_state = AVDTP_SIGNALING_CONNECTION_INITIATOR_IDLE;
84 } else {
85 stream_endpoint = avdtp_get_stream_endpoint_for_seid(connection->initiator_local_seid);
86 if (stream_endpoint == NULL) {
87 log_debug("no stream endpoint for local seid %u", connection->initiator_local_seid);
88 return;
89 }
90 log_debug("using stream endpoint %p for local seid %u", stream_endpoint, connection->initiator_local_seid);
91
92 sep.seid = connection->initiator_remote_seid;
93
94 if (stream_endpoint->initiator_config_state != AVDTP_INITIATOR_W4_ANSWER) {
95 log_error("initiator_config_state is in wrong state %d, expected %d", stream_endpoint->initiator_config_state, AVDTP_INITIATOR_W4_ANSWER);
96 return;
97 }
98 stream_endpoint->initiator_config_state = AVDTP_INITIATOR_STREAM_CONFIG_IDLE;
99 }
100
101 switch (connection->initiator_signaling_packet.message_type){
102 case AVDTP_RESPONSE_ACCEPT_MSG:
103 switch (connection->initiator_signaling_packet.signal_identifier){
104 case AVDTP_SI_DISCOVER:{
105 if (connection->initiator_signaling_packet.transaction_label != connection->initiator_transaction_label){
106 log_info("unexpected transaction label, got %d, expected %d", connection->initiator_signaling_packet.transaction_label, connection->initiator_transaction_label);
107 // status = BAD_HEADER_FORMAT;
108 break;
109 }
110
111 if (size == 3){
112 log_info("ERROR code %02x", packet[offset]);
113 break;
114 }
115
116 int i;
117 for (i = offset; i < size; i += 2){
118 sep.seid = packet[i] >> 2;
119 offset++;
120 if ((sep.seid < 0x01) || (sep.seid > 0x3E)){
121 log_info("invalid sep id");
122 // status = BAD_ACP_SEID;
123 break;
124 }
125 sep.in_use = (packet[i] >> 1) & 0x01;
126 sep.media_type = (avdtp_media_type_t)(packet[i+1] >> 4);
127 sep.type = (avdtp_sep_type_t)((packet[i+1] >> 3) & 0x01);
128 avdtp_signaling_emit_sep(connection->avdtp_cid, sep);
129 }
130 avdtp_signaling_emit_sep_done(connection->avdtp_cid);
131 break;
132 }
133
134 case AVDTP_SI_GET_CAPABILITIES:
135 case AVDTP_SI_GET_ALL_CAPABILITIES:
136 sep.registered_service_categories = avdtp_unpack_service_capabilities(connection, connection->initiator_signaling_packet.signal_identifier, &sep.capabilities, packet+offset, size-offset);
137 avdtp_signaling_emit_capabilities(connection->avdtp_cid,
138 connection->initiator_remote_seid, &sep.capabilities,
139 sep.registered_service_categories);
140 break;
141
142 case AVDTP_SI_RECONFIGURE:
143 if (!stream_endpoint){
144 log_error("AVDTP_SI_RECONFIGURE: stream endpoint is null");
145 break;
146 }
147 stream_endpoint_for_event = stream_endpoint;
148 stream_endpoint->remote_sep.configured_service_categories |= stream_endpoint->remote_configuration_bitmap;
149 stream_endpoint->remote_sep.configuration = stream_endpoint->remote_configuration;
150 stream_endpoint->state = AVDTP_STREAM_ENDPOINT_OPENED;
151
152 // copy media codec configuration if reconfigured and emit config
153 if ((stream_endpoint->remote_configuration_bitmap & (1 << AVDTP_MEDIA_CODEC)) != 0){
154 btstack_assert(stream_endpoint->remote_configuration.media_codec.media_codec_information_len == stream_endpoint->media_codec_configuration_len);
155 (void)memcpy(stream_endpoint->media_codec_configuration_info, stream_endpoint->remote_configuration.media_codec.media_codec_information, stream_endpoint->media_codec_configuration_len);
156 stream_endpoint->sep.configuration.media_codec = stream_endpoint->remote_configuration.media_codec;
157 avdtp_signaling_emit_configuration(stream_endpoint, connection->avdtp_cid, 1, &stream_endpoint->sep.configuration, (1 << AVDTP_MEDIA_CODEC));
158 }
159 break;
160
161 case AVDTP_SI_SET_CONFIGURATION:
162 if (!stream_endpoint){
163 log_error("AVDTP_SI_SET_CONFIGURATION: stream endpoint is null");
164 break;
165 }
166
167 stream_endpoint_for_event = stream_endpoint;
168
169 sep.configured_service_categories = stream_endpoint->remote_configuration_bitmap;
170 sep.configuration = stream_endpoint->remote_configuration;
171 sep.in_use = 1;
172
173 stream_endpoint->state = AVDTP_STREAM_ENDPOINT_CONFIGURED;
174 stream_endpoint->sep.in_use = 1;
175 stream_endpoint->remote_sep = sep;
176 stream_endpoint->connection = connection;
177 connection->configuration_state = AVDTP_CONFIGURATION_STATE_LOCAL_CONFIGURED;
178
179 log_info("configured remote seid %d", stream_endpoint->remote_sep.seid);
180
181 // copy media codec configuration if configured and emit config
182 if ((stream_endpoint->remote_configuration_bitmap & (1 << AVDTP_MEDIA_CODEC)) != 0) {
183 btstack_assert(stream_endpoint->remote_configuration.media_codec.media_codec_information_len == stream_endpoint->media_codec_configuration_len);
184 // copy media codec configuration if length correct
185 (void) memcpy(stream_endpoint->media_codec_configuration_info,
186 stream_endpoint->remote_configuration.media_codec.media_codec_information,
187 stream_endpoint->media_codec_configuration_len);
188 stream_endpoint->sep.configuration.media_codec = stream_endpoint->remote_configuration.media_codec;
189 avdtp_signaling_emit_configuration(stream_endpoint, connection->avdtp_cid, 0, &sep.configuration, (1 << AVDTP_MEDIA_CODEC));
190 }
191 break;
192
193 case AVDTP_SI_OPEN:
194 if (!stream_endpoint){
195 log_error("AVDTP_SI_OPEN: stream endpoint is null");
196 break;
197 }
198 if (stream_endpoint->state != AVDTP_STREAM_ENDPOINT_W4_ACCEPT_OPEN_STREAM) {
199 log_error("AVDTP_SI_OPEN in wrong stream endpoint state %d", stream_endpoint->state);
200 return;
201 }
202 stream_endpoint_for_event = stream_endpoint;
203 stream_endpoint->state = AVDTP_STREAM_ENDPOINT_W4_L2CAP_FOR_MEDIA_CONNECTED;
204 connection->initiator_local_seid = stream_endpoint->sep.seid;
205 l2cap_create_channel(avdtp_packet_handler, connection->remote_addr, BLUETOOTH_PSM_AVDTP, AVDTP_L2CAP_MTU, NULL);
206 return;
207 case AVDTP_SI_START:
208 if (!stream_endpoint){
209 log_error("AVDTP_SI_START: stream endpoint is null");
210 break;
211 }
212 if (stream_endpoint->state != AVDTP_STREAM_ENDPOINT_OPENED) {
213 log_error("AVDTP_SI_START in wrong stream endpoint state %d", stream_endpoint->state);
214 return;
215 }
216 stream_endpoint_for_event = stream_endpoint;
217 stream_endpoint->state = AVDTP_STREAM_ENDPOINT_STREAMING;
218 break;
219 case AVDTP_SI_SUSPEND:
220 if (!stream_endpoint){
221 log_error("AVDTP_SI_SUSPEND: stream endpoint is null");
222 break;
223 }
224 if (stream_endpoint->state != AVDTP_STREAM_ENDPOINT_STREAMING) {
225 log_error("AVDTP_SI_SUSPEND in wrong stream endpoint state %d", stream_endpoint->state);
226 return;
227 }
228 stream_endpoint_for_event = stream_endpoint;
229 stream_endpoint->state = AVDTP_STREAM_ENDPOINT_OPENED;
230 break;
231 case AVDTP_SI_CLOSE:
232 if (!stream_endpoint){
233 log_error("AVDTP_SI_CLOSE: stream endpoint is null");
234 break;
235 }
236 switch (stream_endpoint->state){
237 case AVDTP_STREAM_ENDPOINT_OPENED:
238 case AVDTP_STREAM_ENDPOINT_STREAMING:
239 stream_endpoint_for_event = stream_endpoint;
240 stream_endpoint->state = AVDTP_STREAM_ENDPOINT_CLOSING;
241 l2cap_disconnect(stream_endpoint->l2cap_media_cid);
242 break;
243 default:
244 break;
245 }
246 break;
247 case AVDTP_SI_ABORT:
248 if (!stream_endpoint){
249 log_error("AVDTP_SI_ABORT: stream endpoint is null");
250 break;
251 }
252 switch (stream_endpoint->state){
253 case AVDTP_STREAM_ENDPOINT_CONFIGURED:
254 case AVDTP_STREAM_ENDPOINT_CLOSING:
255 case AVDTP_STREAM_ENDPOINT_OPENED:
256 case AVDTP_STREAM_ENDPOINT_STREAMING:
257 stream_endpoint_for_event = stream_endpoint;
258 stream_endpoint->state = AVDTP_STREAM_ENDPOINT_ABORTING;
259 l2cap_disconnect(stream_endpoint->l2cap_media_cid);
260 break;
261 default:
262 break;
263 }
264 break;
265
266 case AVDTP_SI_DELAYREPORT:
267 break;
268 case AVDTP_SI_GET_CONFIGURATION:
269 break;
270 default:
271 log_info("AVDTP_RESPONSE_ACCEPT_MSG, signal %d not implemented", connection->initiator_signaling_packet.signal_identifier);
272 break;
273 }
274 if (stream_endpoint_for_event != NULL){
275 avdtp_signaling_emit_accept_for_stream_endpoint(stream_endpoint_for_event, connection->initiator_local_seid,
276 connection->initiator_signaling_packet.signal_identifier, true);
277 } else {
278 avdtp_signaling_emit_accept(connection->avdtp_cid, 0, connection->initiator_signaling_packet.signal_identifier, true);
279 }
280 connection->initiator_transaction_label = avdtp_get_next_transaction_label();
281 break;
282 case AVDTP_RESPONSE_REJECT_MSG:
283 switch (connection->initiator_signaling_packet.signal_identifier){
284 case AVDTP_SI_SET_CONFIGURATION:
285 connection->configuration_state = AVDTP_CONFIGURATION_STATE_IDLE;
286 sep.in_use = 0;
287 log_info("Received reject for set configuration, role changed from initiator to acceptor. TODO: implement retry.");
288 break;
289 case AVDTP_SI_RECONFIGURE:
290 stream_endpoint->state = AVDTP_STREAM_ENDPOINT_OPENED;
291 log_info("Received reject for reconfigure, state = opened");
292 break;
293 default:
294 break;
295 }
296 log_info("AVDTP_RESPONSE_REJECT_MSG signal %s", avdtp_si2str(connection->initiator_signaling_packet.signal_identifier));
297 avdtp_signaling_emit_reject(connection->avdtp_cid, connection->initiator_local_seid,
298 connection->initiator_signaling_packet.signal_identifier, true);
299 return;
300 case AVDTP_GENERAL_REJECT_MSG:
301 log_info("AVDTP_GENERAL_REJECT_MSG signal %s", avdtp_si2str(connection->initiator_signaling_packet.signal_identifier));
302 avdtp_signaling_emit_general_reject(connection->avdtp_cid, connection->initiator_local_seid,
303 connection->initiator_signaling_packet.signal_identifier, true);
304 return;
305 default:
306 break;
307 }
308 }
309
avdtp_initiator_stream_config_subsm_run_signaling(avdtp_connection_t * connection)310 static bool avdtp_initiator_stream_config_subsm_run_signaling(avdtp_connection_t * connection){
311 switch (connection->initiator_connection_state){
312 case AVDTP_SIGNALING_CONNECTION_INITIATOR_W2_DISCOVER_SEPS:
313 log_info("W2_DISCOVER_SEPS");
314 connection->initiator_connection_state = AVDTP_SIGNALING_CONNECTION_INITIATOR_W4_ANSWER;
315 avdtp_initiator_send_signaling_cmd(connection->l2cap_signaling_cid, AVDTP_SI_DISCOVER, connection->initiator_transaction_label);
316 return true;
317 case AVDTP_SIGNALING_CONNECTION_INITIATOR_W2_GET_CAPABILITIES:
318 log_info("W2_GET_CAPABILITIES");
319 connection->initiator_connection_state = AVDTP_SIGNALING_CONNECTION_INITIATOR_W4_ANSWER;
320 avdtp_initiator_send_signaling_cmd_with_seid(connection->l2cap_signaling_cid, AVDTP_SI_GET_CAPABILITIES, connection->initiator_transaction_label, connection->initiator_remote_seid);
321 return true;
322 case AVDTP_SIGNALING_CONNECTION_INITIATOR_W2_GET_ALL_CAPABILITIES:
323 log_info("W2_GET_ALL_CAPABILITIES");
324 connection->initiator_connection_state = AVDTP_SIGNALING_CONNECTION_INITIATOR_W4_ANSWER;
325 avdtp_initiator_send_signaling_cmd_with_seid(connection->l2cap_signaling_cid, AVDTP_SI_GET_ALL_CAPABILITIES, connection->initiator_transaction_label, connection->initiator_remote_seid);
326 return true;
327 case AVDTP_SIGNALING_CONNECTION_INITIATOR_W2_GET_CONFIGURATION:
328 log_info("W4_GET_CONFIGURATION");
329 connection->initiator_connection_state = AVDTP_SIGNALING_CONNECTION_INITIATOR_W4_ANSWER;
330 avdtp_initiator_send_signaling_cmd_with_seid(connection->l2cap_signaling_cid, AVDTP_SI_GET_CONFIGURATION, connection->initiator_transaction_label, connection->initiator_remote_seid);
331 return true;
332 case AVDTP_SIGNALING_CONNECTION_INITIATOR_W2_SEND_DELAY_REPORT:
333 log_info("W4_DELAY_REPORT");
334 connection->initiator_connection_state = AVDTP_SIGNALING_CONNECTION_INITIATOR_W4_ANSWER;
335 avdtp_initiator_send_signaling_cmd_delay_report(connection->l2cap_signaling_cid, connection->initiator_transaction_label,
336 connection->initiator_remote_seid, connection->delay_ms);
337 return true;
338 default:
339 break;
340 }
341 return false;
342 }
343
avdtp_initiator_stream_config_subsm_run_endpoint(avdtp_connection_t * connection,avdtp_stream_endpoint_t * stream_endpoint)344 static bool avdtp_initiator_stream_config_subsm_run_endpoint(avdtp_connection_t * connection, avdtp_stream_endpoint_t * stream_endpoint){
345 log_debug("SE %p, initiator_config_state: 0x%02x", stream_endpoint, stream_endpoint->initiator_config_state);
346 switch (stream_endpoint->initiator_config_state){
347 case AVDTP_INITIATOR_W2_SET_CONFIGURATION:
348 case AVDTP_INITIATOR_W2_RECONFIGURE_STREAM_WITH_SEID:{
349 if ((stream_endpoint->initiator_config_state == AVDTP_INITIATOR_W2_SET_CONFIGURATION) && (connection->configuration_state != AVDTP_CONFIGURATION_STATE_LOCAL_INITIATED)){
350 log_info("initiator SM stop sending SET_CONFIGURATION cmd:");
351 break;
352 }
353 log_info("W2_(RE)CONFIGURATION bitmap, local seid 0x%02x, remote seid 0x%02x", connection->initiator_local_seid, connection->initiator_remote_seid);
354 // log_info_hexdump( connection->remote_capabilities.media_codec.media_codec_information, connection->remote_capabilities.media_codec.media_codec_information_len);
355 connection->initiator_signaling_packet.acp_seid = connection->initiator_remote_seid;
356 connection->initiator_signaling_packet.int_seid = connection->initiator_local_seid;
357
358 connection->initiator_signaling_packet.signal_identifier = AVDTP_SI_SET_CONFIGURATION;
359 stream_endpoint->state = AVDTP_STREAM_ENDPOINT_CONFIGURATION_SUBSTATEMACHINE;
360 if (stream_endpoint->initiator_config_state == AVDTP_INITIATOR_W2_RECONFIGURE_STREAM_WITH_SEID){
361 connection->initiator_signaling_packet.signal_identifier = AVDTP_SI_RECONFIGURE;
362 }
363
364 avdtp_prepare_capabilities(&connection->initiator_signaling_packet, connection->initiator_transaction_label, stream_endpoint->remote_configuration_bitmap, stream_endpoint->remote_configuration, connection->initiator_signaling_packet.signal_identifier);
365 l2cap_reserve_packet_buffer();
366 uint8_t * out_buffer = l2cap_get_outgoing_buffer();
367 uint16_t pos = avdtp_signaling_create_fragment(connection->l2cap_signaling_cid, &connection->initiator_signaling_packet, out_buffer);
368 if ((connection->initiator_signaling_packet.packet_type != AVDTP_SINGLE_PACKET) && (connection->initiator_signaling_packet.packet_type != AVDTP_END_PACKET)){
369 stream_endpoint->initiator_config_state = AVDTP_INITIATOR_FRAGMENTATED_COMMAND;
370 log_info("fragmented");
371 } else {
372 stream_endpoint->initiator_config_state = AVDTP_INITIATOR_W4_ANSWER;
373 }
374 l2cap_send_prepared(connection->l2cap_signaling_cid, pos);
375 if (stream_endpoint->initiator_config_state == AVDTP_INITIATOR_FRAGMENTATED_COMMAND){
376 avdtp_request_can_send_now_initiator(connection);
377 }
378 return true;
379 }
380 case AVDTP_INITIATOR_FRAGMENTATED_COMMAND:{
381 l2cap_reserve_packet_buffer();
382 uint8_t * out_buffer = l2cap_get_outgoing_buffer();
383 uint16_t pos = avdtp_signaling_create_fragment(connection->l2cap_signaling_cid, &connection->initiator_signaling_packet, out_buffer);
384 if ((connection->initiator_signaling_packet.packet_type != AVDTP_SINGLE_PACKET) && (connection->initiator_signaling_packet.packet_type != AVDTP_END_PACKET)){
385 stream_endpoint->initiator_config_state = AVDTP_INITIATOR_FRAGMENTATED_COMMAND;
386 log_info("fragmented");
387 } else {
388 stream_endpoint->initiator_config_state = AVDTP_INITIATOR_W4_ANSWER;
389 }
390 l2cap_send_prepared(connection->l2cap_signaling_cid, pos);
391 if (stream_endpoint->initiator_config_state == AVDTP_INITIATOR_FRAGMENTATED_COMMAND){
392 avdtp_request_can_send_now_initiator(connection);
393 }
394 return true;
395 }
396 case AVDTP_INITIATOR_W2_OPEN_STREAM:
397 switch (stream_endpoint->state){
398 case AVDTP_STREAM_ENDPOINT_W2_REQUEST_OPEN_STREAM:
399 stream_endpoint->state = AVDTP_STREAM_ENDPOINT_W4_ACCEPT_OPEN_STREAM;
400 log_info("send AVDTP_SI_OPEN signaling to remote, transaction_label %d, remote seid 0x%02x", connection->initiator_transaction_label, connection->initiator_remote_seid);
401 avdtp_initiator_send_signaling_cmd_with_seid(connection->l2cap_signaling_cid, AVDTP_SI_OPEN, connection->initiator_transaction_label, connection->initiator_remote_seid);
402 stream_endpoint->initiator_config_state = AVDTP_INITIATOR_W4_ANSWER;
403 return true;
404 default:
405 break;
406 }
407 break;
408 default:
409 break;
410 }
411 return false;
412 }
413
avdtp_initiator_stream_config_subsm_handle_can_send_now_signaling(avdtp_connection_t * connection)414 void avdtp_initiator_stream_config_subsm_handle_can_send_now_signaling(avdtp_connection_t *connection) {
415 bool sent;
416
417 sent = avdtp_initiator_stream_config_subsm_run_signaling(connection);
418 if (sent) return;
419
420 avdtp_stream_endpoint_t * stream_endpoint = avdtp_get_stream_endpoint_for_seid(connection->initiator_local_seid);
421
422 if (stream_endpoint == NULL) return;
423 sent = avdtp_initiator_stream_config_subsm_run_endpoint(connection, stream_endpoint);
424 if (sent) return;
425
426 log_debug("stream: start %u, close %u, abort %u, suspend %u, request %u", stream_endpoint->start_stream, stream_endpoint->close_stream,
427 stream_endpoint->abort_stream, stream_endpoint->suspend_stream, stream_endpoint->request_can_send_now);
428
429 if (stream_endpoint->start_stream){
430 stream_endpoint->start_stream = 0;
431 if (stream_endpoint->state == AVDTP_STREAM_ENDPOINT_OPENED){
432 stream_endpoint->initiator_config_state = AVDTP_INITIATOR_W4_ANSWER;
433 connection->initiator_local_seid = stream_endpoint->sep.seid;
434 connection->initiator_remote_seid = stream_endpoint->remote_sep.seid;
435 connection->initiator_transaction_label = avdtp_get_next_transaction_label();
436 avdtp_initiator_send_signaling_cmd_with_seid(connection->l2cap_signaling_cid, AVDTP_SI_START, connection->initiator_transaction_label, connection->initiator_remote_seid);
437 return;
438 }
439 }
440
441 if (stream_endpoint->close_stream){
442 stream_endpoint->close_stream = 0;
443 switch (stream_endpoint->state){
444 case AVDTP_STREAM_ENDPOINT_OPENED:
445 case AVDTP_STREAM_ENDPOINT_STREAMING:
446 stream_endpoint->initiator_config_state = AVDTP_INITIATOR_W4_ANSWER;
447 connection->initiator_local_seid = stream_endpoint->sep.seid;
448 connection->initiator_remote_seid = stream_endpoint->remote_sep.seid;
449 connection->initiator_transaction_label = avdtp_get_next_transaction_label();
450 avdtp_initiator_send_signaling_cmd_with_seid(connection->l2cap_signaling_cid, AVDTP_SI_CLOSE, connection->initiator_transaction_label, connection->initiator_remote_seid);
451 return;
452 default:
453 break;
454 }
455 }
456
457 if (stream_endpoint->abort_stream){
458 stream_endpoint->abort_stream = 0;
459 switch (stream_endpoint->state){
460 case AVDTP_STREAM_ENDPOINT_CONFIGURED:
461 case AVDTP_STREAM_ENDPOINT_CLOSING:
462 case AVDTP_STREAM_ENDPOINT_OPENED:
463 case AVDTP_STREAM_ENDPOINT_STREAMING:
464 stream_endpoint->initiator_config_state = AVDTP_INITIATOR_W4_ANSWER;
465 connection->initiator_local_seid = stream_endpoint->sep.seid;
466 connection->initiator_remote_seid = stream_endpoint->remote_sep.seid;
467 connection->initiator_transaction_label = avdtp_get_next_transaction_label();
468 avdtp_initiator_send_signaling_cmd_with_seid(connection->l2cap_signaling_cid, AVDTP_SI_ABORT, connection->initiator_transaction_label, connection->initiator_remote_seid);
469 return;
470 default:
471 break;
472 }
473 }
474
475 if (stream_endpoint->suspend_stream){
476 stream_endpoint->suspend_stream = 0;
477 if (stream_endpoint->state == AVDTP_STREAM_ENDPOINT_STREAMING){
478 stream_endpoint->initiator_config_state = AVDTP_INITIATOR_W4_ANSWER;
479 connection->initiator_local_seid = stream_endpoint->sep.seid;
480 connection->initiator_remote_seid = stream_endpoint->remote_sep.seid;
481 connection->initiator_transaction_label = avdtp_get_next_transaction_label();
482 avdtp_initiator_send_signaling_cmd_with_seid(connection->l2cap_signaling_cid, AVDTP_SI_SUSPEND, connection->initiator_transaction_label, connection->initiator_remote_seid);
483 return;
484 }
485 }
486
487 }
488
avdtp_initiator_stream_config_subsm_handle_can_send_now_stream_endpoint(avdtp_stream_endpoint_t * stream_endpoint)489 void avdtp_initiator_stream_config_subsm_handle_can_send_now_stream_endpoint(avdtp_stream_endpoint_t * stream_endpoint) {
490 if (stream_endpoint->state == AVDTP_STREAM_ENDPOINT_STREAMING){
491 stream_endpoint->state = AVDTP_STREAM_ENDPOINT_STREAMING;
492 avdtp_streaming_emit_can_send_media_packet_now(stream_endpoint, stream_endpoint->sequence_number);
493 }
494 }
495