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