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