// Copyright 2023 The Pigweed Authors // // 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 // // https://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 "pw_bluetooth_sapphire/internal/host/gatt/server.h" #include "pw_bluetooth_sapphire/internal/host/att/att.h" #include "pw_bluetooth_sapphire/internal/host/att/attribute.h" #include "pw_bluetooth_sapphire/internal/host/att/database.h" #include "pw_bluetooth_sapphire/internal/host/common/macros.h" #include "pw_bluetooth_sapphire/internal/host/common/uuid.h" #include "pw_bluetooth_sapphire/internal/host/gatt/gatt_defs.h" #include "pw_bluetooth_sapphire/internal/host/gatt/local_service_manager.h" #include "pw_bluetooth_sapphire/internal/host/l2cap/mock_channel_test.h" #include "pw_bluetooth_sapphire/internal/host/testing/test_helpers.h" #pragma clang diagnostic ignored "-Wshadow" namespace bt::gatt { namespace { constexpr UUID kTestSvcType(uint16_t{0xDEAD}); constexpr UUID kTestChrcType(uint16_t{0xFEED}); constexpr IdType kTestChrcId{0xFADE}; constexpr PeerId kTestPeerId(1); constexpr UUID kTestType16(uint16_t{0xBEEF}); constexpr UUID kTestType128( {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}); const StaticByteBuffer kTestValue1('f', 'o', 'o'); const StaticByteBuffer kTestValue2('b', 'a', 'r'); const StaticByteBuffer kTestValue3('b', 'a', 'z'); const StaticByteBuffer kTestValue4('l', 'o', 'l'); const StaticByteBuffer kTestValueLong('l', 'o', 'n', 'g'); inline att::AccessRequirements AllowedNoSecurity() { return att::AccessRequirements(/*encryption=*/false, /*authentication=*/false, /*authorization=*/false); } class ServerTest : public l2cap::testing::MockChannelTest { public: ServerTest() = default; ~ServerTest() override = default; protected: void SetUp() override { local_services_ = std::make_unique(); ChannelOptions options(l2cap::kATTChannelId); fake_att_chan_ = CreateFakeChannel(options); att_ = att::Bearer::Create(fake_att_chan_->GetWeakPtr(), dispatcher()); server_ = gatt::Server::Create( kTestPeerId, local_services_->GetWeakPtr(), att_->GetWeakPtr()); } void TearDown() override { RunUntilIdle(); server_ = nullptr; att_ = nullptr; fake_att_chan_ = l2cap::testing::FakeChannel::WeakPtr(); local_services_ = nullptr; } // Registers a service with UUID |svc_type| containing a single characteristic // of UUID |chrc_type| and represented by |chrc_id|. The characteristic // supports the indicate and notify properties, but has not configured them // via the CCC. Returns the ID of the registered service. IdType RegisterSvcWithSingleChrc(UUID svc_type, IdType chrc_id, UUID chrc_type) { ServicePtr svc = std::make_unique(/*primary=*/true, svc_type); CharacteristicPtr chr = std::make_unique( chrc_id, chrc_type, Property::kIndicate | Property::kNotify, /*extended_properties=*/0u, /*read_permission=*/att::AccessRequirements(), /*write_permissions=*/att::AccessRequirements(), /*update_permisisons=*/AllowedNoSecurity()); svc->AddCharacteristic(std::move(chr)); return local_services_->RegisterService( std::move(svc), NopReadHandler, NopWriteHandler, NopCCCallback); } struct SvcIdAndChrcHandle { IdType svc_id; att::Handle chrc_val_handle; }; // RegisterSvcWithSingleChrc, but the CCC is configured to |ccc_val| for // kTestPeerId. Returns the ID of the service alongside the handle of the // registered characteristic value. SvcIdAndChrcHandle RegisterSvcWithConfiguredChrc( UUID svc_type, IdType chrc_id, UUID chrc_type, uint16_t ccc_val = kCCCIndicationBit | kCCCNotificationBit) { IdType svc_id = RegisterSvcWithSingleChrc(svc_type, chrc_id, chrc_type); std::vector chrc_val_handle = SetCCCs(kTestPeerId, chrc_type, ccc_val); EXPECT_EQ(1u, chrc_val_handle.size()); return SvcIdAndChrcHandle{.svc_id = svc_id, .chrc_val_handle = chrc_val_handle[0]}; } Server* server() const { return server_.get(); } att::Database::WeakPtr db() const { return local_services_->database(); } // TODO(armansito): Consider introducing a FakeBearer for testing // (fxbug.dev/42142784). att::Bearer* att() const { return att_.get(); } private: enum CCCSearchState { kSearching, kChrcDeclarationFound, kCorrectChrcUuidFound, }; // Sets |local_services_|' CCCs for |peer_id| to |ccc_val| for all // characteristics of |chrc_type|, and returns the handles of the // characteristic values for which the CCC was modified. std::vector SetCCCs(PeerId peer_id, bt::UUID chrc_type, uint16_t ccc_val) { std::vector modified_attrs; CCCSearchState state = kSearching; for (auto& grouping : db()->groupings()) { att::Handle matching_chrc_value_handle = att::kInvalidHandle; for (auto& attr : grouping.attributes()) { if (attr.type() == types::kCharacteristicDeclaration) { EXPECT_NE(state, kChrcDeclarationFound) << "unexpectedly found two consecutive characteristic " "declarations"; state = kChrcDeclarationFound; } else if (state == kChrcDeclarationFound && attr.type() == chrc_type) { state = kCorrectChrcUuidFound; matching_chrc_value_handle = attr.handle(); } else if (state == kChrcDeclarationFound) { state = kSearching; } else if (state == kCorrectChrcUuidFound && attr.type() == types::kClientCharacteristicConfig) { BT_ASSERT(matching_chrc_value_handle != att::kInvalidHandle); DynamicByteBuffer new_ccc(sizeof(ccc_val)); new_ccc.WriteObj(ccc_val); fit::result write_status = fit::error(att::ErrorCode::kReadNotPermitted); EXPECT_TRUE(attr.WriteAsync(peer_id, /*offset=*/0, new_ccc, [&](fit::result status) { write_status = status; })); // Not strictly necessary with the current WriteAsync implementation, // but running the loop here makes this more future-proof. RunUntilIdle(); EXPECT_EQ(fit::ok(), write_status); modified_attrs.push_back(matching_chrc_value_handle); } } } EXPECT_NE(0u, modified_attrs.size()) << "Couldn't find CCC attribute!"; return modified_attrs; } std::unique_ptr local_services_; l2cap::testing::FakeChannel::WeakPtr fake_att_chan_; std::unique_ptr att_; std::unique_ptr server_; BT_DISALLOW_COPY_AND_ASSIGN_ALLOW_MOVE(ServerTest); }; TEST_F(ServerTest, ExchangeMTURequestInvalidPDU) { // Just opcode // clang-format off const StaticByteBuffer kInvalidPDU(0x02); const StaticByteBuffer kExpected( 0x01, // opcode: error response 0x02, // request: exchange MTU 0x00, 0x00, // handle: 0 0x04 // error: Invalid PDU ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kInvalidPDU); } TEST_F(ServerTest, ExchangeMTURequestValueTooSmall) { const uint16_t kServerMTU = att::kLEMaxMTU; constexpr uint16_t kClientMTU = 1; // clang-format off const StaticByteBuffer kRequest( 0x02, // opcode: exchange MTU kClientMTU, 0x00 // client rx mtu: |kClientMTU| ); const StaticByteBuffer kExpected( 0x03, // opcode: exchange MTU response 0xF7, 0x00 // server rx mtu: |kServerMTU| ); // clang-format on ASSERT_EQ(kServerMTU, att()->preferred_mtu()); EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); // Should default to kLEMinMTU since kClientMTU is too small. EXPECT_EQ(att::kLEMinMTU, att()->mtu()); } TEST_F(ServerTest, ExchangeMTURequest) { constexpr uint16_t kServerMTU = att::kLEMaxMTU; constexpr uint16_t kClientMTU = 0x64; // clang-format off const StaticByteBuffer kRequest( 0x02, // opcode: exchange MTU kClientMTU, 0x00 // client rx mtu: |kClientMTU| ); const StaticByteBuffer kExpected( 0x03, // opcode: exchange MTU response 0xF7, 0x00 // server rx mtu: |kServerMTU| ); // clang-format on ASSERT_EQ(kServerMTU, att()->preferred_mtu()); EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); EXPECT_EQ(kClientMTU, att()->mtu()); } TEST_F(ServerTest, FindInformationInvalidPDU) { // Just opcode // clang-format off const StaticByteBuffer kInvalidPDU(0x04); const StaticByteBuffer kExpected( 0x01, // opcode: error response 0x04, // request: find information 0x00, 0x00, // handle: 0 0x04 // error: Invalid PDU ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kInvalidPDU); } TEST_F(ServerTest, FindInformationInvalidHandle) { // Start handle is 0 // clang-format off const StaticByteBuffer kInvalidStartHandle( 0x04, // opcode: find information 0x00, 0x00, // start: 0x0000 0xFF, 0xFF // end: 0xFFFF ); const StaticByteBuffer kExpected1( 0x01, // opcode: error response 0x04, // request: find information 0x00, 0x00, // handle: 0x0000 (start handle in request) 0x01 // error: Invalid handle ); // End handle is smaller than start handle const StaticByteBuffer kInvalidEndHandle( 0x04, // opcode: find information 0x02, 0x00, // start: 0x0002 0x01, 0x00 // end: 0x0001 ); const StaticByteBuffer kExpected2( 0x01, // opcode: error response 0x04, // request: find information 0x02, 0x00, // handle: 0x0002 (start handle in request) 0x01 // error: Invalid handle ); // clang-format on EXPECT_PACKET_OUT(kExpected1); fake_chan()->Receive(kInvalidStartHandle); EXPECT_PACKET_OUT(kExpected2); fake_chan()->Receive(kInvalidEndHandle); } TEST_F(ServerTest, FindInformationAttributeNotFound) { // clang-format off const StaticByteBuffer kRequest( 0x04, // opcode: find information request 0x01, 0x00, // start: 0x0001 0xFF, 0xFF // end: 0xFFFF ); const StaticByteBuffer kExpected( 0x01, // opcode: error response 0x04, // request: find information 0x01, 0x00, // handle: 0x0001 (start handle in request) 0x0A // error: Attribute not found ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, FindInformation16) { auto* grp = db()->NewGrouping(types::kPrimaryService, 2, kTestValue1); grp->AddAttribute(kTestType16); grp->AddAttribute(kTestType16); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x04, // opcode: find information request 0x01, 0x00, // start: 0x0001 0xFF, 0xFF // end: 0xFFFF ); const StaticByteBuffer kExpected( 0x05, // opcode: find information response 0x01, // format: 16-bit 0x01, 0x00, // handle: 0x0001 0x00, 0x28, // uuid: primary service group type 0x02, 0x00, // handle: 0x0002 0xEF, 0xBE, // uuid: 0xBEEF 0x03, 0x00, // handle: 0x0003 0xEF, 0xBE // uuid: 0xBEEF ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, FindInformation128) { auto* grp = db()->NewGrouping(kTestType128, 0, kTestValue1); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x04, // opcode: find information request 0x01, 0x00, // start: 0x0001 0xFF, 0xFF // end: 0xFFFF ); const StaticByteBuffer kExpected( 0x05, // opcode: find information response 0x02, // format: 128-bit 0x01, 0x00, // handle: 0x0001 // uuid: 0F0E0D0C-0B0A-0908-0706-050403020100 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, FindByTypeValueSuccess) { // handle: 1 (active) db()->NewGrouping(types::kPrimaryService, 0, kTestValue1)->set_active(true); // handle: 2 (active) db()->NewGrouping(types::kPrimaryService, 0, kTestValue2)->set_active(true); // handle: 3 (active) db()->NewGrouping(types::kPrimaryService, 0, kTestValue1)->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x06, // opcode: find by type value request 0x01, 0x00, // start: 0x0001 0xFF, 0xFF, // end: 0xFFFF 0x00, 0x28, // uuid: primary service group type 'f', 'o', 'o' // value: foo ); const StaticByteBuffer kExpected( 0x07, // opcode: find by type value response 0x01, 0x00, // handle: 0x0001 0x01, 0x00, // group handle: 0x0001 0x03, 0x00, // handle: 0x0003 0x03, 0x00 // group handle: 0x0003 ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, FindByTypeValueFail) { // handle: 1 (active) db()->NewGrouping(types::kPrimaryService, 0, kTestValue1)->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x06, // opcode: find by type value request 0x01, 0x00, // start: 0x0001 0xFF, 0xFF, // end: 0xFFFF 0x00, 0x28, // uuid: primary service group type 'n', 'o' // value: no ); const StaticByteBuffer kExpected( 0x01, // Error 0x06, // opcode: find by type value 0x00, 0x00, // group handle: 0x0000 0x0a // Attribute Not Found ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, FindByTypeValueEmptyDB) { // clang-format off const StaticByteBuffer kRequest( 0x06, // opcode: find by type value request 0x01, 0x00, // start: 0x0001 0xFF, 0xFF, // end: 0xFFFF 0x00, 0x28, // uuid: primary service group type 'n', 'o' // value: no ); const StaticByteBuffer kExpected( 0x01, // Error 0x06, // opcode: find by type value 0x00, 0x00, // group handle: 0x0000 0x0a // Attribute Not Found ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, FindByTypeValueInvalidHandle) { // clang-format off const StaticByteBuffer kRequest( 0x06, // opcode: find by type value request 0x02, 0x00, // start: 0x0002 0x01, 0x00, // end: 0x0001 0x00, 0x28, // uuid: primary service group type 'n', 'o' // value: no ); const StaticByteBuffer kExpected( 0x01, // Error 0x06, // opcode: find by type value 0x00, 0x00, // group handle: 0x0000 0x01 // Invalid Handle ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, FindByTypeValueInvalidPDUError) { // handle: 1 (active) db()->NewGrouping(types::kPrimaryService, 0, kTestValue1)->set_active(true); // clang-format off const StaticByteBuffer kInvalidPDU(0x06); const StaticByteBuffer kExpected( 0x01, // Error 0x06, // opcode: find by type value 0x00, 0x00, // group handle: 0x0000 0x04 // Invalid PDU ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kInvalidPDU); } TEST_F(ServerTest, FindByTypeValueZeroLengthValueError) { // handle: 1 (active) db()->NewGrouping(types::kPrimaryService, 0, kTestValue1)->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x06, // opcode: find by type value request 0x01, 0x00, // start: 0x0001 0xFF, 0xFF, // end: 0xFFFF 0x00, 0x28 // uuid: primary service group type ); const StaticByteBuffer kExpected( 0x01, // Error 0x06, // opcode: find by type value 0x00, 0x00, // group handle: 0x0000 0x0a // Attribute Not Found ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, FindByTypeValueOutsideRangeError) { // handle: 1 (active) auto* grp = db()->NewGrouping(kTestType16, 2, kTestValue2); // handle: 2 - value: "long" grp->AddAttribute(kTestType16, AllowedNoSecurity())->SetValue(kTestValue2); // handle: 3 - value: "foo" grp->AddAttribute(kTestType16, AllowedNoSecurity())->SetValue(kTestValue1); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x06, // opcode: find by type value request 0x01, 0x00, // start: 0x0001 0x02, 0x00, // end: 0xFFFF 0x00, 0x28, // uuid: primary service group type 'f', 'o', 'o' // value: foo ); const StaticByteBuffer kExpected( 0x01, // Error 0x06, // opcode: find by type value 0x00, 0x00, // group handle: 0x0000 0x0a // Attribute Not Found ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, FindInfomationInactive) { // handle: 1 (active) db()->NewGrouping(types::kPrimaryService, 0, kTestValue1)->set_active(true); // handle: 2, 3, 4 (inactive) auto* grp = db()->NewGrouping(types::kPrimaryService, 2, kTestValue1); grp->AddAttribute(kTestType16); grp->AddAttribute(kTestType16); // handle: 5 (active) db()->NewGrouping(types::kPrimaryService, 0, kTestValue1)->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x04, // opcode: find information request 0x01, 0x00, // start: 0x0001 0xFF, 0xFF // end: 0xFFFF ); const StaticByteBuffer kExpected( 0x05, // opcode: find information response 0x01, // format: 16-bit 0x01, 0x00, // handle: 0x0001 0x00, 0x28, // uuid: primary service group type 0x05, 0x00, // handle: 0x0005 0x00, 0x28 // uuid: primary service group type ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, FindInfomationRange) { auto* grp = db()->NewGrouping(types::kPrimaryService, 2, kTestValue1); grp->AddAttribute(kTestType16); grp->AddAttribute(kTestType16); grp->set_active(true); // handle: 5 (active) db()->NewGrouping(types::kPrimaryService, 0, kTestValue1)->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x04, // opcode: find information request 0x02, 0x00, // start: 0x0002 0x02, 0x00 // end: 0x0002 ); const StaticByteBuffer kExpected( 0x05, // opcode: find information response 0x01, // format: 16-bit 0x02, 0x00, // handle: 0x0001 0xEF, 0xBE // uuid: 0xBEEF ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, ReadByGroupTypeInvalidPDU) { // Just opcode // clang-format off const StaticByteBuffer kInvalidPDU(0x10); const StaticByteBuffer kExpected( 0x01, // opcode: error response 0x10, // request: read by group type 0x00, 0x00, // handle: 0 0x04 // error: Invalid PDU ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kInvalidPDU); } TEST_F(ServerTest, ReadByGroupTypeUnsupportedGroupType) { // 16-bit UUID // clang-format off const StaticByteBuffer kUsing16BitType( 0x10, // opcode: read by group type 0x01, 0x00, // start: 0x0001 0xFF, 0xFF, // end: 0xFFFF 0x01, 0x00 // group type: 1 (unsupported) ); // 128-bit UUID const StaticByteBuffer kUsing128BitType( 0x10, // opcode: read by group type 0x01, 0x00, // start: 0x0001 0xFF, 0xFF, // end: 0xFFFF // group type: 00112233-4455-6677-8899-AABBCCDDEEFF (unsupported) 0xFF, 0xEE, 0xDD, 0xCC, 0xBB, 0xAA, 0x99, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11, 0x00); const StaticByteBuffer kExpected( 0x01, // opcode: error response 0x10, // request: read by group type 0x01, 0x00, // handle: 0x0001 (start handle in request) 0x10 // error: Unsupported Group Type ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kUsing16BitType); EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kUsing128BitType); } TEST_F(ServerTest, ReadByGroupTypeInvalidHandle) { // Start handle is 0 // clang-format off const StaticByteBuffer kInvalidStartHandle( 0x10, // opcode: read by group type 0x00, 0x00, // start: 0x0000 0xFF, 0xFF, // end: 0xFFFF 0x00, 0x28 // group type: 0x2800 (primary service) ); const StaticByteBuffer kExpected1( 0x01, // opcode: error response 0x10, // request: read by group type 0x00, 0x00, // handle: 0x0000 (start handle in request) 0x01 // error: Invalid handle ); // End handle is smaller than start handle const StaticByteBuffer kInvalidEndHandle( 0x10, // opcode: read by group type 0x02, 0x00, // start: 0x0002 0x01, 0x00, // end: 0x0001 0x00, 0x28 // group type: 0x2800 (primary service) ); const StaticByteBuffer kExpected2( 0x01, // opcode: error response 0x10, // request: read by group type 0x02, 0x00, // handle: 0x0002 (start handle in request) 0x01 // error: Invalid handle ); // clang-format on EXPECT_PACKET_OUT(kExpected1); fake_chan()->Receive(kInvalidStartHandle); EXPECT_PACKET_OUT(kExpected2); fake_chan()->Receive(kInvalidEndHandle); } TEST_F(ServerTest, ReadByGroupTypeAttributeNotFound) { // clang-format off const StaticByteBuffer kRequest( 0x10, // opcode: read by group type 0x01, 0x00, // start: 0x0001 0xFF, 0xFF, // end: 0xFFFF 0x00, 0x28 // group type: 0x2800 (primary service) ); const StaticByteBuffer kExpected( 0x01, // opcode: error response 0x10, // request: read by group type 0x01, 0x00, // handle: 0x0001 (start handle in request) 0x0A // error: Attribute not found ); // clang-format on // Database is empty. EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); // Group type does not match. db()->NewGrouping(types::kSecondaryService, 0, kTestValue1)->set_active(true); EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, ReadByGroupTypeSingle) { const StaticByteBuffer kTestValue('t', 'e', 's', 't'); // Start: 1, end: 2 auto* grp = db()->NewGrouping(types::kPrimaryService, 1, kTestValue); grp->AddAttribute( UUID(), att::AccessRequirements(), att::AccessRequirements()); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x10, // opcode: read by group type 0x01, 0x00, // start: 0x0001 0xFF, 0xFF, // end: 0xFFFF 0x00, 0x28 // group type: 0x2800 (primary service) ); const StaticByteBuffer kExpected( 0x11, // opcode: read by group type response 0x08, // length: 8 (strlen("test") + 4) 0x01, 0x00, // start: 0x0001 0x02, 0x00, // end: 0x0002 't', 'e', 's', 't' // value: "test" ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, ReadByGroupTypeSingle128) { const StaticByteBuffer kTestValue('t', 'e', 's', 't'); // Start: 1, end: 2 auto* grp = db()->NewGrouping(types::kPrimaryService, 1, kTestValue); grp->AddAttribute( UUID(), att::AccessRequirements(), att::AccessRequirements()); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x10, // opcode: read by group type 0x01, 0x00, // start: 0x0001 0xFF, 0xFF, // end: 0xFFFF // group type: 00002800-0000-1000-8000-00805F9B34FB (primary service) 0xFB, 0x34, 0x9B, 0x5F, 0x80, 0x00, 0x00, 0x80, 0x00, 0x10, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00); const StaticByteBuffer kExpected( 0x11, // opcode: read by group type response 0x08, // length: 8 (strlen("test") + 4) 0x01, 0x00, // start: 0x0001 0x02, 0x00, // end: 0x0002 't', 'e', 's', 't' // value: "test" ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, ReadByGroupTypeSingleTruncated) { const StaticByteBuffer kTestValue('t', 'e', 's', 't'); // Start: 1, end: 1 auto* grp = db()->NewGrouping(types::kPrimaryService, 0, kTestValue); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x10, // opcode: read by group type 0x01, 0x00, // start: 0x0001 0xFF, 0xFF, // end: 0xFFFF 0x00, 0x28 // group type: 0x2800 (primary service) ); const StaticByteBuffer kExpected( 0x11, // opcode: read by group type response 0x06, // length: 6 (strlen("te") + 4) 0x01, 0x00, // start: 0x0001 0x01, 0x00, // end: 0x0001 't', 'e' // value: "te" ); // clang-format on // Force the MTU to exactly fit |kExpected| which partially contains // |kTestValue|. att()->set_mtu(kExpected.size()); EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, ReadByGroupTypeMultipleSameValueSize) { // Start: 1, end: 1 db()->NewGrouping(types::kPrimaryService, 0, kTestValue1)->set_active(true); // Start: 2, end: 2 auto* grp2 = db()->NewGrouping(types::kPrimaryService, 0, kTestValue2); grp2->set_active(true); // Start: 3, end: 3 db()->NewGrouping(types::kSecondaryService, 0, kTestValue3)->set_active(true); // Start: 4, end: 4 db()->NewGrouping(types::kPrimaryService, 0, kTestValue3)->set_active(true); // Start: 5, end: 5 db()->NewGrouping(types::kPrimaryService, 0, kTestValue4)->set_active(true); // clang-format off const StaticByteBuffer kRequest1( 0x10, // opcode: read by group type 0x01, 0x00, // start: 0x0001 0xFF, 0xFF, // end: 0xFFFF 0x00, 0x28 // group type: 0x2800 (primary service) ); const StaticByteBuffer kExpected1( 0x11, // opcode: read by group type response 0x07, // length: 7 (strlen("foo") + 4) 0x01, 0x00, // start: 0x0001 0x01, 0x00, // end: 0x0001 'f', 'o', 'o', // value: "foo" 0x02, 0x00, // start: 0x0002 0x02, 0x00, // end: 0x0002 'b', 'a', 'r', // value: "bar" 0x04, 0x00, // start: 0x0004 0x04, 0x00, // end: 0x0004 'b', 'a', 'z' // value: "baz" ); // clang-format on // Set the MTU to be one byte too short to include the 5th attribute group. // The 3rd group is omitted as its group type does not match. att()->set_mtu(kExpected1.size() + 6); EXPECT_PACKET_OUT(kExpected1); fake_chan()->Receive(kRequest1); // Search a narrower range. Only two groups should be returned even with room // in MTU. // clang-format off const StaticByteBuffer kRequest2( 0x10, // opcode: read by group type 0x02, 0x00, // start: 0x0002 0x04, 0x00, // end: 0x0004 0x00, 0x28 // group type: 0x2800 (primary service) ); const StaticByteBuffer kExpected2( 0x11, // opcode: read by group type response 0x07, // length: 7 (strlen("foo") + 4) 0x02, 0x00, // start: 0x0002 0x02, 0x00, // end: 0x0002 'b', 'a', 'r', // value: "bar" 0x04, 0x00, // start: 0x0004 0x04, 0x00, // end: 0x0004 'b', 'a', 'z' // value: "baz" ); // clang-format on EXPECT_PACKET_OUT(kExpected2); fake_chan()->Receive(kRequest2); // Make the second group inactive. It should get omitted. // clang-format off const StaticByteBuffer kExpected3( 0x11, // opcode: read by group type response 0x07, // length: 7 (strlen("foo") + 4) 0x04, 0x00, // start: 0x0004 0x04, 0x00, // end: 0x0004 'b', 'a', 'z' // value: "baz" ); // clang-format on grp2->set_active(false); EXPECT_PACKET_OUT(kExpected3); fake_chan()->Receive(kRequest2); } // The responses should only include 1 value because the next value has a // different length. TEST_F(ServerTest, ReadByGroupTypeMultipleVaryingLengths) { // Start: 1, end: 1 db()->NewGrouping(types::kPrimaryService, 0, kTestValue1)->set_active(true); // Start: 2, end: 2 db()->NewGrouping(types::kPrimaryService, 0, kTestValueLong) ->set_active(true); // Start: 3, end: 3 db()->NewGrouping(types::kPrimaryService, 0, kTestValue1)->set_active(true); // clang-format off const StaticByteBuffer kRequest1( 0x10, // opcode: read by group type 0x01, 0x00, // start: 0x0001 0xFF, 0xFF, // end: 0xFFFF 0x00, 0x28 // group type: 0x2800 (primary service) ); const StaticByteBuffer kExpected1( 0x11, // opcode: read by group type response 0x07, // length: 7 (strlen("foo") + 4) 0x01, 0x00, // start: 0x0001 0x01, 0x00, // end: 0x0001 'f', 'o', 'o' // value: "foo" ); const StaticByteBuffer kRequest2( 0x10, // opcode: read by group type 0x02, 0x00, // start: 0x0002 0xFF, 0xFF, // end: 0xFFFF 0x00, 0x28 // group type: 0x2800 (primary service) ); const StaticByteBuffer kExpected2( 0x11, // opcode: read by group type response 0x08, // length: 8 (strlen("long") + 4) 0x02, 0x00, // start: 0x0002 0x02, 0x00, // end: 0x0002 'l', 'o', 'n', 'g' // value ); const StaticByteBuffer kRequest3( 0x10, // opcode: read by group type 0x03, 0x00, // start: 0x0003 0xFF, 0xFF, // end: 0xFFFF 0x00, 0x28 // group type: 0x2800 (primary service) ); const StaticByteBuffer kExpected3( 0x11, // opcode: read by group type response 0x07, // length: 7 (strlen("foo") + 4) 0x03, 0x00, // start: 0x0003 0x03, 0x00, // end: 0x0003 'f', 'o', 'o' // value: "foo" ); // clang-format on EXPECT_PACKET_OUT(kExpected1); fake_chan()->Receive(kRequest1); EXPECT_PACKET_OUT(kExpected2); fake_chan()->Receive(kRequest2); EXPECT_PACKET_OUT(kExpected3); fake_chan()->Receive(kRequest3); } TEST_F(ServerTest, ReadByTypeInvalidPDU) { // Just opcode // clang-format off const StaticByteBuffer kInvalidPDU(0x08); const StaticByteBuffer kExpected( 0x01, // opcode: error response 0x08, // request: read by type 0x00, 0x00, // handle: 0 0x04 // error: Invalid PDU ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kInvalidPDU); } TEST_F(ServerTest, ReadByTypeInvalidHandle) { // Start handle is 0 // clang-format off const StaticByteBuffer kInvalidStartHandle( 0x08, // opcode: read by type 0x00, 0x00, // start: 0x0000 0xFF, 0xFF, // end: 0xFFFF 0x00, 0x28 // group type: 0x2800 (primary service) ); const StaticByteBuffer kExpected1( 0x01, // opcode: error response 0x08, // request: read by type 0x00, 0x00, // handle: 0x0000 (start handle in request) 0x01 // error: Invalid handle ); // End handle is smaller than start handle const StaticByteBuffer kInvalidEndHandle( 0x08, // opcode: read by type 0x02, 0x00, // start: 0x0002 0x01, 0x00, // end: 0x0001 0x00, 0x28 // group type: 0x2800 (primary service) ); const StaticByteBuffer kExpected2( 0x01, // opcode: error response 0x08, // request: read by type 0x02, 0x00, // handle: 0x0002 (start handle in request) 0x01 // error: Invalid handle ); // clang-format on EXPECT_PACKET_OUT(kExpected1); fake_chan()->Receive(kInvalidStartHandle); EXPECT_PACKET_OUT(kExpected2); fake_chan()->Receive(kInvalidEndHandle); } TEST_F(ServerTest, ReadByTypeAttributeNotFound) { // clang-format off const StaticByteBuffer kRequest( 0x08, // opcode: read by type 0x01, 0x00, // start: 0x0001 0xFF, 0xFF, // end: 0xFFFF 0xEF, 0xBE // type: 0xBEEF ); const StaticByteBuffer kExpected( 0x01, // opcode: error response 0x08, // request: read by type 0x01, 0x00, // handle: 0x0001 (start handle in request) 0x0A // error: Attribute not found ); // clang-format on // Database is empty. EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); // Attribute type does not match. db()->NewGrouping(types::kSecondaryService, 0, kTestValue1)->set_active(true); EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, ReadByTypeDynamicValueNoHandler) { const StaticByteBuffer kTestValue('t', 'e', 's', 't'); auto* grp = db()->NewGrouping(types::kPrimaryService, 1, kTestValue); grp->AddAttribute( kTestType16, AllowedNoSecurity(), att::AccessRequirements()); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x08, // opcode: read by type 0x01, 0x00, // start: 0x0001 0xFF, 0xFF, // end: 0xFFFF 0xEF, 0xBE // type: 0xBEEF ); const StaticByteBuffer kExpected( 0x01, // opcode: error response 0x08, // request: read by type 0x02, 0x00, // handle: 0x0002 (the attribute causing the error) 0x02 // error: Read not permitted ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, ReadByTypeDynamicValue) { auto* grp = db()->NewGrouping(types::kPrimaryService, 2, kTestValue1); auto* attr = grp->AddAttribute(kTestType16, AllowedNoSecurity()); attr->set_read_handler( [attr](PeerId peer_id, auto handle, uint16_t offset, auto result_cb) { EXPECT_EQ(attr->handle(), handle); EXPECT_EQ(0u, offset); result_cb(fit::ok(), StaticByteBuffer('f', 'o', 'r', 'k')); }); // Add a second dynamic attribute, which should be omitted. attr = grp->AddAttribute(kTestType16, AllowedNoSecurity()); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x08, // opcode: read by type 0x01, 0x00, // start: 0x0001 0xFF, 0xFF, // end: 0xFFFF 0xEF, 0xBE // type: 0xBEEF ); const StaticByteBuffer kExpected( 0x09, // opcode: read by type response 0x06, // length: 6 (strlen("fork") + 2) 0x02, 0x00, // handle: 0x0002 'f', 'o', 'r', 'k' // value: "fork" ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); // Assign a static value to the second attribute. It should still be omitted // as the first attribute is dynamic. attr->SetValue(kTestValue1); EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, ReadByTypeDynamicValueError) { const StaticByteBuffer kTestValue('t', 'e', 's', 't'); auto* grp = db()->NewGrouping(types::kPrimaryService, 1, kTestValue); auto* attr = grp->AddAttribute( kTestType16, AllowedNoSecurity(), att::AccessRequirements()); attr->set_read_handler( [](PeerId peer_id, auto handle, uint16_t offset, auto result_cb) { result_cb(fit::error(att::ErrorCode::kUnlikelyError), BufferView()); }); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x08, // opcode: read by type 0x01, 0x00, // start: 0x0001 0xFF, 0xFF, // end: 0xFFFF 0xEF, 0xBE // type: 0xBEEF ); const StaticByteBuffer kExpected( 0x01, // opcode: error response 0x08, // request: read by type 0x02, 0x00, // handle: 0x0002 (the attribute causing the error) 0x0E // error: Unlikely error ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, ReadByTypeSingle) { const StaticByteBuffer kTestValue1('f', 'o', 'o'); const StaticByteBuffer kTestValue2('t', 'e', 's', 't'); auto* grp = db()->NewGrouping(types::kPrimaryService, 1, kTestValue1); grp->AddAttribute(kTestType16, AllowedNoSecurity(), att::AccessRequirements()) ->SetValue(kTestValue2); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x08, // opcode: read by type 0x01, 0x00, // start: 0x0001 0xFF, 0xFF, // end: 0xFFFF 0xEF, 0xBE // type: 0xBEEF ); const StaticByteBuffer kExpected( 0x09, // opcode: read by type response 0x06, // length: 6 (strlen("test") + 2) 0x02, 0x00, // handle: 0x0002 't', 'e', 's', 't' // value: "test" ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, ReadByTypeSingle128) { const StaticByteBuffer kTestValue1('f', 'o', 'o'); const StaticByteBuffer kTestValue2('t', 'e', 's', 't'); auto* grp = db()->NewGrouping(types::kPrimaryService, 1, kTestValue1); grp->AddAttribute( kTestType128, AllowedNoSecurity(), att::AccessRequirements()) ->SetValue(kTestValue2); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x08, // opcode: read by type 0x01, 0x00, // start: 0x0001 0xFF, 0xFF, // end: 0xFFFF // type: 0F0E0D0C-0B0A-0908-0706-050403020100 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F); const StaticByteBuffer kExpected( 0x09, // opcode: read by type response 0x06, // length: 6 (strlen("test") + 2) 0x02, 0x00, // handle: 0x0002 't', 'e', 's', 't' // value: "test" ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, ReadByTypeSingleTruncated) { const StaticByteBuffer kVeryLongValue( 't', 'e', 's', 't', 'i', 'n', 'g', ' ', 'i', 's', ' ', 'f', 'u', 'n'); auto* grp = db()->NewGrouping(types::kPrimaryService, 1, kTestValue1); grp->AddAttribute(kTestType16, AllowedNoSecurity(), att::AccessRequirements()) ->SetValue(kVeryLongValue); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x08, // opcode: read by type 0x01, 0x00, // start: 0x0001 0xFF, 0xFF, // end: 0xFFFF 0xEF, 0xBE // type: 0xBEEF ); const StaticByteBuffer kExpected( 0x09, // opcode: read by type response 0x05, // length: 5 (strlen("tes") + 2) 0x02, 0x00, // handle: 0x0002 't', 'e', 's' // value: "tes" ); // clang-format on // Force the MTU to exactly fit |kExpected| which partially contains // |kTestValue2| (the packet is crafted so that both |kRequest| and // |kExpected| fit within the MTU). att()->set_mtu(kExpected.size()); EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } // When there are more than one matching attributes, the list should end at the // first attribute that causes an error. TEST_F(ServerTest, ReadByTypeMultipleExcludeFirstError) { // handle 1: readable auto* grp = db()->NewGrouping(kTestType16, 1, kTestValue1); // handle 2: not readable. grp->AddAttribute(kTestType16)->SetValue(kTestValue1); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x08, // opcode: read by type 0x01, 0x00, // start: 0x0001 0xFF, 0xFF, // end: 0xFFFF 0xEF, 0xBE // type: 0xBEEF ); const StaticByteBuffer kExpected( 0x09, // opcode: read by type response 0x05, // length: 5 (strlen("foo") + 2) 0x01, 0x00, // handle: 0x0001 'f', 'o', 'o' // value: "foo" ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, ReadByTypeMultipleSameValueSize) { // handle: 1, value: foo auto* grp = db()->NewGrouping(types::kPrimaryService, 2, kTestValue1); // handle: 2, value: foo grp->AddAttribute(kTestType16, AllowedNoSecurity(), att::AccessRequirements()) ->SetValue(kTestValue1); // handle: 3, value: bar grp->AddAttribute(kTestType16, AllowedNoSecurity(), att::AccessRequirements()) ->SetValue(kTestValue2); grp->set_active(true); // handle: 4, value: foo (new grouping) grp = db()->NewGrouping(types::kPrimaryService, 1, kTestValue1); // handle: 5, value: baz grp->AddAttribute(kTestType16, AllowedNoSecurity(), att::AccessRequirements()) ->SetValue(kTestValue3); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest1( 0x08, // opcode: read by type 0x01, 0x00, // start: 0x0001 0xFF, 0xFF, // end: 0xFFFF 0xEF, 0xBE // type: 0xBEEF ); const StaticByteBuffer kExpected1( 0x09, // opcode: read by type response 0x05, // length: 5 (strlen("foo") + 2) 0x02, 0x00, // handle: 0x0002 'f', 'o', 'o', // value: "foo" 0x03, 0x00, // handle: 0x0003 'b', 'a', 'r', // value: "bar" 0x05, 0x00, // handle: 0x0005 'b', 'a', 'z' // value: "baz" ); // clang-format on EXPECT_PACKET_OUT(kExpected1); fake_chan()->Receive(kRequest1); // Set the MTU 1 byte too short for |kExpected1|. att()->set_mtu(kExpected1.size() - 1); // clang-format off const StaticByteBuffer kExpected2( 0x09, // opcode: read by type response 0x05, // length: 5 (strlen("foo") + 2) 0x02, 0x00, // handle: 0x0002 'f', 'o', 'o', // value: "foo" 0x03, 0x00, // handle: 0x0003 'b', 'a', 'r' // value: "bar" ); // clang-format on EXPECT_PACKET_OUT(kExpected2); fake_chan()->Receive(kRequest1); // Try a different range. // clang-format off const StaticByteBuffer kRequest2( 0x08, // opcode: read by type 0x03, 0x00, // start: 0x0003 0x05, 0x00, // end: 0x0005 0xEF, 0xBE // type: 0xBEEF ); const StaticByteBuffer kExpected3( 0x09, // opcode: read by type response 0x05, // length: 5 (strlen("bar") + 2) 0x03, 0x00, // handle: 0x0003 'b', 'a', 'r', // value: "bar" 0x05, 0x00, // handle: 0x0005 'b', 'a', 'z' // value: "baz" ); // clang-format on EXPECT_PACKET_OUT(kExpected3); fake_chan()->Receive(kRequest2); // Make the second group inactive. grp->set_active(false); // clang-format off const StaticByteBuffer kExpected4( 0x09, // opcode: read by type response 0x05, // length: 5 (strlen("bar") + 2) 0x03, 0x00, // handle: 0x0003 'b', 'a', 'r' // value: "bar" ); // clang-format on EXPECT_PACKET_OUT(kExpected4); fake_chan()->Receive(kRequest2); } // A response packet should only include consecutive attributes with the same // value size. TEST_F(ServerTest, ReadByTypeMultipleVaryingLengths) { // handle: 1 - value: "foo" auto* grp = db()->NewGrouping(kTestType16, 2, kTestValue1); // handle: 2 - value: "long" grp->AddAttribute(kTestType16, AllowedNoSecurity())->SetValue(kTestValueLong); // handle: 3 - value: "foo" grp->AddAttribute(kTestType16, AllowedNoSecurity())->SetValue(kTestValue1); grp->set_active(true); // Even though we have 3 attributes with a matching type, the requests below // will always return one attribute at a time as their values have different // sizes. // clang-format off const StaticByteBuffer kRequest1( 0x08, // opcode: read by type 0x01, 0x00, // start: 0x0001 0xFF, 0xFF, // end: 0xFFFF 0xEF, 0xBE // type: 0xBEEF ); const StaticByteBuffer kExpected1( 0x09, // opcode: read by type response 0x05, // length: 5 (strlen("foo") + 2) 0x01, 0x00, // handle: 0x0001 'f', 'o', 'o' // value: "foo" ); const StaticByteBuffer kRequest2( 0x08, // opcode: read by type 0x02, 0x00, // start: 0x0002 0xFF, 0xFF, // end: 0xFFFF 0xEF, 0xBE // type: 0xBEEF ); const StaticByteBuffer kExpected2( 0x09, // opcode: read by type response 0x06, // length: 6 (strlen("long") + 2) 0x02, 0x00, // handle: 0x0002 'l', 'o', 'n', 'g' // value: "long" ); const StaticByteBuffer kRequest3( 0x08, // opcode: read by type 0x03, 0x00, // start: 0x0003 0xFF, 0xFF, // end: 0xFFFF 0xEF, 0xBE // type: 0xBEEF ); const StaticByteBuffer kExpected3( 0x09, // opcode: read by type response 0x05, // length: 5 (strlen("foo") + 2) 0x03, 0x00, // handle: 0x0003 'f', 'o', 'o' // value: "foo" ); // clang-format on EXPECT_PACKET_OUT(kExpected1); fake_chan()->Receive(kRequest1); EXPECT_PACKET_OUT(kExpected2); fake_chan()->Receive(kRequest2); EXPECT_PACKET_OUT(kExpected3); fake_chan()->Receive(kRequest3); } // When there are more than one matching attributes, the list should end at the // first attribute with a dynamic value. TEST_F(ServerTest, ReadByTypeMultipleExcludeFirstDynamic) { // handle: 1 - value: "foo" auto* grp = db()->NewGrouping(kTestType16, 1, kTestValue1); // handle: 2 - value: dynamic grp->AddAttribute(kTestType16, AllowedNoSecurity()); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x08, // opcode: read by type 0x01, 0x00, // start: 0x0001 0xFF, 0xFF, // end: 0xFFFF 0xEF, 0xBE // type: 0xBEEF ); const StaticByteBuffer kExpected( 0x09, // opcode: read by type response 0x05, // length: 5 (strlen("foo") + 2) 0x01, 0x00, // handle: 0x0001 'f', 'o', 'o' // value: "foo" ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, WriteRequestInvalidPDU) { // Just opcode // clang-format off const StaticByteBuffer kInvalidPDU(0x12); const StaticByteBuffer kExpected( 0x01, // opcode: error response 0x12, // request: write request 0x00, 0x00, // handle: 0 0x04 // error: Invalid PDU ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kInvalidPDU); } TEST_F(ServerTest, WriteRequestInvalidHandle) { // clang-format off const StaticByteBuffer kRequest( 0x12, // opcode: write request 0x01, 0x00, // handle: 0x0001 // value: "test" 't', 'e', 's', 't'); const StaticByteBuffer kExpected( 0x01, // opcode: error response 0x12, // request: write request 0x01, 0x00, // handle: 0x0001 0x01 // error: invalid handle ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, WriteRequestSecurity) { const StaticByteBuffer kTestValue('f', 'o', 'o'); auto* grp = db()->NewGrouping(types::kPrimaryService, 1, kTestValue); // Requires encryption grp->AddAttribute(kTestType16, att::AccessRequirements(), att::AccessRequirements(/*encryption=*/true, /*authentication=*/false, /*authorization=*/false)); grp->set_active(true); // We send two write requests: // 1. 0x0001: not writable // 2. 0x0002: writable but requires encryption // // clang-format off const StaticByteBuffer kRequest1( 0x12, // opcode: write request 0x01, 0x00, // handle: 0x0001 // value: "test" 't', 'e', 's', 't'); const StaticByteBuffer kExpected1( 0x01, // opcode: error response 0x12, // request: write request 0x01, 0x00, // handle: 0x0001 0x03 // error: write not permitted ); const StaticByteBuffer kRequest2( 0x12, // opcode: write request 0x02, 0x00, // handle: 0x0002 // value: "test" 't', 'e', 's', 't'); const StaticByteBuffer kExpected2( 0x01, // opcode: error response 0x12, // request: write request 0x02, 0x00, // handle: 0x0002 0x05 // error: insufficient authentication ); // clang-format on EXPECT_PACKET_OUT(kExpected1); fake_chan()->Receive(kRequest1); EXPECT_PACKET_OUT(kExpected2); fake_chan()->Receive(kRequest2); } TEST_F(ServerTest, WriteRequestNoHandler) { const StaticByteBuffer kTestValue('f', 'o', 'o'); auto* grp = db()->NewGrouping(types::kPrimaryService, 1, kTestValue); grp->AddAttribute( kTestType16, att::AccessRequirements(), AllowedNoSecurity()); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x12, // opcode: write request 0x02, 0x00, // handle: 0x0002 // value: "test" 't', 'e', 's', 't'); const StaticByteBuffer kExpected( 0x01, // opcode: error response 0x12, // request: write request 0x02, 0x00, // handle: 0x0002 0x03 // error: write not permitted ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, WriteRequestError) { const StaticByteBuffer kTestValue('f', 'o', 'o'); auto* grp = db()->NewGrouping(types::kPrimaryService, 1, kTestValue); auto* attr = grp->AddAttribute( kTestType16, att::AccessRequirements(), AllowedNoSecurity()); attr->set_write_handler([&](PeerId peer_id, att::Handle handle, uint16_t offset, const auto& value, auto result_cb) { EXPECT_EQ(kTestPeerId, peer_id); EXPECT_EQ(attr->handle(), handle); EXPECT_EQ(0u, offset); EXPECT_TRUE(ContainersEqual(StaticByteBuffer('t', 'e', 's', 't'), value)); result_cb(fit::error(att::ErrorCode::kUnlikelyError)); }); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x12, // opcode: write request 0x02, 0x00, // handle: 0x0002 // value: "test" 't', 'e', 's', 't'); const StaticByteBuffer kExpected( 0x01, // opcode: error response 0x12, // request: write request 0x02, 0x00, // handle: 0x0002 0x0E // error: unlikely error ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, WriteRequestSuccess) { const StaticByteBuffer kTestValue('f', 'o', 'o'); auto* grp = db()->NewGrouping(types::kPrimaryService, 1, kTestValue); auto* attr = grp->AddAttribute( kTestType16, att::AccessRequirements(), AllowedNoSecurity()); attr->set_write_handler([&](PeerId peer_id, att::Handle handle, uint16_t offset, const auto& value, auto result_cb) { EXPECT_EQ(kTestPeerId, peer_id); EXPECT_EQ(attr->handle(), handle); EXPECT_EQ(0u, offset); EXPECT_TRUE(ContainersEqual(StaticByteBuffer('t', 'e', 's', 't'), value)); result_cb(fit::ok()); }); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x12, // opcode: write request 0x02, 0x00, // handle: 0x0002 // value: "test" 't', 'e', 's', 't'); // clang-format on // opcode: write response const StaticByteBuffer kExpected(0x13); EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } // TODO(bwb): Add test cases for the error conditions involved in a Write // Command (fxbug.dev/42146420) TEST_F(ServerTest, WriteCommandSuccess) { const StaticByteBuffer kTestValue('f', 'o', 'o'); auto* grp = db()->NewGrouping(types::kPrimaryService, 1, kTestValue); auto* attr = grp->AddAttribute( kTestType16, att::AccessRequirements(), AllowedNoSecurity()); attr->set_write_handler([&](PeerId peer_id, att::Handle handle, uint16_t offset, const auto& value, const auto& result_cb) { EXPECT_EQ(kTestPeerId, peer_id); EXPECT_EQ(attr->handle(), handle); EXPECT_EQ(0u, offset); EXPECT_TRUE(ContainersEqual(StaticByteBuffer('t', 'e', 's', 't'), value)); }); grp->set_active(true); // clang-format off const StaticByteBuffer kCmd( 0x52, // opcode: write command 0x02, 0x00, // handle: 0x0002 't', 'e', 's', 't'); // clang-format on fake_chan()->Receive(kCmd); } TEST_F(ServerTest, ReadRequestInvalidPDU) { // Just opcode // clang-format off const StaticByteBuffer kInvalidPDU(0x0A); const StaticByteBuffer kExpected( 0x01, // opcode: error response 0x0A, // request: read request 0x00, 0x00, // handle: 0 0x04 // error: Invalid PDU ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kInvalidPDU); } TEST_F(ServerTest, ReadRequestInvalidHandle) { // clang-format off const StaticByteBuffer kRequest( 0x0A, // opcode: read request 0x01, 0x00 // handle: 0x0001 ); const StaticByteBuffer kExpected( 0x01, // opcode: error response 0x0A, // request: read request 0x01, 0x00, // handle: 0x0001 0x01 // error: invalid handle ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, ReadRequestSecurity) { const StaticByteBuffer kTestValue('f', 'o', 'o'); auto* grp = db()->NewGrouping(types::kPrimaryService, 1, kTestValue); // Requires encryption grp->AddAttribute(kTestType16, att::AccessRequirements(/*encryption=*/true, /*authentication=*/false, /*authorization=*/false), att::AccessRequirements()); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x0A, // opcode: read request 0x02, 0x00 // handle: 0x0002 ); const StaticByteBuffer kExpected( 0x01, // opcode: error response 0x0A, // request: read request 0x02, 0x00, // handle: 0x0002 0x05 // error: insufficient authentication ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, ReadRequestCached) { const StaticByteBuffer kDeclValue('d', 'e', 'c', 'l'); const StaticByteBuffer kTestValue('f', 'o', 'o'); auto* grp = db()->NewGrouping(types::kPrimaryService, 1, kDeclValue); auto* attr = grp->AddAttribute( kTestType16, AllowedNoSecurity(), att::AccessRequirements()); attr->SetValue(kTestValue); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest1( 0x0A, // opcode: read request 0x01, 0x00 // handle: 0x0001 ); const StaticByteBuffer kExpected1( 0x0B, // opcode: read response 'd', 'e', 'c', 'l' // value: kDeclValue ); const StaticByteBuffer kRequest2( 0x0A, // opcode: read request 0x02, 0x00 // handle: 0x0002 ); const StaticByteBuffer kExpected2( 0x0B, // opcode: read response 'f', 'o', 'o' // value: kTestValue ); // clang-format on EXPECT_PACKET_OUT(kExpected1); fake_chan()->Receive(kRequest1); EXPECT_PACKET_OUT(kExpected2); fake_chan()->Receive(kRequest2); } TEST_F(ServerTest, ReadRequestNoHandler) { const StaticByteBuffer kTestValue('f', 'o', 'o'); auto* grp = db()->NewGrouping(types::kPrimaryService, 1, kTestValue); grp->AddAttribute( kTestType16, AllowedNoSecurity(), att::AccessRequirements()); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x0A, // opcode: read request 0x02, 0x00 // handle: 0x0002 ); const StaticByteBuffer kExpected( 0x01, // opcode: error response 0x0A, // request: read request 0x02, 0x00, // handle: 0x0002 0x02 // error: read not permitted ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, ReadRequestError) { const StaticByteBuffer kTestValue('f', 'o', 'o'); auto* grp = db()->NewGrouping(types::kPrimaryService, 1, kTestValue); auto* attr = grp->AddAttribute( kTestType16, AllowedNoSecurity(), att::AccessRequirements()); attr->set_read_handler( [&](PeerId peer_id, att::Handle handle, uint16_t offset, auto result_cb) { EXPECT_EQ(kTestPeerId, peer_id); EXPECT_EQ(attr->handle(), handle); EXPECT_EQ(0u, offset); result_cb(fit::error(att::ErrorCode::kUnlikelyError), BufferView()); }); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x0A, // opcode: read request 0x02, 0x00 // handle: 0x0002 ); const StaticByteBuffer kExpected( 0x01, // opcode: error response 0x0A, // request: read request 0x02, 0x00, // handle: 0x0002 0x0E // error: unlikely error ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, ReadBlobRequestInvalidPDU) { // Just opcode // clang-format off const StaticByteBuffer kInvalidPDU(0x0C); const StaticByteBuffer kExpected( 0x01, // opcode: error response 0x0C, // request: read blob request 0x00, 0x00, // handle: 0 0x04 // error: Invalid PDU ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kInvalidPDU); } TEST_F(ServerTest, ReadBlobRequestDynamicSuccess) { const StaticByteBuffer kDeclValue('d', 'e', 'c', 'l'); const StaticByteBuffer kTestValue('A', ' ', 'V', 'e', 'r', 'y', ' ', 'L', 'o', 'n', 'g', ' ', 'D', 'e', 'v', 'i', 'c', 'e', ' ', 'N', 'a', 'm', 'e', ' ', 'U', 's', 'i', 'n', 'g', ' ', 'A', ' ', 'L', 'o', 'n', 'g', ' ', 'A', 't', 't', 'r', 'i', 'b', 'u', 't', 'e'); auto* grp = db()->NewGrouping(types::kPrimaryService, 1, kTestValue); auto* attr = grp->AddAttribute( kTestType16, AllowedNoSecurity(), att::AccessRequirements()); attr->set_read_handler( [&](PeerId peer_id, att::Handle handle, uint16_t offset, auto result_cb) { EXPECT_EQ(kTestPeerId, peer_id); EXPECT_EQ(attr->handle(), handle); EXPECT_EQ(22u, offset); result_cb(fit::ok(), StaticByteBuffer('e', ' ', 'U', 's', 'i', 'n', 'g', ' ', 'A', ' ', 'L', 'o', 'n', 'g', ' ', 'A', 't', 't', 'r', 'i', 'b', 'u')); }); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x0C, // opcode: read blob request 0x02, 0x00, // handle: 0x0002 0x16, 0x00 // offset: 0x0016 ); const StaticByteBuffer kExpected( 0x0D, // opcode: read blob response // Read Request response 'e', ' ', 'U', 's', 'i', 'n', 'g', ' ', 'A', ' ', 'L', 'o', 'n', 'g', ' ', 'A', 't', 't', 'r', 'i', 'b', 'u' ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, ReadBlobDynamicRequestError) { const StaticByteBuffer kTestValue('A', ' ', 'V', 'e', 'r', 'y', ' ', 'L', 'o', 'n', 'g', ' ', 'D', 'e', 'v', 'i', 'c', 'e', ' ', 'N', 'a', 'm', 'e', ' ', 'U', 's', 'i', 'n', 'g', ' ', 'A', ' ', 'L', 'o', 'n', 'g', ' ', 'A', 't', 't', 'r', 'i', 'b', 'u', 't', 'e'); auto* grp = db()->NewGrouping(types::kPrimaryService, 1, kTestValue); auto* attr = grp->AddAttribute( kTestType16, AllowedNoSecurity(), att::AccessRequirements()); attr->set_read_handler( [&](PeerId peer_id, att::Handle handle, uint16_t offset, auto result_cb) { EXPECT_EQ(kTestPeerId, peer_id); EXPECT_EQ(attr->handle(), handle); result_cb(fit::error(att::ErrorCode::kUnlikelyError), BufferView()); }); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x0C, // opcode: read blob request 0x02, 0x00, // handle: 0x0002 0x16, 0x00 // offset: 0x0016 ); const StaticByteBuffer kExpected( 0x01, // opcode: error response 0x0C, // request: read by type 0x02, 0x00, // handle: 0x0002 (the attribute causing the error) 0x0E // error: Unlikely error ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, ReadBlobRequestStaticSuccess) { const StaticByteBuffer kTestValue('A', ' ', 'V', 'e', 'r', 'y', ' ', 'L', 'o', 'n', 'g', ' ', 'D', 'e', 'v', 'i', 'c', 'e', ' ', 'N', 'a', 'm', 'e', ' ', 'U', 's', 'i', 'n', 'g', ' ', 'A', ' ', 'L', 'o', 'n', 'g', ' ', 'A', 't', 't', 'r', 'i', 'b', 'u', 't', 'e'); auto* grp = db()->NewGrouping(types::kPrimaryService, 0, kTestValue); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x0C, // opcode: read blob request 0x01, 0x00, // handle: 0x0002 0x16, 0x00 // offset: 0x0016 ); const StaticByteBuffer kExpected( 0x0D, // opcode: read blob response // Read Request response 'e', ' ', 'U', 's', 'i', 'n', 'g', ' ', 'A', ' ', 'L', 'o', 'n', 'g', ' ', 'A', 't', 't', 'r', 'i', 'b', 'u' ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, ReadBlobRequestStaticOverflowError) { const StaticByteBuffer kTestValue('s', 'h', 'o', 'r', 't', 'e', 'r'); auto* grp = db()->NewGrouping(types::kPrimaryService, 0, kTestValue); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x0C, // opcode: read blob request 0x01, 0x00, // handle: 0x0001 0x16, 0x10 // offset: 0x1016 ); const StaticByteBuffer kExpected( 0x01, // Error 0x0C, // opcode 0x01, 0x00, // handle: 0x0001 0x07 // InvalidOffset ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, ReadBlobRequestInvalidHandleError) { const StaticByteBuffer kTestValue('A', ' ', 'V', 'e', 'r', 'y', ' ', 'L', 'o', 'n', 'g', ' ', 'D', 'e', 'v', 'i', 'c', 'e', ' ', 'N', 'a', 'm', 'e', ' ', 'U', 's', 'i', 'n', 'g', ' ', 'A', ' ', 'L', 'o', 'n', 'g', ' ', 'A', 't', 't', 'r', 'i', 'b', 'u', 't', 'e'); auto* grp = db()->NewGrouping(types::kPrimaryService, 0, kTestValue); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x0C, // opcode: read blob request 0x02, 0x30, // handle: 0x0002 0x16, 0x00 // offset: 0x0016 ); const StaticByteBuffer kExpected( 0x01, // opcode: error response 0x0C, // request: read blob request 0x02, 0x30, // handle: 0x0001 0x01 // error: invalid handle ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, ReadBlobRequestNotPermitedError) { const StaticByteBuffer kTestValue('A', ' ', 'V', 'e', 'r', 'y', ' ', 'L', 'o', 'n', 'g', ' ', 'D', 'e', 'v', 'i', 'c', 'e', ' ', 'N', 'a', 'm', 'e', ' ', 'U', 's', 'i', 'n', 'g', ' ', 'A', ' ', 'L', 'o', 'n', 'g', ' ', 'A', 't', 't', 'r', 'i', 'b', 'u', 't', 'e'); auto* grp = db()->NewGrouping(types::kPrimaryService, 1, kTestValue); auto* attr = grp->AddAttribute(kTestType16, att::AccessRequirements(), att::AccessRequirements(/*encryption=*/true, /*authentication=*/false, /*authorization=*/false)); attr->set_read_handler( [&](PeerId peer_id, att::Handle handle, uint16_t offset, auto result_cb) { EXPECT_EQ(kTestPeerId, peer_id); EXPECT_EQ(attr->handle(), handle); result_cb(fit::error(att::ErrorCode::kUnlikelyError), BufferView()); }); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x0C, // opcode: read blob request 0x02, 0x00, // handle: 0x0002 0x16, 0x00 // offset: 0x0016 ); const StaticByteBuffer kExpected( 0x01, // opcode: error response 0x0C, // request: read by type 0x02, 0x00, // handle: 0x0002 (the attribute causing the error) 0x02 // error: Not Permitted ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, ReadBlobRequestInvalidOffsetError) { const StaticByteBuffer kTestValue('A', ' ', 'V', 'e', 'r', 'y', ' ', 'L', 'o', 'n', 'g', ' ', 'D', 'e', 'v', 'i', 'c', 'e', ' ', 'N', 'a', 'm', 'e', ' ', 'U', 's', 'i', 'n', 'g', ' ', 'A', ' ', 'L', 'o', 'n', 'g', ' ', 'A', 't', 't', 'r', 'i', 'b', 'u', 't', 'e'); auto* grp = db()->NewGrouping(types::kPrimaryService, 1, kTestValue); auto* attr = grp->AddAttribute( kTestType16, AllowedNoSecurity(), att::AccessRequirements()); attr->set_read_handler( [&](PeerId peer_id, att::Handle handle, uint16_t offset, auto result_cb) { EXPECT_EQ(kTestPeerId, peer_id); EXPECT_EQ(attr->handle(), handle); result_cb(fit::error(att::ErrorCode::kInvalidOffset), BufferView()); }); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x0C, // opcode: read blob request 0x02, 0x00, // handle: 0x0002 0x16, 0x40 // offset: 0x4016 ); const StaticByteBuffer kExpected( 0x01, // opcode: error response 0x0C, // request: read by type 0x02, 0x00, // handle: 0x0002 (the attribute causing the error) 0x07 // error: Invalid Offset Error ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, ReadRequestSuccess) { const StaticByteBuffer kDeclValue('d', 'e', 'c', 'l'); const StaticByteBuffer kTestValue('f', 'o', 'o'); auto* grp = db()->NewGrouping(types::kPrimaryService, 1, kTestValue); auto* attr = grp->AddAttribute( kTestType16, AllowedNoSecurity(), att::AccessRequirements()); attr->set_read_handler( [&](PeerId peer_id, att::Handle handle, uint16_t offset, auto result_cb) { EXPECT_EQ(kTestPeerId, peer_id); EXPECT_EQ(attr->handle(), handle); EXPECT_EQ(0u, offset); result_cb(fit::ok(), kTestValue); }); grp->set_active(true); // clang-format off const StaticByteBuffer kRequest( 0x0A, // opcode: read request 0x02, 0x00 // handle: 0x0002 ); const StaticByteBuffer kExpected( 0x0B, // opcode: read response 'f', 'o', 'o' // value: kTestValue ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, PrepareWriteRequestInvalidPDU) { // Payload is one byte too short. // clang-format off const StaticByteBuffer kInvalidPDU( 0x16, // opcode: prepare write request 0x01, 0x00, // handle: 0x0001 0x01 // offset (should be 2 bytes). ); const StaticByteBuffer kExpected( 0x01, // opcode: error response 0x16, // request: prepare write request 0x00, 0x00, // handle: 0 0x04 // error: Invalid PDU ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kInvalidPDU); } TEST_F(ServerTest, PrepareWriteRequestInvalidHandle) { // clang-format off const StaticByteBuffer kRequest( 0x16, // opcode: prepare write request 0x01, 0x00, // handle: 0x0001 0x00, 0x00, // offset: 0 't', 'e', 's', 't' // value: "test" ); const StaticByteBuffer kResponse( 0x01, // opcode: error response 0x16, // request: prepare write request 0x01, 0x00, // handle: 0x0001 0x01 // error: invalid handle ); // clang-format on EXPECT_PACKET_OUT(kResponse); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, PrepareWriteRequestSucceeds) { const StaticByteBuffer kTestValue('f', 'o', 'o'); auto* grp = db()->NewGrouping(types::kPrimaryService, 1, kTestValue); // No security requirement auto* attr = grp->AddAttribute(kTestType16, att::AccessRequirements(), att::AccessRequirements(/*encryption=*/false, /*authentication=*/false, /*authorization=*/false)); grp->set_active(true); int write_count = 0; attr->set_write_handler( [&](PeerId, att::Handle, uint16_t, const auto&, const auto&) { write_count++; }); ASSERT_EQ(0x0002, attr->handle()); // clang-format off const StaticByteBuffer kRequest( 0x16, // opcode: prepare write request 0x02, 0x00, // handle: 0x0002 0x00, 0x00, // offset: 0 't', 'e', 's', 't' // value: "test" ); const StaticByteBuffer kResponse( 0x17, // opcode: prepare write response 0x02, 0x00, // handle: 0x0002 0x00, 0x00, // offset: 0 't', 'e', 's', 't' // value: "test" ); // clang-format on EXPECT_PACKET_OUT(kResponse); fake_chan()->Receive(kRequest); // The attribute should not have been written yet. EXPECT_EQ(0, write_count); } TEST_F(ServerTest, PrepareWriteRequestPrepareQueueFull) { const StaticByteBuffer kTestValue('f', 'o', 'o'); auto* grp = db()->NewGrouping(types::kPrimaryService, 1, kTestValue); // No security requirement const auto* attr = grp->AddAttribute(kTestType16, att::AccessRequirements(), att::AccessRequirements(/*encryption=*/false, /*authentication=*/false, /*authorization=*/false)); grp->set_active(true); ASSERT_EQ(0x0002, attr->handle()); // clang-format off const StaticByteBuffer kRequest( 0x16, // opcode: prepare write request 0x02, 0x00, // handle: 0x0002 0x00, 0x00, // offset: 0 't', 'e', 's', 't' // value: "test" ); const StaticByteBuffer kSuccessResponse( 0x17, // opcode: prepare write response 0x02, 0x00, // handle: 0x0002 0x00, 0x00, // offset: 0 't', 'e', 's', 't' // value: "test" ); const StaticByteBuffer kErrorResponse( 0x01, // opcode: error response 0x16, // request: prepare write request 0x02, 0x00, // handle: 0x0002 0x09 // error: prepare queue full ); // clang-format on // Write requests should succeed until capacity is filled. for (unsigned i = 0; i < att::kPrepareQueueMaxCapacity; i++) { EXPECT_PACKET_OUT(kSuccessResponse); fake_chan()->Receive(kRequest); ASSERT_TRUE(AllExpectedPacketsSent()) << "Unexpected failure at attempt: " << i; } // The next request should fail with a capacity error. EXPECT_PACKET_OUT(kErrorResponse); fake_chan()->Receive(kRequest); } TEST_F(ServerTest, ExecuteWriteMalformedPayload) { // Payload is one byte too short. // clang-format off const StaticByteBuffer kInvalidPDU( 0x18 // opcode: execute write request ); const StaticByteBuffer kExpected( 0x01, // opcode: error response 0x18, // request: execute write request 0x00, 0x00, // handle: 0 0x04 // error: Invalid PDU ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kInvalidPDU); } TEST_F(ServerTest, ExecuteWriteInvalidFlag) { // Payload is one byte too short. // clang-format off const StaticByteBuffer kInvalidPDU( 0x18, // opcode: execute write request 0xFF // flag: invalid ); const StaticByteBuffer kExpected( 0x01, // opcode: error response 0x18, // request: execute write request 0x00, 0x00, // handle: 0 0x04 // error: Invalid PDU ); // clang-format on EXPECT_PACKET_OUT(kExpected); fake_chan()->Receive(kInvalidPDU); } // Tests that an "execute write request" without any prepared writes returns // success without writing to any attributes. TEST_F(ServerTest, ExecuteWriteQueueEmpty) { // clang-format off const StaticByteBuffer kExecute( 0x18, // opcode: execute write request 0x01 // flag: "write pending" ); const StaticByteBuffer kExecuteResponse( 0x19 // opcode: execute write response ); // clang-format on // |buffer| should contain the partial writes. EXPECT_PACKET_OUT(kExecuteResponse); fake_chan()->Receive(kExecute); } TEST_F(ServerTest, ExecuteWriteSuccess) { StaticByteBuffer buffer('x', 'x', 'x', 'x', 'x', 'x'); auto* grp = db()->NewGrouping(types::kPrimaryService, 1, kTestValue1); auto* attr = grp->AddAttribute( kTestType16, att::AccessRequirements(), AllowedNoSecurity()); attr->set_write_handler([&](const auto& peer_id, att::Handle handle, uint16_t offset, const auto& value, auto result_cb) { EXPECT_EQ(kTestPeerId, peer_id); EXPECT_EQ(attr->handle(), handle); // Write the contents into |buffer|. buffer.Write(value, offset); result_cb(fit::ok()); }); grp->set_active(true); // Prepare two partial writes of the string "hello!". // clang-format off const StaticByteBuffer kPrepare1( 0x016, // opcode: prepare write request 0x02, 0x00, // handle: 0x0002 0x00, 0x00, // offset: 0 'h', 'e', 'l', 'l' // value: "hell" ); const StaticByteBuffer kPrepareResponse1( 0x017, // opcode: prepare write response 0x02, 0x00, // handle: 0x0002 0x00, 0x00, // offset: 0 'h', 'e', 'l', 'l' // value: "hell" ); const StaticByteBuffer kPrepare2( 0x016, // opcode: prepare write request 0x02, 0x00, // handle: 0x0002 0x04, 0x00, // offset: 4 'o', '!' // value: "o!" ); const StaticByteBuffer kPrepareResponse2( 0x017, // opcode: prepare write response 0x02, 0x00, // handle: 0x0002 0x04, 0x00, // offset: 4 'o', '!' // value: "o!" ); // Add an overlapping write that partial overwrites data from previous // payloads. const StaticByteBuffer kPrepare3( 0x016, // opcode: prepare write request 0x02, 0x00, // handle: 0x0002 0x02, 0x00, // offset: 2 'r', 'p', '?' // value: "rp?" ); const StaticByteBuffer kPrepareResponse3( 0x017, // opcode: prepare write response 0x02, 0x00, // handle: 0x0002 0x02, 0x00, // offset: 2 'r', 'p', '?' // value: "rp?" ); // clang-format on EXPECT_PACKET_OUT(kPrepareResponse1); fake_chan()->Receive(kPrepare1); EXPECT_PACKET_OUT(kPrepareResponse2); fake_chan()->Receive(kPrepare2); EXPECT_PACKET_OUT(kPrepareResponse3); fake_chan()->Receive(kPrepare3); // The writes should not be committed yet. EXPECT_EQ("xxxxxx", buffer.AsString()); // clang-format off const StaticByteBuffer kExecute( 0x18, // opcode: execute write request 0x01 // flag: "write pending" ); const StaticByteBuffer kExecuteResponse( 0x19 // opcode: execute write response ); // clang-format on // |buffer| should contain the partial writes. EXPECT_PACKET_OUT(kExecuteResponse); fake_chan()->Receive(kExecute); EXPECT_EQ("herp?!", buffer.AsString()); } // Tests that the rest of the queue is dropped if a prepared write fails. TEST_F(ServerTest, ExecuteWriteError) { StaticByteBuffer buffer('x', 'x', 'x', 'x', 'x', 'x'); auto* grp = db()->NewGrouping(types::kPrimaryService, 1, kTestValue1); auto* attr = grp->AddAttribute( kTestType16, att::AccessRequirements(), AllowedNoSecurity()); attr->set_write_handler([&](const auto& peer_id, att::Handle handle, uint16_t offset, const auto& value, auto result_cb) { EXPECT_EQ(kTestPeerId, peer_id); EXPECT_EQ(attr->handle(), handle); // Make the write to non-zero offsets fail (this corresponds to the second // partial write we prepare below. if (offset) { result_cb(fit::error(att::ErrorCode::kUnlikelyError)); } else { buffer.Write(value); result_cb(fit::ok()); } }); grp->set_active(true); // Prepare two partial writes of the string "hello!". // clang-format off const StaticByteBuffer kPrepare1( 0x016, // opcode: prepare write request 0x02, 0x00, // handle: 0x0002 0x00, 0x00, // offset: 0 'h', 'e', 'l', 'l' // value: "hell" ); const StaticByteBuffer kPrepareResponse1( 0x017, // opcode: prepare write response 0x02, 0x00, // handle: 0x0002 0x00, 0x00, // offset: 0 'h', 'e', 'l', 'l' // value: "hell" ); const StaticByteBuffer kPrepare2( 0x016, // opcode: prepare write request 0x02, 0x00, // handle: 0x0002 0x04, 0x00, // offset: 4 'o', '!' // value: "o!" ); const StaticByteBuffer kPrepareResponse2( 0x017, // opcode: prepare write response 0x02, 0x00, // handle: 0x0002 0x04, 0x00, // offset: 4 'o', '!' // value: "o!" ); // clang-format on EXPECT_PACKET_OUT(kPrepareResponse1); fake_chan()->Receive(kPrepare1); EXPECT_PACKET_OUT(kPrepareResponse2); fake_chan()->Receive(kPrepare2); // The writes should not be committed yet. EXPECT_EQ("xxxxxx", buffer.AsString()); // clang-format off const StaticByteBuffer kExecute( 0x18, // opcode: execute write request 0x01 // flag: "write pending" ); const StaticByteBuffer kExecuteResponse( 0x01, // opcode: error response 0x18, // request: execute write request 0x02, 0x00, // handle: 2 (the attribute in error) 0x0E // error: Unlikely Error (returned by callback above). ); // clang-format on // Only the first partial write should have gone through as the second one // is expected to fail. EXPECT_PACKET_OUT(kExecuteResponse); fake_chan()->Receive(kExecute); EXPECT_EQ("hellxx", buffer.AsString()); } TEST_F(ServerTest, ExecuteWriteAbort) { auto* grp = db()->NewGrouping(types::kPrimaryService, 1, kTestValue1); // |attr| has handle "2". auto* attr = grp->AddAttribute( kTestType16, att::AccessRequirements(), AllowedNoSecurity()); int write_count = 0; attr->set_write_handler([&](const auto& peer_id, att::Handle handle, uint16_t offset, const auto& value, auto result_cb) { write_count++; EXPECT_EQ(kTestPeerId, peer_id); EXPECT_EQ(attr->handle(), handle); EXPECT_EQ(0u, offset); EXPECT_TRUE(ContainersEqual(StaticByteBuffer('l', 'o', 'l'), value)); result_cb(fit::ok()); }); grp->set_active(true); // clang-format off const StaticByteBuffer kPrepareToAbort( 0x016, // opcode: prepare write request 0x02, 0x00, // handle: 0x0002 0x00, 0x00, // offset: 0 't', 'e', 's', 't' // value: "test" ); const StaticByteBuffer kPrepareToAbortResponse( 0x017, // opcode: prepare write response 0x02, 0x00, // handle: 0x0002 0x00, 0x00, // offset: 0 't', 'e', 's', 't' // value: "test" ); // clang-format on // Prepare writes. These should get committed right away. EXPECT_PACKET_OUT(kPrepareToAbortResponse); fake_chan()->Receive(kPrepareToAbort); EXPECT_PACKET_OUT(kPrepareToAbortResponse); fake_chan()->Receive(kPrepareToAbort); EXPECT_PACKET_OUT(kPrepareToAbortResponse); fake_chan()->Receive(kPrepareToAbort); EXPECT_PACKET_OUT(kPrepareToAbortResponse); fake_chan()->Receive(kPrepareToAbort); EXPECT_TRUE(AllExpectedPacketsSent()); EXPECT_EQ(0, write_count); // Abort the writes. They should get dropped. // clang-format off const StaticByteBuffer kAbort( 0x18, // opcode: execute write request 0x00 // flag: "cancel all" ); const StaticByteBuffer kAbortResponse( 0x19 // opcode: execute write response ); // clang-format on EXPECT_PACKET_OUT(kAbortResponse); fake_chan()->Receive(kAbort); EXPECT_EQ(0, write_count); // Prepare and commit a new write request. This one should take effect without // involving the previously aborted writes. // clang-format off const StaticByteBuffer kPrepareToCommit( 0x016, // opcode: prepare write request 0x02, 0x00, // handle: 0x0002 0x00, 0x00, // offset: 0 'l', 'o', 'l' // value: "lol" ); const StaticByteBuffer kPrepareToCommitResponse( 0x017, // opcode: prepare write response 0x02, 0x00, // handle: 0x0002 0x00, 0x00, // offset: 0 'l', 'o', 'l' // value: "lol" ); const StaticByteBuffer kCommit( 0x18, // opcode: execute write request 0x01 // flag: "write pending" ); const StaticByteBuffer kCommitResponse( 0x19 // opcode: execute write response ); // clang-format on EXPECT_PACKET_OUT(kPrepareToCommitResponse); fake_chan()->Receive(kPrepareToCommit); EXPECT_PACKET_OUT(kCommitResponse); fake_chan()->Receive(kCommit); EXPECT_EQ(1, write_count); } TEST_F(ServerTest, TrySendNotificationNoCccConfig) { IdType svc_id = RegisterSvcWithSingleChrc(kTestSvcType, kTestChrcId, kTestChrcType); const BufferView kTestValue; server()->SendUpdate( svc_id, kTestChrcId, kTestValue, /*indicate_cb=*/nullptr); } TEST_F(ServerTest, TrySendNotificationConfiguredForIndicationsOnly) { SvcIdAndChrcHandle registered = RegisterSvcWithConfiguredChrc( kTestSvcType, kTestChrcId, kTestChrcType, kCCCIndicationBit); const BufferView kTestValue; server()->SendUpdate( registered.svc_id, kTestChrcId, kTestValue, /*indicate_cb=*/nullptr); } TEST_F(ServerTest, SendNotificationEmpty) { SvcIdAndChrcHandle registered = RegisterSvcWithConfiguredChrc(kTestSvcType, kTestChrcId, kTestChrcType); const BufferView kTestValue; // clang-format off const StaticByteBuffer kExpected{ att::kNotification, // Opcode // Handle of the characteristic value being notified LowerBits(registered.chrc_val_handle), UpperBits(registered.chrc_val_handle) }; // clang-format on EXPECT_PACKET_OUT(kExpected); server()->SendUpdate( registered.svc_id, kTestChrcId, kTestValue, /*indicate_cb=*/nullptr); } TEST_F(ServerTest, SendNotification) { SvcIdAndChrcHandle registered = RegisterSvcWithConfiguredChrc(kTestSvcType, kTestChrcId, kTestChrcType); const StaticByteBuffer kTestValue('f', 'o', 'o'); // clang-format off const StaticByteBuffer kExpected{ att::kNotification, // Opcode // Handle of the characteristic value being notified LowerBits(registered.chrc_val_handle), UpperBits(registered.chrc_val_handle), kTestValue[0], kTestValue[1], kTestValue[2] }; // clang-format on EXPECT_PACKET_OUT(kExpected); server()->SendUpdate(registered.svc_id, kTestChrcId, kTestValue.view(), /*indicate_cb=*/nullptr); } TEST_F(ServerTest, TrySendIndicationNoCccConfig) { IdType svc_id = RegisterSvcWithSingleChrc(kTestSvcType, kTestChrcId, kTestChrcType); const BufferView kTestValue; att::Result<> indicate_res = fit::ok(); auto indicate_cb = [&](att::Result<> res) { indicate_res = res; }; server()->SendUpdate(svc_id, kTestChrcId, kTestValue, std::move(indicate_cb)); EXPECT_EQ(fit::failed(), indicate_res); } TEST_F(ServerTest, TrySendIndicationConfiguredForNotificationsOnly) { SvcIdAndChrcHandle registered = RegisterSvcWithConfiguredChrc( kTestSvcType, kTestChrcId, kTestChrcType, kCCCNotificationBit); const BufferView kTestValue; att::Result<> indicate_res = fit::ok(); auto indicate_cb = [&](att::Result<> res) { indicate_res = res; }; server()->SendUpdate( registered.svc_id, kTestChrcId, kTestValue, std::move(indicate_cb)); EXPECT_EQ(fit::failed(), indicate_res); } TEST_F(ServerTest, SendIndicationEmpty) { SvcIdAndChrcHandle registered = RegisterSvcWithConfiguredChrc(kTestSvcType, kTestChrcId, kTestChrcType); const BufferView kTestValue; att::Result<> indicate_res = ToResult(HostError::kFailed); auto indicate_cb = [&](att::Result<> res) { indicate_res = res; }; // clang-format off const StaticByteBuffer kExpected{ att::kIndication, // Opcode // Handle of the characteristic value being notified LowerBits(registered.chrc_val_handle), UpperBits(registered.chrc_val_handle) }; // clang-format on EXPECT_PACKET_OUT(kExpected); server()->SendUpdate( registered.svc_id, kTestChrcId, kTestValue, std::move(indicate_cb)); EXPECT_TRUE(AllExpectedPacketsSent()); const StaticByteBuffer kIndicationConfirmation{att::kConfirmation}; fake_chan()->Receive(kIndicationConfirmation); EXPECT_EQ(fit::ok(), indicate_res); } TEST_F(ServerTest, SendIndication) { SvcIdAndChrcHandle registered = RegisterSvcWithConfiguredChrc(kTestSvcType, kTestChrcId, kTestChrcType); const StaticByteBuffer kTestValue('f', 'o', 'o'); att::Result<> indicate_res = ToResult(HostError::kFailed); auto indicate_cb = [&](att::Result<> res) { indicate_res = res; }; // clang-format off const StaticByteBuffer kExpected{ att::kIndication, // Opcode // Handle of the characteristic value being notified LowerBits(registered.chrc_val_handle), UpperBits(registered.chrc_val_handle), kTestValue[0], kTestValue[1], kTestValue[2] }; // clang-format on EXPECT_PACKET_OUT(kExpected); server()->SendUpdate(registered.svc_id, kTestChrcId, kTestValue.view(), std::move(indicate_cb)); EXPECT_TRUE(AllExpectedPacketsSent()); const StaticByteBuffer kIndicationConfirmation{att::kConfirmation}; fake_chan()->Receive(kIndicationConfirmation); EXPECT_EQ(fit::ok(), indicate_res); } class ServerTestSecurity : public ServerTest { protected: void InitializeAttributesForReading() { auto* grp = db()->NewGrouping(types::kPrimaryService, 4, kTestValue1); const att::AccessRequirements encryption(/*encryption=*/true, /*authentication=*/false, /*authorization=*/false); const att::AccessRequirements authentication(/*encryption=*/false, /*authentication=*/true, /*authorization=*/false); const att::AccessRequirements authorization(/*encryption=*/false, /*authentication=*/false, /*authorization=*/true); not_permitted_attr_ = grp->AddAttribute(kTestType16); encryption_required_attr_ = grp->AddAttribute(kTestType16, encryption); authentication_required_attr_ = grp->AddAttribute(kTestType16, authentication); authorization_required_attr_ = grp->AddAttribute(kTestType16, authorization); // Assigns all tests attributes a static value. Intended to be used by read // requests. (Note: assigning a static value makes an attribute // non-writable). All attributes are assigned kTestValue1 as their static // value. not_permitted_attr_->SetValue(kTestValue1); encryption_required_attr_->SetValue(kTestValue1); authentication_required_attr_->SetValue(kTestValue1); authorization_required_attr_->SetValue(kTestValue1); grp->set_active(true); } void InitializeAttributesForWriting() { auto* grp = db()->NewGrouping(types::kPrimaryService, 4, kTestValue1); const att::AccessRequirements encryption(/*encryption=*/true, /*authentication=*/false, /*authorization=*/false); const att::AccessRequirements authentication(/*encryption=*/false, /*authentication=*/true, /*authorization=*/false); const att::AccessRequirements authorization(/*encryption=*/false, /*authentication=*/false, /*authorization=*/true); auto write_handler = [this](const auto&, att::Handle, uint16_t, const auto& value, auto responder) { write_count_++; if (responder) { responder(fit::ok()); } }; not_permitted_attr_ = grp->AddAttribute(kTestType16); not_permitted_attr_->set_write_handler(write_handler); encryption_required_attr_ = grp->AddAttribute(kTestType16, att::AccessRequirements(), encryption); encryption_required_attr_->set_write_handler(write_handler); authentication_required_attr_ = grp->AddAttribute( kTestType16, att::AccessRequirements(), authentication); authentication_required_attr_->set_write_handler(write_handler); authorization_required_attr_ = grp->AddAttribute( kTestType16, att::AccessRequirements(), authorization); authorization_required_attr_->set_write_handler(write_handler); grp->set_active(true); } auto MakeAttError(att::OpCode request, att::Handle handle, att::ErrorCode ecode) { return StaticByteBuffer(0x01, // opcode: error response request, // request opcode LowerBits(handle), UpperBits(handle), // handle ecode // error code ); } // Helpers for emulating the receipt of an ATT read/write request PDU and // expecting back a security error. Expects a successful response if // |expected_status| is fit::ok(). bool EmulateReadByTypeRequest(att::Handle handle, fit::result expected_status) { const StaticByteBuffer kReadByTypeRequestPdu( 0x08, // opcode: read by type LowerBits(handle), UpperBits(handle), // start handle LowerBits(handle), UpperBits(handle), // end handle 0xEF, 0xBE); // type: 0xBEEF, i.e. kTestType16 if (expected_status.is_ok()) { EXPECT_PACKET_OUT(StaticByteBuffer(0x09, // opcode: read by type response 0x05, // length: 5 (strlen("foo") + 2) LowerBits(handle), UpperBits(handle), // handle 'f', 'o', 'o' // value: "foo", i.e. kTestValue1 )); } else { EXPECT_PACKET_OUT( MakeAttError(0x08, handle, expected_status.error_value())); } fake_chan()->Receive(kReadByTypeRequestPdu); return AllExpectedPacketsSent(); } bool EmulateReadBlobRequest(att::Handle handle, fit::result expected_status) { const StaticByteBuffer kReadBlobRequestPdu(0x0C, // opcode: read blob LowerBits(handle), UpperBits(handle), // handle 0x00, 0x00); // offset: 0 if (expected_status.is_ok()) { EXPECT_PACKET_OUT(StaticByteBuffer(0x0D, // opcode: read blob response 'f', 'o', 'o' // value: "foo", i.e. kTestValue1 )); } else { EXPECT_PACKET_OUT( MakeAttError(0x0C, handle, expected_status.error_value())); } fake_chan()->Receive(kReadBlobRequestPdu); return AllExpectedPacketsSent(); } bool EmulateReadRequest(att::Handle handle, fit::result expected_status) { const StaticByteBuffer kReadRequestPdu(0x0A, // opcode: read request LowerBits(handle), UpperBits(handle)); // handle if (expected_status.is_ok()) { EXPECT_PACKET_OUT(StaticByteBuffer(0x0B, // opcode: read response 'f', 'o', 'o' // value: "foo", i.e. kTestValue1 )); } else { EXPECT_PACKET_OUT( MakeAttError(0x0A, handle, expected_status.error_value())); } fake_chan()->Receive(kReadRequestPdu); return AllExpectedPacketsSent(); } bool EmulateWriteRequest(att::Handle handle, fit::result expected_status) { const StaticByteBuffer kWriteRequestPdu(0x12, // opcode: write request LowerBits(handle), UpperBits(handle), // handle 't', 'e', 's', 't'); // value: "test" if (expected_status.is_ok()) { EXPECT_PACKET_OUT(StaticByteBuffer(0x13)); } else { EXPECT_PACKET_OUT( MakeAttError(0x12, handle, expected_status.error_value())); } fake_chan()->Receive(kWriteRequestPdu); return AllExpectedPacketsSent(); } bool EmulatePrepareWriteRequest(att::Handle handle, fit::result expected_status) { const auto kPrepareWriteRequestPdu = StaticByteBuffer(0x16, // opcode: prepare write request LowerBits(handle), UpperBits(handle), // handle 0x00, 0x00, // offset: 0 't', 'e', 's', 't' // value: "test" ); if (expected_status.is_ok()) { EXPECT_PACKET_OUT(StaticByteBuffer(0x17, // prepare write response LowerBits(handle), UpperBits(handle), // handle 0x00, 0x00, // offset: 0 't', 'e', 's', 't' // value: "test" )); } else { EXPECT_PACKET_OUT( MakeAttError(0x16, handle, expected_status.error_value())); } fake_chan()->Receive(kPrepareWriteRequestPdu); return AllExpectedPacketsSent(); } // Emulates the receipt of a Write Command. The expected error code parameter // is unused since ATT commands do not have a response. bool EmulateWriteCommand(att::Handle handle, fit::result) { fake_chan()->Receive(StaticByteBuffer(0x52, // opcode: write command LowerBits(handle), UpperBits(handle), // handle 't', 'e', 's', 't' // value: "test" )); RunUntilIdle(); return true; } template ), bool IsWrite> void RunTest() { const fit::error kNotPermittedError = fit::error(IsWrite ? att::ErrorCode::kWriteNotPermitted : att::ErrorCode::kReadNotPermitted); // No security. EXPECT_TRUE((this->*EmulateMethod)(not_permitted_attr()->handle(), fit::error(kNotPermittedError))); EXPECT_TRUE((this->*EmulateMethod)( encryption_required_attr()->handle(), fit::error(att::ErrorCode::kInsufficientAuthentication))); EXPECT_TRUE((this->*EmulateMethod)( authentication_required_attr()->handle(), fit::error(att::ErrorCode::kInsufficientAuthentication))); EXPECT_TRUE((this->*EmulateMethod)( authorization_required_attr()->handle(), fit::error(att::ErrorCode::kInsufficientAuthentication))); // Link encrypted. fake_chan()->set_security(sm::SecurityProperties( sm::SecurityLevel::kEncrypted, 16, /*secure_connections=*/false)); EXPECT_TRUE((this->*EmulateMethod)(not_permitted_attr()->handle(), kNotPermittedError)); EXPECT_TRUE((this->*EmulateMethod)(encryption_required_attr()->handle(), fit::ok())); EXPECT_TRUE((this->*EmulateMethod)( authentication_required_attr()->handle(), fit::error(att::ErrorCode::kInsufficientAuthentication))); EXPECT_TRUE((this->*EmulateMethod)( authorization_required_attr()->handle(), fit::error(att::ErrorCode::kInsufficientAuthentication))); // inclusive-language: ignore // Link encrypted w/ MITM. fake_chan()->set_security( sm::SecurityProperties(sm::SecurityLevel::kAuthenticated, 16, /*secure_connections=*/false)); EXPECT_TRUE((this->*EmulateMethod)(not_permitted_attr()->handle(), kNotPermittedError)); EXPECT_TRUE((this->*EmulateMethod)(encryption_required_attr()->handle(), fit::ok())); EXPECT_TRUE((this->*EmulateMethod)(authentication_required_attr()->handle(), fit::ok())); EXPECT_TRUE((this->*EmulateMethod)(authorization_required_attr()->handle(), fit::ok())); } void RunReadByTypeTest() { RunTest<&ServerTestSecurity::EmulateReadByTypeRequest, false>(); } void RunReadBlobTest() { RunTest<&ServerTestSecurity::EmulateReadBlobRequest, false>(); } void RunReadRequestTest() { RunTest<&ServerTestSecurity::EmulateReadRequest, false>(); } void RunWriteRequestTest() { RunTest<&ServerTestSecurity::EmulateWriteRequest, true>(); } void RunPrepareWriteRequestTest() { RunTest<&ServerTestSecurity::EmulatePrepareWriteRequest, true>(); } void RunWriteCommandTest() { RunTest<&ServerTestSecurity::EmulateWriteCommand, true>(); } const att::Attribute* not_permitted_attr() const { return not_permitted_attr_; } const att::Attribute* encryption_required_attr() const { return encryption_required_attr_; } const att::Attribute* authentication_required_attr() const { return authentication_required_attr_; } const att::Attribute* authorization_required_attr() const { return authorization_required_attr_; } size_t write_count() const { return write_count_; } private: att::Attribute* not_permitted_attr_ = nullptr; att::Attribute* encryption_required_attr_ = nullptr; att::Attribute* authentication_required_attr_ = nullptr; att::Attribute* authorization_required_attr_ = nullptr; size_t write_count_ = 0u; }; // Tests receiving a Read By Type error under 3 possible link security levels. TEST_F(ServerTestSecurity, ReadByTypeErrorSecurity) { InitializeAttributesForReading(); RunReadByTypeTest(); } TEST_F(ServerTestSecurity, ReadBlobErrorSecurity) { InitializeAttributesForReading(); RunReadBlobTest(); } TEST_F(ServerTestSecurity, ReadErrorSecurity) { InitializeAttributesForReading(); RunReadRequestTest(); } TEST_F(ServerTestSecurity, WriteErrorSecurity) { InitializeAttributesForWriting(); RunWriteRequestTest(); // Only 4 writes should have gone through. EXPECT_EQ(4u, write_count()); } TEST_F(ServerTestSecurity, WriteCommandErrorSecurity) { InitializeAttributesForWriting(); RunWriteCommandTest(); // Only 4 writes should have gone through. EXPECT_EQ(4u, write_count()); } TEST_F(ServerTestSecurity, PrepareWriteRequestSecurity) { InitializeAttributesForWriting(); RunPrepareWriteRequestTest(); // None of the write handlers should have been called since no execute write // request has been sent. EXPECT_EQ(0u, write_count()); } } // namespace } // namespace bt::gatt