| // Copyright 2018 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "fake_l2cap.h" |
| |
| #include <lib/async/cpp/task.h> |
| #include <lib/async/default.h> |
| #include <zircon/assert.h> |
| |
| #include "src/connectivity/bluetooth/core/bt-host/l2cap/fake_channel.h" |
| #include "src/connectivity/bluetooth/core/bt-host/l2cap/l2cap_defs.h" |
| |
| namespace bt { |
| |
| using l2cap::testing::FakeChannel; |
| |
| namespace l2cap::testing { |
| namespace { |
| |
| // Use plausible ERTM parameters that do not necessarily match values in production. See Core Spec |
| // v5.0 Vol 3, Part A, Sec 5.4 for meanings. |
| constexpr uint8_t kErtmNFramesInTxWindow = 32; |
| constexpr uint8_t kErtmMaxTransmissions = 8; |
| constexpr uint16_t kMaxTxPduPayloadSize = 1024; |
| |
| } // namespace |
| |
| bool FakeL2cap::IsLinkConnected(hci::ConnectionHandle handle) const { |
| auto link_iter = links_.find(handle); |
| if (link_iter == links_.end()) { |
| return false; |
| } |
| return link_iter->second.connected; |
| } |
| |
| void FakeL2cap::TriggerLEConnectionParameterUpdate( |
| hci::ConnectionHandle handle, const hci::LEPreferredConnectionParameters& params) { |
| LinkData& link_data = ConnectedLinkData(handle); |
| link_data.le_conn_param_cb(params); |
| } |
| |
| void FakeL2cap::ExpectOutboundL2capChannel(hci::ConnectionHandle handle, l2cap::PSM psm, |
| l2cap::ChannelId id, l2cap::ChannelId remote_id, |
| l2cap::ChannelParameters params) { |
| LinkData& link_data = GetLinkData(handle); |
| ChannelData chan_data; |
| chan_data.local_id = id; |
| chan_data.remote_id = remote_id; |
| chan_data.params = params; |
| link_data.expected_outbound_conns[psm].push(chan_data); |
| } |
| |
| bool FakeL2cap::TriggerInboundL2capChannel(hci::ConnectionHandle handle, l2cap::PSM psm, |
| l2cap::ChannelId id, l2cap::ChannelId remote_id, |
| uint16_t max_tx_sdu_size) { |
| LinkData& link_data = ConnectedLinkData(handle); |
| auto cb_iter = registered_services_.find(psm); |
| |
| // No service registered for the PSM. |
| if (cb_iter == registered_services_.end()) { |
| return false; |
| } |
| |
| l2cap::ChannelCallback& cb = cb_iter->second.channel_cb; |
| auto chan_params = cb_iter->second.channel_params; |
| auto mode = chan_params.mode.value_or(l2cap::ChannelMode::kBasic); |
| auto max_rx_sdu_size = chan_params.max_rx_sdu_size.value_or(l2cap::kDefaultMTU); |
| auto channel_info = l2cap::ChannelInfo::MakeBasicMode(max_rx_sdu_size, max_tx_sdu_size); |
| if (mode == l2cap::ChannelMode::kEnhancedRetransmission) { |
| channel_info = l2cap::ChannelInfo::MakeEnhancedRetransmissionMode( |
| max_rx_sdu_size, max_tx_sdu_size, /*n_frames_in_tx_window=*/kErtmNFramesInTxWindow, |
| /*max_transmissions=*/kErtmMaxTransmissions, |
| /*max_tx_pdu_payload_size=*/kMaxTxPduPayloadSize); |
| } |
| |
| auto chan = OpenFakeChannel(&link_data, id, remote_id, channel_info); |
| cb(std::move(chan)); |
| |
| return true; |
| } |
| |
| void FakeL2cap::TriggerLinkError(hci::ConnectionHandle handle) { |
| LinkData& link_data = ConnectedLinkData(handle); |
| link_data.link_error_cb(); |
| } |
| |
| void FakeL2cap::AddACLConnection(hci::ConnectionHandle handle, hci::Connection::Role role, |
| l2cap::LinkErrorCallback link_error_cb, |
| l2cap::SecurityUpgradeCallback security_cb) { |
| RegisterInternal(handle, role, hci::Connection::LinkType::kACL, std::move(link_error_cb)); |
| } |
| |
| L2cap::LEFixedChannels FakeL2cap::AddLEConnection( |
| hci::ConnectionHandle handle, hci::Connection::Role role, |
| l2cap::LinkErrorCallback link_error_cb, |
| l2cap::LEConnectionParameterUpdateCallback conn_param_cb, |
| l2cap::SecurityUpgradeCallback security_cb) { |
| LinkData* data = |
| RegisterInternal(handle, role, hci::Connection::LinkType::kLE, std::move(link_error_cb)); |
| data->le_conn_param_cb = std::move(conn_param_cb); |
| |
| // Open the ATT and SMP fixed channels. |
| auto att = OpenFakeFixedChannel(data, l2cap::kATTChannelId); |
| auto smp = OpenFakeFixedChannel(data, l2cap::kLESMPChannelId); |
| return LEFixedChannels{.att = std::move(att), .smp = std::move(smp)}; |
| } |
| |
| void FakeL2cap::RemoveConnection(hci::ConnectionHandle handle) { links_.erase(handle); } |
| |
| void FakeL2cap::AssignLinkSecurityProperties(hci::ConnectionHandle handle, |
| sm::SecurityProperties security) { |
| // TODO(armansito): implement |
| } |
| |
| void FakeL2cap::RequestConnectionParameterUpdate( |
| hci::ConnectionHandle handle, hci::LEPreferredConnectionParameters params, |
| l2cap::ConnectionParameterUpdateRequestCallback request_cb) { |
| bool response = connection_parameter_update_request_responder_ |
| ? connection_parameter_update_request_responder_(handle, params) |
| : true; |
| // Simulate async response. |
| async::PostTask(async_get_default_dispatcher(), std::bind(std::move(request_cb), response)); |
| } |
| |
| void FakeL2cap::OpenL2capChannel(hci::ConnectionHandle handle, l2cap::PSM psm, |
| l2cap::ChannelParameters params, l2cap::ChannelCallback cb) { |
| LinkData& link_data = ConnectedLinkData(handle); |
| auto psm_it = link_data.expected_outbound_conns.find(psm); |
| |
| ZX_DEBUG_ASSERT_MSG(psm_it != link_data.expected_outbound_conns.end() && !psm_it->second.empty(), |
| "Unexpected outgoing L2CAP connection (PSM %#.4x)", psm); |
| |
| auto chan_data = psm_it->second.front(); |
| psm_it->second.pop(); |
| |
| auto mode = params.mode.value_or(l2cap::ChannelMode::kBasic); |
| auto max_rx_sdu_size = params.max_rx_sdu_size.value_or(l2cap::kMaxMTU); |
| |
| ZX_ASSERT_MSG(chan_data.params == params, |
| "Didn't receive expected L2CAP channel parameters (expected: %s, found: %s)", |
| bt_str(chan_data.params), bt_str(params)); |
| |
| auto channel_info = l2cap::ChannelInfo::MakeBasicMode(max_rx_sdu_size, l2cap::kDefaultMTU); |
| if (mode == l2cap::ChannelMode::kEnhancedRetransmission) { |
| channel_info = l2cap::ChannelInfo::MakeEnhancedRetransmissionMode( |
| max_rx_sdu_size, l2cap::kDefaultMTU, /*n_frames_in_tx_window=*/kErtmNFramesInTxWindow, |
| /*max_transmissions=*/kErtmMaxTransmissions, |
| /*max_tx_pdu_payload_size=*/kMaxTxPduPayloadSize); |
| } |
| |
| auto chan = OpenFakeChannel(&link_data, chan_data.local_id, chan_data.remote_id, channel_info); |
| |
| // Simulate async channel creation process. |
| async::PostTask(async_get_default_dispatcher(), |
| [cb = std::move(cb), chan = std::move(chan)]() { cb(std::move(chan)); }); |
| } |
| |
| void FakeL2cap::RegisterService(l2cap::PSM psm, l2cap::ChannelParameters params, |
| l2cap::ChannelCallback channel_callback) { |
| ZX_DEBUG_ASSERT(registered_services_.count(psm) == 0); |
| registered_services_.emplace(psm, ServiceInfo(params, std::move(channel_callback))); |
| } |
| |
| void FakeL2cap::UnregisterService(l2cap::PSM psm) { registered_services_.erase(psm); } |
| |
| FakeL2cap::~FakeL2cap() { |
| for (auto& link_it : links_) { |
| for (auto& psm_it : link_it.second.expected_outbound_conns) { |
| ZX_DEBUG_ASSERT_MSG(psm_it.second.empty(), "didn't receive expected connection on PSM %#.4x", |
| psm_it.first); |
| } |
| } |
| } |
| |
| FakeL2cap::LinkData* FakeL2cap::RegisterInternal(hci::ConnectionHandle handle, |
| hci::Connection::Role role, |
| hci::Connection::LinkType link_type, |
| l2cap::LinkErrorCallback link_error_cb) { |
| auto& data = GetLinkData(handle); |
| ZX_DEBUG_ASSERT_MSG(!data.connected, "connection handle re-used (handle: %#.4x)", handle); |
| |
| data.connected = true; |
| data.role = role; |
| data.type = link_type; |
| data.link_error_cb = std::move(link_error_cb); |
| |
| return &data; |
| } |
| |
| fbl::RefPtr<FakeChannel> FakeL2cap::OpenFakeChannel(LinkData* link, l2cap::ChannelId id, |
| l2cap::ChannelId remote_id, |
| l2cap::ChannelInfo info) { |
| fbl::RefPtr<FakeChannel> chan; |
| if (!simulate_open_channel_failure_) { |
| chan = fbl::AdoptRef(new FakeChannel(id, remote_id, link->handle, link->type, info)); |
| chan->SetLinkErrorCallback(link->link_error_cb.share()); |
| } |
| |
| if (chan_cb_) { |
| chan_cb_(chan); |
| } |
| |
| return chan; |
| } |
| |
| fbl::RefPtr<FakeChannel> FakeL2cap::OpenFakeFixedChannel(LinkData* link, l2cap::ChannelId id) { |
| return OpenFakeChannel(link, id, id); |
| } |
| |
| FakeL2cap::LinkData& FakeL2cap::GetLinkData(hci::ConnectionHandle handle) { |
| auto [it, inserted] = links_.try_emplace(handle); |
| auto& data = it->second; |
| if (inserted) { |
| data.connected = false; |
| data.handle = handle; |
| } |
| return data; |
| } |
| |
| FakeL2cap::LinkData& FakeL2cap::ConnectedLinkData(hci::ConnectionHandle handle) { |
| auto link_iter = links_.find(handle); |
| ZX_DEBUG_ASSERT_MSG(link_iter != links_.end(), "fake link not found (handle: %#.4x)", handle); |
| ZX_DEBUG_ASSERT_MSG(link_iter->second.connected, "fake link not connected yet (handle: %#.4x)", |
| handle); |
| return link_iter->second; |
| } |
| |
| } // namespace l2cap::testing |
| } // namespace bt |