| // Copyright 2017 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "recombiner.h" |
| #include "pdu.h" |
| |
| #include "gtest/gtest.h" |
| |
| #include "garnet/drivers/bluetooth/lib/hci/hci.h" |
| #include "garnet/drivers/bluetooth/lib/hci/packet.h" |
| |
| namespace btlib { |
| namespace l2cap { |
| namespace { |
| |
| template <typename... T> |
| hci::ACLDataPacketPtr PacketFromBytes(T... data) { |
| auto bytes = common::CreateStaticByteBuffer(std::forward<T>(data)...); |
| ZX_DEBUG_ASSERT(bytes.size() >= sizeof(hci::ACLDataHeader)); |
| |
| auto packet = |
| hci::ACLDataPacket::New(bytes.size() - sizeof(hci::ACLDataHeader)); |
| packet->mutable_view()->mutable_data().Write(bytes); |
| packet->InitializeFromBuffer(); |
| |
| return packet; |
| } |
| |
| TEST(L2CAP_RecombinerTest, BadFirstFragment) { |
| Recombiner recombiner; |
| PDU pdu; |
| EXPECT_FALSE(pdu.is_valid()); |
| |
| EXPECT_FALSE(recombiner.ready()); |
| EXPECT_TRUE(recombiner.empty()); |
| EXPECT_FALSE(recombiner.Release(&pdu)); |
| |
| // clang-format off |
| |
| // Too small (no basic L2CAP header) |
| auto packet0 = PacketFromBytes( |
| // ACL data header |
| 0x01, 0x00, 0x03, 0x00, |
| |
| // Incomplete basic L2CAP header (one byte short) |
| 0x00, 0x00, 0x03 |
| ); |
| |
| // Too large |
| auto packet1 = PacketFromBytes( |
| // ACL data header |
| 0x01, 0x00, 0x06, 0x00, |
| |
| // PDU length (2 bytes) is larger than reported length (1 byte) |
| 0x01, 0x00, 0xFF, 0xFF, 0x00, 0x00 |
| ); |
| |
| // Continuation fragment |
| auto packet2 = PacketFromBytes( |
| // ACL data header (PBF: continuing fragment) |
| 0x01, 0x10, 0x05, 0x00, |
| |
| // L2CAP header + PDU |
| 0x01, 0x00, 0xFF, 0xFF, 0x00 |
| ); |
| |
| // clang-format on |
| |
| EXPECT_FALSE(recombiner.AddFragment(std::move(packet0))); |
| EXPECT_FALSE(recombiner.AddFragment(std::move(packet1))); |
| EXPECT_FALSE(recombiner.AddFragment(std::move(packet2))); |
| |
| // None of the packets should have been moved. |
| EXPECT_TRUE(packet0); |
| EXPECT_TRUE(packet1); |
| EXPECT_TRUE(packet2); |
| |
| EXPECT_FALSE(recombiner.ready()); |
| EXPECT_TRUE(recombiner.empty()); |
| EXPECT_FALSE(recombiner.Release(&pdu)); |
| } |
| |
| TEST(L2CAP_RecombinerTest, CompleteFirstFragmentEmptyPDU) { |
| Recombiner recombiner; |
| |
| // clang-format off |
| |
| // Zero-length PDU |
| auto packet0 = PacketFromBytes( |
| // ACL data header |
| 0x01, 0x00, 0x04, 0x00, |
| |
| // Basic L2CAP header |
| 0x00, 0x00, 0xFF, 0xFF |
| ); |
| |
| // Continuation fragment |
| auto packet1 = PacketFromBytes( |
| // ACL data header (PBF: continuing fragment) |
| 0x01, 0x10, 0x05, 0x00, |
| |
| // L2CAP header + PDU |
| 0x01, 0x00, 0xFF, 0xFF, 0x00 |
| ); |
| |
| // clang-format on |
| |
| EXPECT_TRUE(recombiner.AddFragment(std::move(packet0))); |
| |
| // |packet0| should have moved. |
| EXPECT_FALSE(packet0); |
| |
| EXPECT_FALSE(recombiner.empty()); |
| EXPECT_TRUE(recombiner.ready()); |
| |
| // Adding a continuation fragment should fail as the PDU is complete. |
| EXPECT_FALSE(recombiner.AddFragment(std::move(packet1))); |
| EXPECT_TRUE(packet1); |
| |
| PDU pdu; |
| EXPECT_TRUE(recombiner.Release(&pdu)); |
| EXPECT_TRUE(pdu.is_valid()); |
| EXPECT_EQ(0u, pdu.length()); |
| EXPECT_EQ(0xFFFF, pdu.channel_id()); |
| |
| EXPECT_FALSE(recombiner.ready()); |
| EXPECT_TRUE(recombiner.empty()); |
| EXPECT_FALSE(recombiner.Release(&pdu)); |
| |
| // PDU should remain unmodified. |
| EXPECT_TRUE(pdu.is_valid()); |
| EXPECT_EQ(0u, pdu.length()); |
| EXPECT_EQ(0xFFFF, pdu.channel_id()); |
| } |
| |
| TEST(L2CAP_RecombinerTest, CompleteFirstFragment) { |
| Recombiner recombiner; |
| |
| // clang-format off |
| |
| // Non-empty PDU |
| auto packet0 = PacketFromBytes( |
| // ACL data header |
| 0x01, 0x00, 0x08, 0x00, |
| |
| // Basic L2CAP header |
| 0x04, 0x00, 0xFF, 0xFF, 'T', 'e', 's', 't' |
| ); |
| |
| // Continuation fragment |
| auto packet1 = PacketFromBytes( |
| // ACL data header (PBF: continuing fragment) |
| 0x01, 0x10, 0x05, 0x00, |
| |
| // L2CAP header + PDU |
| 0x01, 0x00, 0xFF, 0xFF, 0x00 |
| ); |
| |
| // clang-format on |
| |
| EXPECT_TRUE(recombiner.AddFragment(std::move(packet0))); |
| |
| // |packet0| should have moved. |
| EXPECT_FALSE(packet0); |
| |
| EXPECT_FALSE(recombiner.empty()); |
| EXPECT_TRUE(recombiner.ready()); |
| |
| // Adding a continuation fragment should fail as the PDU is complete. |
| EXPECT_FALSE(recombiner.AddFragment(std::move(packet1))); |
| EXPECT_TRUE(packet1); |
| |
| PDU pdu; |
| EXPECT_TRUE(recombiner.Release(&pdu)); |
| EXPECT_TRUE(pdu.is_valid()); |
| EXPECT_EQ(0xFFFF, pdu.channel_id()); |
| |
| ASSERT_EQ(4u, pdu.length()); |
| |
| common::StaticByteBuffer<4> pdu_data; |
| pdu.Copy(&pdu_data); |
| EXPECT_EQ("Test", pdu_data.AsString()); |
| |
| EXPECT_FALSE(recombiner.ready()); |
| EXPECT_TRUE(recombiner.empty()); |
| EXPECT_FALSE(recombiner.Release(&pdu)); |
| } |
| |
| TEST(L2CAP_RecombinerTest, BadContinuationFragment) { |
| Recombiner recombiner; |
| |
| // clang-format off |
| |
| // Partial initial fragment |
| auto packet0 = PacketFromBytes( |
| // ACL data header (total size is 4, packet contains 1) |
| 0x01, 0x00, 0x05, 0x00, |
| |
| // Basic L2CAP header |
| 0x04, 0x00, 0xFF, 0xFF, 'T' |
| ); |
| |
| // Beginning fragment (instead of continuation). |
| auto packet1 = PacketFromBytes( |
| // ACL data header (PBF: first non-flushable) |
| 0x01, 0x00, 0x03, 0x00, |
| |
| // L2CAP PDU fragment |
| 'e', 's', 't' |
| ); |
| |
| // Continuation fragment too long |
| auto packet2 = PacketFromBytes( |
| // ACL data header (PBF: continuing fragment) |
| 0x01, 0x10, 0x04, 0x00, |
| |
| // L2CAP PDU fragment |
| 'e', 's', 't', '!' |
| ); |
| |
| // clang-format on |
| |
| EXPECT_TRUE(recombiner.AddFragment(std::move(packet0))); |
| EXPECT_FALSE(packet0); |
| |
| // recombiner is no longer empty but also not ready yet. |
| EXPECT_FALSE(recombiner.empty()); |
| EXPECT_FALSE(recombiner.ready()); |
| |
| EXPECT_FALSE(recombiner.AddFragment(std::move(packet1))); |
| EXPECT_FALSE(recombiner.AddFragment(std::move(packet2))); |
| EXPECT_TRUE(packet1); |
| EXPECT_TRUE(packet2); |
| |
| // recombiner state should not have changed. |
| EXPECT_FALSE(recombiner.empty()); |
| EXPECT_FALSE(recombiner.ready()); |
| } |
| |
| TEST(L2CAP_RecombinerTest, CompleteContinuationFragment) { |
| Recombiner recombiner; |
| |
| // clang-format off |
| |
| // Partial initial fragment |
| auto packet0 = PacketFromBytes( |
| // ACL data header (total size is 4, packet contains 1) |
| 0x01, 0x00, 0x05, 0x00, |
| |
| // Basic L2CAP header |
| 0x04, 0x00, 0xFF, 0xFF, 'T' |
| ); |
| |
| // Continuation fragment |
| auto packet1 = PacketFromBytes( |
| // ACL data header (PBF: continuing fragment) |
| 0x01, 0x10, 0x03, 0x00, |
| |
| // L2CAP PDU fragment |
| 'e', 's', 't' |
| ); |
| |
| // clang-format on |
| |
| EXPECT_TRUE(recombiner.AddFragment(std::move(packet0))); |
| EXPECT_FALSE(packet0); |
| |
| // recombiner is no longer empty but also not ready yet. |
| EXPECT_FALSE(recombiner.empty()); |
| EXPECT_FALSE(recombiner.ready()); |
| |
| EXPECT_TRUE(recombiner.AddFragment(std::move(packet1))); |
| EXPECT_FALSE(packet1); |
| |
| // recombiner should be ready. |
| EXPECT_FALSE(recombiner.empty()); |
| EXPECT_TRUE(recombiner.ready()); |
| |
| PDU pdu; |
| EXPECT_TRUE(recombiner.Release(&pdu)); |
| EXPECT_TRUE(pdu.is_valid()); |
| EXPECT_EQ(0xFFFF, pdu.channel_id()); |
| |
| ASSERT_EQ(4u, pdu.length()); |
| |
| common::StaticByteBuffer<4> pdu_data; |
| pdu.Copy(&pdu_data); |
| EXPECT_EQ("Test", pdu_data.AsString()); |
| |
| EXPECT_FALSE(recombiner.ready()); |
| EXPECT_TRUE(recombiner.empty()); |
| EXPECT_FALSE(recombiner.Release(&pdu)); |
| } |
| |
| TEST(L2CAP_RecombinerTest, MultipleContinuationFragments) { |
| Recombiner recombiner; |
| |
| // clang-format off |
| |
| // Partial initial fragment |
| auto packet0 = PacketFromBytes( |
| // ACL data header (total size is 4, packet contains 1) |
| 0x01, 0x00, 0x0A, 0x00, |
| |
| // Basic L2CAP header |
| 0x0F, 0x00, 0xFF, 0xFF, 'T', 'h', 'i', 's', ' ', 'i' |
| ); |
| |
| // Continuation fragment |
| auto packet1 = PacketFromBytes( |
| // ACL data header (PBF: continuing fragment) |
| 0x01, 0x10, 0x06, 0x00, |
| |
| // L2CAP PDU fragment |
| 's', ' ', 'a', ' ', 't', 'e' |
| ); |
| |
| // Continuation fragment |
| auto packet2 = PacketFromBytes( |
| // ACL data header (PBF: continuing fragment) |
| 0x01, 0x10, 0x02, 0x00, |
| |
| // L2CAP PDU fragment |
| 's', 't' |
| ); |
| |
| // Continuation fragment |
| auto packet3 = PacketFromBytes( |
| // ACL data header (PBF: continuing fragment) |
| 0x01, 0x10, 0x01, 0x00, |
| |
| // L2CAP PDU fragment |
| '!' |
| ); |
| |
| // clang-format on |
| |
| EXPECT_TRUE(recombiner.AddFragment(std::move(packet0))); |
| EXPECT_FALSE(packet0); |
| |
| // recombiner is no longer empty but also not ready yet. |
| EXPECT_FALSE(recombiner.empty()); |
| EXPECT_FALSE(recombiner.ready()); |
| |
| EXPECT_TRUE(recombiner.AddFragment(std::move(packet1))); |
| EXPECT_TRUE(recombiner.AddFragment(std::move(packet2))); |
| EXPECT_TRUE(recombiner.AddFragment(std::move(packet3))); |
| EXPECT_FALSE(packet1); |
| EXPECT_FALSE(packet2); |
| EXPECT_FALSE(packet3); |
| |
| // recombiner should be ready. |
| EXPECT_FALSE(recombiner.empty()); |
| EXPECT_TRUE(recombiner.ready()); |
| |
| PDU pdu; |
| EXPECT_TRUE(recombiner.Release(&pdu)); |
| EXPECT_TRUE(pdu.is_valid()); |
| |
| ASSERT_EQ(15u, pdu.length()); |
| |
| common::StaticByteBuffer<15u> pdu_data; |
| pdu.Copy(&pdu_data); |
| EXPECT_EQ("This is a test!", pdu_data.AsString()); |
| |
| EXPECT_FALSE(recombiner.ready()); |
| EXPECT_TRUE(recombiner.empty()); |
| EXPECT_FALSE(recombiner.Release(&pdu)); |
| } |
| |
| TEST(L2CAP_RecombinerTest, Drop) { |
| Recombiner recombiner; |
| |
| // clang-format off |
| |
| // Partial initial fragment |
| auto packet0 = PacketFromBytes( |
| // ACL data header (total size is 4, packet contains 1) |
| 0x01, 0x00, 0x05, 0x00, |
| |
| // Basic L2CAP header |
| 0x04, 0x00, 0xFF, 0xFF, 'T' |
| ); |
| |
| // Continuation fragment |
| auto packet1 = PacketFromBytes( |
| // ACL data header (PBF: continuing fragment) |
| 0x01, 0x10, 0x03, 0x00, |
| |
| // L2CAP PDU fragment |
| 'e', 's', 't' |
| ); |
| |
| // clang-format on |
| |
| EXPECT_TRUE(recombiner.AddFragment(std::move(packet0))); |
| EXPECT_TRUE(recombiner.AddFragment(std::move(packet1))); |
| |
| // recombiner should be ready. |
| EXPECT_FALSE(recombiner.empty()); |
| EXPECT_TRUE(recombiner.ready()); |
| |
| recombiner.Drop(); |
| |
| PDU pdu; |
| EXPECT_FALSE(recombiner.ready()); |
| EXPECT_TRUE(recombiner.empty()); |
| EXPECT_FALSE(recombiner.Release(&pdu)); |
| } |
| |
| TEST(L2CAP_RecombinerTest, DropPartial) { |
| Recombiner recombiner; |
| |
| // clang-format off |
| |
| // Partial initial fragment |
| auto packet0 = PacketFromBytes( |
| // ACL data header (total size is 4, packet contains 1) |
| 0x01, 0x00, 0x05, 0x00, |
| |
| // Basic L2CAP header |
| 0x04, 0x00, 0xFF, 0xFF, 'T' |
| ); |
| |
| // Complete packet |
| auto packet1 = PacketFromBytes( |
| // ACL data header |
| 0x01, 0x00, 0x08, 0x00, |
| |
| // Basic L2CAP header |
| 0x04, 0x00, 0xFF, 0xFF, 'T', 'e', 's', 't' |
| ); |
| |
| // clang-format on |
| |
| // Partially fill packet. |
| EXPECT_TRUE(recombiner.AddFragment(std::move(packet0))); |
| EXPECT_FALSE(recombiner.empty()); |
| EXPECT_FALSE(recombiner.ready()); |
| |
| recombiner.Drop(); |
| EXPECT_TRUE(recombiner.empty()); |
| EXPECT_FALSE(recombiner.ready()); |
| |
| // Build a new PDU. The previous packet should have no effect. |
| EXPECT_TRUE(recombiner.AddFragment(std::move(packet1))); |
| |
| // recombiner should be ready. |
| EXPECT_FALSE(recombiner.empty()); |
| EXPECT_TRUE(recombiner.ready()); |
| |
| PDU pdu; |
| EXPECT_TRUE(recombiner.Release(&pdu)); |
| EXPECT_EQ(4u, pdu.length()); |
| } |
| |
| } // namespace |
| } // namespace l2cap |
| } // namespace btlib |
