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