| // Copyright 2025 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 <cstdint> |
| |
| #include "pw_bluetooth/att.emb.h" |
| #include "pw_bluetooth/hci_data.emb.h" |
| #include "pw_bluetooth/hci_h4.emb.h" |
| #include "pw_bluetooth/l2cap_frames.emb.h" |
| #include "pw_bluetooth_proxy/h4_packet.h" |
| #include "pw_bluetooth_proxy/l2cap_channel_common.h" |
| #include "pw_bluetooth_proxy/proxy_host.h" |
| #include "pw_bluetooth_proxy_private/test_utils.h" |
| #include "pw_function/function.h" |
| #include "pw_span/span.h" |
| #include "pw_status/status.h" |
| #include "pw_status/try.h" |
| #include "pw_unit_test/framework.h" |
| #include "pw_unit_test/status_macros.h" |
| |
| namespace pw::bluetooth::proxy { |
| |
| namespace { |
| struct AttNotifyWithStorage { |
| BFrameWithStorage bframe; |
| emboss::AttHandleValueNtfWriter writer; |
| }; |
| |
| Result<AttNotifyWithStorage> SetupAttNotify( |
| uint16_t connection_handle, |
| uint16_t attribute_handle, |
| const pw::span<const uint8_t> attribute_value) { |
| const uint16_t kAttChannelId = 0x0004; |
| const size_t att_size = |
| emboss::AttHandleValueNtf::MinSizeInBytes() + attribute_value.size(); |
| |
| AttNotifyWithStorage frame; |
| PW_TRY_ASSIGN(frame.bframe, |
| SetupBFrame(connection_handle, kAttChannelId, att_size)); |
| |
| EXPECT_EQ(att_size, frame.bframe.writer.payload().SizeInBytes()); |
| PW_TRY_ASSIGN(frame.writer, |
| MakeEmbossWriter<emboss::AttHandleValueNtfWriter>( |
| attribute_value.size(), |
| frame.bframe.writer.payload().BackingStorage().data(), |
| frame.bframe.writer.payload().SizeInBytes())); |
| EXPECT_TRUE(frame.writer.IsComplete()); |
| |
| frame.writer.attribute_opcode().Write( |
| emboss::AttOpcode::ATT_HANDLE_VALUE_NTF); |
| frame.writer.attribute_handle().Write(attribute_handle); |
| |
| EXPECT_TRUE( |
| TryToCopyToEmbossStruct(frame.writer.attribute_value(), attribute_value)); |
| |
| return frame; |
| } |
| |
| class GattNotifyTest : public ProxyHostTest {}; |
| |
| TEST_F(GattNotifyTest, TestSetupAttNotify) { |
| std::array<uint8_t, 1> attribute_value = {0xFA}; |
| PW_TEST_ASSERT_OK_AND_ASSIGN( |
| AttNotifyWithStorage att, |
| SetupAttNotify(0x0ACB, 0x4321, pw::span(attribute_value))); |
| |
| // Built from the preceding values in little endian order. |
| std::array<uint8_t, 13> expected_gatt_notify_packet = {0x02, |
| 0xCB, |
| 0x0A, |
| 0x08, |
| 0x00, |
| 0x04, |
| 0x00, |
| 0x04, |
| 0x00, |
| 0x1B, |
| 0x21, |
| 0x43, |
| 0xFA}; |
| |
| EXPECT_EQ(att.bframe.acl.h4_span().size(), |
| expected_gatt_notify_packet.size()); |
| EXPECT_TRUE(std::equal(att.bframe.acl.h4_span().begin(), |
| att.bframe.acl.h4_span().end(), |
| expected_gatt_notify_packet.begin(), |
| expected_gatt_notify_packet.end())); |
| } |
| |
| TEST_F(GattNotifyTest, GetAttributeHandle) { |
| pw::Function<void(H4PacketWithHci && packet)>&& send_to_host_fn( |
| []([[maybe_unused]] H4PacketWithHci&& packet) {}); |
| |
| pw::Function<void(H4PacketWithH4 && packet)>&& send_to_controller_fn( |
| []([[maybe_unused]] H4PacketWithH4&& packet) {}); |
| |
| ProxyHost proxy = ProxyHost(std::move(send_to_host_fn), |
| std::move(send_to_controller_fn), |
| /*le_acl_credits_to_reserve=*/0, |
| /*br_edr_acl_credits_to_reserve=*/0); |
| |
| GattNotifyChannel channel = |
| BuildGattNotifyChannel(proxy, {.attribute_handle = 0x234}); |
| EXPECT_EQ(channel.attribute_handle(), 0x234); |
| } |
| |
| TEST_F(GattNotifyTest, Send1ByteAttribute) { |
| struct { |
| int sends_called = 0; |
| // First four bits 0x0 encode PB & BC flags |
| uint16_t handle = 0x0ACB; |
| // Length of L2CAP PDU |
| uint16_t acl_data_total_length = 0x0008; |
| // Length of ATT PDU |
| uint16_t pdu_length = 0x0004; |
| // Attribute protocol channel ID (0x0004) |
| uint16_t channel_id = 0x0004; |
| // ATT_HANDLE_VALUE_NTF opcode 0x1B |
| uint8_t attribute_opcode = 0x1B; |
| uint16_t attribute_handle = 0x4321; |
| std::array<uint8_t, 1> attribute_value = {0xFA}; |
| AttNotifyWithStorage att; |
| } capture; |
| |
| PW_TEST_ASSERT_OK_AND_ASSIGN( |
| capture.att, |
| SetupAttNotify(/*connection_handle=*/capture.handle, |
| /*attribute_handle=*/capture.attribute_handle, |
| capture.attribute_value)); |
| |
| pw::Function<void(H4PacketWithHci && packet)>&& send_to_host_fn( |
| []([[maybe_unused]] H4PacketWithHci&& packet) {}); |
| |
| pw::Function<void(H4PacketWithH4 && packet)>&& send_to_controller_fn( |
| [&capture](H4PacketWithH4&& packet) { |
| capture.sends_called++; |
| EXPECT_EQ(packet.GetH4Type(), emboss::H4PacketType::ACL_DATA); |
| EXPECT_EQ(packet.GetH4Span().size(), |
| capture.att.bframe.acl.h4_span().size()); |
| EXPECT_TRUE(std::equal(packet.GetH4Span().begin(), |
| packet.GetH4Span().end(), |
| capture.att.bframe.acl.h4_span().begin(), |
| capture.att.bframe.acl.h4_span().end())); |
| PW_TEST_ASSERT_OK_AND_ASSIGN( |
| auto acl, |
| MakeEmbossView<emboss::AclDataFrameView>(packet.GetHciSpan())); |
| emboss::BFrameView l2cap = |
| emboss::MakeBFrameView(acl.payload().BackingStorage().data(), |
| acl.data_total_length().Read()); |
| emboss::AttHandleValueNtfView gatt_notify = |
| emboss::MakeAttHandleValueNtfView( |
| capture.attribute_value.size(), |
| l2cap.payload().BackingStorage().data(), |
| l2cap.pdu_length().Read()); |
| EXPECT_EQ(acl.header().handle().Read(), capture.handle); |
| EXPECT_EQ(acl.header().packet_boundary_flag().Read(), |
| emboss::AclDataPacketBoundaryFlag::FIRST_NON_FLUSHABLE); |
| EXPECT_EQ(acl.header().broadcast_flag().Read(), |
| emboss::AclDataPacketBroadcastFlag::POINT_TO_POINT); |
| EXPECT_EQ(acl.data_total_length().Read(), |
| capture.acl_data_total_length); |
| EXPECT_EQ(l2cap.pdu_length().Read(), capture.pdu_length); |
| EXPECT_EQ(l2cap.channel_id().Read(), capture.channel_id); |
| EXPECT_EQ(gatt_notify.attribute_opcode().Read(), |
| static_cast<emboss::AttOpcode>(capture.attribute_opcode)); |
| EXPECT_EQ(gatt_notify.attribute_handle().Read(), |
| capture.attribute_handle); |
| EXPECT_EQ(gatt_notify.attribute_value()[0].Read(), |
| capture.attribute_value[0]); |
| }); |
| |
| ProxyHost proxy = ProxyHost(std::move(send_to_host_fn), |
| std::move(send_to_controller_fn), |
| /*le_acl_credits_to_reserve=*/1, |
| /*br_edr_acl_credits_to_reserve=*/0); |
| // Allow proxy to reserve 1 credit. |
| PW_TEST_EXPECT_OK(SendLeReadBufferResponseFromController(proxy, 1)); |
| |
| GattNotifyChannel channel = BuildGattNotifyChannel( |
| proxy, |
| {.handle = capture.handle, .attribute_handle = capture.attribute_handle}); |
| PW_TEST_EXPECT_OK( |
| channel.Write(MultiBufFromArray(capture.attribute_value)).status); |
| EXPECT_EQ(capture.sends_called, 1); |
| } |
| |
| TEST_F(GattNotifyTest, Send2ByteAttribute) { |
| struct { |
| int sends_called = 0; |
| // Max connection_handle value; first four bits 0x0 encode PB & BC flags |
| const uint16_t handle = 0x0EFF; |
| // Length of L2CAP PDU |
| const uint16_t acl_data_total_length = 0x0009; |
| // Length of ATT PDU |
| const uint16_t pdu_length = 0x0005; |
| // Attribute protocol channel ID (0x0004) |
| const uint16_t channel_id = 0x0004; |
| // ATT_HANDLE_VALUE_NTF opcode 0x1B |
| const uint8_t attribute_opcode = 0x1B; |
| const uint16_t attribute_handle = 0x1234; |
| const std::array<uint8_t, 2> attribute_value = {0xAB, 0xCD}; |
| AttNotifyWithStorage att; |
| } capture; |
| |
| PW_TEST_ASSERT_OK_AND_ASSIGN( |
| capture.att, |
| SetupAttNotify(/*connection_handle=*/capture.handle, |
| /*attribute_handle=*/capture.attribute_handle, |
| capture.attribute_value)); |
| |
| pw::Function<void(H4PacketWithHci && packet)>&& send_to_host_fn( |
| []([[maybe_unused]] H4PacketWithHci&& packet) {}); |
| |
| pw::Function<void(H4PacketWithH4 && packet)>&& send_to_controller_fn( |
| [&capture](H4PacketWithH4&& packet) { |
| ++capture.sends_called; |
| EXPECT_EQ(packet.GetH4Type(), emboss::H4PacketType::ACL_DATA); |
| EXPECT_EQ(packet.GetH4Span().size(), |
| capture.att.bframe.acl.h4_span().size()); |
| EXPECT_TRUE(std::equal(packet.GetH4Span().begin(), |
| packet.GetH4Span().end(), |
| capture.att.bframe.acl.h4_span().begin(), |
| capture.att.bframe.acl.h4_span().end())); |
| PW_TEST_ASSERT_OK_AND_ASSIGN( |
| auto acl, |
| MakeEmbossView<emboss::AclDataFrameView>(packet.GetHciSpan())); |
| emboss::BFrameView l2cap = emboss::MakeBFrameView( |
| acl.payload().BackingStorage().data(), acl.SizeInBytes()); |
| emboss::AttHandleValueNtfView gatt_notify = |
| emboss::MakeAttHandleValueNtfView( |
| capture.attribute_value.size(), |
| l2cap.payload().BackingStorage().data(), |
| l2cap.pdu_length().Read()); |
| EXPECT_EQ(acl.header().handle().Read(), capture.handle); |
| EXPECT_EQ(acl.header().packet_boundary_flag().Read(), |
| emboss::AclDataPacketBoundaryFlag::FIRST_NON_FLUSHABLE); |
| EXPECT_EQ(acl.header().broadcast_flag().Read(), |
| emboss::AclDataPacketBroadcastFlag::POINT_TO_POINT); |
| EXPECT_EQ(acl.data_total_length().Read(), |
| capture.acl_data_total_length); |
| EXPECT_EQ(l2cap.pdu_length().Read(), capture.pdu_length); |
| EXPECT_EQ(l2cap.channel_id().Read(), capture.channel_id); |
| EXPECT_EQ(gatt_notify.attribute_opcode().Read(), |
| static_cast<emboss::AttOpcode>(capture.attribute_opcode)); |
| EXPECT_EQ(gatt_notify.attribute_handle().Read(), |
| capture.attribute_handle); |
| EXPECT_EQ(gatt_notify.attribute_value()[0].Read(), |
| capture.attribute_value[0]); |
| EXPECT_EQ(gatt_notify.attribute_value()[1].Read(), |
| capture.attribute_value[1]); |
| }); |
| |
| ProxyHost proxy = ProxyHost(std::move(send_to_host_fn), |
| std::move(send_to_controller_fn), |
| /*le_acl_credits_to_reserve=*/1, |
| /*br_edr_acl_credits_to_reserve=*/0); |
| // Allow proxy to reserve 1 credit. |
| PW_TEST_EXPECT_OK(SendLeReadBufferResponseFromController(proxy, 1)); |
| |
| GattNotifyChannel channel = BuildGattNotifyChannel( |
| proxy, |
| {.handle = capture.handle, .attribute_handle = capture.attribute_handle}); |
| PW_TEST_EXPECT_OK( |
| channel.Write(MultiBufFromArray(capture.attribute_value)).status); |
| EXPECT_EQ(capture.sends_called, 1); |
| } |
| |
| TEST_F(GattNotifyTest, ReturnsErrorIfAttributeTooLarge) { |
| pw::Function<void(H4PacketWithHci && packet)>&& send_to_host_fn( |
| []([[maybe_unused]] H4PacketWithHci&& packet) {}); |
| pw::Function<void(H4PacketWithH4 && packet)> send_to_controller_fn( |
| []([[maybe_unused]] H4PacketWithH4 packet) { FAIL(); }); |
| |
| ProxyHost proxy = ProxyHost(std::move(send_to_host_fn), |
| std::move(send_to_controller_fn), |
| /*le_acl_credits_to_reserve=*/0, |
| /*br_edr_acl_credits_to_reserve=*/0); |
| PW_TEST_EXPECT_OK(SendLeReadBufferResponseFromController(proxy, 0)); |
| |
| // attribute_value 1 byte too large |
| std::array<uint8_t, |
| proxy.GetMaxAclSendSize() - |
| emboss::AclDataFrameHeader::IntrinsicSizeInBytes() - |
| emboss::BasicL2capHeader::IntrinsicSizeInBytes() - |
| emboss::AttHandleValueNtf::MinSizeInBytes() + 1> |
| attribute_value_too_large; |
| GattNotifyChannel channel = BuildGattNotifyChannel(proxy, {}); |
| EXPECT_EQ(channel.Write(MultiBufFromArray(attribute_value_too_large)).status, |
| PW_STATUS_INVALID_ARGUMENT); |
| } |
| |
| TEST_F(GattNotifyTest, ChannelIsNotConstructedIfParametersInvalid) { |
| pw::Function<void(H4PacketWithHci && packet)>&& send_to_host_fn( |
| []([[maybe_unused]] H4PacketWithHci&& packet) {}); |
| pw::Function<void(H4PacketWithH4 && packet)> send_to_controller_fn( |
| []([[maybe_unused]] H4PacketWithH4 packet) { FAIL(); }); |
| |
| ProxyHost proxy = ProxyHost(std::move(send_to_host_fn), |
| std::move(send_to_controller_fn), |
| /*le_acl_credits_to_reserve=*/0, |
| /*br_edr_acl_credits_to_reserve=*/0); |
| |
| // attribute value is zero |
| EXPECT_EQ( |
| BuildGattNotifyChannelWithResult(proxy, {.attribute_handle = 0}).status(), |
| PW_STATUS_INVALID_ARGUMENT); |
| |
| // connection_handle too large |
| EXPECT_EQ( |
| BuildGattNotifyChannelWithResult(proxy, {.handle = 0x0FFF}).status(), |
| PW_STATUS_INVALID_ARGUMENT); |
| } |
| |
| TEST_F(GattNotifyTest, PayloadIsReturnedOnError) { |
| pw::Function<void(H4PacketWithHci && packet)>&& send_to_host_fn( |
| []([[maybe_unused]] H4PacketWithHci&& packet) {}); |
| pw::Function<void(H4PacketWithH4 && packet)> send_to_controller_fn( |
| []([[maybe_unused]] H4PacketWithH4 packet) { FAIL(); }); |
| |
| ProxyHost proxy = ProxyHost(std::move(send_to_host_fn), |
| std::move(send_to_controller_fn), |
| /*le_acl_credits_to_reserve=*/0, |
| /*br_edr_acl_credits_to_reserve=*/0); |
| |
| const std::array<const uint8_t, 2> attribute_value = {5}; |
| |
| GattNotifyChannel channel = BuildGattNotifyChannel(proxy, {}); |
| StatusWithMultiBuf result = |
| channel.Write(MultiBufFromSpan(pw::span{attribute_value})); |
| ASSERT_EQ(result.status, Status::FailedPrecondition()); |
| auto s = result.buf->ContiguousSpan(); |
| ASSERT_TRUE(s.has_value()); |
| EXPECT_EQ(s.value().size(), attribute_value.size()); |
| EXPECT_EQ((std::byte)attribute_value[0], s.value().data()[0]); |
| } |
| |
| } // namespace |
| } // namespace pw::bluetooth::proxy |
