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