/* * Copyright (c) 2017-2019 Cisco and/or its affiliates. * 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: * * http://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 #include #include #include #include #include #include namespace transport { namespace core { /** * Since packet is an abstract class, we derive a concrete class to be used for * the test. */ class PacketForTest : public Packet { public: template PacketForTest(Args &&... args) : Packet(std::forward(args)...) {} virtual ~PacketForTest() {} const Name &getName() const override { throw errors::NotImplementedException(); } Name &getWritableName() override { throw errors::NotImplementedException(); } void setName(const Name &name) override { throw errors::NotImplementedException(); } void setName(Name &&name) override { throw errors::NotImplementedException(); } void setLifetime(uint32_t lifetime) override { throw errors::NotImplementedException(); } uint32_t getLifetime() const override { throw errors::NotImplementedException(); } void setLocator(const ip_address_t &locator) override { throw errors::NotImplementedException(); } void resetForHash() override { throw errors::NotImplementedException(); } ip_address_t getLocator() const override { throw errors::NotImplementedException(); } }; namespace { // The fixture for testing class Foo. class PacketTest : public ::testing::Test { protected: PacketTest() : name_("b001::123|321"), packet(Packet::COPY_BUFFER, &raw_packets_[HF_INET6_TCP][0], raw_packets_[HF_INET6_TCP].size()) { // You can do set-up work for each test here. } virtual ~PacketTest() { // You can do clean-up work that doesn't throw exceptions here. } // If the constructor and destructor are not enough for setting up // and cleaning up each test, you can define the following methods: virtual void SetUp() { // Code here will be called immediately after the constructor (right // before each test). } virtual void TearDown() { // Code here will be called immediately after each test (right // before the destructor). } Name name_; PacketForTest packet; static std::map> raw_packets_; std::vector payload = { 0x11, 0x11, 0x01, 0x00, 0xb0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xad // , 0x00, 0x00, // 0x00, 0x45, 0xa3, // 0xd1, 0xf2, 0x2b, // 0x94, 0x41, 0x22, // 0xc9, 0x00, 0x00, // 0x00, 0x44, 0xa3, // 0xd1, 0xf2, 0x2b, // 0x94, 0x41, 0x22, // 0xc8 }; }; std::map> PacketTest::raw_packets_ = { {Packet::Format::HF_INET6_TCP, {// IPv6 src=b001::ab:cdab:cdef, dst=b002::ca IPV6_HEADER(TCP_PROTO, 20 + PAYLOAD_SIZE), // TCP src=0x1234 dst=0x4321, seq=0x0001 TCP_HEADER(0x00), // Payload PAYLOAD}}, {Packet::Format::HF_INET_TCP, {// IPv4 src=3.13.127.8, dst=192.168.1.92 IPV4_HEADER(TCP_PROTO, 20 + PAYLOAD_SIZE), // TCP src=0x1234 dst=0x4321, seq=0x0001 TCP_HEADER(0x00), // Other PAYLOAD}}, {Packet::Format::HF_INET_ICMP, {// IPv4 src=3.13.127.8, dst=192.168.1.92 IPV4_HEADER(ICMP_PROTO, 64), // ICMP echo request ICMP_ECHO_REQUEST}}, {Packet::Format::HF_INET6_ICMP, {// IPv6 src=b001::ab:cdab:cdef, dst=b002::ca IPV6_HEADER(ICMP6_PROTO, 60), // ICMP6 echo request ICMP6_ECHO_REQUEST}}, {Packet::Format::HF_INET6_TCP_AH, {// IPv6 src=b001::ab:cdab:cdef, dst=b002::ca IPV6_HEADER(TCP_PROTO, 20 + 44 + 128), // ICMP6 echo request TCP_HEADER(0x18), // hICN AH header AH_HEADER}}, {Packet::Format::HF_INET_TCP_AH, {// IPv6 src=b001::ab:cdab:cdef, dst=b002::ca IPV4_HEADER(TCP_PROTO, 20 + 44 + 128), // ICMP6 echo request TCP_HEADER(0x18), // hICN AH header AH_HEADER}}, // XXX No flag defined in ICMP header to signal AH header. {Packet::Format::HF_INET_ICMP_AH, {// IPv6 src=b001::ab:cdab:cdef, dst=b002::ca IPV4_HEADER(ICMP_PROTO, 64 + 44), // ICMP6 echo request ICMP_ECHO_REQUEST, // hICN AH header AH_HEADER}}, {Packet::Format::HF_INET6_ICMP_AH, {// IPv6 src=b001::ab:cdab:cdef, dst=b002::ca IPV6_HEADER(ICMP6_PROTO, 60 + 44), // ICMP6 echo request ICMP6_ECHO_REQUEST, // hICN AH header AH_HEADER}}, }; void testFormatConstructor(Packet::Format format = HF_UNSPEC) { try { PacketForTest packet(format); } catch (...) { FAIL() << "ERROR: Unexpected exception thrown for " << format; } } void testFormatAndAdditionalHeaderConstructor(Packet::Format format, std::size_t additional_header) { PacketForTest packet(format, additional_header); // Packet length should be the one of the normal header + the // additional_header EXPECT_EQ(packet.headerSize(), Packet::getHeaderSizeFromFormat(format) + additional_header); } void testRawBufferConstructor(std::vector packet, Packet::Format format) { try { // Try to construct packet from correct buffer PacketForTest p(Packet::WRAP_BUFFER, &packet[0], packet.size(), packet.size()); // Check format is expected one. EXPECT_EQ(p.getFormat(), format); // // Try the same using a MemBuf // auto buf = utils::MemBuf::wrapBuffer(&packet[0], packet.size()); // buf->append(packet.size()); // PacketForTest p2(std::move(buf)); // EXPECT_EQ(p2.getFormat(), format); } catch (...) { FAIL() << "ERROR: Unexpected exception thrown"; } try { // Try to construct packet from wrong buffer // Modify next header to 0 /* ipv6 */ packet[6] = 0x00; /* ipv4 */ packet[9] = 0x00; PacketForTest p(Packet::WRAP_BUFFER, &packet[0], packet.size(), packet.size()); // Format should fallback to HF_UNSPEC EXPECT_EQ(p.getFormat(), HF_UNSPEC); } catch (...) { FAIL() << "ERROR: Unexpected exception thrown."; } } void getHeaderSizeFromBuffer(Packet::Format format, std::vector &packet, std::size_t expected) { auto header_size = PacketForTest::getHeaderSizeFromBuffer(format, &packet[0]); EXPECT_EQ(header_size, expected); } void getHeaderSizeFromFormat(Packet::Format format, std::size_t expected) { auto header_size = PacketForTest::getHeaderSizeFromFormat(format); EXPECT_EQ(header_size, expected); } void getPayloadSizeFromBuffer(Packet::Format format, std::vector &packet, std::size_t expected) { auto payload_size = PacketForTest::getPayloadSizeFromBuffer(format, &packet[0]); EXPECT_EQ(payload_size, expected); } void getFormatFromBuffer(Packet::Format expected, std::vector &packet) { auto format = PacketForTest::getFormatFromBuffer(&packet[0], packet.size()); EXPECT_EQ(format, expected); } void getHeaderSize(std::size_t expected, const PacketForTest &packet) { auto size = packet.headerSize(); EXPECT_EQ(size, expected); } void testGetFormat(Packet::Format expected, const Packet &packet) { auto format = packet.getFormat(); EXPECT_EQ(format, expected); } } // namespace TEST_F(PacketTest, ConstructorWithFormat) { testFormatConstructor(Packet::Format::HF_INET_TCP); testFormatConstructor(Packet::Format::HF_INET6_TCP); testFormatConstructor(Packet::Format::HF_INET_ICMP); testFormatConstructor(Packet::Format::HF_INET6_ICMP); testFormatConstructor(Packet::Format::HF_INET_TCP_AH); testFormatConstructor(Packet::Format::HF_INET6_TCP_AH); testFormatConstructor(Packet::Format::HF_INET_ICMP_AH); testFormatConstructor(Packet::Format::HF_INET6_ICMP_AH); } TEST_F(PacketTest, ConstructorWithFormatAndAdditionalHeader) { testFormatAndAdditionalHeaderConstructor(Packet::Format::HF_INET_TCP, 123); testFormatAndAdditionalHeaderConstructor(Packet::Format::HF_INET6_TCP, 360); testFormatAndAdditionalHeaderConstructor(Packet::Format::HF_INET_ICMP, 21); testFormatAndAdditionalHeaderConstructor(Packet::Format::HF_INET6_ICMP, 444); testFormatAndAdditionalHeaderConstructor(Packet::Format::HF_INET_TCP_AH, 555); testFormatAndAdditionalHeaderConstructor(Packet::Format::HF_INET6_TCP_AH, 321); testFormatAndAdditionalHeaderConstructor(Packet::Format::HF_INET_ICMP_AH, 123); testFormatAndAdditionalHeaderConstructor(Packet::Format::HF_INET6_ICMP_AH, 44); } TEST_F(PacketTest, ConstructorWithNew) { auto &_packet = raw_packets_[HF_INET6_TCP]; auto packet_ptr = new PacketForTest(Packet::WRAP_BUFFER, &_packet[0], _packet.size(), _packet.size()); (void)packet_ptr; } TEST_F(PacketTest, ConstructorWithRawBufferInet6Tcp) { auto format = Packet::Format::HF_INET6_TCP; testRawBufferConstructor(raw_packets_[format], format); } TEST_F(PacketTest, ConstructorWithRawBufferInetTcp) { auto format = Packet::Format::HF_INET_TCP; testRawBufferConstructor(raw_packets_[format], format); } TEST_F(PacketTest, ConstructorWithRawBufferInetIcmp) { auto format = Packet::Format::HF_INET_ICMP; testRawBufferConstructor(raw_packets_[format], format); } TEST_F(PacketTest, ConstructorWithRawBufferInet6Icmp) { auto format = Packet::Format::HF_INET6_ICMP; testRawBufferConstructor(raw_packets_[format], format); } TEST_F(PacketTest, ConstructorWithRawBufferInet6TcpAh) { auto format = Packet::Format::HF_INET6_TCP_AH; testRawBufferConstructor(raw_packets_[format], format); } TEST_F(PacketTest, ConstructorWithRawBufferInetTcpAh) { auto format = Packet::Format::HF_INET_TCP_AH; testRawBufferConstructor(raw_packets_[format], format); } TEST_F(PacketTest, MoveConstructor) { PacketForTest p0(Packet::Format::HF_INET6_TCP); PacketForTest p1(std::move(p0)); EXPECT_EQ(p0.getFormat(), Packet::Format::HF_UNSPEC); EXPECT_EQ(p1.getFormat(), Packet::Format::HF_INET6_TCP); } TEST_F(PacketTest, TestGetHeaderSizeFromBuffer) { getHeaderSizeFromBuffer(HF_INET6_TCP, raw_packets_[HF_INET6_TCP], HICN_V6_TCP_HDRLEN); getHeaderSizeFromBuffer(HF_INET_TCP, raw_packets_[HF_INET_TCP], HICN_V4_TCP_HDRLEN); getHeaderSizeFromBuffer(HF_INET6_ICMP, raw_packets_[HF_INET6_ICMP], IPV6_HDRLEN + 4); getHeaderSizeFromBuffer(HF_INET_ICMP, raw_packets_[HF_INET_ICMP], IPV4_HDRLEN + 4); getHeaderSizeFromBuffer(HF_INET6_TCP_AH, raw_packets_[HF_INET6_TCP_AH], HICN_V6_TCP_AH_HDRLEN + 128); getHeaderSizeFromBuffer(HF_INET_TCP_AH, raw_packets_[HF_INET_TCP_AH], HICN_V4_TCP_AH_HDRLEN + 128); } TEST_F(PacketTest, TestGetHeaderSizeFromFormat) { getHeaderSizeFromFormat(HF_INET6_TCP, HICN_V6_TCP_HDRLEN); getHeaderSizeFromFormat(HF_INET_TCP, HICN_V4_TCP_HDRLEN); getHeaderSizeFromFormat(HF_INET6_ICMP, IPV6_HDRLEN + 4); getHeaderSizeFromFormat(HF_INET_ICMP, IPV4_HDRLEN + 4); getHeaderSizeFromFormat(HF_INET6_TCP_AH, HICN_V6_TCP_AH_HDRLEN); getHeaderSizeFromFormat(HF_INET_TCP_AH, HICN_V4_TCP_AH_HDRLEN); } TEST_F(PacketTest, TestGetPayloadSizeFromBuffer) { getPayloadSizeFromBuffer(HF_INET6_TCP, raw_packets_[HF_INET6_TCP], 12); getPayloadSizeFromBuffer(HF_INET_TCP, raw_packets_[HF_INET_TCP], 12); getPayloadSizeFromBuffer(HF_INET6_ICMP, raw_packets_[HF_INET6_ICMP], 56); getPayloadSizeFromBuffer(HF_INET_ICMP, raw_packets_[HF_INET_ICMP], 60); getPayloadSizeFromBuffer(HF_INET6_TCP_AH, raw_packets_[HF_INET6_TCP_AH], 0); getPayloadSizeFromBuffer(HF_INET_TCP_AH, raw_packets_[HF_INET_TCP_AH], 0); } TEST_F(PacketTest, TestIsInterest) { auto ret = PacketForTest::isInterest(&raw_packets_[HF_INET6_TCP][0]); EXPECT_TRUE(ret); } TEST_F(PacketTest, TestGetFormatFromBuffer) { getFormatFromBuffer(HF_INET6_TCP, raw_packets_[HF_INET6_TCP]); getFormatFromBuffer(HF_INET_TCP, raw_packets_[HF_INET_TCP]); getFormatFromBuffer(HF_INET6_ICMP, raw_packets_[HF_INET6_ICMP]); getFormatFromBuffer(HF_INET_ICMP, raw_packets_[HF_INET_ICMP]); getFormatFromBuffer(HF_INET6_TCP_AH, raw_packets_[HF_INET6_TCP_AH]); getFormatFromBuffer(HF_INET_TCP_AH, raw_packets_[HF_INET_TCP_AH]); } // TEST_F(PacketTest, TestReplace) { // PacketForTest packet(Packet::WRAP_BUFFER, &raw_packets_[HF_INET6_TCP][0], // raw_packets_[HF_INET6_TCP].size()); // // Replace current packet with another one // packet.replace(&raw_packets_[HF_INET_TCP][0], // raw_packets_[HF_INET_TCP].size()); // // Check new format // ASSERT_EQ(packet.getFormat(), HF_INET_TCP); // } TEST_F(PacketTest, TestPayloadSize) { // Check payload size of existing packet auto &_packet = raw_packets_[HF_INET6_TCP]; PacketForTest packet(Packet::WRAP_BUFFER, &_packet[0], _packet.size(), _packet.size()); EXPECT_EQ(packet.payloadSize(), std::size_t(PAYLOAD_SIZE)); // Check for dynamic generated packet std::string payload0(1024, 'X'); // Create the packet PacketForTest packet2(HF_INET6_TCP); // Payload size should now be zero EXPECT_EQ(packet2.payloadSize(), std::size_t(0)); // Append payload 1 time packet2.appendPayload((const uint8_t *)payload0.c_str(), payload0.size()); // size should now be 1024 EXPECT_EQ(packet2.payloadSize(), std::size_t(1024)); // Append second payload std::string payload1(1024, 'X'); packet2.appendPayload((const uint8_t *)payload1.c_str(), payload1.size()); // Check size is 2048 EXPECT_EQ(packet2.payloadSize(), std::size_t(2048)); // Append Membuf packet2.appendPayload(utils::MemBuf::copyBuffer( (const uint8_t *)payload1.c_str(), payload1.size())); // Check size is 3072 EXPECT_EQ(packet2.payloadSize(), std::size_t(3072)); } TEST_F(PacketTest, TestHeaderSize) { getHeaderSize(HICN_V6_TCP_HDRLEN, PacketForTest(Packet::Format::HF_INET6_TCP)); getHeaderSize(HICN_V4_TCP_HDRLEN, PacketForTest(Packet::Format::HF_INET_TCP)); getHeaderSize(HICN_V6_ICMP_HDRLEN, PacketForTest(Packet::Format::HF_INET6_ICMP)); getHeaderSize(HICN_V4_ICMP_HDRLEN, PacketForTest(Packet::Format::HF_INET_ICMP)); getHeaderSize(HICN_V6_TCP_AH_HDRLEN, PacketForTest(Packet::Format::HF_INET6_TCP_AH)); getHeaderSize(HICN_V4_TCP_AH_HDRLEN, PacketForTest(Packet::Format::HF_INET_TCP_AH)); } TEST_F(PacketTest, TestMemBufReference) { // Create packet auto &_packet = raw_packets_[HF_INET6_TCP]; // Packet was not created as a shared_ptr. If we try to get a membuf shared // ptr we should get an exception. // TODO test with c++ 17 // try { // PacketForTest packet(&_packet[0], _packet.size()); // auto membuf_ref = packet.acquireMemBufReference(); // FAIL() << "The acquireMemBufReference() call should have throwed an " // "exception!"; // } catch (const std::bad_weak_ptr &e) { // // Ok // } catch (...) { // FAIL() << "Not expected exception."; // } auto packet_ptr = std::make_shared( Packet::WRAP_BUFFER, &_packet[0], _packet.size(), _packet.size()); PacketForTest &packet = *packet_ptr; // Acquire a reference to the membuf auto membuf_ref = packet.acquireMemBufReference(); // Check refcount. It should be 2 EXPECT_EQ(membuf_ref.use_count(), 2); // Now increment membuf references Packet::MemBufPtr membuf = packet.acquireMemBufReference(); // Now reference count should be 2 EXPECT_EQ(membuf_ref.use_count(), 3); // Copy again Packet::MemBufPtr membuf2 = membuf; // Now reference count should be 3 EXPECT_EQ(membuf_ref.use_count(), 4); } TEST_F(PacketTest, TestReset) { // Check everything is ok EXPECT_EQ(packet.getFormat(), HF_INET6_TCP); EXPECT_EQ(packet.length(), raw_packets_[HF_INET6_TCP].size()); EXPECT_EQ(packet.headerSize(), HICN_V6_TCP_HDRLEN); EXPECT_EQ(packet.payloadSize(), packet.length() - packet.headerSize()); // Reset the packet packet.reset(); // Rerun test EXPECT_EQ(packet.getFormat(), HF_UNSPEC); EXPECT_EQ(packet.length(), std::size_t(0)); EXPECT_EQ(packet.headerSize(), std::size_t(0)); EXPECT_EQ(packet.payloadSize(), std::size_t(0)); } TEST_F(PacketTest, TestAppendPayload) { // Append payload with raw buffer uint8_t raw_buffer[2048]; auto original_payload_length = packet.payloadSize(); packet.appendPayload(raw_buffer, 1024); EXPECT_EQ(original_payload_length + 1024, packet.payloadSize()); for (int i = 0; i < 10; i++) { // Append other payload 10 times packet.appendPayload(raw_buffer, 1024); EXPECT_EQ(original_payload_length + 1024 + (1024) * (i + 1), packet.payloadSize()); } // Append payload using membuf packet.appendPayload(utils::MemBuf::copyBuffer(raw_buffer, 2048)); EXPECT_EQ(original_payload_length + 1024 + 1024 * 10 + 2048, packet.payloadSize()); // Check the underlying MemBuf length is the expected one utils::MemBuf *current = &packet; size_t total = 0; do { total += current->length(); current = current->next(); } while (current != &packet); EXPECT_EQ(total, packet.headerSize() + packet.payloadSize()); // LEt's try now to reset this packet packet.reset(); // There should be no more bufferls left in the chain EXPECT_EQ(&packet, packet.next()); EXPECT_EQ(packet.getFormat(), HF_UNSPEC); EXPECT_EQ(packet.length(), std::size_t(0)); EXPECT_EQ(packet.headerSize(), std::size_t(0)); EXPECT_EQ(packet.payloadSize(), std::size_t(0)); } TEST_F(PacketTest, GetPayload) { // Append payload with raw buffer uint8_t raw_buffer[2048]; auto original_payload_length = packet.payloadSize(); packet.appendPayload(raw_buffer, 2048); // Get payload auto payload = packet.getPayload(); // Check payload length is correct utils::MemBuf *current = payload.get(); size_t total = 0; do { total += current->length(); current = current->next(); } while (current != payload.get()); ASSERT_EQ(total, packet.payloadSize()); // Linearize the payload payload->gather(total); // Check memory correspond payload->trimStart(original_payload_length); auto ret = memcmp(raw_buffer, payload->data(), 2048); EXPECT_EQ(ret, 0); } TEST_F(PacketTest, UpdateLength) { auto original_payload_size = packet.payloadSize(); // Add some fake payload without using the API packet.append(200); // payloadSize does not know about the new payload, yet EXPECT_EQ(packet.payloadSize(), original_payload_size); // Let's now update the packet length packet.updateLength(); // Now payloadSize knows EXPECT_EQ(packet.payloadSize(), std::size_t(original_payload_size + 200)); // We may also update the length without adding real content. This is only // written in the packet header. packet.updateLength(128); EXPECT_EQ(packet.payloadSize(), std::size_t(original_payload_size + 200 + 128)); } TEST_F(PacketTest, SetGetPayloadType) { auto payload_type = packet.getPayloadType(); // It should be normal content object by default EXPECT_EQ(payload_type, PayloadType::DATA); // Set it to be manifest packet.setPayloadType(PayloadType::MANIFEST); // Check it is manifest payload_type = packet.getPayloadType(); EXPECT_EQ(payload_type, PayloadType::MANIFEST); } TEST_F(PacketTest, GetFormat) { { PacketForTest p0(Packet::WRAP_BUFFER, &raw_packets_[Packet::Format::HF_INET_TCP][0], raw_packets_[Packet::Format::HF_INET_TCP].size(), raw_packets_[Packet::Format::HF_INET_TCP].size()); testGetFormat(Packet::Format::HF_INET_TCP, p0); PacketForTest p1(Packet::WRAP_BUFFER, &raw_packets_[Packet::Format::HF_INET6_TCP][0], raw_packets_[Packet::Format::HF_INET6_TCP].size(), raw_packets_[Packet::Format::HF_INET6_TCP].size()); testGetFormat(Packet::Format::HF_INET6_TCP, p1); PacketForTest p2(Packet::WRAP_BUFFER, &raw_packets_[Packet::Format::HF_INET_ICMP][0], raw_packets_[Packet::Format::HF_INET_ICMP].size(), raw_packets_[Packet::Format::HF_INET_ICMP].size()); testGetFormat(Packet::Format::HF_INET_ICMP, p2); PacketForTest p3(Packet::WRAP_BUFFER, &raw_packets_[Packet::Format::HF_INET6_ICMP][0], raw_packets_[Packet::Format::HF_INET6_ICMP].size(), raw_packets_[Packet::Format::HF_INET6_ICMP].size()); testGetFormat(Packet::Format::HF_INET6_ICMP, p3); PacketForTest p4(Packet::WRAP_BUFFER, &raw_packets_[Packet::Format::HF_INET_TCP_AH][0], raw_packets_[Packet::Format::HF_INET_TCP_AH].size(), raw_packets_[Packet::Format::HF_INET_TCP_AH].size()); testGetFormat(Packet::Format::HF_INET_TCP_AH, p4); PacketForTest p5(Packet::WRAP_BUFFER, &raw_packets_[Packet::Format::HF_INET6_TCP_AH][0], raw_packets_[Packet::Format::HF_INET6_TCP_AH].size(), raw_packets_[Packet::Format::HF_INET6_TCP_AH].size()); testGetFormat(Packet::Format::HF_INET6_TCP_AH, p5); } // Let's try now creating empty packets { PacketForTest p0(Packet::Format::HF_INET_TCP); testGetFormat(Packet::Format::HF_INET_TCP, p0); PacketForTest p1(Packet::Format::HF_INET6_TCP); testGetFormat(Packet::Format::HF_INET6_TCP, p1); PacketForTest p2(Packet::Format::HF_INET_ICMP); testGetFormat(Packet::Format::HF_INET_ICMP, p2); PacketForTest p3(Packet::Format::HF_INET6_ICMP); testGetFormat(Packet::Format::HF_INET6_ICMP, p3); PacketForTest p4(Packet::Format::HF_INET_TCP_AH); testGetFormat(Packet::Format::HF_INET_TCP_AH, p4); PacketForTest p5(Packet::Format::HF_INET6_TCP_AH); testGetFormat(Packet::Format::HF_INET6_TCP_AH, p5); } } TEST_F(PacketTest, SetGetTestSignatureTimestamp) { // Let's try to set the signature timestamp in a packet without AH header. We // expect an exception. using namespace std::chrono; uint64_t now = duration_cast(system_clock::now().time_since_epoch()) .count(); try { packet.setSignatureTimestamp(now); FAIL() << "We should not reach this point."; } catch (const errors::RuntimeException &exc) { /* ok right exception*/ } catch (...) { FAIL() << "Unexpected exception"; } // Same fot get method try { auto t = packet.getSignatureTimestamp(); // Let's make compiler happy (void)t; FAIL() << "We should not reach this point."; } catch (const errors::RuntimeException &exc) { /* ok right exception*/ } catch (...) { FAIL() << "Unexpected exception"; } // Now let's construct a AH packet, with no additional space for signature PacketForTest p(HF_INET6_TCP_AH); p.setSignatureTimestamp(now); uint64_t now_get = p.getSignatureTimestamp(); // Check we got the right value EXPECT_EQ(now_get, now); } TEST_F(PacketTest, TestSetGetValidationAlgorithm) { // Let's try to set the validation algorithm in a packet without AH header. We // expect an exception. try { packet.setValidationAlgorithm(auth::CryptoSuite::RSA_SHA256); FAIL() << "We should not reach this point."; } catch (const errors::RuntimeException &exc) { /* ok right exception*/ } catch (...) { FAIL() << "Unexpected exception"; } // Same fot get method try { auto v = packet.getSignatureTimestamp(); // Let's make compiler happy (void)v; FAIL() << "We should not reach this point."; } catch (const errors::RuntimeException &exc) { /* ok right exception*/ } catch (...) { FAIL() << "Unexpected exception"; } // Now let's construct a AH packet, with no additional space for signature PacketForTest p(HF_INET6_TCP_AH); p.setValidationAlgorithm(auth::CryptoSuite::RSA_SHA256); auto v_get = p.getValidationAlgorithm(); // Check we got the right value EXPECT_EQ(v_get, auth::CryptoSuite::RSA_SHA256); } TEST_F(PacketTest, TestSetGetKeyId) { uint8_t key[32]; auth::KeyId key_id = std::make_pair(key, sizeof(key)); try { packet.setKeyId(key_id); FAIL() << "We should not reach this point."; } catch (const errors::RuntimeException &exc) { /* ok right exception*/ } catch (...) { FAIL() << "Unexpected exception"; } // Same fot get method try { auto k = packet.getKeyId(); // Let's make compiler happy (void)k; FAIL() << "We should not reach this point."; } catch (const errors::RuntimeException &exc) { /* ok right exception*/ } catch (...) { FAIL() << "Unexpected exception"; } // Now let's construct a AH packet, with no additional space for signature PacketForTest p(HF_INET6_TCP_AH); p.setKeyId(key_id); auto p_get = p.getKeyId(); // Check we got the right value EXPECT_EQ(p_get.second, key_id.second); auto ret = memcmp(p_get.first, key_id.first, p_get.second); EXPECT_EQ(ret, 0); } TEST_F(PacketTest, DISABLED_TestChecksum) { // Checksum should be wrong bool integrity = packet.checkIntegrity(); EXPECT_FALSE(integrity); // Let's fix it packet.setChecksum(); // Check again integrity = packet.checkIntegrity(); EXPECT_TRUE(integrity); // Check with AH header and 300 bytes signature PacketForTest p(HF_INET6_TCP_AH, 300); std::string payload(5000, 'X'); p.appendPayload((const uint8_t *)payload.c_str(), payload.size() / 2); p.appendPayload((const uint8_t *)(payload.c_str() + payload.size() / 2), payload.size() / 2); p.setChecksum(); integrity = p.checkIntegrity(); EXPECT_TRUE(integrity); } TEST_F(PacketTest, TestSetSyn) { // Test syn of non-tcp format and check exception is thrown try { auto p = PacketForTest(Packet::WRAP_BUFFER, &raw_packets_[HF_INET6_ICMP][0], raw_packets_[HF_INET6_ICMP].size(), raw_packets_[HF_INET6_ICMP].size()); // Let's make compiler happy p.setSyn(); FAIL() << "We should not reach this point."; } catch (const errors::RuntimeException &exc) { /* ok right exception*/ } catch (...) { FAIL() << "Unexpected exception"; } packet.setSyn(); EXPECT_TRUE(packet.testSyn()); packet.resetSyn(); EXPECT_FALSE(packet.testSyn()); } TEST_F(PacketTest, TestSetFin) { // Test syn of non-tcp format and check exception is thrown try { auto p = PacketForTest(Packet::WRAP_BUFFER, &raw_packets_[HF_INET6_ICMP][0], raw_packets_[HF_INET6_ICMP].size(), raw_packets_[HF_INET6_ICMP].size()); // Let's make compiler happy p.setFin(); FAIL() << "We should not reach this point."; } catch (const errors::RuntimeException &exc) { /* ok right exception*/ } catch (...) { FAIL() << "Unexpected exception"; } packet.setFin(); EXPECT_TRUE(packet.testFin()); packet.resetFin(); EXPECT_FALSE(packet.testFin()); } TEST_F(PacketTest, TestSetAck) { // Test syn of non-tcp format and check exception is thrown try { auto p = PacketForTest(Packet::WRAP_BUFFER, &raw_packets_[HF_INET6_ICMP][0], raw_packets_[HF_INET6_ICMP].size(), raw_packets_[HF_INET6_ICMP].size()); // Let's make compiler happy p.setAck(); FAIL() << "We should not reach this point."; } catch (const errors::RuntimeException &exc) { /* ok right exception*/ } catch (...) { FAIL() << "Unexpected exception"; } packet.setAck(); EXPECT_TRUE(packet.testAck()); packet.resetAck(); EXPECT_FALSE(packet.testAck()); } TEST_F(PacketTest, TestSetRst) { // Test syn of non-tcp format and check exception is thrown try { auto p = PacketForTest(Packet::WRAP_BUFFER, &raw_packets_[HF_INET6_ICMP][0], raw_packets_[HF_INET6_ICMP].size(), raw_packets_[HF_INET6_ICMP].size()); // Let's make compiler happy p.setRst(); FAIL() << "We should not reach this point."; } catch (const errors::RuntimeException &exc) { /* ok right exception*/ } catch (...) { FAIL() << "Unexpected exception"; } packet.setRst(); EXPECT_TRUE(packet.testRst()); packet.resetRst(); EXPECT_FALSE(packet.testRst()); } TEST_F(PacketTest, TestResetFlags) { packet.setRst(); packet.setSyn(); packet.setAck(); packet.setFin(); EXPECT_TRUE(packet.testRst()); EXPECT_TRUE(packet.testAck()); EXPECT_TRUE(packet.testFin()); EXPECT_TRUE(packet.testSyn()); packet.resetFlags(); EXPECT_FALSE(packet.testRst()); EXPECT_FALSE(packet.testAck()); EXPECT_FALSE(packet.testFin()); EXPECT_FALSE(packet.testSyn()); } TEST_F(PacketTest, TestSetGetSrcPort) { try { auto p = PacketForTest(Packet::WRAP_BUFFER, &raw_packets_[HF_INET6_ICMP][0], raw_packets_[HF_INET6_ICMP].size(), raw_packets_[HF_INET6_ICMP].size()); // Let's make compiler happy p.setSrcPort(12345); FAIL() << "We should not reach this point."; } catch (const errors::RuntimeException &exc) { /* ok right exception*/ } catch (...) { FAIL() << "Unexpected exception"; } packet.setSrcPort(12345); EXPECT_EQ(packet.getSrcPort(), 12345); } TEST_F(PacketTest, TestSetGetDstPort) { try { auto p = PacketForTest(Packet::WRAP_BUFFER, &raw_packets_[HF_INET6_ICMP][0], raw_packets_[HF_INET6_ICMP].size(), raw_packets_[HF_INET6_ICMP].size()); // Let's make compiler happy p.setDstPort(12345); FAIL() << "We should not reach this point."; } catch (const errors::RuntimeException &exc) { /* ok right exception*/ } catch (...) { FAIL() << "Unexpected exception"; } packet.setDstPort(12345); EXPECT_EQ(packet.getDstPort(), 12345); } TEST_F(PacketTest, TestEnsureCapacity) { PacketForTest &p = packet; // This shoul be false auto ret = p.ensureCapacity(raw_packets_[HF_INET6_TCP].size() + 10); EXPECT_FALSE(ret); // This should be true ret = p.ensureCapacity(raw_packets_[HF_INET6_TCP].size()); EXPECT_TRUE(ret); // This should be true ret = p.ensureCapacity(raw_packets_[HF_INET6_TCP].size() - 10); EXPECT_TRUE(ret); // Try to trim the packet start p.trimStart(10); // Now this should be false ret = p.ensureCapacity(raw_packets_[HF_INET6_TCP].size()); EXPECT_FALSE(ret); // Create a new packet auto p2 = PacketForTest(Packet::WRAP_BUFFER, &raw_packets_[HF_INET6_ICMP][0], raw_packets_[HF_INET6_ICMP].size(), raw_packets_[HF_INET6_ICMP].size()); p2.appendPayload(utils::MemBuf::createCombined(2000)); // This should be false, since the buffer is chained ret = p2.ensureCapacity(raw_packets_[HF_INET6_TCP].size() - 10); EXPECT_FALSE(ret); } TEST_F(PacketTest, TestEnsureCapacityAndFillUnused) { // Create packet by excluding the payload (So only L3 + L4 headers). The // payload will be trated as unused tailroom PacketForTest p = PacketForTest(Packet::WRAP_BUFFER, &raw_packets_[HF_INET6_TCP][0], raw_packets_[HF_INET6_TCP].size() - PAYLOAD_SIZE, raw_packets_[HF_INET6_TCP].size()); // Copy original packet payload, which is here trated as a unused tailroom uint8_t original_payload[PAYLOAD_SIZE]; uint8_t *payload = &raw_packets_[HF_INET6_TCP][0] + raw_packets_[HF_INET6_TCP].size() - PAYLOAD_SIZE; std::memcpy(original_payload, payload, PAYLOAD_SIZE); // This should be true and the unused tailroom should be unmodified auto ret = p.ensureCapacityAndFillUnused( raw_packets_[HF_INET6_TCP].size() - (PAYLOAD_SIZE + 10), 0); EXPECT_TRUE(ret); ret = std::memcmp(original_payload, payload, PAYLOAD_SIZE); EXPECT_EQ(ret, 0); // This should fill the payload with zeros ret = p.ensureCapacityAndFillUnused(raw_packets_[HF_INET6_TCP].size(), 0); EXPECT_TRUE(ret); uint8_t zeros[PAYLOAD_SIZE]; std::memset(zeros, 0, PAYLOAD_SIZE); ret = std::memcmp(payload, zeros, PAYLOAD_SIZE); EXPECT_EQ(ret, 0); // This should fill the payload with ones ret = p.ensureCapacityAndFillUnused(raw_packets_[HF_INET6_TCP].size(), 1); EXPECT_TRUE(ret); uint8_t ones[PAYLOAD_SIZE]; std::memset(ones, 1, PAYLOAD_SIZE); ret = std::memcmp(payload, ones, PAYLOAD_SIZE); EXPECT_EQ(ret, 0); // This should return false and the payload should be unmodified ret = p.ensureCapacityAndFillUnused(raw_packets_[HF_INET6_TCP].size() + 1, 1); EXPECT_FALSE(ret); ret = std::memcmp(payload, ones, PAYLOAD_SIZE); EXPECT_EQ(ret, 0); } TEST_F(PacketTest, TestSetGetTTL) { packet.setTTL(128); EXPECT_EQ(packet.getTTL(), 128); } } // namespace core } // namespace transport int main(int argc, char **argv) { ::testing::InitGoogleTest(&argc, argv); return RUN_ALL_TESTS(); }