gd/l2cap/le/internal/signalling_manager.cc - platform/system/bt - Git at Google

 /*
  * Copyright 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include "l2cap/le/internal/signalling_manager.h"

 #include <chrono>

 #include "common/bind.h"
 #include "l2cap/internal/data_pipeline_manager.h"
 #include "l2cap/internal/dynamic_channel_impl.h"
 #include "l2cap/internal/le_credit_based_channel_data_controller.h"
 #include "l2cap/l2cap_packets.h"
 #include "l2cap/le/internal/link.h"
 #include "os/log.h"
 #include "packet/raw_builder.h"

 namespace bluetooth {
 namespace l2cap {
 namespace le {
 namespace internal {

 static constexpr auto kTimeout = std::chrono::seconds(3);

 LeSignallingManager::LeSignallingManager(os::Handler* handler, Link* link,
                                          l2cap::internal::DataPipelineManager* data_pipeline_manager,
                                          DynamicChannelServiceManagerImpl* dynamic_service_manager,
                                          l2cap::internal::DynamicChannelAllocator* channel_allocator)
     : handler_(handler), link_(link), data_pipeline_manager_(data_pipeline_manager),
       dynamic_service_manager_(dynamic_service_manager), channel_allocator_(channel_allocator), alarm_(handler) {
   ASSERT(handler_ != nullptr);
   ASSERT(link_ != nullptr);
   signalling_channel_ = link_->AllocateFixedChannel(kLeSignallingCid, {});
   signalling_channel_->GetQueueUpEnd()->RegisterDequeue(
       handler_, common::Bind(&LeSignallingManager::on_incoming_packet, common::Unretained(this)));
   enqueue_buffer_ =
       std::make_unique<os::EnqueueBuffer<packet::BasePacketBuilder>>(signalling_channel_->GetQueueUpEnd());
 }

 LeSignallingManager::~LeSignallingManager() {
   enqueue_buffer_.reset();
   signalling_channel_->GetQueueUpEnd()->UnregisterDequeue();
   signalling_channel_ = nullptr;
 }

 void LeSignallingManager::SendConnectionRequest(Psm psm, Cid local_cid, Mtu mtu) {
   PendingCommand pending_command = PendingCommand::CreditBasedConnectionRequest(
       next_signal_id_, psm, local_cid, mtu, link_->GetMps(), link_->GetInitialCredit());
   next_signal_id_++;
   pending_commands_.push(pending_command);
   if (pending_commands_.size() == 1) {
     handle_send_next_command();
   }
 }

 void LeSignallingManager::SendDisconnectRequest(Cid scid, Cid dcid) {
   PendingCommand pending_command = PendingCommand::DisconnectionRequest(next_signal_id_, scid, dcid);
   next_signal_id_++;
   pending_commands_.push(pending_command);
   if (pending_commands_.size() == 1) {
     handle_send_next_command();
   }
 }

 void LeSignallingManager::SendConnectionParameterUpdateRequest(uint16_t interval_min, uint16_t interval_max,
                                                                uint16_t slave_latency, uint16_t timeout_multiplier) {
   PendingCommand pending_command = PendingCommand::ConnectionParameterUpdate(
       next_signal_id_, interval_min, interval_max, slave_latency, timeout_multiplier);
   next_signal_id_++;
   pending_commands_.push(pending_command);
   if (pending_commands_.size() == 1) {
     handle_send_next_command();
   }
 }

 void LeSignallingManager::SendConnectionParameterUpdateResponse(SignalId signal_id,
                                                                 ConnectionParameterUpdateResponseResult result) {
   auto builder = ConnectionParameterUpdateResponseBuilder::Create(signal_id.Value(), result);
   enqueue_buffer_->Enqueue(std::move(builder), handler_);
 }

 void LeSignallingManager::SendCredit(Cid local_cid, uint16_t credits) {
   auto builder = LeFlowControlCreditBuilder::Create(next_signal_id_.Value(), local_cid, credits);
   next_signal_id_++;
   enqueue_buffer_->Enqueue(std::move(builder), handler_);
 }

 void LeSignallingManager::CancelAlarm() {
   alarm_.Cancel();
 }

 void LeSignallingManager::OnCommandReject(LeCommandRejectView command_reject_view) {
   auto signal_id = command_reject_view.GetIdentifier();
   if (signal_id != command_just_sent_.signal_id_) {
     LOG_WARN("Unexpected response: no pending request");
     return;
   }
   alarm_.Cancel();
   if (command_just_sent_.command_code_ == LeCommandCode::LE_CREDIT_BASED_CONNECTION_REQUEST) {
     link_->OnOutgoingConnectionRequestFail(command_just_sent_.source_cid_,
                                            LeCreditBasedConnectionResponseResult::NO_RESOURCES_AVAILABLE);
   }
   handle_send_next_command();

   LOG_WARN("Command rejected");
 }

 void LeSignallingManager::OnConnectionParameterUpdateRequest(SignalId signal_id, uint16_t interval_min,
                                                              uint16_t interval_max, uint16_t slave_latency,
                                                              uint16_t timeout_multiplier) {
   if (link_->GetRole() == hci::Role::SLAVE) {
     LOG_WARN("Received request from LL master");
     auto builder = LeCommandRejectNotUnderstoodBuilder::Create(signal_id.Value());
     enqueue_buffer_->Enqueue(std::move(builder), handler_);
     return;
   }
   if (interval_min < 6 || interval_min > 3200 || interval_max < 6 || interval_max > 3200 || slave_latency >= 500 ||
       timeout_multiplier < 10 || timeout_multiplier > 3200) {
     LOG_WARN("Received invalid connection parameter update request from LL master");
     auto builder = ConnectionParameterUpdateResponseBuilder::Create(signal_id.Value(),
                                                                     ConnectionParameterUpdateResponseResult::REJECTED);
     enqueue_buffer_->Enqueue(std::move(builder), handler_);
     return;
   }
   link_->UpdateConnectionParameterFromRemote(signal_id, interval_min, interval_max, slave_latency, timeout_multiplier);
 }

 void LeSignallingManager::OnConnectionParameterUpdateResponse(SignalId signal_id,
                                                               ConnectionParameterUpdateResponseResult result) {
   if (signal_id != command_just_sent_.signal_id_) {
     LOG_WARN("Unexpected response: no pending request");
     return;
   }
   if (command_just_sent_.command_code_ != LeCommandCode::CONNECTION_PARAMETER_UPDATE_REQUEST) {
     LOG_WARN("Unexpected response: no pending request");
     return;
   }
   alarm_.Cancel();
   command_just_sent_.signal_id_ = kInitialSignalId;
   if (result != ConnectionParameterUpdateResponseResult::ACCEPTED) {
     LOG_ERROR("Connection parameter update is not accepted");
   }
 }

 void LeSignallingManager::OnConnectionRequest(SignalId signal_id, Psm psm, Cid remote_cid, Mtu mtu, uint16_t mps,
                                               uint16_t initial_credits) {
   if (!IsPsmValid(psm)) {
     LOG_WARN("Invalid psm received from remote psm:%d remote_cid:%d", psm, remote_cid);
     send_connection_response(signal_id, kInvalidCid, 0, 0, 0,
                              LeCreditBasedConnectionResponseResult::LE_PSM_NOT_SUPPORTED);
     return;
   }

   if (remote_cid == kInvalidCid) {
     LOG_WARN("Invalid remote cid received from remote psm:%d remote_cid:%d", psm, remote_cid);
     send_connection_response(signal_id, kInvalidCid, 0, 0, 0,
                              LeCreditBasedConnectionResponseResult::INVALID_SOURCE_CID);
     return;
   }

   if (channel_allocator_->IsPsmUsed(psm)) {
     LOG_WARN("Psm already exists");
     send_connection_response(signal_id, kInvalidCid, 0, 0, 0,
                              LeCreditBasedConnectionResponseResult::LE_PSM_NOT_SUPPORTED);
     return;
   }

   if (!dynamic_service_manager_->IsServiceRegistered(psm)) {
     LOG_INFO("Service for this psm (%d) is not registered", psm);
     send_connection_response(signal_id, kInvalidCid, 0, 0, 0,
                              LeCreditBasedConnectionResponseResult::LE_PSM_NOT_SUPPORTED);
     return;
   }

   auto* service = dynamic_service_manager_->GetService(psm);
   auto config = service->GetConfigOption();
   auto local_mtu = config.mtu;
   auto local_mps = link_->GetMps();

   auto new_channel = link_->AllocateDynamicChannel(psm, remote_cid, {});
   if (new_channel == nullptr) {
     LOG_WARN("Can't allocate dynamic channel");
     send_connection_response(signal_id, kInvalidCid, 0, 0, 0,
                              LeCreditBasedConnectionResponseResult::NO_RESOURCES_AVAILABLE);

     return;
   }
   send_connection_response(signal_id, new_channel->GetCid(), local_mtu, local_mps, link_->GetInitialCredit(),
                            LeCreditBasedConnectionResponseResult::SUCCESS);
   auto* data_controller = reinterpret_cast<l2cap::internal::LeCreditBasedDataController*>(
       data_pipeline_manager_->GetDataController(new_channel->GetCid()));
   data_controller->SetMtu(std::min(mtu, local_mtu));
   data_controller->SetMps(std::min(mps, local_mps));
   data_controller->OnCredit(initial_credits);
   auto user_channel = std::make_unique<DynamicChannel>(new_channel, handler_);
   dynamic_service_manager_->GetService(psm)->NotifyChannelCreation(std::move(user_channel));
 }

 void LeSignallingManager::OnConnectionResponse(SignalId signal_id, Cid remote_cid, Mtu mtu, uint16_t mps,
                                                uint16_t initial_credits, LeCreditBasedConnectionResponseResult result) {
   if (signal_id != command_just_sent_.signal_id_) {
     LOG_WARN("Unexpected response: no pending request");
     return;
   }
   if (command_just_sent_.command_code_ != LeCommandCode::LE_CREDIT_BASED_CONNECTION_REQUEST) {
     LOG_WARN("Unexpected response: no pending request");
     return;
   }
   alarm_.Cancel();
   command_just_sent_.signal_id_ = kInitialSignalId;
   if (result != LeCreditBasedConnectionResponseResult::SUCCESS) {
     LOG_WARN("Connection failed: %s", LeCreditBasedConnectionResponseResultText(result).data());
     link_->OnOutgoingConnectionRequestFail(command_just_sent_.source_cid_, result);
     handle_send_next_command();
     return;
   }
   auto new_channel =
       link_->AllocateReservedDynamicChannel(command_just_sent_.source_cid_, command_just_sent_.psm_, remote_cid, {});
   if (new_channel == nullptr) {
     LOG_WARN("Can't allocate dynamic channel");
     link_->OnOutgoingConnectionRequestFail(command_just_sent_.source_cid_,
                                            LeCreditBasedConnectionResponseResult::NO_RESOURCES_AVAILABLE);
     handle_send_next_command();
     return;
   }
   auto* data_controller = reinterpret_cast<l2cap::internal::LeCreditBasedDataController*>(
       data_pipeline_manager_->GetDataController(new_channel->GetCid()));
   data_controller->SetMtu(std::min(mtu, command_just_sent_.mtu_));
   data_controller->SetMps(std::min(mps, command_just_sent_.mps_));
   data_controller->OnCredit(initial_credits);
   std::unique_ptr<DynamicChannel> user_channel = std::make_unique<DynamicChannel>(new_channel, handler_);
   dynamic_service_manager_->GetService(command_just_sent_.psm_)->NotifyChannelCreation(std::move(user_channel));
 }

 void LeSignallingManager::OnDisconnectionRequest(SignalId signal_id, Cid cid, Cid remote_cid) {
   auto channel = channel_allocator_->FindChannelByCid(cid);
   if (channel == nullptr) {
     LOG_WARN("Disconnect request for an unknown channel");
     return;
   }
   if (channel->GetRemoteCid() != remote_cid) {
     LOG_WARN("Disconnect request for an unmatching channel");
     return;
   }
   auto builder = LeDisconnectionResponseBuilder::Create(signal_id.Value(), cid, remote_cid);
   enqueue_buffer_->Enqueue(std::move(builder), handler_);
   channel->OnClosed(hci::ErrorCode::SUCCESS);
   link_->FreeDynamicChannel(cid);
 }

 void LeSignallingManager::OnDisconnectionResponse(SignalId signal_id, Cid remote_cid, Cid cid) {
   if (signal_id != command_just_sent_.signal_id_ ||
       command_just_sent_.command_code_ != LeCommandCode::DISCONNECTION_REQUEST) {
     LOG_WARN("Unexpected response: no pending request");
     return;
   }
   if (command_just_sent_.source_cid_ != cid || command_just_sent_.destination_cid_ != remote_cid) {
     LOG_WARN("Unexpected response: cid doesn't match. Expected scid %d dcid %d, got scid %d dcid %d",
              command_just_sent_.source_cid_, command_just_sent_.destination_cid_, cid, remote_cid);
     handle_send_next_command();
     return;
   }
   alarm_.Cancel();
   command_just_sent_.signal_id_ = kInitialSignalId;
   auto channel = channel_allocator_->FindChannelByCid(cid);
   if (channel == nullptr) {
     LOG_WARN("Disconnect response for an unknown channel");
     handle_send_next_command();
     return;
   }

   channel->OnClosed(hci::ErrorCode::SUCCESS);
   link_->FreeDynamicChannel(cid);
   handle_send_next_command();
 }

 void LeSignallingManager::OnCredit(Cid remote_cid, uint16_t credits) {
   auto channel = channel_allocator_->FindChannelByRemoteCid(remote_cid);
   if (channel == nullptr) {
     LOG_WARN("Received credit for invalid cid %d", channel->GetCid());
     return;
   }
   auto* data_controller = reinterpret_cast<l2cap::internal::LeCreditBasedDataController*>(
       data_pipeline_manager_->GetDataController(channel->GetCid()));
   data_controller->OnCredit(credits);
 }

 void LeSignallingManager::on_incoming_packet() {
   auto packet = signalling_channel_->GetQueueUpEnd()->TryDequeue();
   LeControlView control_packet_view = LeControlView::Create(*packet);
   if (!control_packet_view.IsValid()) {
     LOG_WARN("Invalid signalling packet received");
     return;
   }
   auto code = control_packet_view.GetCode();
   switch (code) {
     case LeCommandCode::COMMAND_REJECT: {
       LeCommandRejectView command_reject_view = LeCommandRejectView::Create(control_packet_view);
       if (!command_reject_view.IsValid()) {
         return;
       }
       OnCommandReject(command_reject_view);
       return;
     }

     case LeCommandCode::CONNECTION_PARAMETER_UPDATE_REQUEST: {
       ConnectionParameterUpdateRequestView parameter_update_req_view =
           ConnectionParameterUpdateRequestView::Create(control_packet_view);
       if (!parameter_update_req_view.IsValid()) {
         return;
       }
       OnConnectionParameterUpdateRequest(
           parameter_update_req_view.GetIdentifier(), parameter_update_req_view.GetIntervalMin(),
           parameter_update_req_view.GetIntervalMax(), parameter_update_req_view.GetSlaveLatency(),
           parameter_update_req_view.GetTimeoutMultiplier());
       return;
     }
     case LeCommandCode::CONNECTION_PARAMETER_UPDATE_RESPONSE: {
       ConnectionParameterUpdateResponseView parameter_update_rsp_view =
           ConnectionParameterUpdateResponseView::Create(control_packet_view);
       if (!parameter_update_rsp_view.IsValid()) {
         return;
       }
       OnConnectionParameterUpdateResponse(parameter_update_rsp_view.GetIdentifier(),
                                           parameter_update_rsp_view.GetResult());
       return;
     }
     case LeCommandCode::LE_CREDIT_BASED_CONNECTION_REQUEST: {
       LeCreditBasedConnectionRequestView connection_request_view =
           LeCreditBasedConnectionRequestView::Create(control_packet_view);
       if (!connection_request_view.IsValid()) {
         return;
       }
       OnConnectionRequest(connection_request_view.GetIdentifier(), connection_request_view.GetLePsm(),
                           connection_request_view.GetSourceCid(), connection_request_view.GetMtu(),
                           connection_request_view.GetMps(), connection_request_view.GetInitialCredits());
       return;
     }
     case LeCommandCode::LE_CREDIT_BASED_CONNECTION_RESPONSE: {
       LeCreditBasedConnectionResponseView connection_response_view =
           LeCreditBasedConnectionResponseView::Create(control_packet_view);
       if (!connection_response_view.IsValid()) {
         return;
       }
       OnConnectionResponse(connection_response_view.GetIdentifier(), connection_response_view.GetDestinationCid(),
                            connection_response_view.GetMtu(), connection_response_view.GetMps(),
                            connection_response_view.GetInitialCredits(), connection_response_view.GetResult());
       return;
     }
     case LeCommandCode::LE_FLOW_CONTROL_CREDIT: {
       LeFlowControlCreditView credit_view = LeFlowControlCreditView::Create(control_packet_view);
       if (!credit_view.IsValid()) {
         return;
       }
       OnCredit(credit_view.GetCid(), credit_view.GetCredits());
       return;
     }
     case LeCommandCode::DISCONNECTION_REQUEST: {
       LeDisconnectionRequestView disconnection_request_view = LeDisconnectionRequestView::Create(control_packet_view);
       if (!disconnection_request_view.IsValid()) {
         return;
       }
       OnDisconnectionRequest(disconnection_request_view.GetIdentifier(), disconnection_request_view.GetDestinationCid(),
                              disconnection_request_view.GetSourceCid());
       return;
     }
     case LeCommandCode::DISCONNECTION_RESPONSE: {
       LeDisconnectionResponseView disconnection_response_view =
           LeDisconnectionResponseView::Create(control_packet_view);
       if (!disconnection_response_view.IsValid()) {
         return;
       }
       OnDisconnectionResponse(disconnection_response_view.GetIdentifier(),
                               disconnection_response_view.GetDestinationCid(),
                               disconnection_response_view.GetSourceCid());
       return;
     }
     default:
       LOG_WARN("Unhandled event 0x%x", static_cast<int>(code));
       auto builder = LeCommandRejectNotUnderstoodBuilder::Create(control_packet_view.GetIdentifier());
       enqueue_buffer_->Enqueue(std::move(builder), handler_);
       return;
   }
 }

 void LeSignallingManager::send_connection_response(SignalId signal_id, Cid local_cid, Mtu mtu, uint16_t mps,
                                                    uint16_t initial_credit,
                                                    LeCreditBasedConnectionResponseResult result) {
   auto builder =
       LeCreditBasedConnectionResponseBuilder::Create(signal_id.Value(), local_cid, mtu, mps, initial_credit, result);
   enqueue_buffer_->Enqueue(std::move(builder), handler_);
 }

 void LeSignallingManager::on_command_timeout() {
   LOG_WARN("Response time out");
   if (command_just_sent_.signal_id_ == kInvalidSignalId) {
     LOG_ERROR("No pending command");
     return;
   }
   switch (command_just_sent_.command_code_) {
     case LeCommandCode::CONNECTION_PARAMETER_UPDATE_REQUEST: {
       link_->OnOutgoingConnectionRequestFail(command_just_sent_.source_cid_,
                                              LeCreditBasedConnectionResponseResult::NO_RESOURCES_AVAILABLE);
       break;
     }
     default:
       break;
   }
   handle_send_next_command();
 }

 void LeSignallingManager::handle_send_next_command() {
   command_just_sent_.signal_id_ = kInvalidSignalId;
   if (pending_commands_.empty()) {
     return;
   }

   command_just_sent_ = pending_commands_.front();
   pending_commands_.pop();
   switch (command_just_sent_.command_code_) {
     case LeCommandCode::LE_CREDIT_BASED_CONNECTION_REQUEST: {
       auto builder = LeCreditBasedConnectionRequestBuilder::Create(
           command_just_sent_.signal_id_.Value(), command_just_sent_.psm_, command_just_sent_.source_cid_,
           command_just_sent_.mtu_, command_just_sent_.mps_, command_just_sent_.credits_);
       enqueue_buffer_->Enqueue(std::move(builder), handler_);
       alarm_.Schedule(common::BindOnce(&LeSignallingManager::on_command_timeout, common::Unretained(this)), kTimeout);
       break;
     }
     case LeCommandCode::DISCONNECTION_REQUEST: {
       auto builder = LeDisconnectionRequestBuilder::Create(
           command_just_sent_.signal_id_.Value(), command_just_sent_.destination_cid_, command_just_sent_.source_cid_);
       enqueue_buffer_->Enqueue(std::move(builder), handler_);
       alarm_.Schedule(common::BindOnce(&LeSignallingManager::on_command_timeout, common::Unretained(this)), kTimeout);
       break;
     }
     case LeCommandCode::CONNECTION_PARAMETER_UPDATE_REQUEST: {
       auto builder = ConnectionParameterUpdateRequestBuilder::Create(command_just_sent_.signal_id_.Value(), 0, 0, 0, 0);
       enqueue_buffer_->Enqueue(std::move(builder), handler_);
       alarm_.Schedule(common::BindOnce(&LeSignallingManager::on_command_timeout, common::Unretained(this)), kTimeout);
       break;
     }
     default: {
       LOG_WARN("Unsupported command code 0x%x", static_cast<int>(command_just_sent_.command_code_));
     }
   }
 }
 }  // namespace internal
 }  // namespace le
 }  // namespace l2cap
 }  // namespace bluetooth
	/*
	* Copyright 2019 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "l2cap/le/internal/signalling_manager.h"

	#include <chrono>

	#include "common/bind.h"
	#include "l2cap/internal/data_pipeline_manager.h"
	#include "l2cap/internal/dynamic_channel_impl.h"
	#include "l2cap/internal/le_credit_based_channel_data_controller.h"
	#include "l2cap/l2cap_packets.h"
	#include "l2cap/le/internal/link.h"
	#include "os/log.h"
	#include "packet/raw_builder.h"

	namespace bluetooth {
	namespace l2cap {
	namespace le {
	namespace internal {

	static constexpr auto kTimeout = std::chrono::seconds(3);

	LeSignallingManager::LeSignallingManager(os::Handler* handler, Link* link,
	l2cap::internal::DataPipelineManager* data_pipeline_manager,
	DynamicChannelServiceManagerImpl* dynamic_service_manager,
	l2cap::internal::DynamicChannelAllocator* channel_allocator)
	: handler_(handler), link_(link), data_pipeline_manager_(data_pipeline_manager),
	dynamic_service_manager_(dynamic_service_manager), channel_allocator_(channel_allocator), alarm_(handler) {
	ASSERT(handler_ != nullptr);
	ASSERT(link_ != nullptr);
	signalling_channel_ = link_->AllocateFixedChannel(kLeSignallingCid, {});
	signalling_channel_->GetQueueUpEnd()->RegisterDequeue(
	handler_, common::Bind(&LeSignallingManager::on_incoming_packet, common::Unretained(this)));
	enqueue_buffer_ =
	std::make_unique<os::EnqueueBuffer<packet::BasePacketBuilder>>(signalling_channel_->GetQueueUpEnd());
	}

	LeSignallingManager::~LeSignallingManager() {
	enqueue_buffer_.reset();
	signalling_channel_->GetQueueUpEnd()->UnregisterDequeue();
	signalling_channel_ = nullptr;
	}

	void LeSignallingManager::SendConnectionRequest(Psm psm, Cid local_cid, Mtu mtu) {
	PendingCommand pending_command = PendingCommand::CreditBasedConnectionRequest(
	next_signal_id_, psm, local_cid, mtu, link_->GetMps(), link_->GetInitialCredit());
	next_signal_id_++;
	pending_commands_.push(pending_command);
	if (pending_commands_.size() == 1) {
	handle_send_next_command();
	}
	}

	void LeSignallingManager::SendDisconnectRequest(Cid scid, Cid dcid) {
	PendingCommand pending_command = PendingCommand::DisconnectionRequest(next_signal_id_, scid, dcid);
	next_signal_id_++;
	pending_commands_.push(pending_command);
	if (pending_commands_.size() == 1) {
	handle_send_next_command();
	}
	}

	void LeSignallingManager::SendConnectionParameterUpdateRequest(uint16_t interval_min, uint16_t interval_max,
	uint16_t slave_latency, uint16_t timeout_multiplier) {
	PendingCommand pending_command = PendingCommand::ConnectionParameterUpdate(
	next_signal_id_, interval_min, interval_max, slave_latency, timeout_multiplier);
	next_signal_id_++;
	pending_commands_.push(pending_command);
	if (pending_commands_.size() == 1) {
	handle_send_next_command();
	}
	}

	void LeSignallingManager::SendConnectionParameterUpdateResponse(SignalId signal_id,
	ConnectionParameterUpdateResponseResult result) {
	auto builder = ConnectionParameterUpdateResponseBuilder::Create(signal_id.Value(), result);
	enqueue_buffer_->Enqueue(std::move(builder), handler_);
	}

	void LeSignallingManager::SendCredit(Cid local_cid, uint16_t credits) {
	auto builder = LeFlowControlCreditBuilder::Create(next_signal_id_.Value(), local_cid, credits);
	next_signal_id_++;
	enqueue_buffer_->Enqueue(std::move(builder), handler_);
	}

	void LeSignallingManager::CancelAlarm() {
	alarm_.Cancel();
	}

	void LeSignallingManager::OnCommandReject(LeCommandRejectView command_reject_view) {
	auto signal_id = command_reject_view.GetIdentifier();
	if (signal_id != command_just_sent_.signal_id_) {
	LOG_WARN("Unexpected response: no pending request");
	return;
	}
	alarm_.Cancel();
	if (command_just_sent_.command_code_ == LeCommandCode::LE_CREDIT_BASED_CONNECTION_REQUEST) {
	link_->OnOutgoingConnectionRequestFail(command_just_sent_.source_cid_,
	LeCreditBasedConnectionResponseResult::NO_RESOURCES_AVAILABLE);
	}
	handle_send_next_command();

	LOG_WARN("Command rejected");
	}

	void LeSignallingManager::OnConnectionParameterUpdateRequest(SignalId signal_id, uint16_t interval_min,
	uint16_t interval_max, uint16_t slave_latency,
	uint16_t timeout_multiplier) {
	if (link_->GetRole() == hci::Role::SLAVE) {
	LOG_WARN("Received request from LL master");
	auto builder = LeCommandRejectNotUnderstoodBuilder::Create(signal_id.Value());
	enqueue_buffer_->Enqueue(std::move(builder), handler_);
	return;
	}
	if (interval_min < 6 \|\| interval_min > 3200 \|\| interval_max < 6 \|\| interval_max > 3200 \|\| slave_latency >= 500 \|\|
	timeout_multiplier < 10 \|\| timeout_multiplier > 3200) {
	LOG_WARN("Received invalid connection parameter update request from LL master");
	auto builder = ConnectionParameterUpdateResponseBuilder::Create(signal_id.Value(),
	ConnectionParameterUpdateResponseResult::REJECTED);
	enqueue_buffer_->Enqueue(std::move(builder), handler_);
	return;
	}
	link_->UpdateConnectionParameterFromRemote(signal_id, interval_min, interval_max, slave_latency, timeout_multiplier);
	}

	void LeSignallingManager::OnConnectionParameterUpdateResponse(SignalId signal_id,
	ConnectionParameterUpdateResponseResult result) {
	if (signal_id != command_just_sent_.signal_id_) {
	LOG_WARN("Unexpected response: no pending request");
	return;
	}
	if (command_just_sent_.command_code_ != LeCommandCode::CONNECTION_PARAMETER_UPDATE_REQUEST) {
	LOG_WARN("Unexpected response: no pending request");
	return;
	}
	alarm_.Cancel();
	command_just_sent_.signal_id_ = kInitialSignalId;
	if (result != ConnectionParameterUpdateResponseResult::ACCEPTED) {
	LOG_ERROR("Connection parameter update is not accepted");
	}
	}

	void LeSignallingManager::OnConnectionRequest(SignalId signal_id, Psm psm, Cid remote_cid, Mtu mtu, uint16_t mps,
	uint16_t initial_credits) {
	if (!IsPsmValid(psm)) {
	LOG_WARN("Invalid psm received from remote psm:%d remote_cid:%d", psm, remote_cid);
	send_connection_response(signal_id, kInvalidCid, 0, 0, 0,
	LeCreditBasedConnectionResponseResult::LE_PSM_NOT_SUPPORTED);
	return;
	}

	if (remote_cid == kInvalidCid) {
	LOG_WARN("Invalid remote cid received from remote psm:%d remote_cid:%d", psm, remote_cid);
	send_connection_response(signal_id, kInvalidCid, 0, 0, 0,
	LeCreditBasedConnectionResponseResult::INVALID_SOURCE_CID);
	return;
	}

	if (channel_allocator_->IsPsmUsed(psm)) {
	LOG_WARN("Psm already exists");
	send_connection_response(signal_id, kInvalidCid, 0, 0, 0,
	LeCreditBasedConnectionResponseResult::LE_PSM_NOT_SUPPORTED);
	return;
	}

	if (!dynamic_service_manager_->IsServiceRegistered(psm)) {
	LOG_INFO("Service for this psm (%d) is not registered", psm);
	send_connection_response(signal_id, kInvalidCid, 0, 0, 0,
	LeCreditBasedConnectionResponseResult::LE_PSM_NOT_SUPPORTED);
	return;
	}

	auto* service = dynamic_service_manager_->GetService(psm);
	auto config = service->GetConfigOption();
	auto local_mtu = config.mtu;
	auto local_mps = link_->GetMps();

	auto new_channel = link_->AllocateDynamicChannel(psm, remote_cid, {});
	if (new_channel == nullptr) {
	LOG_WARN("Can't allocate dynamic channel");
	send_connection_response(signal_id, kInvalidCid, 0, 0, 0,
	LeCreditBasedConnectionResponseResult::NO_RESOURCES_AVAILABLE);

	return;
	}
	send_connection_response(signal_id, new_channel->GetCid(), local_mtu, local_mps, link_->GetInitialCredit(),
	LeCreditBasedConnectionResponseResult::SUCCESS);
	auto* data_controller = reinterpret_cast<l2cap::internal::LeCreditBasedDataController*>(
	data_pipeline_manager_->GetDataController(new_channel->GetCid()));
	data_controller->SetMtu(std::min(mtu, local_mtu));
	data_controller->SetMps(std::min(mps, local_mps));
	data_controller->OnCredit(initial_credits);
	auto user_channel = std::make_unique<DynamicChannel>(new_channel, handler_);
	dynamic_service_manager_->GetService(psm)->NotifyChannelCreation(std::move(user_channel));
	}

	void LeSignallingManager::OnConnectionResponse(SignalId signal_id, Cid remote_cid, Mtu mtu, uint16_t mps,
	uint16_t initial_credits, LeCreditBasedConnectionResponseResult result) {
	if (signal_id != command_just_sent_.signal_id_) {
	LOG_WARN("Unexpected response: no pending request");
	return;
	}
	if (command_just_sent_.command_code_ != LeCommandCode::LE_CREDIT_BASED_CONNECTION_REQUEST) {
	LOG_WARN("Unexpected response: no pending request");
	return;
	}
	alarm_.Cancel();
	command_just_sent_.signal_id_ = kInitialSignalId;
	if (result != LeCreditBasedConnectionResponseResult::SUCCESS) {
	LOG_WARN("Connection failed: %s", LeCreditBasedConnectionResponseResultText(result).data());
	link_->OnOutgoingConnectionRequestFail(command_just_sent_.source_cid_, result);
	handle_send_next_command();
	return;
	}
	auto new_channel =
	link_->AllocateReservedDynamicChannel(command_just_sent_.source_cid_, command_just_sent_.psm_, remote_cid, {});
	if (new_channel == nullptr) {
	LOG_WARN("Can't allocate dynamic channel");
	link_->OnOutgoingConnectionRequestFail(command_just_sent_.source_cid_,
	LeCreditBasedConnectionResponseResult::NO_RESOURCES_AVAILABLE);
	handle_send_next_command();
	return;
	}
	auto* data_controller = reinterpret_cast<l2cap::internal::LeCreditBasedDataController*>(
	data_pipeline_manager_->GetDataController(new_channel->GetCid()));
	data_controller->SetMtu(std::min(mtu, command_just_sent_.mtu_));
	data_controller->SetMps(std::min(mps, command_just_sent_.mps_));
	data_controller->OnCredit(initial_credits);
	std::unique_ptr<DynamicChannel> user_channel = std::make_unique<DynamicChannel>(new_channel, handler_);
	dynamic_service_manager_->GetService(command_just_sent_.psm_)->NotifyChannelCreation(std::move(user_channel));
	}

	void LeSignallingManager::OnDisconnectionRequest(SignalId signal_id, Cid cid, Cid remote_cid) {
	auto channel = channel_allocator_->FindChannelByCid(cid);
	if (channel == nullptr) {
	LOG_WARN("Disconnect request for an unknown channel");
	return;
	}
	if (channel->GetRemoteCid() != remote_cid) {
	LOG_WARN("Disconnect request for an unmatching channel");
	return;
	}
	auto builder = LeDisconnectionResponseBuilder::Create(signal_id.Value(), cid, remote_cid);
	enqueue_buffer_->Enqueue(std::move(builder), handler_);
	channel->OnClosed(hci::ErrorCode::SUCCESS);
	link_->FreeDynamicChannel(cid);
	}

	void LeSignallingManager::OnDisconnectionResponse(SignalId signal_id, Cid remote_cid, Cid cid) {
	if (signal_id != command_just_sent_.signal_id_ \|\|
	command_just_sent_.command_code_ != LeCommandCode::DISCONNECTION_REQUEST) {
	LOG_WARN("Unexpected response: no pending request");
	return;
	}
	if (command_just_sent_.source_cid_ != cid \|\| command_just_sent_.destination_cid_ != remote_cid) {
	LOG_WARN("Unexpected response: cid doesn't match. Expected scid %d dcid %d, got scid %d dcid %d",
	command_just_sent_.source_cid_, command_just_sent_.destination_cid_, cid, remote_cid);
	handle_send_next_command();
	return;
	}
	alarm_.Cancel();
	command_just_sent_.signal_id_ = kInitialSignalId;
	auto channel = channel_allocator_->FindChannelByCid(cid);
	if (channel == nullptr) {
	LOG_WARN("Disconnect response for an unknown channel");
	handle_send_next_command();
	return;
	}

	channel->OnClosed(hci::ErrorCode::SUCCESS);
	link_->FreeDynamicChannel(cid);
	handle_send_next_command();
	}

	void LeSignallingManager::OnCredit(Cid remote_cid, uint16_t credits) {
	auto channel = channel_allocator_->FindChannelByRemoteCid(remote_cid);
	if (channel == nullptr) {
	LOG_WARN("Received credit for invalid cid %d", channel->GetCid());
	return;
	}
	auto* data_controller = reinterpret_cast<l2cap::internal::LeCreditBasedDataController*>(
	data_pipeline_manager_->GetDataController(channel->GetCid()));
	data_controller->OnCredit(credits);
	}

	void LeSignallingManager::on_incoming_packet() {
	auto packet = signalling_channel_->GetQueueUpEnd()->TryDequeue();
	LeControlView control_packet_view = LeControlView::Create(*packet);
	if (!control_packet_view.IsValid()) {
	LOG_WARN("Invalid signalling packet received");
	return;
	}
	auto code = control_packet_view.GetCode();
	switch (code) {
	case LeCommandCode::COMMAND_REJECT: {
	LeCommandRejectView command_reject_view = LeCommandRejectView::Create(control_packet_view);
	if (!command_reject_view.IsValid()) {
	return;
	}
	OnCommandReject(command_reject_view);
	return;
	}

	case LeCommandCode::CONNECTION_PARAMETER_UPDATE_REQUEST: {
	ConnectionParameterUpdateRequestView parameter_update_req_view =
	ConnectionParameterUpdateRequestView::Create(control_packet_view);
	if (!parameter_update_req_view.IsValid()) {
	return;
	}
	OnConnectionParameterUpdateRequest(
	parameter_update_req_view.GetIdentifier(), parameter_update_req_view.GetIntervalMin(),
	parameter_update_req_view.GetIntervalMax(), parameter_update_req_view.GetSlaveLatency(),
	parameter_update_req_view.GetTimeoutMultiplier());
	return;
	}
	case LeCommandCode::CONNECTION_PARAMETER_UPDATE_RESPONSE: {
	ConnectionParameterUpdateResponseView parameter_update_rsp_view =
	ConnectionParameterUpdateResponseView::Create(control_packet_view);
	if (!parameter_update_rsp_view.IsValid()) {
	return;
	}
	OnConnectionParameterUpdateResponse(parameter_update_rsp_view.GetIdentifier(),
	parameter_update_rsp_view.GetResult());
	return;
	}
	case LeCommandCode::LE_CREDIT_BASED_CONNECTION_REQUEST: {
	LeCreditBasedConnectionRequestView connection_request_view =
	LeCreditBasedConnectionRequestView::Create(control_packet_view);
	if (!connection_request_view.IsValid()) {
	return;
	}
	OnConnectionRequest(connection_request_view.GetIdentifier(), connection_request_view.GetLePsm(),
	connection_request_view.GetSourceCid(), connection_request_view.GetMtu(),
	connection_request_view.GetMps(), connection_request_view.GetInitialCredits());
	return;
	}
	case LeCommandCode::LE_CREDIT_BASED_CONNECTION_RESPONSE: {
	LeCreditBasedConnectionResponseView connection_response_view =
	LeCreditBasedConnectionResponseView::Create(control_packet_view);
	if (!connection_response_view.IsValid()) {
	return;
	}
	OnConnectionResponse(connection_response_view.GetIdentifier(), connection_response_view.GetDestinationCid(),
	connection_response_view.GetMtu(), connection_response_view.GetMps(),
	connection_response_view.GetInitialCredits(), connection_response_view.GetResult());
	return;
	}
	case LeCommandCode::LE_FLOW_CONTROL_CREDIT: {
	LeFlowControlCreditView credit_view = LeFlowControlCreditView::Create(control_packet_view);
	if (!credit_view.IsValid()) {
	return;
	}
	OnCredit(credit_view.GetCid(), credit_view.GetCredits());
	return;
	}
	case LeCommandCode::DISCONNECTION_REQUEST: {
	LeDisconnectionRequestView disconnection_request_view = LeDisconnectionRequestView::Create(control_packet_view);
	if (!disconnection_request_view.IsValid()) {
	return;
	}
	OnDisconnectionRequest(disconnection_request_view.GetIdentifier(), disconnection_request_view.GetDestinationCid(),
	disconnection_request_view.GetSourceCid());
	return;
	}
	case LeCommandCode::DISCONNECTION_RESPONSE: {
	LeDisconnectionResponseView disconnection_response_view =
	LeDisconnectionResponseView::Create(control_packet_view);
	if (!disconnection_response_view.IsValid()) {
	return;
	}
	OnDisconnectionResponse(disconnection_response_view.GetIdentifier(),
	disconnection_response_view.GetDestinationCid(),
	disconnection_response_view.GetSourceCid());
	return;
	}
	default:
	LOG_WARN("Unhandled event 0x%x", static_cast<int>(code));
	auto builder = LeCommandRejectNotUnderstoodBuilder::Create(control_packet_view.GetIdentifier());
	enqueue_buffer_->Enqueue(std::move(builder), handler_);
	return;
	}
	}

	void LeSignallingManager::send_connection_response(SignalId signal_id, Cid local_cid, Mtu mtu, uint16_t mps,
	uint16_t initial_credit,
	LeCreditBasedConnectionResponseResult result) {
	auto builder =
	LeCreditBasedConnectionResponseBuilder::Create(signal_id.Value(), local_cid, mtu, mps, initial_credit, result);
	enqueue_buffer_->Enqueue(std::move(builder), handler_);
	}

	void LeSignallingManager::on_command_timeout() {
	LOG_WARN("Response time out");
	if (command_just_sent_.signal_id_ == kInvalidSignalId) {
	LOG_ERROR("No pending command");
	return;
	}
	switch (command_just_sent_.command_code_) {
	case LeCommandCode::CONNECTION_PARAMETER_UPDATE_REQUEST: {
	link_->OnOutgoingConnectionRequestFail(command_just_sent_.source_cid_,
	LeCreditBasedConnectionResponseResult::NO_RESOURCES_AVAILABLE);
	break;
	}
	default:
	break;
	}
	handle_send_next_command();
	}

	void LeSignallingManager::handle_send_next_command() {
	command_just_sent_.signal_id_ = kInvalidSignalId;
	if (pending_commands_.empty()) {
	return;
	}

	command_just_sent_ = pending_commands_.front();
	pending_commands_.pop();
	switch (command_just_sent_.command_code_) {
	case LeCommandCode::LE_CREDIT_BASED_CONNECTION_REQUEST: {
	auto builder = LeCreditBasedConnectionRequestBuilder::Create(
	command_just_sent_.signal_id_.Value(), command_just_sent_.psm_, command_just_sent_.source_cid_,
	command_just_sent_.mtu_, command_just_sent_.mps_, command_just_sent_.credits_);
	enqueue_buffer_->Enqueue(std::move(builder), handler_);
	alarm_.Schedule(common::BindOnce(&LeSignallingManager::on_command_timeout, common::Unretained(this)), kTimeout);
	break;
	}
	case LeCommandCode::DISCONNECTION_REQUEST: {
	auto builder = LeDisconnectionRequestBuilder::Create(
	command_just_sent_.signal_id_.Value(), command_just_sent_.destination_cid_, command_just_sent_.source_cid_);
	enqueue_buffer_->Enqueue(std::move(builder), handler_);
	alarm_.Schedule(common::BindOnce(&LeSignallingManager::on_command_timeout, common::Unretained(this)), kTimeout);
	break;
	}
	case LeCommandCode::CONNECTION_PARAMETER_UPDATE_REQUEST: {
	auto builder = ConnectionParameterUpdateRequestBuilder::Create(command_just_sent_.signal_id_.Value(), 0, 0, 0, 0);
	enqueue_buffer_->Enqueue(std::move(builder), handler_);
	alarm_.Schedule(common::BindOnce(&LeSignallingManager::on_command_timeout, common::Unretained(this)), kTimeout);
	break;
	}
	default: {
	LOG_WARN("Unsupported command code 0x%x", static_cast<int>(command_just_sent_.command_code_));
	}
	}
	}
	} // namespace internal
	} // namespace le
	} // namespace l2cap
	} // namespace bluetooth