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