mirror/btstack
1
0
Fork 0
mirror of https://github.com/bluekitchen/btstack.git synced 2025-03-12 10:13:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

move acceptor signaling connection state from sink

Browse Source
This commit is contained in:
Milanka Ringwald 2017-01-17 14:42:03 +01:00
parent cab4a0b539
commit 5ea47e31d2
7 changed files with 103 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

89
test/avdtp/avdtp_acceptor.c
View File

@ -93,21 +93,23 @@ static int avdtp_acceptor_validate_msg_length(avdtp_signal_identifier_t signal_i
return msg_size >= minimal_msg_lenght;
}
void avdtp_acceptor_stream_config_subsm(avdtp_connection_t * connection, avdtp_stream_endpoint_t * _stream_endpoint, uint8_t * packet, uint16_t size, int offset){
if (avdtp_acceptor_validate_msg_length(connection->signaling_packet.signal_identifier, size)) {
void avdtp_acceptor_stream_config_subsm(avdtp_connection_t * connection, uint8_t * packet, uint16_t size, int offset){
avdtp_stream_endpoint_t * stream_endpoint;
if (!avdtp_acceptor_validate_msg_length(connection->signaling_packet.signal_identifier, size)) {
connection->error_code = BAD_LENGTH;
connection->acceptor_connection_state = AVDTP_SIGNALING_CONNECTION_ACCEPTOR_W2_REJECT_WITH_ERROR_CODE;
connection->reject_signal_identifier = connection->signaling_packet.signal_identifier;
avdtp_sink_request_can_send_now_self(connection, connection->l2cap_signaling_cid);
avdtp_sink_request_can_send_now_acceptor(connection, connection->l2cap_signaling_cid);
return;
}
avdtp_stream_endpoint_t * stream_endpoint;
switch (connection->signaling_packet.signal_identifier){
case AVDTP_SI_DISCOVER:
if (connection->state != AVDTP_SIGNALING_CONNECTION_OPENED) return;
printf(" ACP: AVDTP_SIGNALING_CONNECTION_ACCEPTOR_W2_ANSWER_DISCOVER_SEPS\n");
connection->acceptor_connection_state = AVDTP_SIGNALING_CONNECTION_ACCEPTOR_W2_ANSWER_DISCOVER_SEPS;
avdtp_sink_request_can_send_now_self(connection, connection->l2cap_signaling_cid);
avdtp_sink_request_can_send_now_acceptor(connection, connection->l2cap_signaling_cid);
return;
case AVDTP_SI_GET_CAPABILITIES:
case AVDTP_SI_GET_ALL_CAPABILITIES:
@ -133,7 +135,7 @@ void avdtp_acceptor_stream_config_subsm(avdtp_connection_t * connection, avdtp_s
connection->acceptor_connection_state = AVDTP_SIGNALING_CONNECTION_ACCEPTOR_W2_REJECT_CATEGORY_WITH_ERROR_CODE;
}
connection->reject_signal_identifier = connection->signaling_packet.signal_identifier;
avdtp_sink_request_can_send_now_self(connection, connection->l2cap_signaling_cid);
avdtp_sink_request_can_send_now_acceptor(connection, connection->l2cap_signaling_cid);
return;
}
break;
@ -156,7 +158,7 @@ void avdtp_acceptor_stream_config_subsm(avdtp_connection_t * connection, avdtp_s
connection->reject_service_category = connection->query_seid;
connection->acceptor_connection_state = AVDTP_SIGNALING_CONNECTION_ACCEPTOR_W2_REJECT_CATEGORY_WITH_ERROR_CODE;
connection->reject_signal_identifier = connection->signaling_packet.signal_identifier;
avdtp_sink_request_can_send_now_self(connection, connection->l2cap_signaling_cid);
avdtp_sink_request_can_send_now_acceptor(connection, connection->l2cap_signaling_cid);
return;
}
// deal with first susspended seid
@ -169,7 +171,7 @@ void avdtp_acceptor_stream_config_subsm(avdtp_connection_t * connection, avdtp_s
connection->acceptor_connection_state = AVDTP_SIGNALING_CONNECTION_ACCEPTOR_W2_REJECT_CATEGORY_WITH_ERROR_CODE;
connection->reject_signal_identifier = connection->signaling_packet.signal_identifier;
connection->num_suspended_seids = 0;
avdtp_sink_request_can_send_now_self(connection, connection->l2cap_signaling_cid);
avdtp_sink_request_can_send_now_acceptor(connection, connection->l2cap_signaling_cid);
return;
}
break;
@ -178,7 +180,7 @@ void avdtp_acceptor_stream_config_subsm(avdtp_connection_t * connection, avdtp_s
connection->acceptor_connection_state = AVDTP_SIGNALING_CONNECTION_ACCEPTOR_W2_GENERAL_REJECT_WITH_ERROR_CODE;
connection->reject_signal_identifier = connection->signaling_packet.signal_identifier;
printf("AVDTP_CMD_MSG signal %d not implemented, general reject\n", connection->signaling_packet.signal_identifier);
avdtp_sink_request_can_send_now_self(connection, connection->l2cap_signaling_cid);
avdtp_sink_request_can_send_now_acceptor(connection, connection->l2cap_signaling_cid);
return;
}
@ -422,7 +424,23 @@ void avdtp_acceptor_stream_config_subsm(avdtp_connection_t * connection, avdtp_s
avdtp_sink_request_can_send_now_acceptor(connection, connection->l2cap_signaling_cid);
}
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){
static int avdtp_acceptor_send_seps_response(uint16_t cid, uint8_t transaction_label, avdtp_stream_endpoint_t * endpoints){
uint8_t command[2+2*MAX_NUM_SEPS];
int pos = 0;
command[pos++] = avdtp_header(transaction_label, AVDTP_SINGLE_PACKET, AVDTP_RESPONSE_ACCEPT_MSG);
command[pos++] = (uint8_t)AVDTP_SI_DISCOVER;
btstack_linked_list_iterator_t it;
btstack_linked_list_iterator_init(&it, (btstack_linked_list_t *) endpoints);
while (btstack_linked_list_iterator_has_next(&it)){
avdtp_stream_endpoint_t * stream_endpoint = (avdtp_stream_endpoint_t *)btstack_linked_list_iterator_next(&it);
command[pos++] = (stream_endpoint->sep.seid << 2) | (stream_endpoint->sep.in_use<<1);
command[pos++] = (stream_endpoint->sep.media_type << 4) | (stream_endpoint->sep.type << 3);
}
return l2cap_send(cid, command, pos);
}
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){
uint8_t command[4];
command[0] = avdtp_header(transaction_label, AVDTP_SINGLE_PACKET, AVDTP_RESPONSE_REJECT_MSG);
command[1] = (uint8_t)identifier;
@ -431,7 +449,7 @@ int avdtp_acceptor_send_response_reject_service_category(uint16_t cid, avdtp_si
return l2cap_send(cid, command, sizeof(command));
}
int avdtp_acceptor_send_response_general_reject(uint16_t cid, avdtp_signal_identifier_t identifier, uint8_t transaction_label){
static int avdtp_acceptor_send_response_general_reject(uint16_t cid, avdtp_signal_identifier_t identifier, uint8_t transaction_label){
uint8_t command[2];
command[0] = avdtp_header(transaction_label, AVDTP_SINGLE_PACKET, AVDTP_GENERAL_REJECT_MSG);
command[1] = (uint8_t)identifier;
@ -445,7 +463,7 @@ static int avdtp_acceptor_send_response_reject(uint16_t cid, avdtp_signal_identi
return l2cap_send(cid, command, sizeof(command));
}
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){
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){
uint8_t command[3];
command[0] = avdtp_header(transaction_label, AVDTP_SINGLE_PACKET, AVDTP_RESPONSE_REJECT_MSG);
command[1] = (uint8_t)identifier;
@ -453,11 +471,36 @@ int avdtp_acceptor_send_response_reject_with_error_code(uint16_t cid, avdtp_sign
return l2cap_send(cid, command, sizeof(command));
}
void avdtp_acceptor_stream_config_subsm_run(avdtp_connection_t * connection){
int sent = 1;
printf("avdtp_acceptor_stream_config_subsm_run connection state \n");
switch (connection->acceptor_connection_state){
case AVDTP_SIGNALING_CONNECTION_ACCEPTOR_W2_ANSWER_DISCOVER_SEPS:
printf(" -> AVDTP_SIGNALING_CONNECTION_OPENED\n");
connection->state = AVDTP_SIGNALING_CONNECTION_OPENED;
connection->acceptor_connection_state = AVDTP_SIGNALING_CONNECTION_ACCEPTOR_IDLE;
avdtp_acceptor_send_seps_response(connection->l2cap_signaling_cid, connection->acceptor_transaction_label, (avdtp_stream_endpoint_t *)&stream_endpoints);
break;
case AVDTP_SIGNALING_CONNECTION_ACCEPTOR_W2_REJECT_WITH_ERROR_CODE:
connection->acceptor_connection_state = AVDTP_SIGNALING_CONNECTION_ACCEPTOR_IDLE;
avdtp_acceptor_send_response_reject_with_error_code(connection->l2cap_signaling_cid, connection->reject_signal_identifier, connection->error_code, connection->acceptor_transaction_label);
break;
case AVDTP_SIGNALING_CONNECTION_ACCEPTOR_W2_REJECT_CATEGORY_WITH_ERROR_CODE:
connection->acceptor_connection_state = AVDTP_SIGNALING_CONNECTION_ACCEPTOR_IDLE;
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);
break;
case AVDTP_SIGNALING_CONNECTION_ACCEPTOR_W2_GENERAL_REJECT_WITH_ERROR_CODE:
connection->acceptor_connection_state = AVDTP_SIGNALING_CONNECTION_ACCEPTOR_IDLE;
avdtp_acceptor_send_response_general_reject(connection->l2cap_signaling_cid, connection->reject_signal_identifier, connection->acceptor_transaction_label);
default:
sent = 0;
break;
}
if (sent) return;
avdtp_stream_endpoint_t * stream_endpoint = get_avdtp_stream_endpoint_for_seid(connection->query_seid);
if (!stream_endpoint) return;
int avdtp_acceptor_stream_config_subsm_run(avdtp_connection_t * connection, avdtp_stream_endpoint_t * stream_endpoint){
if (!stream_endpoint) return 0;
uint8_t reject_service_category = connection->reject_service_category;
avdtp_signal_identifier_t reject_signal_identifier = connection->reject_signal_identifier;
uint8_t error_code = connection->error_code;
@ -466,7 +509,6 @@ int avdtp_acceptor_stream_config_subsm_run(avdtp_connection_t * connection, avdt
avdtp_acceptor_stream_endpoint_state_t acceptor_config_state = stream_endpoint->acceptor_config_state;
stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE;
int sent = 1;
uint8_t * out_buffer;
uint16_t pos;
@ -523,7 +565,7 @@ int avdtp_acceptor_stream_config_subsm_run(avdtp_connection_t * connection, avdt
}
case AVDTP_ACCEPTOR_W4_L2CAP_FOR_MEDIA_CONNECTED:
stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W4_L2CAP_FOR_MEDIA_CONNECTED;
return 0;
break;
case AVDTP_ACCEPTOR_W2_ANSWER_OPEN_STREAM:
printf(" ACP: DONE\n");
avdtp_acceptor_send_accept_response(cid, trid, AVDTP_SI_OPEN);
@ -574,9 +616,10 @@ int avdtp_acceptor_stream_config_subsm_run(avdtp_connection_t * connection, avdt
}
avdtp_signaling_emit_done(avdtp_sink_callback, connection->con_handle, status);
if (connection->signaling_packet.packet_type != AVDTP_SINGLE_PACKET && connection->signaling_packet.packet_type != AVDTP_END_PACKET){
stream_endpoint->acceptor_config_state = acceptor_config_state;
connection->wait_to_send_acceptor = 1;
// check fragmentation
if (stream_endpoint->acceptor_config_state != AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE){
avdtp_sink_request_can_send_now_acceptor(connection, connection->l2cap_signaling_cid);
}
return sent;
return;
}

8
test/avdtp/avdtp_acceptor.h
View File

@ -51,12 +51,8 @@
extern "C" {
#endif
void avdtp_acceptor_stream_config_subsm(avdtp_connection_t * connection, avdtp_stream_endpoint_t * stream_endpoint, uint8_t *packet, uint16_t size, int offset);
int avdtp_acceptor_stream_config_subsm_run(avdtp_connection_t * connection, avdtp_stream_endpoint_t * stream_endpoint);
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);
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);
int avdtp_acceptor_send_response_general_reject(uint16_t cid, avdtp_signal_identifier_t identifier, uint8_t transaction_label);
void avdtp_acceptor_stream_config_subsm(avdtp_connection_t * connection, uint8_t *packet, uint16_t size, int offset);
void avdtp_acceptor_stream_config_subsm_run(avdtp_connection_t * connection);
#if defined __cplusplus
}

32
test/avdtp/avdtp_initiator.c
View File

@ -64,10 +64,11 @@
// }
int avdtp_initiator_stream_config_subsm(avdtp_connection_t * connection, avdtp_stream_endpoint_t * stream_endpoint, uint8_t *packet, uint16_t size){
int avdtp_initiator_stream_config_subsm(avdtp_connection_t * connection, uint8_t *packet, uint16_t size, int offset){
//if (!stream_endpoint) return 0;
if (avdtp_initiator_stream_config_subsm_run(connection, stream_endpoint)) return 1;
if (avdtp_initiator_stream_config_subsm_run(connection)) return 1;
avdtp_stream_endpoint_t * stream_endpoint = NULL;
if (!stream_endpoint) return 0;
int responded = 1;
printf(" avdtp_initiator_stream_config_subsm got response\n");
switch (stream_endpoint->initiator_config_state){
@ -79,29 +80,10 @@ int avdtp_initiator_stream_config_subsm(avdtp_connection_t * connection, avdtp_s
return responded;
}
int avdtp_initiator_stream_config_subsm_run(avdtp_connection_t * connection, avdtp_stream_endpoint_t * stream_endpoint){
int avdtp_initiator_stream_config_subsm_run(avdtp_connection_t * connection){
int sent = 1;
// if (stream_endpoint->media_connect){
// switch (stream_endpoint->initiator_config_state){
// case AVDTP_INITIATOR_STREAM_CONFIG_IDLE:
// stream_endpoint->initiator_config_state = AVDTP_INITIATOR_W2_GET_CAPABILITIES
// // case AVDTP_INITIATOR_W2_GET_CAPABILITIES:
// // printf(" INT: AVDTP_INITIATOR_W2_GET_CAPABILITIES -> AVDTP_INITIATOR_W4_CAPABILITIES\n");
// // stream_endpoint->initiator_config_state = AVDTP_INITIATOR_W4_CAPABILITIES;
// // avdtp_initiator_send_get_capabilities_cmd(connection->l2cap_signaling_cid, connection->initiator_transaction_label, connection->query_seid);
// // break;
// // case AVDTP_INITIATOR_W2_GET_ALL_CAPABILITIES:
// // printf(" INT: AVDTP_INITIATOR_W2_GET_ALL_CAPABILITIES -> AVDTP_INITIATOR_W4_ALL_CAPABILITIES\n");
// // stream_endpoint->initiator_config_state = AVDTP_INITIATOR_W4_ALL_CAPABILITIES;
// // avdtp_initiator_send_get_all_capabilities_cmd(connection->l2cap_signaling_cid, connection->initiator_transaction_label, connection->query_seid);
// // break;
// default:
// sent = 0;
// break;
// }
// if (sent) return 1;
avdtp_stream_endpoint_t * stream_endpoint = NULL;
if (!stream_endpoint) return 0;
switch (stream_endpoint->initiator_config_state){
// case AVDTP_INITIATOR_W2_GET_CAPABILITIES:
// printf(" INT: AVDTP_INITIATOR_W2_GET_CAPABILITIES -> AVDTP_INITIATOR_W4_CAPABILITIES\n");

4
test/avdtp/avdtp_initiator.h
View File

@ -51,8 +51,8 @@
extern "C" {
#endif
int avdtp_initiator_stream_config_subsm(avdtp_connection_t * connection, avdtp_stream_endpoint_t * stream_endpoint, uint8_t *packet, uint16_t size);
int avdtp_initiator_stream_config_subsm_run(avdtp_connection_t * connection, avdtp_stream_endpoint_t * stream_endpoint);
int avdtp_initiator_stream_config_subsm(avdtp_connection_t * connection, uint8_t *packet, uint16_t size, int offset);
int avdtp_initiator_stream_config_subsm_run(avdtp_connection_t * connection);
#if defined __cplusplus
}

113
test/avdtp/avdtp_sink.c
View File

@ -144,18 +144,6 @@ void a2dp_sink_create_sdp_record(uint8_t * service, uint32_t service_record_han
}
static avdtp_stream_endpoint_t * get_avdtp_stream_endpoint_for_seid(uint16_t seid){
btstack_linked_list_iterator_t it;
btstack_linked_list_iterator_init(&it, (btstack_linked_list_t *) &stream_endpoints);
while (btstack_linked_list_iterator_has_next(&it)){
avdtp_stream_endpoint_t * stream_endpoint = (avdtp_stream_endpoint_t *)btstack_linked_list_iterator_next(&it);
if (stream_endpoint->sep.seid == seid){
return stream_endpoint;
}
}
return NULL;
}
static avdtp_connection_t * avdtp_sink_create_connection(bd_addr_t remote_addr){
avdtp_connection_t * connection = btstack_memory_avdtp_connection_get();
memset(connection, 0, sizeof(avdtp_connection_t));
@ -341,29 +329,6 @@ static avdtp_stream_endpoint_t * get_avdtp_stream_endpoint_for_connection(avdtp_
return NULL;
}
// static int avdtp_acceptor_send_accept_response(uint16_t cid, avdtp_signal_identifier_t identifier, uint8_t transaction_label){
// uint8_t command[2];
// command[0] = avdtp_header(transaction_label, AVDTP_SINGLE_PACKET, AVDTP_RESPONSE_ACCEPT_MSG);
// command[1] = (uint8_t)identifier;
// return l2cap_send(cid, command, sizeof(command));
// }
static int avdtp_send_seps_response(uint16_t cid, uint8_t transaction_label, avdtp_stream_endpoint_t * endpoints){
uint8_t command[2+2*MAX_NUM_SEPS];
int pos = 0;
command[pos++] = avdtp_header(transaction_label, AVDTP_SINGLE_PACKET, AVDTP_RESPONSE_ACCEPT_MSG);
command[pos++] = (uint8_t)AVDTP_SI_DISCOVER;
btstack_linked_list_iterator_t it;
btstack_linked_list_iterator_init(&it, (btstack_linked_list_t *) endpoints);
while (btstack_linked_list_iterator_has_next(&it)){
avdtp_stream_endpoint_t * stream_endpoint = (avdtp_stream_endpoint_t *)btstack_linked_list_iterator_next(&it);
command[pos++] = (stream_endpoint->sep.seid << 2) | (stream_endpoint->sep.in_use<<1);
command[pos++] = (stream_endpoint->sep.media_type << 4) | (stream_endpoint->sep.type << 3);
}
return l2cap_send(cid, command, pos);
}
static int avdtp_initiator_send_signaling_cmd(uint16_t cid, avdtp_signal_identifier_t identifier, uint8_t transaction_label){
uint8_t command[2];
command[0] = avdtp_header(transaction_label, AVDTP_SINGLE_PACKET, AVDTP_CMD_MSG);
@ -382,27 +347,17 @@ static int avdtp_initiator_send_signaling_cmd_with_seid(uint16_t cid, avdtp_sign
/* START: tracking can send now requests pro l2cap cid */
static void avdtp_sink_handle_can_send_now(avdtp_connection_t * connection, uint16_t l2cap_cid){
printf("avdtp_sink_handle_can_send_now: ");
if (connection->wait_to_send_acceptor){
connection->wait_to_send_acceptor = 0;
avdtp_stream_endpoint_t * stream_endpoint = get_avdtp_stream_endpoint_for_seid(connection->query_seid);
if (!stream_endpoint) return;
int sent = avdtp_acceptor_stream_config_subsm_run(connection, stream_endpoint);
// check fragmentation
if (stream_endpoint->acceptor_config_state != AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE){
avdtp_sink_request_can_send_now_acceptor(connection, l2cap_cid);
}
if (sent) return;
avdtp_acceptor_stream_config_subsm_run(connection);
} else if (connection->wait_to_send_initiator){
connection->wait_to_send_initiator = 0;
avdtp_stream_endpoint_t * stream_endpoint = get_avdtp_stream_endpoint_for_seid(connection->query_seid);
if (!stream_endpoint) return;
if (avdtp_initiator_stream_config_subsm_run(connection, stream_endpoint)) return;
avdtp_initiator_stream_config_subsm_run(connection);
} else if (connection->wait_to_send_self){
connection->wait_to_send_self = 0;
if (connection->disconnect){
btstack_linked_list_iterator_t it;
btstack_linked_list_iterator_init(&it, (btstack_linked_list_t *) &stream_endpoints);
@ -422,29 +377,6 @@ static void avdtp_sink_handle_can_send_now(avdtp_connection_t * connection, uint
l2cap_disconnect(connection->l2cap_signaling_cid, 0);
return;
}
switch (connection->acceptor_connection_state){
case AVDTP_SIGNALING_CONNECTION_ACCEPTOR_W2_ANSWER_DISCOVER_SEPS:
printf(" -> AVDTP_SIGNALING_CONNECTION_OPENED\n");
connection->state = AVDTP_SIGNALING_CONNECTION_OPENED;
connection->acceptor_connection_state = AVDTP_SIGNALING_CONNECTION_ACCEPTOR_IDLE;
avdtp_send_seps_response(connection->l2cap_signaling_cid, connection->acceptor_transaction_label, (avdtp_stream_endpoint_t *)&stream_endpoints);
return;
case AVDTP_SIGNALING_CONNECTION_ACCEPTOR_W2_REJECT_WITH_ERROR_CODE:
connection->acceptor_connection_state = AVDTP_SIGNALING_CONNECTION_ACCEPTOR_IDLE;
avdtp_acceptor_send_response_reject_with_error_code(connection->l2cap_signaling_cid, connection->reject_signal_identifier, connection->error_code, connection->acceptor_transaction_label);
return;
case AVDTP_SIGNALING_CONNECTION_ACCEPTOR_W2_REJECT_CATEGORY_WITH_ERROR_CODE:
connection->acceptor_connection_state = AVDTP_SIGNALING_CONNECTION_ACCEPTOR_IDLE;
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);
return;
case AVDTP_SIGNALING_CONNECTION_ACCEPTOR_W2_GENERAL_REJECT_WITH_ERROR_CODE:
connection->acceptor_connection_state = AVDTP_SIGNALING_CONNECTION_ACCEPTOR_IDLE;
avdtp_acceptor_send_response_general_reject(connection->l2cap_signaling_cid, connection->reject_signal_identifier, connection->acceptor_transaction_label);
default:
break;
}
switch (connection->initiator_connection_state){
case AVDTP_SIGNALING_CONNECTION_INITIATOR_W2_L2CAP_FOR_STREAMING_STOPED:
printf(" -> AVDTP_SIGNALING_CONNECTION_INITIATOR_W4_L2CAP_FOR_STREAMING_STOPED\n");
@ -542,21 +474,7 @@ static void avdtp_sink_handle_can_send_now(avdtp_connection_t * connection, uint
}
/* END: tracking can send now requests pro l2cap cid */
static int handle_l2cap_data_packet_for_stream_endpoint(avdtp_connection_t * connection, avdtp_stream_endpoint_t * stream_endpoint, uint8_t *packet, uint16_t size, int offset){
avdtp_read_signaling_header(&connection->signaling_packet, packet, size);
if (connection->signaling_packet.message_type == AVDTP_CMD_MSG){
avdtp_acceptor_stream_config_subsm(connection, stream_endpoint, packet, size, offset);
} else {
if (avdtp_initiator_stream_config_subsm(connection, stream_endpoint, packet, size)){
avdtp_sink_request_can_send_now_initiator(connection, connection->l2cap_signaling_cid);
return 1;
}
}
return 0;
}
static void handle_l2cap_data_packet_for_signaling_connection(avdtp_connection_t * connection, uint8_t *packet, uint16_t size){
avdtp_stream_endpoint_t * stream_endpoint = NULL;
@ -566,18 +484,8 @@ static void handle_l2cap_data_packet_for_signaling_connection(avdtp_connection_t
switch (connection->signaling_packet.message_type){
case AVDTP_CMD_MSG:
switch (connection->signaling_packet.signal_identifier){
case AVDTP_SI_DISCOVER:
if (connection->state != AVDTP_SIGNALING_CONNECTION_OPENED) return;
connection->acceptor_connection_state = AVDTP_SIGNALING_CONNECTION_ACCEPTOR_W2_ANSWER_DISCOVER_SEPS;
avdtp_sink_request_can_send_now_self(connection, connection->l2cap_signaling_cid);
return;
default:
avdtp_acceptor_stream_config_subsm(connection, stream_endpoint, packet, size, offset);
return;
}
avdtp_acceptor_stream_config_subsm(connection, packet, size, offset);
break;
case AVDTP_RESPONSE_ACCEPT_MSG:
printf(" AVDTP_RESPONSE_ACCEPT_MSG: ");
@ -836,17 +744,20 @@ static void handle_l2cap_data_packet_for_signaling_connection(avdtp_connection_t
avdtp_signaling_emit_done(avdtp_sink_callback, connection->con_handle, 1);
return;
}
printf(" handle_l2cap_data_packet_for_signaling_connection, signal %d not handled\n", connection->signaling_packet.signal_identifier);
return;
}
static void stream_endpoint_state_machine(avdtp_connection_t * connection, avdtp_stream_endpoint_t * stream_endpoint, uint8_t packet_type, uint8_t event, uint8_t *packet, uint16_t size){
uint16_t local_cid;
switch (packet_type){
case L2CAP_DATA_PACKET:
handle_l2cap_data_packet_for_stream_endpoint(connection, stream_endpoint, packet, size, 0);
case L2CAP_DATA_PACKET:{
int offset = avdtp_read_signaling_header(&connection->signaling_packet, packet, size);
if (connection->signaling_packet.message_type == AVDTP_CMD_MSG){
avdtp_acceptor_stream_config_subsm(connection, packet, size, offset);
} else {
avdtp_initiator_stream_config_subsm(connection, packet, size, offset);
}
break;
}
case HCI_EVENT_PACKET:
switch (event){
case L2CAP_EVENT_CHANNEL_OPENED:

12
test/avdtp/avdtp_util.c
View File

@ -597,4 +597,16 @@ void avdtp_sink_request_can_send_now_self(avdtp_connection_t * connection, uint1
connection->wait_to_send_self = 1;
l2cap_request_can_send_now_event(l2cap_cid);
}
avdtp_stream_endpoint_t * get_avdtp_stream_endpoint_for_seid(uint16_t seid){
btstack_linked_list_iterator_t it;
btstack_linked_list_iterator_init(&it, (btstack_linked_list_t *) &stream_endpoints);
while (btstack_linked_list_iterator_has_next(&it)){
avdtp_stream_endpoint_t * stream_endpoint = (avdtp_stream_endpoint_t *)btstack_linked_list_iterator_next(&it);
if (stream_endpoint->sep.seid == seid){
return stream_endpoint;
}
}
return NULL;
}

2
test/avdtp/avdtp_util.h
View File

@ -79,6 +79,8 @@ void avdtp_sink_request_can_send_now_acceptor(avdtp_connection_t * connection, u
void avdtp_sink_request_can_send_now_initiator(avdtp_connection_t * connection, uint16_t l2cap_cid);
void avdtp_sink_request_can_send_now_self(avdtp_connection_t * connection, uint16_t l2cap_cid);
avdtp_stream_endpoint_t * get_avdtp_stream_endpoint_for_seid(uint16_t seid);
#if defined __cplusplus
}
#endif