static void sdp_client_send_request(uint16_t channel){ if (sdp_client_state != W2_SEND) return; l2cap_reserve_packet_buffer(); uint8_t * data = l2cap_get_outgoing_buffer(); uint16_t request_len = 0; switch (PDU_ID){ #ifdef ENABLE_SDP_EXTRA_QUERIES case SDP_ServiceSearchResponse: request_len = sdp_client_setup_service_search_request(data); break; case SDP_ServiceAttributeResponse: request_len = sdp_client_setup_service_attribute_request(data); break; #endif case SDP_ServiceSearchAttributeResponse: request_len = sdp_client_setup_service_search_attribute_request(data); break; default: log_error("SDP Client sdp_client_send_request :: PDU ID invalid. %u", PDU_ID); return; } // prevent re-entrance sdp_client_state = W4_RESPONSE; PDU_ID = SDP_Invalid; l2cap_send_prepared(channel, request_len); }
int a2dp_source_stream_send_media_payload(uint16_t a2dp_cid, uint8_t local_seid, uint8_t * storage, int num_bytes_to_copy, uint8_t num_frames, uint8_t marker){ avdtp_stream_endpoint_t * stream_endpoint = avdtp_stream_endpoint_for_seid(local_seid, &a2dp_source_context); if (!stream_endpoint) { log_error("A2DP source: no stream_endpoint with seid %d", local_seid); return 0; } if (a2dp_source_context.avdtp_cid != a2dp_cid){ log_error("A2DP source: a2dp cid 0x%02x not known, expected 0x%02x", a2dp_cid, a2dp_source_context.avdtp_cid); return 0; } if (stream_endpoint->l2cap_media_cid == 0){ log_error("A2DP source: no media connection for seid %d", local_seid); return 0; } int size = l2cap_get_remote_mtu_for_local_cid(stream_endpoint->l2cap_media_cid); int offset = 0; l2cap_reserve_packet_buffer(); uint8_t * media_packet = l2cap_get_outgoing_buffer(); //int size = l2cap_get_remote_mtu_for_local_cid(stream_endpoint->l2cap_media_cid); a2dp_source_setup_media_header(media_packet, size, &offset, marker, stream_endpoint->sequence_number); a2dp_source_copy_media_payload(media_packet, size, &offset, storage, num_bytes_to_copy, num_frames); stream_endpoint->sequence_number++; l2cap_send_prepared(stream_endpoint->l2cap_media_cid, offset); return size; }
static int avdtp_source_stream_send_media_payload(uint8_t local_seid, uint8_t * storage, int num_bytes_to_copy, uint8_t num_frames, uint8_t marker){ avdtp_stream_endpoint_t * stream_endpoint = avdtp_stream_endpoint_for_seid(local_seid, &a2dp_source_context); if (!stream_endpoint) { log_error("no stream_endpoint found for seid %d", local_seid); return 0; } if (stream_endpoint->l2cap_media_cid == 0){ log_error("no media cid found for seid %d", local_seid); return 0; } int size = l2cap_get_remote_mtu_for_local_cid(stream_endpoint->l2cap_media_cid); int offset = 0; // HACK / PTS requests ERTM although we did not offer it in L2CAP Information Request. Withouth ERTM support, default MTU of 48 will be used, but that's to // small for a 44.1kHz/16/8/Stereo/bitpool 53 sbc frame of 119 bytes (+ media info) size = 0x290; l2cap_reserve_packet_buffer(); uint8_t * media_packet = l2cap_get_outgoing_buffer(); //int size = l2cap_get_remote_mtu_for_local_cid(stream_endpoint->l2cap_media_cid); a2dp_source_setup_media_header(media_packet, size, &offset, marker, stream_endpoint->sequence_number); a2dp_source_copy_media_payload(media_packet, size, &offset, storage, num_bytes_to_copy, num_frames); stream_endpoint->sequence_number++; l2cap_send_prepared(stream_endpoint->l2cap_media_cid, offset); return size; }
int att_server_notify(uint16_t handle, uint8_t *value, uint16_t value_len){ if (!l2cap_can_send_fixed_channel_packet_now(att_connection.con_handle)) return BTSTACK_ACL_BUFFERS_FULL; l2cap_reserve_packet_buffer(); uint8_t * packet_buffer = l2cap_get_outgoing_buffer(); uint16_t size = att_prepare_handle_value_notification(&att_connection, handle, value, value_len, packet_buffer); return l2cap_send_prepared_connectionless(att_connection.con_handle, L2CAP_CID_ATTRIBUTE_PROTOCOL, size); }
int l2cap_send_prepared_connectionless(uint16_t handle, uint16_t cid, uint16_t len){ att_connection_t att_connection; att_init_connection(&att_connection); uint8_t response[max_mtu]; uint16_t response_len = att_handle_request(&att_connection, l2cap_get_outgoing_buffer(), len, &response[0]); if (response_len){ att_packet_handler(ATT_DATA_PACKET, gatt_client_handle, &response[0], response_len); } return 0; }
int att_server_notify(hci_con_handle_t con_handle, uint16_t attribute_handle, uint8_t *value, uint16_t value_len){ att_server_t * att_server = att_server_for_handle(con_handle); if (!att_server) return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; if (!att_dispatch_server_can_send_now(con_handle)) return BTSTACK_ACL_BUFFERS_FULL; l2cap_reserve_packet_buffer(); uint8_t * packet_buffer = l2cap_get_outgoing_buffer(); uint16_t size = att_prepare_handle_value_notification(&att_server->connection, attribute_handle, value, value_len, packet_buffer); return l2cap_send_prepared_connectionless(att_server->connection.con_handle, L2CAP_CID_ATTRIBUTE_PROTOCOL, size); }
void send_ucd_packet(void){ l2cap_reserve_packet_buffer(); int ucd_size = 50; uint8_t * ucd_buffer = l2cap_get_outgoing_buffer(); bt_store_16(ucd_buffer, 0, 0x2211); int i; for (i=2; i< ucd_size ; i++){ ucd_buffer[i] = i; } l2cap_send_prepared_connectionless(handle, L2CAP_CID_CONNECTIONLESS_CHANNEL, ucd_size); }
// pre: att_server->state == ATT_SERVER_REQUEST_RECEIVED_AND_VALIDATED // pre: can send now // returns: 1 if packet was sent static int att_server_process_validated_request(att_server_t * att_server){ l2cap_reserve_packet_buffer(); uint8_t * att_response_buffer = l2cap_get_outgoing_buffer(); uint16_t att_response_size = att_handle_request(&att_server->connection, att_server->request_buffer, att_server->request_size, att_response_buffer); #ifdef ENABLE_ATT_DELAYED_READ_RESPONSE if (att_response_size == ATT_READ_RESPONSE_PENDING){ // update state att_server->state = ATT_SERVER_READ_RESPONSE_PENDING; // callback with handle ATT_READ_RESPONSE_PENDING att_server_client_read_callback(att_server->connection.con_handle, ATT_READ_RESPONSE_PENDING, 0, NULL, 0); // free reserved buffer l2cap_release_packet_buffer(); return 0; } #endif // intercept "insufficient authorization" for authenticated connections to allow for user authorization if ((att_response_size >= 4) && (att_response_buffer[0] == ATT_ERROR_RESPONSE) && (att_response_buffer[4] == ATT_ERROR_INSUFFICIENT_AUTHORIZATION) && (att_server->connection.authenticated)){ switch (gap_authorization_state(att_server->connection.con_handle)){ case AUTHORIZATION_UNKNOWN: l2cap_release_packet_buffer(); sm_request_pairing(att_server->connection.con_handle); return 0; case AUTHORIZATION_PENDING: l2cap_release_packet_buffer(); return 0; default: break; } } att_server->state = ATT_SERVER_IDLE; if (att_response_size == 0) { l2cap_release_packet_buffer(); return 0; } l2cap_send_prepared_connectionless(att_server->connection.con_handle, L2CAP_CID_ATTRIBUTE_PROTOCOL, att_response_size); // notify client about MTU exchange result if (att_response_buffer[0] == ATT_EXCHANGE_MTU_RESPONSE){ att_emit_mtu_event(att_server->connection.con_handle, att_server->connection.mtu); } return 1; }
int att_server_indicate(uint16_t handle, uint8_t *value, uint16_t value_len){ if (att_handle_value_indication_handle) return ATT_HANDLE_VALUE_INDICATION_IN_PORGRESS; if (!l2cap_can_send_fixed_channel_packet_now(att_connection.con_handle)) return BTSTACK_ACL_BUFFERS_FULL; // track indication att_handle_value_indication_handle = handle; run_loop_set_timer_handler(&att_handle_value_indication_timer, att_handle_value_indication_timeout); run_loop_set_timer(&att_handle_value_indication_timer, ATT_TRANSACTION_TIMEOUT_MS); run_loop_add_timer(&att_handle_value_indication_timer); l2cap_reserve_packet_buffer(); uint8_t * packet_buffer = l2cap_get_outgoing_buffer(); uint16_t size = att_prepare_handle_value_indication(&att_connection, handle, value, value_len, packet_buffer); l2cap_send_prepared_connectionless(att_connection.con_handle, L2CAP_CID_ATTRIBUTE_PROTOCOL, size); return 0; }
int att_server_indicate(hci_con_handle_t con_handle, uint16_t attribute_handle, uint8_t *value, uint16_t value_len){ att_server_t * att_server = att_server_for_handle(con_handle); if (!att_server) return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER; if (att_server->value_indication_handle) return ATT_HANDLE_VALUE_INDICATION_IN_PROGRESS; if (!att_dispatch_server_can_send_now(con_handle)) return BTSTACK_ACL_BUFFERS_FULL; // track indication att_server->value_indication_handle = attribute_handle; btstack_run_loop_set_timer_handler(&att_server->value_indication_timer, att_handle_value_indication_timeout); btstack_run_loop_set_timer(&att_server->value_indication_timer, ATT_TRANSACTION_TIMEOUT_MS); btstack_run_loop_add_timer(&att_server->value_indication_timer); l2cap_reserve_packet_buffer(); uint8_t * packet_buffer = l2cap_get_outgoing_buffer(); uint16_t size = att_prepare_handle_value_indication(&att_server->connection, attribute_handle, value, value_len, packet_buffer); l2cap_send_prepared_connectionless(att_server->connection.con_handle, L2CAP_CID_ATTRIBUTE_PROTOCOL, size); return 0; }
static void send_request(uint16_t channel){ l2cap_reserve_packet_buffer(); uint8_t * data = l2cap_get_outgoing_buffer(); uint16_t request_len = 0; switch (PDU_ID){ #ifdef HAVE_SDP_EXTRA_QUERIES case SDP_ServiceSearchResponse: request_len = setup_service_search_request(data); break; case SDP_ServiceAttributeResponse: request_len = setup_service_attribute_request(data); break; #endif case SDP_ServiceSearchAttributeResponse: request_len = setup_service_search_attribute_request(data); break; default: log_error("SDP Client send_request :: PDU ID invalid. %u", PDU_ID); return; } // prevent re-entrance sdp_client_state = W4_RESPONSE; int err = l2cap_send_prepared(channel, request_len); // l2cap_send_prepared shouldn't have failed as l2ap_can_send_packet_now() was true switch (err){ case 0: log_debug("l2cap_send_internal() -> OK"); PDU_ID = SDP_Invalid; break; case BTSTACK_ACL_BUFFERS_FULL: sdp_client_state = W2_SEND; log_info("l2cap_send_internal() ->BTSTACK_ACL_BUFFERS_FULL"); break; default: sdp_client_state = W2_SEND; log_error("l2cap_send_internal() -> err %d", err); break; } }
static void att_run(void){ switch (att_server_state){ case ATT_SERVER_IDLE: case ATT_SERVER_W4_SIGNED_WRITE_VALIDATION: return; case ATT_SERVER_REQUEST_RECEIVED: if (att_request_buffer[0] == ATT_SIGNED_WRITE_COMMAND){ log_info("ATT Signed Write!"); if (!sm_cmac_ready()) { log_info("ATT Signed Write, sm_cmac engine not ready. Abort"); att_server_state = ATT_SERVER_IDLE; return; } if (att_request_size < (3 + 12)) { log_info("ATT Signed Write, request to short. Abort."); att_server_state = ATT_SERVER_IDLE; return; } if (att_ir_lookup_active){ return; } if (att_ir_le_device_db_index < 0){ log_info("ATT Signed Write, CSRK not available"); att_server_state = ATT_SERVER_IDLE; return; } // check counter uint32_t counter_packet = READ_BT_32(att_request_buffer, att_request_size-12); uint32_t counter_db = le_device_db_remote_counter_get(att_ir_le_device_db_index); log_info("ATT Signed Write, DB counter %u, packet counter %u", counter_db, counter_packet); if (counter_packet < counter_db){ log_info("ATT Signed Write, db reports higher counter, abort"); att_server_state = ATT_SERVER_IDLE; return; } // signature is { sequence counter, secure hash } sm_key_t csrk; le_device_db_csrk_get(att_ir_le_device_db_index, csrk); att_server_state = ATT_SERVER_W4_SIGNED_WRITE_VALIDATION; log_info("Orig Signature: "); hexdump( &att_request_buffer[att_request_size-8], 8); sm_cmac_start(csrk, att_request_size - 12, att_request_buffer, counter_packet, att_signed_write_handle_cmac_result); return; } // NOTE: fall through for regular commands case ATT_SERVER_REQUEST_RECEIVED_AND_VALIDATED: if (!l2cap_can_send_fixed_channel_packet_now(att_connection.con_handle)) return; l2cap_reserve_packet_buffer(); uint8_t * att_response_buffer = l2cap_get_outgoing_buffer(); uint16_t att_response_size = att_handle_request(&att_connection, att_request_buffer, att_request_size, att_response_buffer); // intercept "insufficient authorization" for authenticated connections to allow for user authorization if ((att_response_size >= 4) && (att_response_buffer[0] == ATT_ERROR_RESPONSE) && (att_response_buffer[4] == ATT_ERROR_INSUFFICIENT_AUTHORIZATION) && (att_connection.authenticated)){ switch (sm_authorization_state(att_client_addr_type, att_client_address)){ case AUTHORIZATION_UNKNOWN: l2cap_release_packet_buffer(); sm_request_authorization(att_client_addr_type, att_client_address); return; case AUTHORIZATION_PENDING: l2cap_release_packet_buffer(); return; default: break; } } att_server_state = ATT_SERVER_IDLE; if (att_response_size == 0) { l2cap_release_packet_buffer(); return; } l2cap_send_prepared_connectionless(att_connection.con_handle, L2CAP_CID_ATTRIBUTE_PROTOCOL, att_response_size); // notify client about MTU exchange result if (att_response_buffer[0] == ATT_EXCHANGE_MTU_RESPONSE){ att_emit_mtu_event(att_connection.con_handle, att_connection.mtu); } break; } }
void avdtp_initiator_stream_config_subsm_run(avdtp_connection_t * connection, avdtp_context_t * context){ int sent = 1; switch (connection->initiator_connection_state){ case AVDTP_SIGNALING_CONNECTION_INITIATOR_W2_DISCOVER_SEPS: log_info("INT: AVDTP_SIGNALING_CONNECTION_INITIATOR_W2_DISCOVER_SEPS"); connection->initiator_connection_state = AVDTP_SIGNALING_CONNECTION_INITIATOR_W4_ANSWER; avdtp_initiator_send_signaling_cmd(connection->l2cap_signaling_cid, AVDTP_SI_DISCOVER, connection->initiator_transaction_label); break; case AVDTP_SIGNALING_CONNECTION_INITIATOR_W2_GET_CAPABILITIES: log_info("INT: AVDTP_SIGNALING_CONNECTION_INITIATOR_W2_GET_CAPABILITIES"); connection->initiator_connection_state = AVDTP_SIGNALING_CONNECTION_INITIATOR_W4_ANSWER; avdtp_initiator_send_signaling_cmd_with_seid(connection->l2cap_signaling_cid, AVDTP_SI_GET_CAPABILITIES, connection->initiator_transaction_label, connection->remote_seid); break; case AVDTP_SIGNALING_CONNECTION_INITIATOR_W2_GET_ALL_CAPABILITIES: log_info("INT: AVDTP_SIGNALING_CONNECTION_INITIATOR_W2_GET_ALL_CAPABILITIES"); connection->initiator_connection_state = AVDTP_SIGNALING_CONNECTION_INITIATOR_W4_ANSWER; avdtp_initiator_send_signaling_cmd_with_seid(connection->l2cap_signaling_cid, AVDTP_SI_GET_ALL_CAPABILITIES, connection->initiator_transaction_label, connection->remote_seid); break; case AVDTP_SIGNALING_CONNECTION_INITIATOR_W2_GET_CONFIGURATION: log_info("INT: AVDTP_INITIATOR_W4_GET_CONFIGURATION"); connection->initiator_connection_state = AVDTP_SIGNALING_CONNECTION_INITIATOR_W4_ANSWER; avdtp_initiator_send_signaling_cmd_with_seid(connection->l2cap_signaling_cid, AVDTP_SI_GET_CONFIGURATION, connection->initiator_transaction_label, connection->remote_seid); break; default: sent = 0; break; } if (sent) return; sent = 1; avdtp_stream_endpoint_t * stream_endpoint = NULL; stream_endpoint = avdtp_stream_endpoint_associated_with_acp_seid(connection->remote_seid, context); if (!stream_endpoint){ stream_endpoint = avdtp_stream_endpoint_with_seid(connection->local_seid, context); } if (!stream_endpoint) return; avdtp_initiator_stream_endpoint_state_t stream_endpoint_state = stream_endpoint->initiator_config_state; stream_endpoint->initiator_config_state = AVDTP_INITIATOR_W4_ANSWER; if (stream_endpoint->start_stream){ stream_endpoint->start_stream = 0; if (stream_endpoint->state == AVDTP_STREAM_ENDPOINT_OPENED){ connection->local_seid = stream_endpoint->sep.seid; connection->remote_seid = connection->remote_seps[stream_endpoint->remote_sep_index].seid; avdtp_initiator_send_signaling_cmd_with_seid(connection->l2cap_signaling_cid, AVDTP_SI_START, connection->initiator_transaction_label++, connection->remote_seid); return; } return; } if (stream_endpoint->stop_stream){ stream_endpoint->stop_stream = 0; if (stream_endpoint->state >= AVDTP_STREAM_ENDPOINT_OPENED){ connection->local_seid = stream_endpoint->sep.seid; connection->remote_seid = connection->remote_seps[stream_endpoint->remote_sep_index].seid; avdtp_initiator_send_signaling_cmd_with_seid(connection->l2cap_signaling_cid, AVDTP_SI_CLOSE, connection->initiator_transaction_label++, connection->remote_seid); return; } } if (stream_endpoint->abort_stream){ stream_endpoint->abort_stream = 0; switch (stream_endpoint->state){ case AVDTP_STREAM_ENDPOINT_CONFIGURED: case AVDTP_STREAM_ENDPOINT_CLOSING: case AVDTP_STREAM_ENDPOINT_OPENED: case AVDTP_STREAM_ENDPOINT_STREAMING: connection->local_seid = stream_endpoint->sep.seid; connection->remote_seid = connection->remote_seps[stream_endpoint->remote_sep_index].seid; stream_endpoint->state = AVDTP_STREAM_ENDPOINT_ABORTING; avdtp_initiator_send_signaling_cmd_with_seid(connection->l2cap_signaling_cid, AVDTP_SI_ABORT, connection->initiator_transaction_label++, connection->remote_seid); return; default: break; } } if (stream_endpoint->suspend_stream){ stream_endpoint->suspend_stream = 0; if (stream_endpoint->state == AVDTP_STREAM_ENDPOINT_STREAMING){ stream_endpoint->state = AVDTP_STREAM_ENDPOINT_STREAMING; avdtp_initiator_send_signaling_cmd_with_seid(connection->l2cap_signaling_cid, AVDTP_SI_SUSPEND, connection->initiator_transaction_label, connection->remote_seid); return; } } if (stream_endpoint->send_stream){ stream_endpoint->send_stream = 0; if (stream_endpoint->state == AVDTP_STREAM_ENDPOINT_STREAMING){ stream_endpoint->state = AVDTP_STREAM_ENDPOINT_STREAMING; avdtp_streaming_emit_can_send_media_packet_now(context->avdtp_callback, stream_endpoint->l2cap_media_cid, stream_endpoint->sep.seid, stream_endpoint->sequence_number); return; } } switch (stream_endpoint_state){ case AVDTP_INITIATOR_W2_SET_CONFIGURATION: case AVDTP_INITIATOR_W2_RECONFIGURE_STREAM_WITH_SEID:{ log_info("INT: AVDTP_INITIATOR_W2_(RE)CONFIGURATION bitmap, int seid %d, acp seid %d", connection->local_seid, connection->remote_seid); // log_info_hexdump( connection->remote_capabilities.media_codec.media_codec_information, connection->remote_capabilities.media_codec.media_codec_information_len); connection->signaling_packet.acp_seid = connection->remote_seid; connection->signaling_packet.int_seid = connection->local_seid; connection->signaling_packet.signal_identifier = AVDTP_SI_SET_CONFIGURATION; if (stream_endpoint_state == AVDTP_INITIATOR_W2_RECONFIGURE_STREAM_WITH_SEID){ connection->signaling_packet.signal_identifier = AVDTP_SI_RECONFIGURE; } avdtp_prepare_capabilities(&connection->signaling_packet, connection->initiator_transaction_label, stream_endpoint->remote_configuration_bitmap, stream_endpoint->remote_configuration, connection->signaling_packet.signal_identifier); l2cap_reserve_packet_buffer(); uint8_t * out_buffer = l2cap_get_outgoing_buffer(); uint16_t pos = avdtp_signaling_create_fragment(connection->l2cap_signaling_cid, &connection->signaling_packet, out_buffer); if (connection->signaling_packet.packet_type != AVDTP_SINGLE_PACKET && connection->signaling_packet.packet_type != AVDTP_END_PACKET){ stream_endpoint->initiator_config_state = AVDTP_INITIATOR_FRAGMENTATED_COMMAND; log_info("INT: fragmented"); } l2cap_send_prepared(connection->l2cap_signaling_cid, pos); break; } case AVDTP_INITIATOR_FRAGMENTATED_COMMAND:{ l2cap_reserve_packet_buffer(); uint8_t * out_buffer = l2cap_get_outgoing_buffer(); uint16_t pos = avdtp_signaling_create_fragment(connection->l2cap_signaling_cid, &connection->signaling_packet, out_buffer); if (connection->signaling_packet.packet_type != AVDTP_SINGLE_PACKET && connection->signaling_packet.packet_type != AVDTP_END_PACKET){ stream_endpoint->initiator_config_state = AVDTP_INITIATOR_FRAGMENTATED_COMMAND; log_info("INT: fragmented"); } l2cap_send_prepared(connection->l2cap_signaling_cid, pos); break; } case AVDTP_INITIATOR_W2_OPEN_STREAM: switch (stream_endpoint->state){ case AVDTP_STREAM_ENDPOINT_W2_REQUEST_OPEN_STREAM: log_info("INT: AVDTP_STREAM_ENDPOINT_W2_REQUEST_OPEN_STREAM"); avdtp_initiator_send_signaling_cmd_with_seid(connection->l2cap_signaling_cid, AVDTP_SI_OPEN, connection->initiator_transaction_label, connection->remote_seid); break; default: sent = 0; break; } break; default: sent = 0; break; } // check fragmentation if (connection->signaling_packet.packet_type != AVDTP_SINGLE_PACKET && connection->signaling_packet.packet_type != AVDTP_END_PACKET){ avdtp_request_can_send_now_initiator(connection, connection->l2cap_signaling_cid); } }