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 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 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 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 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 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 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 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 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