Add MPLS PDU and hook it up with ICMP extensions

tests/src/CMakeLists.txt

@@ -70,6 +70,7 @@ ADD_CUSTOM_TARGET(
     LLCTest
     LoopbackTest
     MatchesResponseTest
+    MPLSTest
     NetworkInterfaceTest
     OfflinePacketFilterTest
     PDUTest
@@ -112,6 +113,7 @@ ADD_EXECUTABLE(IPv6Test EXCLUDE_FROM_ALL ipv6.cpp)
 ADD_EXECUTABLE(IPv6AddressTest EXCLUDE_FROM_ALL ipv6address.cpp)
 ADD_EXECUTABLE(LLCTest EXCLUDE_FROM_ALL llc.cpp)
 ADD_EXECUTABLE(LoopbackTest EXCLUDE_FROM_ALL loopback.cpp)
+ADD_EXECUTABLE(MPLSTest EXCLUDE_FROM_ALL mpls.cpp)
 ADD_EXECUTABLE(MatchesResponseTest EXCLUDE_FROM_ALL matches_response.cpp)
 ADD_EXECUTABLE(NetworkInterfaceTest EXCLUDE_FROM_ALL network_interface.cpp)
 ADD_EXECUTABLE(OfflinePacketFilterTest EXCLUDE_FROM_ALL offline_packet_filter.cpp)
@@ -193,6 +195,7 @@ ADD_TEST(IPv6Address IPv6AddressTest)
 ADD_TEST(LLC LLCTest)
 ADD_TEST(Loopback LoopbackTest)
 ADD_TEST(MatchesResponse MatchesResponseTest)
+ADD_TEST(MPLS MPLSTest)
 ADD_TEST(NetworkInterface NetworkInterfaceTest)
 ADD_TEST(OfflinePacketFilter OfflinePacketFilterTest)
 ADD_TEST(PDU PDUTest)

tests/src/icmp.cpp

@@ -6,6 +6,7 @@
 #include "ip.h"
 #include "ethernetII.h"
 #include "utils.h"
+#include "mpls.h"
 #include "rawpdu.h"
 
 using namespace std;
@@ -313,6 +314,8 @@ TEST_F(ICMPTest, ExtensionsParsingWithoutALengthField) {
     ICMP icmp(packet_with_extensions, sizeof(packet_with_extensions));
     ICMPExtensionsStructure extensions = icmp.extensions();
     ASSERT_EQ(1, extensions.extensions().size());
+    MPLS mpls(*extensions.extensions().begin());
+    EXPECT_EQ(100704, mpls.label());
     EXPECT_EQ(
         ICMPExtension::payload_type(ext, ext + sizeof(ext)), 
         extensions.extensions().begin()->serialize()

tests/src/icmp_extension.cpp

@@ -1,8 +1,11 @@
 #include <gtest/gtest.h>
 #include "icmp_extension.h"
+#include "mpls.h"
 
 using Tins::ICMPExtension;
 using Tins::ICMPExtensionsStructure;
+using Tins::MPLS;
+using Tins::PDU;
 
 class ICMPExtensionTest : public testing::Test {
 public:
@@ -93,3 +96,20 @@ TEST_F(ICMPExtensionTest, Version) {
     EXPECT_EQ(0xdea, structure.reserved());
     EXPECT_EQ(0xf, structure.version());
 }
+
+TEST_F(ICMPExtensionTest, MPLSExtension) {
+    ICMPExtensionsStructure structure;
+    MPLS mpls1;
+    mpls1.label(10012);
+    mpls1.bottom_of_stack(1);
+    mpls1.ttl(15);
+    structure.add_extension(mpls1);
+    
+    PDU::serialization_type buffer = structure.serialize();
+    ICMPExtensionsStructure new_structure(&buffer[0], buffer.size());
+    ASSERT_EQ(1, new_structure.extensions().size());
+    MPLS mpls2(*new_structure.extensions().begin());
+    EXPECT_EQ(mpls1.label(), mpls2.label());
+    EXPECT_EQ(mpls1.bottom_of_stack(), mpls2.bottom_of_stack());
+    EXPECT_EQ(mpls1.ttl(), mpls2.ttl());
+}

tests/src/mpls.cpp

@@ -0,0 +1,124 @@
+#include <gtest/gtest.h>
+#include <cstring>
+#include <string>
+#include <algorithm>
+#include <stdint.h>
+#include "mpls.h"
+#include "ip.h"
+#include "udp.h"
+#include "rawpdu.h"
+#include "ethernetII.h"
+
+using namespace std;
+using namespace Tins;
+
+class MPLSTest : public testing::Test {
+public:
+    static const uint8_t eth_and_mpls[];
+    static const uint8_t mpls_layer[];
+};
+
+const uint8_t MPLSTest::eth_and_mpls[] = {
+    0, 1, 1, 0, 0, 2, 0, 1, 1, 0, 0, 1, 136, 71, 0, 62, 144, 128, 0, 62, 
+    160, 128, 0, 62, 177, 128, 69, 0, 0, 39, 147, 163, 0, 0, 128, 17, 
+    169, 32, 127, 0, 0, 1, 127, 0, 0, 1, 0, 7, 0, 7, 0, 19, 35, 34, 72, 
+    101, 108, 108, 111, 32, 77, 80, 76, 83, 33
+};
+
+const uint8_t MPLSTest::mpls_layer[] = {
+    24, 150, 1, 1
+};
+
+TEST_F(MPLSTest, ConstructWholePacket) {
+    // This has 3 MPLS labels
+    EthernetII eth(eth_and_mpls, sizeof(eth_and_mpls));
+    const MPLS* mpls1 = eth.find_pdu<MPLS>();
+    ASSERT_TRUE(mpls1 != 0);
+    ASSERT_TRUE(mpls1->inner_pdu() != 0);
+
+    const MPLS* mpls2 = mpls1->inner_pdu()->find_pdu<MPLS>();
+    ASSERT_TRUE(mpls2 != 0);
+    ASSERT_TRUE(mpls2->inner_pdu() != 0);
+
+    const MPLS* mpls3 = mpls2->inner_pdu()->find_pdu<MPLS>();
+    ASSERT_TRUE(mpls3 != 0);
+    ASSERT_TRUE(mpls3->inner_pdu() != 0);
+
+    const IP* ip = mpls3->find_pdu<IP>();
+    ASSERT_TRUE(ip != 0);
+
+    const RawPDU* raw = ip->find_pdu<RawPDU>();
+    ASSERT_TRUE(raw != 0);
+
+    string payload = "Hello MPLS!";
+    EXPECT_EQ(RawPDU::payload_type(payload.begin(), payload.end()), raw->payload());
+
+    MPLS::serialization_type buffer = eth.serialize();
+    EXPECT_EQ(
+        MPLS::serialization_type(eth_and_mpls, eth_and_mpls + sizeof(eth_and_mpls)),
+        buffer
+    );
+}
+
+TEST_F(MPLSTest, ConstructorFromBuffer) {
+    MPLS mpls(mpls_layer, sizeof(mpls_layer));
+    EXPECT_EQ(100704, mpls.label());
+    EXPECT_EQ(1, mpls.bottom_of_stack());
+    EXPECT_EQ(1, mpls.ttl());
+}
+
+TEST_F(MPLSTest, Serialize) {
+    MPLS mpls(mpls_layer, sizeof(mpls_layer));
+    MPLS::serialization_type buffer = mpls.serialize();
+    EXPECT_EQ(
+        MPLS::serialization_type(mpls_layer, mpls_layer + sizeof(mpls_layer)),
+        buffer
+    );
+}
+
+TEST_F(MPLSTest, SerializeAfterEthernet) {
+    EthernetII eth = EthernetII() / MPLS() / IP() / UDP() / RawPDU("hehehe");
+    eth.serialize();
+    // Bottom of stack should be 1
+    EXPECT_EQ(1, eth.rfind_pdu<MPLS>().bottom_of_stack());
+}
+
+TEST_F(MPLSTest, SerializeAfterEthernetUsingTwoMPLSLayers) {
+    EthernetII eth = EthernetII() / MPLS() / MPLS() / IP() / UDP() / RawPDU("hehehe");
+    eth.serialize();
+
+    const MPLS& mpls1 = eth.rfind_pdu<MPLS>();
+    const MPLS& mpls2 = mpls1.inner_pdu()->rfind_pdu<MPLS>();
+    // Bottom of stack should be 0 for the first MPLS layer
+    EXPECT_EQ(0, mpls1.bottom_of_stack());
+    // 1 for the second one
+    EXPECT_EQ(1, mpls2.bottom_of_stack());
+}
+
+TEST_F(MPLSTest, SetAllFields) {
+    MPLS mpls;
+    mpls.ttl(0xde);
+    mpls.bottom_of_stack(1);
+    mpls.label(0xdead8);
+    EXPECT_EQ(0xdead8, mpls.label());
+    EXPECT_EQ(1, mpls.bottom_of_stack());
+    EXPECT_EQ(0xde, mpls.ttl());
+}
+
+TEST_F(MPLSTest, Label) {
+    MPLS mpls;
+    mpls.label(0xdead8);
+    EXPECT_EQ(0xdead8, mpls.label());
+}
+
+TEST_F(MPLSTest, BottomOfStack) {
+    MPLS mpls;
+    mpls.bottom_of_stack(1);
+    EXPECT_EQ(1, mpls.bottom_of_stack());
+}
+
+TEST_F(MPLSTest, TTL) {
+    MPLS mpls;
+    mpls.ttl(0xde);
+    EXPECT_EQ(0xde, mpls.ttl());
+}