| // 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 "src/connectivity/bluetooth/core/bt-host/sdp/server.h" |
| |
| #include <lib/inspect/testing/cpp/inspect.h> |
| |
| #include <gtest/gtest.h> |
| |
| #include "src/connectivity/bluetooth/core/bt-host/common/test_helpers.h" |
| #include "src/connectivity/bluetooth/core/bt-host/l2cap/fake_channel.h" |
| #include "src/connectivity/bluetooth/core/bt-host/l2cap/fake_channel_test.h" |
| #include "src/connectivity/bluetooth/core/bt-host/l2cap/fake_l2cap.h" |
| #include "src/connectivity/bluetooth/core/bt-host/l2cap/l2cap_defs.h" |
| #include "src/connectivity/bluetooth/core/bt-host/sdp/pdu.h" |
| #include "src/connectivity/bluetooth/core/bt-host/testing/fake_controller.h" |
| |
| namespace bt::sdp { |
| |
| using RegistrationHandle = Server::RegistrationHandle; |
| |
| namespace { |
| |
| using namespace inspect::testing; |
| |
| using TestingBase = l2cap::testing::FakeChannelTest; |
| |
| constexpr hci_spec::ConnectionHandle kTestHandle1 = 1; |
| constexpr hci_spec::ConnectionHandle kTestHandle2 = 2; |
| |
| void NopConnectCallback(fbl::RefPtr<l2cap::Channel>, const DataElement&) {} |
| |
| constexpr l2cap::ChannelParameters kChannelParams; |
| |
| class ServerTest : public TestingBase { |
| public: |
| ServerTest() = default; |
| ~ServerTest() = default; |
| |
| protected: |
| void SetUp() override { |
| l2cap_ = std::make_unique<l2cap::testing::FakeL2cap>(); |
| l2cap_->set_channel_callback([this](auto fake_chan) { |
| channel_ = std::move(fake_chan); |
| set_fake_chan(channel_->AsWeakPtr()); |
| }); |
| l2cap_->AddACLConnection(kTestHandle1, hci_spec::ConnectionRole::kPeripheral, nullptr, nullptr); |
| l2cap_->AddACLConnection(kTestHandle2, hci_spec::ConnectionRole::kPeripheral, nullptr, nullptr); |
| server_ = std::make_unique<Server>(l2cap_.get()); |
| } |
| |
| void TearDown() override { |
| channel_ = nullptr; |
| server_ = nullptr; |
| l2cap_ = nullptr; |
| } |
| |
| Server* server() const { return server_.get(); } |
| |
| l2cap::testing::FakeL2cap* l2cap() const { return l2cap_.get(); } |
| |
| RegistrationHandle AddSPP(sdp::Server::ConnectCallback cb = NopConnectCallback) { |
| ServiceRecord record; |
| |
| record.SetServiceClassUUIDs({profile::kSerialPort}); |
| record.AddProtocolDescriptor(ServiceRecord::kPrimaryProtocolList, protocol::kL2CAP, |
| DataElement()); |
| record.AddProtocolDescriptor(ServiceRecord::kPrimaryProtocolList, protocol::kRFCOMM, |
| DataElement(uint8_t{0})); |
| record.AddProfile(profile::kSerialPort, 1, 2); |
| record.AddInfo("en", "FAKE", "", ""); |
| std::vector<ServiceRecord> records; |
| records.emplace_back(std::move(record)); |
| RegistrationHandle handle = |
| server()->RegisterService(std::move(records), kChannelParams, std::move(cb)); |
| EXPECT_TRUE(handle); |
| return handle; |
| } |
| |
| RegistrationHandle AddA2DPSink(sdp::Server::ConnectCallback cb = NopConnectCallback) { |
| ServiceRecord record; |
| record.SetServiceClassUUIDs({profile::kAudioSink}); |
| record.AddProtocolDescriptor(ServiceRecord::kPrimaryProtocolList, protocol::kL2CAP, |
| DataElement(l2cap::kAVDTP)); |
| record.AddProtocolDescriptor(ServiceRecord::kPrimaryProtocolList, protocol::kAVDTP, |
| DataElement(uint16_t{0x0103})); // Version |
| record.AddProfile(profile::kAdvancedAudioDistribution, 1, 3); |
| record.SetAttribute(kA2DP_SupportedFeatures, DataElement(uint16_t{0x0001})); // Headphones |
| std::vector<ServiceRecord> records; |
| records.emplace_back(std::move(record)); |
| RegistrationHandle handle = |
| server()->RegisterService(std::move(records), kChannelParams, std::move(cb)); |
| EXPECT_TRUE(handle); |
| return handle; |
| } |
| |
| RegistrationHandle AddL2capService(l2cap::PSM channel, |
| l2cap::ChannelParameters chan_params = kChannelParams, |
| sdp::Server::ConnectCallback cb = NopConnectCallback) { |
| ServiceRecord record; |
| record.SetServiceClassUUIDs({profile::kAudioSink}); |
| record.AddProtocolDescriptor(ServiceRecord::kPrimaryProtocolList, protocol::kL2CAP, |
| DataElement(channel)); |
| record.AddProtocolDescriptor(ServiceRecord::kPrimaryProtocolList, protocol::kAVDTP, |
| DataElement(uint16_t{0x0103})); // Version |
| record.AddProfile(profile::kAdvancedAudioDistribution, 1, 3); |
| record.SetAttribute(kA2DP_SupportedFeatures, DataElement(uint16_t{0x0001})); // Headphones |
| std::vector<ServiceRecord> records; |
| records.emplace_back(std::move(record)); |
| RegistrationHandle handle = |
| server()->RegisterService(std::move(records), chan_params, std::move(cb)); |
| EXPECT_TRUE(handle); |
| return handle; |
| } |
| |
| private: |
| fbl::RefPtr<l2cap::testing::FakeChannel> channel_; |
| std::unique_ptr<l2cap::testing::FakeL2cap> l2cap_; |
| std::unique_ptr<Server> server_; |
| }; |
| |
| constexpr l2cap::ChannelId kSdpChannel = 0x0041; |
| |
| #define SDP_ERROR_RSP(t_id, code) \ |
| StaticByteBuffer(0x01, UpperBits(t_id), LowerBits(t_id), 0x00, 0x02, UpperBits(uint16_t(code)), \ |
| LowerBits(uint16_t(code))); |
| |
| // Test: |
| // - Accepts channels and holds channel open correctly. |
| // - More than one channel from the same peer can be open at once. |
| // - Packets that are the wrong length are responded to with kInvalidSize |
| // - Answers with the same TransactionID as sent |
| TEST_F(ServerTest, BasicError) { |
| EXPECT_TRUE(l2cap()->TriggerInboundL2capChannel(kTestHandle1, l2cap::kSDP, kSdpChannel, 0x0bad)); |
| RunLoopUntilIdle(); |
| ASSERT_TRUE(fake_chan()); |
| EXPECT_TRUE(fake_chan()->activated()); |
| |
| const auto kRspErrSize = SDP_ERROR_RSP(0x1001, ErrorCode::kInvalidSize); |
| |
| const StaticByteBuffer kTooSmall(0x01, // SDP_ServiceSearchRequest |
| 0x10, 0x01, // Transaction ID (0x1001) |
| 0x00, 0x09 // Parameter length (9 bytes) |
| ); |
| |
| const auto kRspTooSmall = SDP_ERROR_RSP(0x1001, ErrorCode::kInvalidSize); |
| |
| const StaticByteBuffer kTooBig(0x01, // SDP_ServiceSearchRequest |
| 0x20, 0x10, // Transaction ID (0x2010) |
| 0x00, 0x02, // Parameter length (2 bytes) |
| 0x01, 0x02, 0x03 // 3 bytes of parameters |
| ); |
| |
| const auto kRspTooBig = SDP_ERROR_RSP(0x2010, ErrorCode::kInvalidSize); |
| |
| EXPECT_TRUE(ReceiveAndExpect(kTooSmall, kRspTooSmall)); |
| EXPECT_TRUE(ReceiveAndExpect(kTooBig, kRspTooBig)); |
| |
| const auto kRspInvalidSyntax = SDP_ERROR_RSP(0x2010, ErrorCode::kInvalidRequestSyntax); |
| |
| // Responses aren't valid requests |
| EXPECT_TRUE(ReceiveAndExpect(kRspTooBig, kRspInvalidSyntax)); |
| |
| EXPECT_TRUE( |
| l2cap()->TriggerInboundL2capChannel(kTestHandle1, l2cap::kSDP, kSdpChannel + 1, 0x0bad)); |
| RunLoopUntilIdle(); |
| ASSERT_TRUE(fake_chan()); |
| EXPECT_TRUE(fake_chan()->activated()); |
| |
| EXPECT_TRUE(ReceiveAndExpect(kTooSmall, kRspTooSmall)); |
| } |
| |
| // Test: |
| // - Passes an initialized ServiceRecord that has a matching ServiceHandle |
| // - Doesn't add a service that doesn't contain a ServiceClassIDList |
| // - Adds a service that is valid. |
| // - Services can be Unregistered. |
| TEST_F(ServerTest, RegisterService) { |
| std::vector<ServiceRecord> records; |
| EXPECT_FALSE(server()->RegisterService(std::move(records), kChannelParams, {})); |
| |
| ServiceRecord record = ServiceRecord(); |
| std::vector<ServiceRecord> records0; |
| records0.emplace_back(std::move(record)); |
| EXPECT_FALSE(server()->RegisterService(std::move(records0), kChannelParams, {})); |
| |
| ServiceRecord record1; |
| record1.SetAttribute(kServiceClassIdList, DataElement(uint16_t{42})); |
| std::vector<ServiceRecord> records1; |
| records1.emplace_back(std::move(record1)); |
| EXPECT_FALSE(server()->RegisterService(std::move(records1), kChannelParams, {})); |
| |
| ServiceRecord has_handle; |
| has_handle.SetHandle(42); |
| std::vector<ServiceRecord> records2; |
| records2.emplace_back(std::move(has_handle)); |
| EXPECT_FALSE(server()->RegisterService(std::move(records2), kChannelParams, {})); |
| |
| ServiceRecord valid; |
| valid.SetServiceClassUUIDs({profile::kAVRemoteControl}); |
| std::vector<ServiceRecord> records3; |
| records3.emplace_back(std::move(valid)); |
| RegistrationHandle handle = server()->RegisterService(std::move(records3), kChannelParams, {}); |
| |
| EXPECT_TRUE(handle); |
| |
| EXPECT_TRUE(server()->UnregisterService(handle)); |
| EXPECT_FALSE(server()->UnregisterService(handle)); |
| } |
| |
| // Test: |
| // - Adds a primary protocol to the service defintion. |
| // - Adds multiple additional protocols to the service definition. |
| // - Tests registration and removal are successful. |
| // - Tests callback correctness when inbound l2cap channels are connected. |
| TEST_F(ServerTest, RegisterServiceWithAdditionalProtocol) { |
| std::vector<l2cap::PSM> psms{500, 27, 29}; |
| |
| ServiceRecord psm_additional; |
| psm_additional.SetServiceClassUUIDs({profile::kAVRemoteControl}); |
| psm_additional.AddProtocolDescriptor(ServiceRecord::kPrimaryProtocolList, protocol::kL2CAP, |
| DataElement(uint16_t(psms[0]))); |
| psm_additional.AddProtocolDescriptor(1, protocol::kL2CAP, DataElement(uint16_t(psms[1]))); |
| psm_additional.AddProtocolDescriptor(2, protocol::kL2CAP, DataElement(uint16_t(psms[2]))); |
| |
| std::vector<uint16_t> protocols_discovered; |
| auto cb = [&](auto /*channel*/, auto& protocol_list) { |
| EXPECT_EQ(DataElement::Type::kSequence, protocol_list.type()); |
| auto* psm = protocol_list.At(0); |
| EXPECT_EQ(DataElement::Type::kSequence, psm->type()); |
| psm = psm->At(1); |
| EXPECT_EQ(DataElement::Type::kUnsignedInt, psm->type()); |
| protocols_discovered.emplace_back(*psm->template Get<uint16_t>()); |
| }; |
| |
| std::vector<ServiceRecord> records; |
| records.emplace_back(std::move(psm_additional)); |
| auto handle = server()->RegisterService(std::move(records), kChannelParams, std::move(cb)); |
| |
| EXPECT_TRUE(handle); |
| |
| EXPECT_TRUE(l2cap()->TriggerInboundL2capChannel(kTestHandle1, psms[0], 0x40, 0x41)); |
| EXPECT_TRUE(l2cap()->TriggerInboundL2capChannel(kTestHandle1, psms[1], 0x42, 0x43)); |
| EXPECT_TRUE(l2cap()->TriggerInboundL2capChannel(kTestHandle1, psms[2], 0x44, 0x44)); |
| RunLoopUntilIdle(); |
| |
| ASSERT_EQ(3u, protocols_discovered.size()); |
| // There should be one connection (and therefore protocol_list) per psm registered. |
| for (auto& psm : psms) { |
| ASSERT_EQ(1u, std::count(protocols_discovered.begin(), protocols_discovered.end(), psm)); |
| } |
| |
| EXPECT_TRUE(server()->UnregisterService(handle)); |
| } |
| |
| // Test: |
| // - Adds a primary protocol to the service defintion. |
| // - Adds an additional protocol to the service definition. |
| // - Adds an additional protocol with missing information. |
| // - Tests that none of protocols are registered. |
| TEST_F(ServerTest, RegisterServiceWithIncompleteAdditionalProtocol) { |
| ServiceRecord psm_additional; |
| psm_additional.SetServiceClassUUIDs({profile::kAVRemoteControl}); |
| psm_additional.AddProtocolDescriptor(ServiceRecord::kPrimaryProtocolList, protocol::kL2CAP, |
| DataElement(uint16_t{500})); |
| psm_additional.AddProtocolDescriptor(1, protocol::kL2CAP, DataElement(uint16_t{27})); |
| psm_additional.AddProtocolDescriptor(2, protocol::kL2CAP, DataElement()); |
| |
| size_t cb_count = 0; |
| auto cb = [&](auto /*channel*/, auto& /* protocol_list */) { cb_count++; }; |
| |
| std::vector<ServiceRecord> records; |
| records.emplace_back(std::move(psm_additional)); |
| RegistrationHandle handle = |
| server()->RegisterService(std::move(records), kChannelParams, std::move(cb)); |
| |
| EXPECT_FALSE(handle); |
| EXPECT_FALSE(l2cap()->TriggerInboundL2capChannel(kTestHandle1, 500, 0x40, 0x41)); |
| RunLoopUntilIdle(); |
| |
| // Despite an incoming L2CAP connection, the callback should never be triggered since |
| // no services should be registered. |
| EXPECT_EQ(0u, cb_count); |
| |
| EXPECT_FALSE(server()->UnregisterService(handle)); |
| } |
| |
| TEST_F(ServerTest, PSMVerification) { |
| ServiceRecord no_psm; |
| no_psm.SetServiceClassUUIDs({profile::kAVRemoteControl}); |
| no_psm.AddProtocolDescriptor(ServiceRecord::kPrimaryProtocolList, protocol::kL2CAP, |
| DataElement()); |
| |
| std::vector<ServiceRecord> records; |
| records.emplace_back(std::move(no_psm)); |
| EXPECT_FALSE(server()->RegisterService(std::move(records), kChannelParams, {})); |
| |
| ServiceRecord psm_wrong_argtype; |
| psm_wrong_argtype.SetServiceClassUUIDs({profile::kAVRemoteControl}); |
| psm_wrong_argtype.AddProtocolDescriptor(ServiceRecord::kPrimaryProtocolList, protocol::kL2CAP, |
| DataElement(bool(true))); |
| |
| std::vector<ServiceRecord> records2; |
| records2.emplace_back(std::move(psm_wrong_argtype)); |
| EXPECT_FALSE(server()->RegisterService(std::move(records2), kChannelParams, {})); |
| |
| ServiceRecord psm_wrong_intsize; |
| psm_wrong_intsize.SetServiceClassUUIDs({profile::kAVRemoteControl}); |
| psm_wrong_intsize.AddProtocolDescriptor(ServiceRecord::kPrimaryProtocolList, protocol::kL2CAP, |
| DataElement(uint8_t{5})); |
| |
| std::vector<ServiceRecord> records_wrong_intsize; |
| records_wrong_intsize.emplace_back(std::move(psm_wrong_intsize)); |
| EXPECT_FALSE(server()->RegisterService(std::move(records_wrong_intsize), kChannelParams, {})); |
| |
| ServiceRecord psm_rfcomm; |
| psm_rfcomm.SetServiceClassUUIDs({profile::kAVRemoteControl}); |
| psm_rfcomm.AddProtocolDescriptor(ServiceRecord::kPrimaryProtocolList, protocol::kL2CAP, |
| DataElement()); |
| psm_rfcomm.AddProtocolDescriptor(ServiceRecord::kPrimaryProtocolList, protocol::kRFCOMM, |
| DataElement(uint16_t{5})); |
| |
| std::vector<ServiceRecord> records3; |
| records3.emplace_back(std::move(psm_rfcomm)); |
| EXPECT_TRUE(server()->RegisterService(std::move(records3), kChannelParams, NopConnectCallback)); |
| |
| // Another RFCOMM should fail, even with a different channel. |
| ServiceRecord psm_rfcomm2; |
| psm_rfcomm2.SetServiceClassUUIDs({profile::kAVRemoteControl}); |
| psm_rfcomm2.AddProtocolDescriptor(ServiceRecord::kPrimaryProtocolList, protocol::kL2CAP, |
| DataElement()); |
| psm_rfcomm2.AddProtocolDescriptor(ServiceRecord::kPrimaryProtocolList, protocol::kRFCOMM, |
| DataElement(uint16_t{7})); |
| |
| std::vector<ServiceRecord> records4; |
| records4.emplace_back(std::move(psm_rfcomm2)); |
| EXPECT_FALSE(server()->RegisterService(std::move(records4), kChannelParams, NopConnectCallback)); |
| |
| ServiceRecord psm_ok; |
| psm_ok.SetServiceClassUUIDs({profile::kAVRemoteControl}); |
| psm_ok.AddProtocolDescriptor(ServiceRecord::kPrimaryProtocolList, protocol::kL2CAP, |
| DataElement(uint16_t{500})); |
| |
| std::vector<ServiceRecord> records5; |
| records5.emplace_back(std::move(psm_ok)); |
| auto handle = server()->RegisterService(std::move(records5), kChannelParams, NopConnectCallback); |
| EXPECT_TRUE(handle); |
| |
| ServiceRecord psm_same; |
| psm_same.SetServiceClassUUIDs({profile::kAVRemoteControl}); |
| psm_same.AddProtocolDescriptor(ServiceRecord::kPrimaryProtocolList, protocol::kL2CAP, |
| DataElement(uint16_t{500})); |
| |
| std::vector<ServiceRecord> records6; |
| records6.emplace_back(std::move(psm_same)); |
| EXPECT_FALSE(server()->RegisterService(std::move(records6), kChannelParams, NopConnectCallback)); |
| |
| // Unregistering allows us to re-register with PSM. |
| server()->UnregisterService(handle); |
| ServiceRecord psm_readd; |
| psm_readd.SetServiceClassUUIDs({profile::kAVRemoteControl}); |
| psm_readd.AddProtocolDescriptor(ServiceRecord::kPrimaryProtocolList, protocol::kL2CAP, |
| DataElement(uint16_t{500})); |
| |
| std::vector<ServiceRecord> records7; |
| records7.emplace_back(std::move(psm_readd)); |
| EXPECT_TRUE(server()->RegisterService(std::move(records7), kChannelParams, NopConnectCallback)); |
| } |
| |
| // Test: |
| // - Registering multiple ServiceRecords from the same client is successful. |
| // - Inbound L2CAP connections on the registered PSMs trigger the callback. |
| TEST_F(ServerTest, RegisterServiceMultipleRecordsSuccess) { |
| ServiceRecord record1; |
| record1.SetServiceClassUUIDs({profile::kAVRemoteControl}); |
| record1.AddProtocolDescriptor(ServiceRecord::kPrimaryProtocolList, protocol::kL2CAP, |
| DataElement(uint16_t{7})); |
| record1.AddProtocolDescriptor(1, protocol::kL2CAP, DataElement(uint16_t{8})); |
| |
| ServiceRecord record2; |
| record2.SetServiceClassUUIDs({profile::kAudioSink}); |
| record2.AddProtocolDescriptor(ServiceRecord::kPrimaryProtocolList, protocol::kL2CAP, |
| DataElement(uint16_t{9})); |
| record2.AddProtocolDescriptor(1, protocol::kL2CAP, DataElement(uint16_t{10})); |
| |
| std::vector<ServiceRecord> records; |
| records.emplace_back(std::move(record1)); |
| records.emplace_back(std::move(record2)); |
| |
| size_t cb_count = 0; |
| auto cb = [&](auto /*channel*/, auto& protocol_list) { cb_count++; }; |
| |
| auto handle = server()->RegisterService(std::move(records), kChannelParams, std::move(cb)); |
| EXPECT_TRUE(handle); |
| |
| EXPECT_TRUE(l2cap()->TriggerInboundL2capChannel(kTestHandle1, 7, 0x40, 0x41)); |
| EXPECT_TRUE(l2cap()->TriggerInboundL2capChannel(kTestHandle1, 8, 0x42, 0x43)); |
| EXPECT_TRUE(l2cap()->TriggerInboundL2capChannel(kTestHandle1, 9, 0x44, 0x44)); |
| EXPECT_TRUE(l2cap()->TriggerInboundL2capChannel(kTestHandle1, 10, 0x45, 0x46)); |
| RunLoopUntilIdle(); |
| |
| EXPECT_EQ(4u, cb_count); |
| |
| EXPECT_TRUE(server()->UnregisterService(handle)); |
| } |
| |
| // Test: |
| // - Registering multiple ServiceRecords with the same PSM from the same client |
| // is successful. |
| // - Inbound L2CAP connections on the registered PSMs trigger the same callback. |
| // - Attempting to register a record with an already taken PSM will fail, and not |
| // register any of the other records in the set of records. |
| TEST_F(ServerTest, RegisterServiceMultipleRecordsSamePSM) { |
| ServiceRecord target_browse_record; |
| target_browse_record.SetServiceClassUUIDs({profile::kAVRemoteControlTarget}); |
| target_browse_record.AddProtocolDescriptor(ServiceRecord::kPrimaryProtocolList, protocol::kL2CAP, |
| DataElement(uint16_t{25})); |
| target_browse_record.AddProtocolDescriptor(1, protocol::kL2CAP, DataElement(uint16_t{27})); |
| |
| ServiceRecord controller_record; |
| controller_record.SetServiceClassUUIDs({profile::kAVRemoteControlController}); |
| controller_record.AddProtocolDescriptor(ServiceRecord::kPrimaryProtocolList, protocol::kL2CAP, |
| DataElement(uint16_t{25})); |
| |
| std::vector<ServiceRecord> records; |
| records.emplace_back(std::move(target_browse_record)); |
| records.emplace_back(std::move(controller_record)); |
| |
| std::vector<uint16_t> protocols_discovered; |
| auto cb = [&](auto /*channel*/, auto& protocol_list) { |
| EXPECT_EQ(DataElement::Type::kSequence, protocol_list.type()); |
| auto* psm = protocol_list.At(0); |
| EXPECT_EQ(DataElement::Type::kSequence, psm->type()); |
| psm = psm->At(1); |
| EXPECT_EQ(DataElement::Type::kUnsignedInt, psm->type()); |
| protocols_discovered.emplace_back(*psm->template Get<uint16_t>()); |
| }; |
| |
| auto handle = server()->RegisterService(std::move(records), kChannelParams, std::move(cb)); |
| EXPECT_TRUE(handle); |
| |
| EXPECT_TRUE(l2cap()->TriggerInboundL2capChannel(kTestHandle1, 25, 0x40, 0x41)); |
| EXPECT_TRUE(l2cap()->TriggerInboundL2capChannel(kTestHandle1, 27, 0x44, 0x44)); |
| EXPECT_TRUE(l2cap()->TriggerInboundL2capChannel(kTestHandle1, 25, 0x42, 0x43)); |
| RunLoopUntilIdle(); |
| |
| // We expect two calls to the callback for psm=25, and one for psm=27. |
| ASSERT_EQ(2u, std::count(protocols_discovered.begin(), protocols_discovered.end(), 25)); |
| ASSERT_EQ(1u, std::count(protocols_discovered.begin(), protocols_discovered.end(), 27)); |
| |
| // Attempt to register existing PSM. |
| ServiceRecord duplicate_psm; |
| duplicate_psm.SetServiceClassUUIDs({profile::kAVRemoteControlTarget}); |
| duplicate_psm.AddProtocolDescriptor(ServiceRecord::kPrimaryProtocolList, protocol::kL2CAP, |
| DataElement(uint16_t{25})); |
| |
| ServiceRecord valid_psm; |
| valid_psm.SetServiceClassUUIDs({profile::kAudioSource}); |
| valid_psm.AddProtocolDescriptor(ServiceRecord::kPrimaryProtocolList, protocol::kL2CAP, |
| DataElement(uint16_t{31})); |
| |
| std::vector<ServiceRecord> invalid_records; |
| invalid_records.emplace_back(std::move(duplicate_psm)); |
| invalid_records.emplace_back(std::move(valid_psm)); |
| EXPECT_FALSE( |
| server()->RegisterService(std::move(invalid_records), kChannelParams, NopConnectCallback)); |
| |
| EXPECT_TRUE(server()->UnregisterService(handle)); |
| } |
| |
| #define UINT32_AS_BE_BYTES(x) \ |
| UpperBits(x >> 16), LowerBits(x >> 16), UpperBits(x & 0xFFFF), LowerBits(x & 0xFFFF) |
| |
| // Test ServiceSearchRequest: |
| // - returns services with the UUID included |
| // - doesn't return services that don't have the UUID |
| // - fails when there are no items or too many items in the search |
| // - doesn't return more than the max requested |
| TEST_F(ServerTest, ServiceSearchRequest) { |
| RegistrationHandle spp_handle = AddSPP(); |
| RegistrationHandle a2dp_handle = AddA2DPSink(); |
| |
| EXPECT_TRUE(l2cap()->TriggerInboundL2capChannel(kTestHandle1, l2cap::kSDP, kSdpChannel, 0x0bad)); |
| RunLoopUntilIdle(); |
| |
| const StaticByteBuffer kL2capSearch(0x02, // SDP_ServiceSearchRequest |
| 0x10, 0x01, // Transaction ID (0x1001) |
| 0x00, 0x08, // Parameter length (8 bytes) |
| // ServiceSearchPattern |
| 0x35, 0x03, // Sequence uint8 3 bytes |
| 0x19, 0x01, 0x00, // UUID: Protocol: L2CAP |
| 0xFF, 0xFF, // MaximumServiceRecordCount: (none) |
| 0x00 // Contunuation State: none |
| ); |
| |
| ServiceSearchRequest search_req; |
| EXPECT_FALSE(search_req.valid()); |
| EXPECT_EQ(nullptr, search_req.GetPDU(0x1001)); |
| |
| search_req.set_search_pattern({protocol::kL2CAP}); |
| |
| auto pdu = search_req.GetPDU(0x1001); |
| EXPECT_NE(nullptr, pdu); |
| |
| EXPECT_TRUE(ContainersEqual(kL2capSearch, *pdu)); |
| |
| const StaticByteBuffer kL2capSearchResponse( |
| 0x03, // SDP_ServicesearchResponse |
| 0x10, 0x01, // Transaction ID (0x1001) |
| 0x00, 0x0D, // Parameter length (13 bytes) |
| 0x00, 0x02, // Total service record count: 2 |
| 0x00, 0x02, // Current service record count: 2 |
| UINT32_AS_BE_BYTES(spp_handle), // This list isn't specifically ordered |
| UINT32_AS_BE_BYTES(a2dp_handle), |
| 0x00 // No continuation state |
| ); |
| |
| bool recv = false; |
| std::vector<ServiceHandle> handles; |
| TransactionId tid; |
| auto cb = [&recv, &handles, &tid](auto cb_packet) { |
| EXPECT_LE(sizeof(Header), cb_packet->size()); |
| PacketView<Header> packet(cb_packet.get()); |
| EXPECT_EQ(kServiceSearchResponse, packet.header().pdu_id); |
| tid = betoh16(packet.header().tid); |
| uint16_t len = betoh16(packet.header().param_length); |
| bt_log(TRACE, "unittest", "resize packet to %d", len); |
| packet.Resize(len); |
| ServiceSearchResponse resp; |
| auto status = resp.Parse(packet.payload_data()); |
| EXPECT_EQ(fitx::ok(), status); |
| handles = resp.service_record_handle_list(); |
| recv = true; |
| }; |
| |
| fake_chan()->SetSendCallback(cb, dispatcher()); |
| fake_chan()->Receive(kL2capSearch); |
| RunLoopUntilIdle(); |
| |
| EXPECT_TRUE(recv); |
| EXPECT_EQ(0x1001, tid); |
| EXPECT_EQ(2u, handles.size()); |
| EXPECT_NE(handles.end(), std::find(handles.begin(), handles.end(), spp_handle)); |
| EXPECT_NE(handles.end(), std::find(handles.begin(), handles.end(), a2dp_handle)); |
| |
| const StaticByteBuffer kInvalidNoItems(0x02, // SDP_ServiceSearchRequest |
| 0x10, 0xA1, // Transaction ID (0x10A1) |
| 0x00, 0x05, // Parameter length (5 bytes) |
| // ServiceSearchPattern |
| 0x35, 0x00, // Sequence uint8 0 bytes |
| 0xFF, 0xFF, // MaximumServiceRecordCount: (none) |
| 0x00 // Contunuation State: none |
| ); |
| |
| const auto kRspErrSyntax = SDP_ERROR_RSP(0x10A1, ErrorCode::kInvalidRequestSyntax); |
| |
| EXPECT_TRUE(ReceiveAndExpect(kInvalidNoItems, kRspErrSyntax)); |
| |
| const StaticByteBuffer kInvalidTooManyItems( |
| 0x02, // SDP_ServiceSearchRequest |
| 0x10, 0xA1, // Transaction ID (0x10B1) |
| 0x00, 0x2C, // Parameter length (44 bytes) |
| // ServiceSearchPattern |
| 0x35, 0x27, // Sequence uint8 27 bytes |
| 0x19, 0x30, 0x01, // 13 UUIDs in the search |
| 0x19, 0x30, 0x02, 0x19, 0x30, 0x03, 0x19, 0x30, 0x04, 0x19, 0x30, 0x05, 0x19, 0x30, 0x06, |
| 0x19, 0x30, 0x07, 0x19, 0x30, 0x08, 0x19, 0x30, 0x09, 0x19, 0x30, 0x10, 0x19, 0x30, 0x11, |
| 0x19, 0x30, 0x12, 0x19, 0x30, 0x13, 0xFF, 0xFF, // MaximumServiceRecordCount: (none) |
| 0x00 // Contunuation State: none |
| ); |
| |
| EXPECT_TRUE(ReceiveAndExpect(kInvalidTooManyItems, kRspErrSyntax)); |
| } |
| |
| // Test ServiceSearchRequest: |
| // - doesn't return more than the max requested |
| TEST_F(ServerTest, ServiceSearchRequestOneOfMany) { |
| EXPECT_TRUE(l2cap()->TriggerInboundL2capChannel(kTestHandle1, l2cap::kSDP, kSdpChannel, 0x0bad)); |
| RunLoopUntilIdle(); |
| |
| RegistrationHandle spp_handle = AddSPP(); |
| RegistrationHandle a2dp_handle = AddA2DPSink(); |
| |
| bool recv = false; |
| std::vector<ServiceHandle> handles; |
| TransactionId tid; |
| auto cb = [&recv, &handles, &tid](auto cb_packet) { |
| EXPECT_LE(sizeof(Header), cb_packet->size()); |
| PacketView<Header> packet(cb_packet.get()); |
| EXPECT_EQ(kServiceSearchResponse, packet.header().pdu_id); |
| tid = betoh16(packet.header().tid); |
| uint16_t len = betoh16(packet.header().param_length); |
| bt_log(TRACE, "unittests", "resizing packet to %d", len); |
| packet.Resize(len); |
| ServiceSearchResponse resp; |
| auto status = resp.Parse(packet.payload_data()); |
| EXPECT_EQ(fitx::ok(), status); |
| handles = resp.service_record_handle_list(); |
| recv = true; |
| }; |
| |
| const StaticByteBuffer kL2capSearchOne(0x02, // SDP_ServiceSearchRequest |
| 0x10, 0xC1, // Transaction ID (0x10C1) |
| 0x00, 0x08, // Parameter length (8 bytes) |
| // ServiceSearchPattern |
| 0x35, 0x03, // Sequence uint8 3 bytes |
| 0x19, 0x01, 0x00, // UUID: Protocol: L2CAP |
| 0x00, 0x01, // MaximumServiceRecordCount: 1 |
| 0x00 // Contunuation State: none |
| ); |
| |
| handles.clear(); |
| recv = false; |
| |
| fake_chan()->SetSendCallback(cb, dispatcher()); |
| fake_chan()->Receive(kL2capSearchOne); |
| RunLoopUntilIdle(); |
| |
| EXPECT_TRUE(recv); |
| EXPECT_EQ(0x10C1, tid); |
| EXPECT_EQ(1u, handles.size()); |
| bool found_spp = std::find(handles.begin(), handles.end(), spp_handle) != handles.end(); |
| bool found_a2dp = std::find(handles.begin(), handles.end(), a2dp_handle) != handles.end(); |
| EXPECT_TRUE(found_spp || found_a2dp); |
| } |
| |
| // Test ServiceSearchRequest: |
| // - returns continuation state if too many services match |
| // - continuation state in request works correctly |
| TEST_F(ServerTest, ServiceSearchContinuationState) { |
| // Set the TX MTU to the lowest that's allowed (48) |
| EXPECT_TRUE(l2cap()->TriggerInboundL2capChannel(kTestHandle1, l2cap::kSDP, kSdpChannel, 0x0bad, |
| 48 /* tx_mtu */)); |
| RunLoopUntilIdle(); |
| |
| // Add enough services to generate a continuation state. |
| AddL2capService(0x1001); |
| AddL2capService(0x1003); |
| AddL2capService(0x1005); |
| AddL2capService(0x1007); |
| AddL2capService(0x1009); |
| AddL2capService(0x100B); |
| AddL2capService(0x100D); |
| AddL2capService(0x100F); |
| AddL2capService(0x1011); |
| AddL2capService(0x1013); |
| AddL2capService(0x1015); |
| |
| size_t received = 0; |
| ServiceSearchResponse rsp; |
| |
| auto send_cb = [this, &rsp, &received](auto cb_packet) { |
| EXPECT_LE(sizeof(Header), cb_packet->size()); |
| PacketView<sdp::Header> packet(cb_packet.get()); |
| ASSERT_EQ(0x03, packet.header().pdu_id); |
| uint16_t len = betoh16(packet.header().param_length); |
| EXPECT_LE(len, |
| 0x2F); // 10 records (4 * 10) + 2 (total count) + 2 (current count) + 3 (cont state) |
| packet.Resize(len); |
| fitx::result<Error<>> result = rsp.Parse(packet.payload_data()); |
| if (received == 0) { |
| // Server should have split this into more than one response. |
| EXPECT_EQ(ToResult(HostError::kInProgress), result); |
| EXPECT_FALSE(rsp.complete()); |
| } |
| received++; |
| if (result.is_error() && !result.error_value().is(HostError::kInProgress)) { |
| // This isn't a valid packet and we shouldn't try to get |
| // a continuation. |
| return; |
| } |
| if (!rsp.complete()) { |
| // Repeat the request with the continuation state if it was returned. |
| auto continuation = rsp.ContinuationState(); |
| uint8_t cont_size = continuation.size(); |
| EXPECT_NE(0u, cont_size); |
| // Make another request with the continutation data. |
| size_t param_size = 8 + cont_size; |
| StaticByteBuffer kContinuedRequestStart(0x02, // SDP_ServiceSearchRequest |
| 0x10, 0xC1, // Transaction ID (0x10C1) |
| UpperBits(param_size), |
| LowerBits(param_size), // Parameter length |
| // ServiceSearchPattern |
| 0x35, 0x03, // Sequence uint8 3 bytes |
| 0x19, 0x01, 0x00, // UUID: Protocol: L2CAP |
| 0x00, 0xFF // MaximumServiceRecordCount: 256 |
| ); |
| |
| DynamicByteBuffer req(kContinuedRequestStart.size() + sizeof(uint8_t) + cont_size); |
| |
| kContinuedRequestStart.Copy(&req); |
| req.Write(&cont_size, sizeof(uint8_t), kContinuedRequestStart.size()); |
| req.Write(continuation, kContinuedRequestStart.size() + sizeof(uint8_t)); |
| |
| fake_chan()->Receive(req); |
| } |
| }; |
| |
| const StaticByteBuffer kL2capSearch(0x02, // SDP_ServiceSearchRequest |
| 0x10, 0xC1, // Transaction ID (0x10C1) |
| 0x00, 0x08, // Parameter length (8 bytes) |
| // ServiceSearchPattern |
| 0x35, 0x03, // Sequence uint8 3 bytes |
| 0x19, 0x01, 0x00, // UUID: Protocol: L2CAP |
| 0x00, 0xFF, // MaximumServiceRecordCount: 256 |
| 0x00 // Contunuation State: none |
| ); |
| |
| fake_chan()->SetSendCallback(send_cb, dispatcher()); |
| fake_chan()->Receive(kL2capSearch); |
| RunLoopUntilIdle(); |
| |
| EXPECT_GE(received, 1u); |
| EXPECT_EQ(11u, rsp.service_record_handle_list().size()); |
| } |
| |
| // Test: |
| // - Answers ServiceAttributeRequest correctly |
| // - Continuation state is generated correctly re: |
| // MaximumAttributeListByteCount |
| // - Valid Continuation state continues response |
| TEST_F(ServerTest, ServiceAttributeRequest) { |
| ServiceRecord record; |
| record.SetServiceClassUUIDs({profile::kAVRemoteControl}); |
| record.SetAttribute(0xf00d, DataElement(uint32_t{0xfeedbeef})); |
| record.SetAttribute(0xf000, DataElement(uint32_t{0x01234567})); |
| |
| std::vector<ServiceRecord> records; |
| records.emplace_back(std::move(record)); |
| RegistrationHandle handle = server()->RegisterService(std::move(records), kChannelParams, {}); |
| |
| EXPECT_TRUE(handle); |
| |
| EXPECT_TRUE(l2cap()->TriggerInboundL2capChannel(kTestHandle1, l2cap::kSDP, kSdpChannel, 0x0bad)); |
| RunLoopUntilIdle(); |
| |
| const auto kRequestAttr = |
| StaticByteBuffer(0x04, // SDP_ServiceAttritbuteRequest |
| 0x10, 0x01, // Transaction ID (0x1001) |
| 0x00, 0x11, // Parameter length (17 bytes) |
| UINT32_AS_BE_BYTES(handle), // ServiceRecordHandle |
| 0x00, 0x0A, // MaximumAttributeByteCount (10 bytes max) |
| // AttributeIDList |
| 0x35, 0x08, // Sequence uint8 8 bytes |
| 0x09, // uint16_t, single attribute |
| 0x00, 0x01, // ServiceClassIDList |
| 0x0A, // uint32_t, which is a range (0x3000 - 0xf000) |
| 0x30, 0x00, // low end of range |
| 0xf0, 0x00, // high end of range |
| 0x00 // Contunuation State: none |
| ); |
| |
| size_t received = 0; |
| |
| ServiceAttributeResponse rsp; |
| |
| auto send_cb = [this, handle, &rsp, &received](auto cb_packet) { |
| EXPECT_LE(sizeof(Header), cb_packet->size()); |
| PacketView<sdp::Header> packet(cb_packet.get()); |
| ASSERT_EQ(0x05, packet.header().pdu_id); |
| uint16_t len = betoh16(packet.header().param_length); |
| EXPECT_LE(len, 0x11); // 10 + 2 (byte count) + 5 (cont state) |
| packet.Resize(len); |
| fitx::result<Error<>> result = rsp.Parse(packet.payload_data()); |
| if (received == 0) { |
| // Server should have split this into more than one response. |
| EXPECT_EQ(ToResult(HostError::kInProgress), result); |
| EXPECT_FALSE(rsp.complete()); |
| } |
| received++; |
| if (result.is_error() && !result.error_value().is(HostError::kInProgress)) { |
| // This isn't a valid packet and we shouldn't try to get |
| // a continuation. |
| return; |
| } |
| if (!rsp.complete()) { |
| // Repeat the request with the continuation state if it was returned. |
| auto continuation = rsp.ContinuationState(); |
| uint8_t cont_size = continuation.size(); |
| EXPECT_NE(0u, cont_size); |
| // Make another request with the continutation data. |
| size_t param_size = 17 + cont_size; |
| auto kContinuedRequestAttrStart = |
| StaticByteBuffer(0x04, // SDP_ServiceAttributeRequest |
| 0x10, 0x01, // Transaction ID (reused) |
| UpperBits(param_size), LowerBits(param_size), // Parameter length |
| UINT32_AS_BE_BYTES(handle), // ServiceRecordHandle |
| 0x00, 0x0A, // MaximumAttributeByteCount (10 bytes max) |
| // AttributeIDList |
| 0x35, 0x08, // Sequence uint8 8 bytes |
| 0x09, // uint16_t, single attribute |
| 0x00, 0x01, // ServiceClassIDList |
| 0x0A, // uint32_t, which is a range (0x3000 - 0xf000) |
| 0x30, 0x00, // low end of range |
| 0xf0, 0x00 // high end of range |
| ); |
| DynamicByteBuffer req(kContinuedRequestAttrStart.size() + sizeof(uint8_t) + cont_size); |
| |
| kContinuedRequestAttrStart.Copy(&req); |
| req.Write(&cont_size, sizeof(uint8_t), kContinuedRequestAttrStart.size()); |
| req.Write(continuation, kContinuedRequestAttrStart.size() + sizeof(uint8_t)); |
| |
| fake_chan()->Receive(req); |
| } |
| }; |
| |
| fake_chan()->SetSendCallback(send_cb, dispatcher()); |
| fake_chan()->Receive(kRequestAttr); |
| RunLoopUntilIdle(); |
| |
| EXPECT_GE(received, 1u); |
| const auto& attrs = rsp.attributes(); |
| EXPECT_EQ(2u, attrs.size()); |
| EXPECT_NE(attrs.end(), attrs.find(kServiceClassIdList)); |
| EXPECT_NE(attrs.end(), attrs.find(0xf000)); |
| |
| const auto kInvalidRangeOrder = |
| StaticByteBuffer(0x04, // SDP_ServiceAttritbuteRequest |
| 0xE0, 0x01, // Transaction ID (0xE001) |
| 0x00, 0x11, // Parameter length (17 bytes) |
| UINT32_AS_BE_BYTES(handle), // ServiceRecordHandle |
| 0x00, 0x0A, // MaximumAttributeByteCount (10 bytes max) |
| // AttributeIDList |
| 0x35, 0x08, // Sequence uint8 8 bytes |
| 0x09, // uint16_t, single attribute |
| 0x00, 0x01, // ServiceClassIDList |
| 0x0A, // uint32_t, which is a range (0x3000 - 0xf000) |
| 0xf0, 0x00, // low end of range |
| 0x30, 0x00, // high end of range |
| 0x00 // Contunuation State: none |
| ); |
| |
| const auto kRspErrSyntax = SDP_ERROR_RSP(0xE001, ErrorCode::kInvalidRequestSyntax); |
| |
| EXPECT_TRUE(ReceiveAndExpect(kInvalidRangeOrder, kRspErrSyntax)); |
| |
| const auto kInvalidMaxBytes = |
| StaticByteBuffer(0x04, // SDP_ServiceAttritbuteRequest |
| 0xE0, 0x02, // Transaction ID (0xE001) |
| 0x00, 0x0C, // Parameter length (12 bytes) |
| UINT32_AS_BE_BYTES(handle), // ServiceRecordHandle |
| 0x00, 0x05, // MaximumAttributeByteCount (5 bytes max) |
| // AttributeIDList |
| 0x35, 0x03, // Sequence uint8 3 bytes |
| 0x09, // uint16_t, single attribute |
| 0x00, 0x01, // ServiceClassIDList |
| 0x00 // Contunuation State: none |
| ); |
| |
| const auto kRspErrSyntax2 = SDP_ERROR_RSP(0xE002, ErrorCode::kInvalidRequestSyntax); |
| |
| EXPECT_TRUE(ReceiveAndExpect(kInvalidMaxBytes, kRspErrSyntax2)); |
| } |
| |
| // Test: |
| // - Answers ServiceSearchAttributeRequest correctly |
| // - Continuation state is generated correctly re: |
| // MaximumAttributeListsByteCount |
| // - Valid Continuation state continues response |
| TEST_F(ServerTest, SearchAttributeRequest) { |
| ServiceRecord record1; |
| record1.SetServiceClassUUIDs({profile::kAVRemoteControl}); |
| record1.AddProtocolDescriptor(ServiceRecord::kPrimaryProtocolList, protocol::kL2CAP, |
| DataElement(uint16_t{500})); |
| record1.SetAttribute(0xf00d, DataElement(uint32_t{0xfeedbeef})); |
| record1.SetAttribute(0xf000, DataElement(uint32_t{0x01234567})); |
| |
| std::vector<ServiceRecord> records1; |
| records1.emplace_back(std::move(record1)); |
| RegistrationHandle handle1 = |
| server()->RegisterService(std::move(records1), kChannelParams, NopConnectCallback); |
| |
| EXPECT_TRUE(handle1); |
| |
| ServiceRecord record2; |
| record2.SetServiceClassUUIDs({profile::kAVRemoteControl}); |
| record2.AddProtocolDescriptor(ServiceRecord::kPrimaryProtocolList, protocol::kL2CAP, |
| DataElement(uint16_t{501})); |
| |
| std::vector<ServiceRecord> records2; |
| records2.emplace_back(std::move(record2)); |
| RegistrationHandle handle2 = |
| server()->RegisterService(std::move(records2), kChannelParams, NopConnectCallback); |
| |
| EXPECT_TRUE(handle2); |
| |
| EXPECT_TRUE(l2cap()->TriggerInboundL2capChannel(kTestHandle1, l2cap::kSDP, kSdpChannel, 0x0bad)); |
| RunLoopUntilIdle(); |
| |
| const auto kRequestAttr = |
| StaticByteBuffer(0x06, // SDP_ServiceAttritbuteRequest |
| 0x10, 0x01, // Transaction ID (0x1001) |
| 0x00, 0x12, // Parameter length (18 bytes) |
| // ServiceSearchPattern |
| 0x35, 0x03, // Sequence uint8 3 bytes |
| 0x19, 0x01, 0x00, // UUID: Protocol: L2CAP |
| 0x00, 0x0A, // MaximumAttributeByteCount (10 bytes max) |
| // AttributeIDList |
| 0x35, 0x08, // Sequence uint8 8 bytes |
| 0x09, // uint16_t, single attribute |
| 0x00, 0x00, // ServiceRecordHandle |
| 0x0A, // uint32_t, which is a range (0x3000 - 0xf000) |
| 0x30, 0x00, // low end of range |
| 0xf0, 0x00, // high end of range |
| 0x00 // Contunuation State: none |
| ); |
| |
| size_t received = 0; |
| |
| ServiceSearchAttributeResponse rsp; |
| |
| auto send_cb = [this, &rsp, &received](auto cb_packet) { |
| EXPECT_LE(sizeof(Header), cb_packet->size()); |
| PacketView<sdp::Header> packet(cb_packet.get()); |
| ASSERT_EQ(0x07, packet.header().pdu_id); |
| uint16_t len = betoh16(packet.header().param_length); |
| EXPECT_LE(len, 0x11); // 2 (byte count) + 10 (max len) + 5 (cont state) |
| packet.Resize(len); |
| fitx::result<Error<>> result = rsp.Parse(packet.payload_data()); |
| if (received == 0) { |
| // Server should have split this into more than one response. |
| EXPECT_EQ(ToResult(HostError::kInProgress), result); |
| EXPECT_FALSE(rsp.complete()); |
| } |
| received++; |
| if (result.is_error() && !result.error_value().is(HostError::kInProgress)) { |
| // This isn't a valid packet and we shouldn't try to get |
| // a continuation. |
| return; |
| } |
| if (!rsp.complete()) { |
| // Repeat the request with the continuation state if it was returned. |
| auto continuation = rsp.ContinuationState(); |
| uint8_t cont_size = continuation.size(); |
| EXPECT_NE(0u, cont_size); |
| // Make another request with the continutation data. |
| size_t param_size = 18 + cont_size; |
| auto kContinuedRequestAttrStart = |
| StaticByteBuffer(0x06, // SDP_ServiceAttributeRequest |
| 0x10, static_cast<uint8_t>(received + 1), // Transaction ID |
| UpperBits(param_size), LowerBits(param_size), // Parameter length |
| 0x35, 0x03, // Sequence uint8 3 bytes |
| 0x19, 0x01, 0x00, // SearchPattern: L2CAP |
| 0x00, 0x0A, // MaximumAttributeByteCount (10 bytes max) |
| // AttributeIDList |
| 0x35, 0x08, // Sequence uint8 8 bytes |
| 0x09, // uint16_t, single attribute |
| 0x00, 0x00, // ServiceRecordHandle |
| 0x0A, // uint32_t, which is a range (0x3000 - 0xf000) |
| 0x30, 0x00, // low end of range |
| 0xf0, 0x00 // high end of range |
| ); |
| DynamicByteBuffer req(kContinuedRequestAttrStart.size() + sizeof(uint8_t) + cont_size); |
| |
| kContinuedRequestAttrStart.Copy(&req); |
| req.Write(&cont_size, sizeof(uint8_t), kContinuedRequestAttrStart.size()); |
| req.Write(continuation, kContinuedRequestAttrStart.size() + sizeof(uint8_t)); |
| |
| fake_chan()->Receive(req); |
| } |
| }; |
| |
| fake_chan()->SetSendCallback(send_cb, dispatcher()); |
| fake_chan()->Receive(kRequestAttr); |
| RunLoopUntilIdle(); |
| |
| EXPECT_GE(received, 1u); |
| // We should receive both of our entered records. |
| EXPECT_EQ(2u, rsp.num_attribute_lists()); |
| for (size_t i = 0; i < rsp.num_attribute_lists(); i++) { |
| const auto& attrs = rsp.attributes(i); |
| // Every service has a record handle |
| auto handle_it = attrs.find(kServiceRecordHandle); |
| EXPECT_NE(attrs.end(), handle_it); |
| ServiceHandle received_handle = *handle_it->second.Get<uint32_t>(); |
| if (received_handle == handle1) { |
| // The first service also has another attribute we should find. |
| EXPECT_EQ(2u, attrs.size()); |
| EXPECT_NE(attrs.end(), attrs.find(0xf000)); |
| } |
| } |
| |
| const auto kInvalidRangeOrder = |
| StaticByteBuffer(0x06, // SDP_ServiceAttritbuteRequest |
| 0xE0, 0x01, // Transaction ID (0xE001) |
| 0x00, 0x12, // Parameter length (18 bytes) |
| 0x35, 0x03, 0x19, 0x01, 0x00, // SearchPattern: L2CAP |
| 0x00, 0x0A, // MaximumAttributeByteCount (10 bytes max) |
| // AttributeIDList |
| 0x35, 0x08, // Sequence uint8 8 bytes |
| 0x09, // uint16_t, single attribute |
| 0x00, 0x01, // ServiceClassIDList |
| 0x0A, // uint32_t, which is a range (0x3000 - 0xf000) |
| 0xf0, 0x00, // low end of range |
| 0x30, 0x00, // high end of range |
| 0x00 // Contunuation State: none |
| ); |
| |
| const auto kRspErrSyntax = SDP_ERROR_RSP(0xE001, ErrorCode::kInvalidRequestSyntax); |
| |
| EXPECT_TRUE(ReceiveAndExpect(kInvalidRangeOrder, kRspErrSyntax)); |
| |
| const auto kInvalidMaxBytes = |
| StaticByteBuffer(0x04, // SDP_ServiceAttritbuteRequest |
| 0xE0, 0x02, // Transaction ID (0xE002) |
| 0x00, 0x0D, // Parameter length (13 bytes) |
| 0x35, 0x03, 0x19, 0x01, 0x00, // SearchPattern: L2CAP |
| 0x00, 0x05, // MaximumAttributeByteCount (5 bytes max) |
| // AttributeIDList |
| 0x35, 0x03, // Sequence uint8 3 bytes |
| 0x09, // uint16_t, single attribute |
| 0x00, 0x01, // ServiceClassIDList |
| 0x00 // Contunuation State: none |
| ); |
| |
| const auto kRspErrSyntax2 = SDP_ERROR_RSP(0xE002, ErrorCode::kInvalidRequestSyntax); |
| |
| EXPECT_TRUE(ReceiveAndExpect(kInvalidMaxBytes, kRspErrSyntax2)); |
| } |
| |
| TEST_F(ServerTest, ConnectionCallbacks) { |
| EXPECT_TRUE(l2cap()->TriggerInboundL2capChannel(kTestHandle1, l2cap::kSDP, kSdpChannel, 0x0bad)); |
| RunLoopUntilIdle(); |
| |
| std::vector<fbl::RefPtr<l2cap::Channel>> channels; |
| hci_spec::ConnectionHandle latest_handle; |
| |
| // Register a service |
| AddA2DPSink([&channels, &latest_handle](auto chan, const auto& protocol) { |
| bt_log(TRACE, "test", "Got channel for the a2dp sink"); |
| latest_handle = chan->link_handle(); |
| channels.emplace_back(std::move(chan)); |
| }); |
| |
| // Connect to the service |
| EXPECT_TRUE( |
| l2cap()->TriggerInboundL2capChannel(kTestHandle1, l2cap::kAVDTP, kSdpChannel + 1, 0x0b00)); |
| RunLoopUntilIdle(); |
| |
| // It should get a callback with a channel |
| EXPECT_EQ(1u, channels.size()); |
| EXPECT_EQ(kTestHandle1, latest_handle); |
| |
| // Connect to the same service again with the same PSM (on a different |
| // connection, it should still work) |
| EXPECT_TRUE( |
| l2cap()->TriggerInboundL2capChannel(kTestHandle2, l2cap::kAVDTP, kSdpChannel + 2, 0x0b01)); |
| RunLoopUntilIdle(); |
| |
| ASSERT_EQ(2u, channels.size()); |
| EXPECT_EQ(kTestHandle2, latest_handle); |
| EXPECT_NE(channels.front(), channels.back()); |
| |
| // Connect to the service again, on the first connection. |
| EXPECT_TRUE( |
| l2cap()->TriggerInboundL2capChannel(kTestHandle1, l2cap::kAVDTP, kSdpChannel + 3, 0x0b00)); |
| RunLoopUntilIdle(); |
| |
| // It should get a callback with a channel |
| EXPECT_EQ(3u, channels.size()); |
| EXPECT_EQ(kTestHandle1, latest_handle); |
| } |
| |
| // Browse Group gets set correctly |
| TEST_F(ServerTest, BrowseGroup) { |
| AddA2DPSink(); |
| |
| EXPECT_TRUE(l2cap()->TriggerInboundL2capChannel(kTestHandle1, l2cap::kSDP, kSdpChannel, 0x0bad)); |
| RunLoopUntilIdle(); |
| |
| const auto kRequestAttr = StaticByteBuffer(0x06, // SDP_ServiceAttritbuteRequest |
| 0x10, 0x01, // Transaction ID (0x1001) |
| 0x00, 0x0D, // Parameter length (12 bytes) |
| // ServiceSearchPattern |
| 0x35, 0x03, // Sequence uint8 3 bytes |
| 0x19, 0x01, 0x00, // UUID: Protocol: L2CAP |
| 0xFF, 0xFF, // MaximumAttributeByteCount (no max) |
| // AttributeIDList |
| 0x35, 0x03, // Sequence uint8 3 bytes |
| 0x09, // uint16_t, single attribute |
| 0x00, 0x05, // BrowseGroupList |
| 0x00 // Contunuation State: none |
| ); |
| |
| ServiceSearchAttributeResponse rsp; |
| auto send_cb = [&rsp](auto cb_packet) { |
| EXPECT_LE(sizeof(Header), cb_packet->size()); |
| PacketView<sdp::Header> packet(cb_packet.get()); |
| ASSERT_EQ(0x07, packet.header().pdu_id); |
| uint16_t len = betoh16(packet.header().param_length); |
| packet.Resize(len); |
| auto status = rsp.Parse(packet.payload_data()); |
| EXPECT_EQ(fitx::ok(), status); |
| }; |
| |
| fake_chan()->SetSendCallback(send_cb, dispatcher()); |
| fake_chan()->Receive(kRequestAttr); |
| RunLoopUntilIdle(); |
| |
| EXPECT_EQ(1u, rsp.num_attribute_lists()); |
| auto& attributes = rsp.attributes(0); |
| auto group_attr_it = attributes.find(kBrowseGroupList); |
| ASSERT_EQ(DataElement::Type::kSequence, group_attr_it->second.type()); |
| ASSERT_EQ(DataElement::Type::kUuid, group_attr_it->second.At(0)->type()); |
| EXPECT_NE(attributes.end(), group_attr_it); |
| EXPECT_EQ(kPublicBrowseRootUuid, *group_attr_it->second.At(0)->Get<UUID>()); |
| } |
| |
| // Channels created for a service registered with channel parameters should be configured with that |
| // service's channel parameters. |
| TEST_F(ServerTest, RegisterServiceWithChannelParameters) { |
| l2cap::PSM kPSM = l2cap::kAVDTP; |
| |
| l2cap::ChannelParameters preferred_params; |
| preferred_params.mode = l2cap::ChannelMode::kEnhancedRetransmission; |
| preferred_params.max_rx_sdu_size = l2cap::kMinACLMTU; |
| |
| std::optional<l2cap::ChannelInfo> params; |
| size_t chan_cb_count = 0; |
| ASSERT_TRUE(AddL2capService(kPSM, preferred_params, [&](auto chan, auto& /*protocol*/) { |
| chan_cb_count++; |
| params = chan->info(); |
| })); |
| |
| EXPECT_TRUE(l2cap()->TriggerInboundL2capChannel(kTestHandle1, kPSM, 0x40, 0x41)); |
| RunLoopUntilIdle(); |
| EXPECT_EQ(1u, chan_cb_count); |
| ASSERT_TRUE(params); |
| EXPECT_EQ(*preferred_params.mode, params->mode); |
| EXPECT_EQ(*preferred_params.max_rx_sdu_size, params->max_rx_sdu_size); |
| } |
| |
| // Test: |
| // - Creation of ServiceDiscoveryService is valid. |
| TEST_F(ServerTest, MakeServiceDiscoveryServiceIsValid) { |
| auto sdp_def = server()->MakeServiceDiscoveryService(); |
| |
| const DataElement& version_number_list = sdp_def.GetAttribute(kSDP_VersionNumberList); |
| EXPECT_EQ(DataElement::Type::kSequence, version_number_list.type()); |
| |
| auto* it = version_number_list.At(0); |
| EXPECT_EQ(DataElement::Type::kUnsignedInt, it->type()); |
| EXPECT_EQ(0x0100u, it->Get<uint16_t>()); |
| } |
| |
| // Test: |
| // - The inspect hierarchy for the initial server is valid. It should |
| // only contain the registered PSM for SDP. |
| TEST_F(ServerTest, InspectHierarchy) { |
| inspect::Inspector inspector; |
| server()->AttachInspect(inspector.GetRoot()); |
| |
| auto psm_matcher = AllOf(NodeMatches( |
| AllOf(NameMatches("psm0x1"), PropertyList(UnorderedElementsAre(StringIs("psm", "SDP")))))); |
| auto reg_psm_matcher = AllOf(NodeMatches(AllOf(NameMatches("registered_psms"))), |
| ChildrenMatch(UnorderedElementsAre(psm_matcher))); |
| |
| auto record_matcher = AllOf( |
| NodeMatches(AllOf( |
| NameMatches("record0x0"), |
| PropertyList(UnorderedElementsAre(StringIs( |
| "record", |
| "Service Class Id List: Sequence { UUID(00001000-0000-1000-8000-00805f9b34fb) }"))))), |
| ChildrenMatch(UnorderedElementsAre(reg_psm_matcher))); |
| |
| auto sdp_matcher = AllOf(NodeMatches(AllOf(NameMatches("sdp_server"))), |
| ChildrenMatch(UnorderedElementsAre(record_matcher))); |
| |
| auto hierarchy = inspect::ReadFromVmo(inspector.DuplicateVmo()); |
| ASSERT_TRUE(hierarchy); |
| EXPECT_THAT(hierarchy.take_value(), AllOf(NodeMatches(NameMatches("root")), |
| ChildrenMatch(UnorderedElementsAre(sdp_matcher)))); |
| } |
| |
| // Test: |
| // - The inspect hierarchy is updated correctly after registering another service. |
| // - The inspect hierarchy is updated correctly after unregistering a service. |
| // Note: None of the matchers test the name of the node. This is because the ordering of |
| // the std::unordered_map of PSMs is not guaranteed. Asserting on the name of the node |
| // is not feasible due to the usage of inspect::UniqueName, which assigns a new name |
| // to a node in every call. The contents of the node are verified. |
| TEST_F(ServerTest, InspectHierarchyAfterUnregisterService) { |
| inspect::Inspector inspector; |
| server()->AttachInspect(inspector.GetRoot()); |
| |
| auto handle = AddA2DPSink(); |
| |
| auto sdp_psm_matcher = |
| AllOf(NodeMatches(AllOf(PropertyList(UnorderedElementsAre(StringIs("psm", "SDP")))))); |
| auto sdp_matcher = AllOf(NodeMatches(AllOf(NameMatches("registered_psms"))), |
| ChildrenMatch(UnorderedElementsAre(sdp_psm_matcher))); |
| |
| auto a2dp_psm_matcher = |
| AllOf(NodeMatches(AllOf(PropertyList(UnorderedElementsAre(StringIs("psm", "AVDTP")))))); |
| auto a2dp_matcher = AllOf(NodeMatches(AllOf(NameMatches("registered_psms"))), |
| ChildrenMatch(UnorderedElementsAre(a2dp_psm_matcher))); |
| |
| auto sdp_record_matcher = AllOf( |
| NodeMatches(AllOf(PropertyList(UnorderedElementsAre(StringIs( |
| "record", |
| "Service Class Id List: Sequence { UUID(00001000-0000-1000-8000-00805f9b34fb) }"))))), |
| ChildrenMatch(UnorderedElementsAre(sdp_matcher))); |
| auto a2dp_record_matcher = |
| AllOf(NodeMatches(AllOf(PropertyList(UnorderedElementsAre(StringIs( |
| "record", |
| "Profile Descriptor: Sequence { Sequence { " |
| "UUID(0000110d-0000-1000-8000-00805f9b34fb) UnsignedInt:2(259) } }\nService Class " |
| "Id List: Sequence { UUID(0000110b-0000-1000-8000-00805f9b34fb) }"))))), |
| ChildrenMatch(UnorderedElementsAre(a2dp_matcher))); |
| |
| auto sdp_server_matcher = |
| AllOf(NodeMatches(AllOf(NameMatches("sdp_server"))), |
| ChildrenMatch(UnorderedElementsAre(sdp_record_matcher, a2dp_record_matcher))); |
| |
| // Hierarchy should contain ServiceRecords and PSMs for SDP and A2DP Sink. |
| auto hierarchy = inspect::ReadFromVmo(inspector.DuplicateVmo()); |
| ASSERT_TRUE(hierarchy); |
| EXPECT_THAT(hierarchy.take_value(), |
| AllOf(NodeMatches(NameMatches("root")), |
| ChildrenMatch(UnorderedElementsAre(sdp_server_matcher)))); |
| |
| // Unregister the A2DP Sink service. |
| EXPECT_TRUE(server()->UnregisterService(handle)); |
| |
| auto sdp_server_matcher2 = AllOf(NodeMatches(AllOf(NameMatches("sdp_server"))), |
| ChildrenMatch(UnorderedElementsAre(sdp_record_matcher))); |
| |
| // The ServiceRecords and PSMs associated with A2DP Sink should be removed |
| // after the service has been registered. Only SDP's data should still exist. |
| auto hierarchy2 = inspect::ReadFromVmo(inspector.DuplicateVmo()); |
| ASSERT_TRUE(hierarchy2); |
| EXPECT_THAT(hierarchy2.take_value(), |
| AllOf(NodeMatches(NameMatches("root")), |
| ChildrenMatch(UnorderedElementsAre(sdp_server_matcher2)))); |
| } |
| |
| // Test: |
| // Server::HandleRequest() provides expected responses when called without |
| // a corresponding l2cap::channel for both successful requests and errors. |
| TEST_F(ServerTest, HandleRequestWithoutChannel) { |
| const auto kRspErrSize = SDP_ERROR_RSP(0x1001, ErrorCode::kInvalidSize); |
| const StaticByteBuffer kTooSmall(0x01, // SDP_ServiceSearchRequest |
| 0x10, 0x01, // Transaction ID (0x1001) |
| 0x00, 0x09 // Parameter length (9 bytes) |
| ); |
| const auto kRspTooSmall = SDP_ERROR_RSP(0x1001, ErrorCode::kInvalidSize); |
| auto too_small_rsp = server()->HandleRequest( |
| std::unique_ptr<ByteBuffer>(new StaticByteBuffer(kTooSmall)), l2cap::kDefaultMTU); |
| EXPECT_TRUE(ContainersEqual(*too_small_rsp.value(), kRspTooSmall)); |
| |
| RegistrationHandle spp_handle = AddSPP(); |
| RegistrationHandle a2dp_handle = AddA2DPSink(); |
| const StaticByteBuffer kL2capSearch(0x02, // SDP_ServiceSearchRequest |
| 0x10, 0x01, // Transaction ID (0x1001) |
| 0x00, 0x08, // Parameter length (8 bytes) |
| // ServiceSearchPattern |
| 0x35, 0x03, // Sequence uint8 3 bytes |
| 0x19, 0x01, 0x00, // UUID: Protocol: L2CAP |
| 0xFF, 0xFF, // MaximumServiceRecordCount: (none) |
| 0x00 // Contunuation State: none |
| ); |
| const StaticByteBuffer kL2capSearchResponse( |
| 0x03, // SDP_ServicesearchResponse |
| 0x10, 0x01, // Transaction ID (0x1001) |
| 0x00, 0x0D, // Parameter length (13 bytes) |
| 0x00, 0x02, // Total service record count: 2 |
| 0x00, 0x02, // Current service record count: 2 |
| UINT32_AS_BE_BYTES(a2dp_handle), // This list isn't specifically ordered |
| UINT32_AS_BE_BYTES(spp_handle), |
| 0x00 // No continuation state |
| ); |
| auto search_rsp = server()->HandleRequest( |
| std::unique_ptr<ByteBuffer>(new StaticByteBuffer(kL2capSearch)), l2cap::kDefaultMTU); |
| EXPECT_TRUE(ContainersEqual(*search_rsp.value(), kL2capSearchResponse)); |
| } |
| |
| #undef SDP_ERROR_RSP |
| #undef UINT32_AS_LE_BYTES |
| |
| } // namespace |
| } // namespace bt::sdp |
