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 #define BTSTACK_FILE__ "avdtp_acceptor.c" 38 39 #include <stdint.h> 40 #include <string.h> 41 42 #include "classic/avdtp.h" 43 #include "classic/avdtp_util.h" 44 #include "classic/avdtp_acceptor.h" 45 46 #include "btstack_debug.h" 47 #include "btstack_util.h" 48 #include "l2cap.h" 49 50 51 static int avdtp_acceptor_send_accept_response(uint16_t cid, uint8_t transaction_label, avdtp_signal_identifier_t identifier){ 52 uint8_t command[2]; 53 command[0] = avdtp_header(transaction_label, AVDTP_SINGLE_PACKET, AVDTP_RESPONSE_ACCEPT_MSG); 54 command[1] = (uint8_t)identifier; 55 return l2cap_send(cid, command, sizeof(command)); 56 } 57 58 // returns true if command complete 59 static bool avdtp_acceptor_process_chunk(avdtp_signaling_packet_t * signaling_packet, uint8_t * packet, uint16_t size){ 60 if ((signaling_packet->size + size) >= sizeof(signaling_packet->command)) { 61 log_info("Dropping incoming data, doesn't fit into command buffer"); 62 signaling_packet->size = 0; 63 return false; 64 } 65 66 (void)memcpy(signaling_packet->command + signaling_packet->size, packet, size); 67 signaling_packet->size += size; 68 return (signaling_packet->packet_type == AVDTP_SINGLE_PACKET) || (signaling_packet->packet_type == AVDTP_END_PACKET); 69 } 70 71 static int avdtp_acceptor_validate_msg_length(avdtp_signal_identifier_t signal_identifier, uint16_t msg_size){ 72 int minimal_msg_lenght = 2; 73 switch (signal_identifier){ 74 case AVDTP_SI_GET_CAPABILITIES: 75 case AVDTP_SI_GET_ALL_CAPABILITIES: 76 case AVDTP_SI_SET_CONFIGURATION: 77 case AVDTP_SI_GET_CONFIGURATION: 78 case AVDTP_SI_START: 79 case AVDTP_SI_CLOSE: 80 case AVDTP_SI_ABORT: 81 case AVDTP_SI_RECONFIGURE: 82 case AVDTP_SI_OPEN: 83 minimal_msg_lenght = 3; 84 break; 85 default: 86 break; 87 } 88 return msg_size >= minimal_msg_lenght; 89 } 90 91 static void 92 avdtp_acceptor_handle_configuration_command(avdtp_connection_t *connection, int offset, uint16_t packet_size, avdtp_stream_endpoint_t *stream_endpoint) { 93 log_info("W2_ANSWER_SET_CONFIGURATION cid 0x%02x", connection->avdtp_cid); 94 stream_endpoint->state = AVDTP_STREAM_ENDPOINT_CONFIGURATION_SUBSTATEMACHINE; 95 stream_endpoint->connection = connection; 96 97 // process capabilities, first rejected service category is stored in connection 98 connection->reject_service_category = 0; 99 avdtp_sep_t sep; 100 sep.seid = connection->acceptor_signaling_packet.command[offset++] >> 2; 101 sep.configured_service_categories = avdtp_unpack_service_capabilities(connection, connection->acceptor_signaling_packet.signal_identifier, &sep.configuration, connection->acceptor_signaling_packet.command+offset, packet_size-offset); 102 sep.in_use = 1; 103 104 // let application validate media configuration as well 105 if (connection->error_code == 0){ 106 if ((sep.configured_service_categories & (1 << AVDTP_MEDIA_CODEC)) != 0){ 107 adtvp_media_codec_capabilities_t * media = & sep.configuration.media_codec; 108 uint8_t error_code = avdtp_validate_media_configuration(stream_endpoint, media->media_codec_type, media->media_codec_information, media->media_codec_information_len); 109 if (error_code != 0){ 110 log_info("media codec rejected by validator, error 0x%02x", error_code); 111 connection->reject_service_category = AVDTP_MEDIA_CODEC; 112 connection->error_code = error_code; 113 } 114 } 115 } 116 117 if (connection->error_code){ 118 connection->reject_signal_identifier = connection->acceptor_signaling_packet.signal_identifier; 119 stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_REJECT_CATEGORY_WITH_ERROR_CODE; 120 return; 121 } 122 123 stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_ANSWER_SET_CONFIGURATION; 124 // find or add sep 125 126 log_info("local seid %d, remote seid %d", connection->acceptor_local_seid, sep.seid); 127 128 if (is_avdtp_remote_seid_registered(stream_endpoint)){ 129 if (stream_endpoint->remote_sep.in_use){ 130 log_info("remote seid already in use"); 131 connection->error_code = AVDTP_ERROR_CODE_SEP_IN_USE; 132 // find first registered category and fire the error 133 connection->reject_service_category = 0; 134 int i; 135 for (i = 1; i < 9; i++){ 136 if (get_bit16(sep.configured_service_categories, i)){ 137 connection->reject_service_category = i; 138 break; 139 } 140 } 141 connection->reject_signal_identifier = connection->acceptor_signaling_packet.signal_identifier; 142 stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_REJECT_CATEGORY_WITH_ERROR_CODE; 143 } else { 144 stream_endpoint->remote_sep = sep; 145 log_info("update remote seid %d", stream_endpoint->remote_sep.seid); 146 } 147 } else { 148 // add new 149 stream_endpoint->remote_sep = sep; 150 log_info("add remote seid %d", stream_endpoint->remote_sep.seid); 151 } 152 153 // if media codec configuration set, copy configuration and emit event 154 if ((sep.configured_service_categories & (1 << AVDTP_MEDIA_CODEC)) != 0){ 155 if (stream_endpoint->media_codec_configuration_len == sep.configuration.media_codec.media_codec_information_len){ 156 (void) memcpy(stream_endpoint->media_codec_configuration_info, sep.configuration.media_codec.media_codec_information, stream_endpoint->media_codec_configuration_len); 157 avdtp_signaling_emit_configuration(stream_endpoint, connection->avdtp_cid, 0, &sep.configuration, sep.configured_service_categories); 158 } 159 } 160 161 avdtp_signaling_emit_accept(connection->avdtp_cid, avdtp_local_seid(stream_endpoint), 162 connection->acceptor_signaling_packet.signal_identifier, false); 163 } 164 165 void avdtp_acceptor_stream_config_subsm(avdtp_connection_t *connection, uint8_t *packet, uint16_t size, int offset) { 166 avdtp_stream_endpoint_t * stream_endpoint = NULL; 167 connection->acceptor_transaction_label = connection->acceptor_signaling_packet.transaction_label; 168 if (!avdtp_acceptor_validate_msg_length(connection->acceptor_signaling_packet.signal_identifier, size)) { 169 connection->error_code = AVDTP_ERROR_CODE_BAD_LENGTH; 170 connection->acceptor_connection_state = AVDTP_SIGNALING_CONNECTION_ACCEPTOR_W2_REJECT_WITH_ERROR_CODE; 171 connection->reject_signal_identifier = connection->acceptor_signaling_packet.signal_identifier; 172 avdtp_request_can_send_now_acceptor(connection); 173 return; 174 } 175 176 // handle error cases 177 switch (connection->acceptor_signaling_packet.signal_identifier){ 178 case AVDTP_SI_DISCOVER: 179 if (connection->state != AVDTP_SIGNALING_CONNECTION_OPENED) return; 180 log_info("W2_ANSWER_DISCOVER_SEPS"); 181 connection->acceptor_connection_state = AVDTP_SIGNALING_CONNECTION_ACCEPTOR_W2_ANSWER_DISCOVER_SEPS; 182 avdtp_request_can_send_now_acceptor(connection); 183 return; 184 case AVDTP_SI_GET_CAPABILITIES: 185 case AVDTP_SI_GET_ALL_CAPABILITIES: 186 case AVDTP_SI_SET_CONFIGURATION: 187 case AVDTP_SI_GET_CONFIGURATION: 188 case AVDTP_SI_START: 189 case AVDTP_SI_CLOSE: 190 case AVDTP_SI_ABORT: 191 case AVDTP_SI_OPEN: 192 case AVDTP_SI_RECONFIGURE: 193 case AVDTP_SI_DELAYREPORT: 194 connection->acceptor_local_seid = packet[offset++] >> 2; 195 stream_endpoint = avdtp_get_stream_endpoint_for_seid(connection->acceptor_local_seid); 196 if (!stream_endpoint){ 197 log_info("cmd %d - REJECT", connection->acceptor_signaling_packet.signal_identifier); 198 connection->error_code = AVDTP_ERROR_CODE_BAD_ACP_SEID; 199 if (connection->acceptor_signaling_packet.signal_identifier == AVDTP_SI_OPEN){ 200 connection->error_code = AVDTP_ERROR_CODE_BAD_STATE; 201 } 202 203 connection->acceptor_connection_state = AVDTP_SIGNALING_CONNECTION_ACCEPTOR_W2_REJECT_WITH_ERROR_CODE; 204 if (connection->acceptor_signaling_packet.signal_identifier == AVDTP_SI_RECONFIGURE){ 205 connection->reject_service_category = connection->acceptor_local_seid; 206 connection->acceptor_connection_state = AVDTP_SIGNALING_CONNECTION_ACCEPTOR_W2_REJECT_CATEGORY_WITH_ERROR_CODE; 207 } 208 connection->reject_signal_identifier = connection->acceptor_signaling_packet.signal_identifier; 209 avdtp_request_can_send_now_acceptor(connection); 210 return; 211 } 212 break; 213 214 case AVDTP_SI_SUSPEND:{ 215 int i; 216 log_info("AVDTP_SI_SUSPEND"); 217 connection->num_suspended_seids = 0; 218 219 for (i = offset; i < size; i++){ 220 connection->suspended_seids[connection->num_suspended_seids] = packet[i] >> 2; 221 offset++; 222 log_info("%d, ", connection->suspended_seids[connection->num_suspended_seids]); 223 connection->num_suspended_seids++; 224 } 225 226 if (connection->num_suspended_seids == 0) { 227 log_info("no susspended seids, BAD_ACP_SEID"); 228 connection->error_code = AVDTP_ERROR_CODE_BAD_ACP_SEID; 229 connection->reject_service_category = connection->acceptor_local_seid; 230 connection->acceptor_connection_state = AVDTP_SIGNALING_CONNECTION_ACCEPTOR_W2_REJECT_CATEGORY_WITH_ERROR_CODE; 231 connection->reject_signal_identifier = connection->acceptor_signaling_packet.signal_identifier; 232 avdtp_request_can_send_now_acceptor(connection); 233 return; 234 } 235 // deal with first susspended seid 236 connection->acceptor_local_seid = connection->suspended_seids[0]; 237 stream_endpoint = avdtp_get_stream_endpoint_for_seid(connection->acceptor_local_seid); 238 if (!stream_endpoint){ 239 log_info("stream_endpoint not found, BAD_ACP_SEID"); 240 connection->error_code = AVDTP_ERROR_CODE_BAD_ACP_SEID; 241 connection->reject_service_category = connection->acceptor_local_seid; 242 connection->acceptor_connection_state = AVDTP_SIGNALING_CONNECTION_ACCEPTOR_W2_REJECT_CATEGORY_WITH_ERROR_CODE; 243 connection->reject_signal_identifier = connection->acceptor_signaling_packet.signal_identifier; 244 connection->num_suspended_seids = 0; 245 avdtp_request_can_send_now_acceptor(connection); 246 return; 247 } 248 break; 249 } 250 default: 251 connection->acceptor_connection_state = AVDTP_SIGNALING_CONNECTION_ACCEPTOR_W2_GENERAL_REJECT_WITH_ERROR_CODE; 252 connection->reject_signal_identifier = connection->acceptor_signaling_packet.signal_identifier; 253 log_info("AVDTP_CMD_MSG signal %d not implemented, general reject", connection->acceptor_signaling_packet.signal_identifier); 254 avdtp_request_can_send_now_acceptor(connection); 255 return; 256 } 257 258 btstack_assert(stream_endpoint != NULL); 259 260 bool command_complete = avdtp_acceptor_process_chunk(&connection->acceptor_signaling_packet, packet, size); 261 if (!command_complete) return; 262 263 uint16_t packet_size = connection->acceptor_signaling_packet.size; 264 connection->acceptor_signaling_packet.size = 0; 265 266 int request_to_send = 1; 267 switch (stream_endpoint->acceptor_config_state){ 268 case AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE: 269 switch (connection->acceptor_signaling_packet.signal_identifier){ 270 case AVDTP_SI_DELAYREPORT: 271 log_info("W2_ANSWER_DELAY_REPORT, local seid %d", connection->acceptor_local_seid); 272 stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_ANSWER_DELAY_REPORT; 273 avdtp_signaling_emit_delay(connection->avdtp_cid, connection->acceptor_local_seid, 274 big_endian_read_16(packet, offset)); 275 break; 276 277 case AVDTP_SI_GET_ALL_CAPABILITIES: 278 log_info("AVDTP_SI_GET_ALL_CAPABILITIES, local seid %d", connection->acceptor_local_seid); 279 stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_ANSWER_GET_ALL_CAPABILITIES; 280 break; 281 case AVDTP_SI_GET_CAPABILITIES: 282 log_info("W2_ANSWER_GET_CAPABILITIES, local seid %d", connection->acceptor_local_seid); 283 stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_ANSWER_GET_CAPABILITIES; 284 break; 285 case AVDTP_SI_SET_CONFIGURATION:{ 286 log_info("Received SET_CONFIGURATION cmd: config state %d", connection->configuration_state); 287 switch (connection->configuration_state){ 288 case AVDTP_CONFIGURATION_STATE_IDLE: 289 avdtp_acceptor_handle_configuration_command(connection, offset, packet_size, 290 stream_endpoint); 291 connection->configuration_state = AVDTP_CONFIGURATION_STATE_REMOTE_INITIATED; 292 break; 293 case AVDTP_CONFIGURATION_STATE_LOCAL_INITIATED: 294 case AVDTP_CONFIGURATION_STATE_REMOTE_INITIATED: 295 log_info("Reject SET_CONFIGURATION BAD_STATE %d", connection->configuration_state); 296 connection->reject_signal_identifier = connection->acceptor_signaling_packet.signal_identifier; 297 connection->reject_service_category = 0; 298 connection->error_code = AVDTP_ERROR_CODE_BAD_STATE; 299 stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_REJECT_CATEGORY_WITH_ERROR_CODE; 300 break; 301 case AVDTP_CONFIGURATION_STATE_LOCAL_CONFIGURED: 302 case AVDTP_CONFIGURATION_STATE_REMOTE_CONFIGURED: 303 log_info("Reject SET_CONFIGURATION SEP_IN_USE"); 304 connection->reject_signal_identifier = connection->acceptor_signaling_packet.signal_identifier; 305 connection->reject_service_category = 0; 306 connection->error_code = AVDTP_ERROR_CODE_SEP_IN_USE; 307 stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_REJECT_CATEGORY_WITH_ERROR_CODE; 308 break; 309 default: 310 break; 311 } 312 break; 313 } 314 case AVDTP_SI_RECONFIGURE:{ 315 stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_ANSWER_RECONFIGURE; 316 connection->reject_service_category = 0; 317 318 avdtp_sep_t sep; 319 log_info("W2_ANSWER_RECONFIGURE, local seid %d, remote seid %d", connection->acceptor_local_seid, stream_endpoint->remote_sep.seid); 320 sep.configured_service_categories = avdtp_unpack_service_capabilities(connection, connection->acceptor_signaling_packet.signal_identifier, &sep.configuration, connection->acceptor_signaling_packet.command+offset, packet_size-offset); 321 if (connection->error_code){ 322 // fire configuration parsing errors 323 connection->reject_signal_identifier = connection->acceptor_signaling_packet.signal_identifier; 324 stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_REJECT_CATEGORY_WITH_ERROR_CODE; 325 break; 326 } 327 328 // find sep or raise error 329 if (!is_avdtp_remote_seid_registered(stream_endpoint)){ 330 log_info("REJECT AVDTP_SI_RECONFIGURE, BAD_ACP_SEID"); 331 stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_REJECT_CATEGORY_WITH_ERROR_CODE; 332 connection->error_code = AVDTP_ERROR_CODE_BAD_ACP_SEID; 333 connection->reject_signal_identifier = connection->acceptor_signaling_packet.signal_identifier; 334 break; 335 } 336 stream_endpoint->remote_sep.configured_service_categories = sep.configured_service_categories; 337 stream_endpoint->remote_sep.configuration = sep.configuration; 338 339 log_info("update active remote seid %d", stream_endpoint->remote_sep.seid); 340 341 // if media codec configuration updated, copy configuration and emit event 342 if ((sep.configured_service_categories & (1 << AVDTP_MEDIA_CODEC)) != 0){ 343 if (stream_endpoint->media_codec_configuration_len == sep.configuration.media_codec.media_codec_information_len){ 344 (void) memcpy(stream_endpoint->media_codec_configuration_info, sep.configuration.media_codec.media_codec_information, stream_endpoint->media_codec_configuration_len); 345 stream_endpoint->sep.configuration.media_codec = stream_endpoint->remote_configuration.media_codec; 346 avdtp_signaling_emit_configuration(stream_endpoint, connection->avdtp_cid, 1, &sep.configuration, sep.configured_service_categories); 347 } 348 } 349 break; 350 } 351 352 case AVDTP_SI_GET_CONFIGURATION: 353 log_info("W2_ANSWER_GET_CONFIGURATION"); 354 stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_ANSWER_GET_CONFIGURATION; 355 break; 356 case AVDTP_SI_OPEN: 357 if (stream_endpoint->state != AVDTP_STREAM_ENDPOINT_CONFIGURED){ 358 log_info("REJECT AVDTP_SI_OPEN, BAD_STATE"); 359 stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_REJECT_WITH_ERROR_CODE; 360 connection->error_code = AVDTP_ERROR_CODE_BAD_STATE; 361 connection->reject_signal_identifier = connection->acceptor_signaling_packet.signal_identifier; 362 break; 363 } 364 log_info("AVDTP_STREAM_ENDPOINT_W2_ANSWER_OPEN_STREAM"); 365 stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_ANSWER_OPEN_STREAM; 366 stream_endpoint->state = AVDTP_STREAM_ENDPOINT_W4_L2CAP_FOR_MEDIA_CONNECTED; 367 connection->acceptor_local_seid = stream_endpoint->sep.seid; 368 break; 369 case AVDTP_SI_START: 370 if (stream_endpoint->state != AVDTP_STREAM_ENDPOINT_OPENED){ 371 log_info("REJECT AVDTP_SI_START, BAD_STATE, state %d", stream_endpoint->state); 372 stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_REJECT_CATEGORY_WITH_ERROR_CODE; 373 connection->error_code = AVDTP_ERROR_CODE_BAD_STATE; 374 connection->reject_signal_identifier = connection->acceptor_signaling_packet.signal_identifier; 375 break; 376 } 377 log_info("W2_ANSWER_START_STREAM"); 378 stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_ANSWER_START_STREAM; 379 break; 380 case AVDTP_SI_CLOSE: 381 switch (stream_endpoint->state){ 382 case AVDTP_STREAM_ENDPOINT_OPENED: 383 case AVDTP_STREAM_ENDPOINT_STREAMING: 384 log_info("W2_ANSWER_CLOSE_STREAM"); 385 stream_endpoint->state = AVDTP_STREAM_ENDPOINT_CLOSING; 386 stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_ANSWER_CLOSE_STREAM; 387 break; 388 default: 389 log_info("AVDTP_SI_CLOSE, bad state %d ", stream_endpoint->state); 390 stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_REJECT_WITH_ERROR_CODE; 391 connection->error_code = AVDTP_ERROR_CODE_BAD_STATE; 392 connection->reject_signal_identifier = connection->acceptor_signaling_packet.signal_identifier; 393 break; 394 } 395 break; 396 case AVDTP_SI_ABORT: 397 switch (stream_endpoint->state){ 398 case AVDTP_STREAM_ENDPOINT_CONFIGURED: 399 case AVDTP_STREAM_ENDPOINT_CLOSING: 400 case AVDTP_STREAM_ENDPOINT_OPENED: 401 case AVDTP_STREAM_ENDPOINT_STREAMING: 402 log_info("W2_ANSWER_ABORT_STREAM"); 403 stream_endpoint->state = AVDTP_STREAM_ENDPOINT_ABORTING; 404 stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_ANSWER_ABORT_STREAM; 405 break; 406 default: 407 log_info("AVDTP_SI_ABORT, bad state %d ", stream_endpoint->state); 408 stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_REJECT_WITH_ERROR_CODE; 409 connection->error_code = AVDTP_ERROR_CODE_BAD_STATE; 410 connection->reject_signal_identifier = connection->acceptor_signaling_packet.signal_identifier; 411 break; 412 } 413 break; 414 case AVDTP_SI_SUSPEND: 415 switch (stream_endpoint->state){ 416 case AVDTP_STREAM_ENDPOINT_OPENED: 417 case AVDTP_STREAM_ENDPOINT_STREAMING: 418 stream_endpoint->state = AVDTP_STREAM_ENDPOINT_OPENED; 419 connection->num_suspended_seids--; 420 if (connection->num_suspended_seids <= 0){ 421 log_info("W2_ANSWER_SUSPEND_STREAM"); 422 stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_ANSWER_SUSPEND_STREAM; 423 } 424 break; 425 default: 426 log_info("AVDTP_SI_SUSPEND, bad state %d", stream_endpoint->state); 427 stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_REJECT_CATEGORY_WITH_ERROR_CODE; 428 connection->error_code = AVDTP_ERROR_CODE_BAD_STATE; 429 connection->reject_signal_identifier = connection->acceptor_signaling_packet.signal_identifier; 430 break; 431 } 432 break; 433 default: 434 log_info("NOT IMPLEMENTED, Reject signal_identifier %02x", connection->acceptor_signaling_packet.signal_identifier); 435 stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_REJECT_UNKNOWN_CMD; 436 connection->reject_signal_identifier = connection->acceptor_signaling_packet.signal_identifier; 437 break; 438 } 439 break; 440 default: 441 return; 442 } 443 444 if (!request_to_send){ 445 log_info("NOT IMPLEMENTED"); 446 } 447 avdtp_request_can_send_now_acceptor(connection); 448 } 449 450 static int avdtp_acceptor_send_seps_response(uint16_t cid, uint8_t transaction_label, avdtp_stream_endpoint_t * endpoints){ 451 uint8_t command[2+2*AVDTP_MAX_NUM_SEPS]; 452 int pos = 0; 453 command[pos++] = avdtp_header(transaction_label, AVDTP_SINGLE_PACKET, AVDTP_RESPONSE_ACCEPT_MSG); 454 command[pos++] = (uint8_t)AVDTP_SI_DISCOVER; 455 456 btstack_linked_list_iterator_t it; 457 btstack_linked_list_iterator_init(&it, (btstack_linked_list_t *) endpoints); 458 while (btstack_linked_list_iterator_has_next(&it)){ 459 avdtp_stream_endpoint_t * stream_endpoint = (avdtp_stream_endpoint_t *)btstack_linked_list_iterator_next(&it); 460 command[pos++] = (stream_endpoint->sep.seid << 2) | (stream_endpoint->sep.in_use<<1); 461 command[pos++] = (stream_endpoint->sep.media_type << 4) | (stream_endpoint->sep.type << 3); 462 } 463 return l2cap_send(cid, command, pos); 464 } 465 466 static int avdtp_acceptor_send_response_reject_service_category(uint16_t cid, avdtp_signal_identifier_t identifier, uint8_t category, uint8_t error_code, uint8_t transaction_label){ 467 uint8_t command[4]; 468 command[0] = avdtp_header(transaction_label, AVDTP_SINGLE_PACKET, AVDTP_RESPONSE_REJECT_MSG); 469 command[1] = (uint8_t)identifier; 470 command[2] = category; 471 command[3] = error_code; 472 return l2cap_send(cid, command, sizeof(command)); 473 } 474 475 static int avdtp_acceptor_send_response_general_reject(uint16_t cid, avdtp_signal_identifier_t identifier, uint8_t transaction_label){ 476 uint8_t command[2]; 477 command[0] = avdtp_header(transaction_label, AVDTP_SINGLE_PACKET, AVDTP_GENERAL_REJECT_MSG); 478 command[1] = (uint8_t)identifier; 479 return l2cap_send(cid, command, sizeof(command)); 480 } 481 482 static int avdtp_acceptor_send_response_reject(uint16_t cid, avdtp_signal_identifier_t identifier, uint8_t transaction_label){ 483 uint8_t command[2]; 484 command[0] = avdtp_header(transaction_label, AVDTP_SINGLE_PACKET, AVDTP_RESPONSE_REJECT_MSG); 485 command[1] = (uint8_t)identifier; 486 return l2cap_send(cid, command, sizeof(command)); 487 } 488 489 static int avdtp_acceptor_send_response_reject_with_error_code(uint16_t cid, avdtp_signal_identifier_t identifier, uint8_t error_code, uint8_t transaction_label){ 490 uint8_t command[3]; 491 command[0] = avdtp_header(transaction_label, AVDTP_SINGLE_PACKET, AVDTP_RESPONSE_REJECT_MSG); 492 command[1] = (uint8_t)identifier; 493 command[2] = error_code; 494 return l2cap_send(cid, command, sizeof(command)); 495 } 496 497 void avdtp_acceptor_stream_config_subsm_run(avdtp_connection_t *connection) { 498 int sent = 1; 499 btstack_linked_list_t * stream_endpoints = avdtp_get_stream_endpoints(); 500 501 switch (connection->acceptor_connection_state){ 502 case AVDTP_SIGNALING_CONNECTION_ACCEPTOR_W2_ANSWER_DISCOVER_SEPS: 503 connection->state = AVDTP_SIGNALING_CONNECTION_OPENED; 504 connection->acceptor_connection_state = AVDTP_SIGNALING_CONNECTION_ACCEPTOR_IDLE; 505 avdtp_acceptor_send_seps_response(connection->l2cap_signaling_cid, connection->acceptor_transaction_label, (avdtp_stream_endpoint_t *) stream_endpoints); 506 break; 507 case AVDTP_SIGNALING_CONNECTION_ACCEPTOR_W2_REJECT_WITH_ERROR_CODE: 508 connection->acceptor_connection_state = AVDTP_SIGNALING_CONNECTION_ACCEPTOR_IDLE; 509 avdtp_acceptor_send_response_reject_with_error_code(connection->l2cap_signaling_cid, connection->reject_signal_identifier, connection->error_code, connection->acceptor_transaction_label); 510 break; 511 case AVDTP_SIGNALING_CONNECTION_ACCEPTOR_W2_REJECT_CATEGORY_WITH_ERROR_CODE: 512 connection->acceptor_connection_state = AVDTP_SIGNALING_CONNECTION_ACCEPTOR_IDLE; 513 avdtp_acceptor_send_response_reject_service_category(connection->l2cap_signaling_cid, connection->reject_signal_identifier, connection->reject_service_category, connection->error_code, connection->acceptor_transaction_label); 514 break; 515 case AVDTP_SIGNALING_CONNECTION_ACCEPTOR_W2_GENERAL_REJECT_WITH_ERROR_CODE: 516 connection->acceptor_connection_state = AVDTP_SIGNALING_CONNECTION_ACCEPTOR_IDLE; 517 avdtp_acceptor_send_response_general_reject(connection->l2cap_signaling_cid, connection->reject_signal_identifier, connection->acceptor_transaction_label); 518 break; 519 default: 520 sent = 0; 521 break; 522 } 523 if (sent){ 524 log_info("DONE"); 525 return; 526 } 527 528 avdtp_stream_endpoint_t * stream_endpoint = avdtp_get_stream_endpoint_for_seid(connection->acceptor_local_seid); 529 if (!stream_endpoint) return; 530 531 uint8_t reject_service_category = connection->reject_service_category; 532 avdtp_signal_identifier_t reject_signal_identifier = connection->reject_signal_identifier; 533 uint8_t error_code = connection->error_code; 534 uint16_t cid = stream_endpoint->connection ? stream_endpoint->connection->l2cap_signaling_cid : connection->l2cap_signaling_cid; 535 uint8_t trid = stream_endpoint->connection ? stream_endpoint->connection->acceptor_transaction_label : connection->acceptor_transaction_label; 536 537 avdtp_acceptor_stream_endpoint_state_t acceptor_config_state = stream_endpoint->acceptor_config_state; 538 stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE; 539 uint8_t * out_buffer; 540 uint16_t pos; 541 542 bool emit_accept = false; 543 bool emit_reject = false; 544 545 switch (acceptor_config_state){ 546 case AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE: 547 break; 548 case AVDTP_ACCEPTOR_W2_ANSWER_GET_CAPABILITIES: 549 avdtp_prepare_capabilities(&connection->acceptor_signaling_packet, trid, stream_endpoint->sep.registered_service_categories, stream_endpoint->sep.capabilities, AVDTP_SI_GET_CAPABILITIES); 550 l2cap_reserve_packet_buffer(); 551 out_buffer = l2cap_get_outgoing_buffer(); 552 pos = avdtp_signaling_create_fragment(cid, &connection->acceptor_signaling_packet, out_buffer); 553 if ((connection->acceptor_signaling_packet.packet_type != AVDTP_SINGLE_PACKET) && (connection->acceptor_signaling_packet.packet_type != AVDTP_END_PACKET)){ 554 stream_endpoint->acceptor_config_state = acceptor_config_state; 555 log_info("fragmented"); 556 } else { 557 log_info("ACP:DONE"); 558 emit_accept = true; 559 } 560 l2cap_send_prepared(cid, pos); 561 break; 562 case AVDTP_ACCEPTOR_W2_ANSWER_DELAY_REPORT: 563 log_info("DONE "); 564 avdtp_acceptor_send_accept_response(cid, trid, AVDTP_SI_DELAYREPORT); 565 emit_accept = true; 566 break; 567 case AVDTP_ACCEPTOR_W2_ANSWER_GET_ALL_CAPABILITIES: 568 avdtp_prepare_capabilities(&connection->acceptor_signaling_packet, trid, stream_endpoint->sep.registered_service_categories, stream_endpoint->sep.capabilities, AVDTP_SI_GET_ALL_CAPABILITIES); 569 l2cap_reserve_packet_buffer(); 570 out_buffer = l2cap_get_outgoing_buffer(); 571 pos = avdtp_signaling_create_fragment(cid, &connection->acceptor_signaling_packet, out_buffer); 572 if ((connection->acceptor_signaling_packet.packet_type != AVDTP_SINGLE_PACKET) && (connection->acceptor_signaling_packet.packet_type != AVDTP_END_PACKET)){ 573 stream_endpoint->acceptor_config_state = acceptor_config_state; 574 log_info("fragmented"); 575 } else { 576 log_info("ACP:DONE"); 577 emit_accept = true; 578 } 579 l2cap_send_prepared(cid, pos); 580 break; 581 case AVDTP_ACCEPTOR_W2_ANSWER_SET_CONFIGURATION: 582 log_info("DONE"); 583 log_info(" -> AVDTP_STREAM_ENDPOINT_CONFIGURED"); 584 stream_endpoint->connection = connection; 585 stream_endpoint->state = AVDTP_STREAM_ENDPOINT_CONFIGURED; 586 connection->configuration_state = AVDTP_CONFIGURATION_STATE_REMOTE_CONFIGURED; 587 // TODO: consider reconfiguration 588 avdtp_acceptor_send_accept_response(cid, trid, AVDTP_SI_SET_CONFIGURATION); 589 emit_accept = true; 590 break; 591 case AVDTP_ACCEPTOR_W2_ANSWER_RECONFIGURE: 592 log_info("DONE "); 593 avdtp_acceptor_send_accept_response(cid, trid, AVDTP_SI_RECONFIGURE); 594 emit_accept = true; 595 break; 596 597 case AVDTP_ACCEPTOR_W2_ANSWER_GET_CONFIGURATION:{ 598 avdtp_sep_t sep = stream_endpoint->remote_sep; 599 avdtp_prepare_capabilities(&connection->acceptor_signaling_packet, trid, sep.configured_service_categories, sep.configuration, AVDTP_SI_GET_CONFIGURATION); 600 l2cap_reserve_packet_buffer(); 601 out_buffer = l2cap_get_outgoing_buffer(); 602 pos = avdtp_signaling_create_fragment(cid, &connection->acceptor_signaling_packet, out_buffer); 603 if ((connection->acceptor_signaling_packet.packet_type != AVDTP_SINGLE_PACKET) && (connection->acceptor_signaling_packet.packet_type != AVDTP_END_PACKET)){ 604 stream_endpoint->acceptor_config_state = acceptor_config_state; 605 log_info("fragmented"); 606 } else { 607 log_info("ACP:DONE"); 608 emit_accept = true; 609 } 610 l2cap_send_prepared(cid, pos); 611 break; 612 } 613 case AVDTP_ACCEPTOR_W2_ANSWER_OPEN_STREAM: 614 log_info("DONE"); 615 avdtp_acceptor_send_accept_response(cid, trid, AVDTP_SI_OPEN); 616 emit_accept = true; 617 break; 618 case AVDTP_ACCEPTOR_W2_ANSWER_START_STREAM: 619 log_info("DONE "); 620 log_info(" -> AVDTP_STREAM_ENDPOINT_STREAMING "); 621 stream_endpoint->state = AVDTP_STREAM_ENDPOINT_STREAMING; 622 avdtp_acceptor_send_accept_response(cid, trid, AVDTP_SI_START); 623 emit_accept = true; 624 break; 625 case AVDTP_ACCEPTOR_W2_ANSWER_CLOSE_STREAM: 626 log_info("DONE"); 627 avdtp_acceptor_send_accept_response(cid, trid, AVDTP_SI_CLOSE); 628 connection->configuration_state = AVDTP_CONFIGURATION_STATE_IDLE; 629 emit_accept = true; 630 break; 631 case AVDTP_ACCEPTOR_W2_ANSWER_ABORT_STREAM: 632 log_info("DONE"); 633 avdtp_acceptor_send_accept_response(cid, trid, AVDTP_SI_ABORT); 634 emit_accept = true; 635 break; 636 case AVDTP_ACCEPTOR_W2_ANSWER_SUSPEND_STREAM: 637 log_info("DONE"); 638 stream_endpoint->state = AVDTP_STREAM_ENDPOINT_OPENED; 639 avdtp_acceptor_send_accept_response(cid, trid, AVDTP_SI_SUSPEND); 640 emit_accept = true; 641 break; 642 case AVDTP_ACCEPTOR_W2_REJECT_UNKNOWN_CMD: 643 log_info("DONE REJECT"); 644 connection->reject_signal_identifier = AVDTP_SI_NONE; 645 avdtp_acceptor_send_response_reject(cid, reject_signal_identifier, trid); 646 emit_reject = true; 647 break; 648 case AVDTP_ACCEPTOR_W2_REJECT_CATEGORY_WITH_ERROR_CODE: 649 log_info("DONE REJECT CATEGORY"); 650 connection->reject_service_category = 0; 651 avdtp_acceptor_send_response_reject_service_category(cid, reject_signal_identifier, reject_service_category, error_code, trid); 652 emit_reject = true; 653 break; 654 case AVDTP_ACCEPTOR_W2_REJECT_WITH_ERROR_CODE: 655 log_info("DONE REJECT"); 656 connection->reject_signal_identifier = AVDTP_SI_NONE; 657 connection->error_code = 0; 658 avdtp_acceptor_send_response_reject_with_error_code(cid, reject_signal_identifier, error_code, trid); 659 emit_reject = true; 660 break; 661 default: 662 log_info("NOT IMPLEMENTED"); 663 sent = 0; 664 break; 665 } 666 667 if (emit_accept == true){ 668 avdtp_signaling_emit_accept(connection->avdtp_cid, avdtp_local_seid(stream_endpoint), 669 connection->acceptor_signaling_packet.signal_identifier, false); 670 } else if (emit_reject == true){ 671 avdtp_signaling_emit_reject(connection->avdtp_cid, avdtp_local_seid(stream_endpoint), 672 connection->acceptor_signaling_packet.signal_identifier, false); 673 } 674 // check fragmentation 675 if ((connection->acceptor_signaling_packet.packet_type != AVDTP_SINGLE_PACKET) && (connection->acceptor_signaling_packet.packet_type != AVDTP_END_PACKET)){ 676 avdtp_request_can_send_now_acceptor(connection); 677 } 678 } 679