add pdutypeforwardhander

.gitignore

@@ -3,6 +3,7 @@
 # project
 test/vm
 projectfiles
+CMakeLists.txt.user
 
 ### C++ ###
 # Prerequisites

CMakeLists.txt

@@ -23,6 +23,6 @@ ADD_SUBDIRECTORY(lib/libtins)
 INCLUDE_DIRECTORIES(lib/libtins/include)
 file(GLOB_RECURSE 1261nat_src_files "src/*.h" "src/*.cpp")
 add_executable(1261nat ${1261nat_src_files} )
-target_link_libraries (1261nat tins)
+target_link_libraries (1261nat pthread tins)
 
 ADD_SUBDIRECTORY(test)

src/AbstractRouter.cpp

@@ -6,5 +6,5 @@ AbstractRouter::AbstractRouter()
 }
 AbstractRouter::~AbstractRouter()
 {
-	//dtor
+    //dtore
 }

src/IRouter.h

@@ -1,6 +1,7 @@
 #ifndef IROUTER_H
 #define IROUTER_H
 
+#include "IRouter_t.h"
 #include "IPacketHandler.h"
 
 interface IRouter: IPacketHandler

src/IpVersionRouter.cpp

@@ -3,8 +3,11 @@
 #include <tins/ip.h>
 #include <tins/ipv6.h>
 #include "INetworkInterfaceCard.h"
-IpVersionRouter::IpVersionRouter()
+
+IpVersionRouter::IpVersionRouter(SPtrINetworkInterfaceCard netv4Card, SPtrINetworkInterfaceCard netv6Card)
 {
+	ipv4Card = netv4Card;
+	ipv6Card = netv6Card;
 }
 
 IpVersionRouter::~IpVersionRouter()

src/IpVersionRouter.h

@@ -7,7 +7,7 @@
 class IpVersionRouter: public AbstractRouter
 {
 public:
-	IpVersionRouter();
+	IpVersionRouter(SPtrINetworkInterfaceCard netv4Card, SPtrINetworkInterfaceCard netv6Card);
 	virtual ~IpVersionRouter();
 	virtual bool handle(IN const Tins::PDU & pdu, IN IPacketHandler *  callBackHandler = nullptr)  override;
 

src/Main.cpp

@@ -1,7 +1,27 @@
 #include "Main_t.h"
-
+#include "ForwardPacketHandler.h"
+#include "Ip4ToIp6PacketHandler.h"
+#include "Ip6ToIp4PacketHandler.h"
+#include "IpVersionRouter.h"
+#include "TinsNetworkInterfaceCard.h"
+#include <tins/ipv6_address.h>
+#include <thread>
 
 int main()
 {
+    SPtrTinsNetworkInterfaceCard ipv4Netcard = std::make_shared<TinsNetworkInterfaceCard>("eth0");
+    SPtrTinsNetworkInterfaceCard ipv6Netcard = std::make_shared<TinsNetworkInterfaceCard>("eth1");
+    Tins::IPv6Address prefix("1::");
+    SPtrIPacketHandler ip4ToIp6Handler = std::make_shared<Ip4ToIp6PacketHandler>(prefix);
+    SPtrIPacketHandler ip6ToIp4Handler = std::make_shared<Ip6ToIp4PacketHandler>();
+    SPtrIRouter router = std::make_shared<IpVersionRouter>(ipv4Netcard, ipv6Netcard);
+    SPtrIPacketHandler nat4to6ForwardHandler = std::make_shared<ForwardPacketHandler>(ip4ToIp6Handler, router);
+    SPtrIPacketHandler nat6to4ForwardHandler = std::make_shared<ForwardPacketHandler>(ip6ToIp4Handler, router);
+    ipv4Netcard->getHandlerList().push_back(nat4to6ForwardHandler);
+    ipv6Netcard->getHandlerList().push_back(nat6to4ForwardHandler);
 
+    std::thread ipv4Thread(&TinsNetworkInterfaceCard::startListen, ipv4Netcard.get());
+    std::thread ipv6Thread(&TinsNetworkInterfaceCard::startListen, ipv6Netcard.get());
+    ipv4Thread.join();
+    ipv6Thread.join();
 }

src/pdutypeforwardpackethandler.cpp

@@ -0,0 +1,37 @@
+#include "pdutypeforwardpackethandler.h"
+#include <tins/ethernetII.h>
+
+PduTypeForwardPacketHandler::PduTypeForwardPacketHandler( SPtrIPacketHandler forwardToCallBackHandler) : AbstractPacketHandler()
+{
+    handlerQueue = std::make_unique<PduTypeHandlerQueue>();
+    targetCallBackHandler = forwardToCallBackHandler;
+}
+
+PduTypeForwardPacketHandler::~PduTypeForwardPacketHandler()
+{
+
+}
+
+bool PduTypeForwardPacketHandler::handle(const Tins::PDU &pdu, IPacketHandler *callBackHandler)
+{
+    for (PduTypeHandlerMapEntry entry : getHandlerQueue())
+    {
+        const Tins::PDU::PDUType entryType = entry.first;
+        const Tins::PDU * ptrFindPdu = pdu.find_pdu<Tins::EthernetII>(entryType);
+        if (ptrFindPdu == nullptr)
+        {
+            continue;
+        }
+
+        SPtrIPacketHandler targetHandler = entry.second;
+        return targetHandler->handle(pdu, targetCallBackHandler.get());
+    }
+
+    return false;
+}
+
+PduTypeHandlerQueue &PduTypeForwardPacketHandler::getHandlerQueue() const
+{
+    return *handlerQueue;
+}
+

src/pdutypeforwardpackethandler.h

@@ -0,0 +1,23 @@
+#ifndef PDUTYPEFORWARDPACKETHANDLER_H
+#define PDUTYPEFORWARDPACKETHANDLER_H
+#include "pdutypeforwardpackethandler_t.h"
+#include "AbstractPacketHandler.h"
+
+
+class PduTypeForwardPacketHandler : public AbstractPacketHandler
+{
+
+public:
+
+    PduTypeForwardPacketHandler(SPtrIPacketHandler forwardToCallBackHandler);
+    virtual ~PduTypeForwardPacketHandler();
+
+    virtual bool handle(IN const Tins::PDU & pdu, IN IPacketHandler *  callBackHandler = nullptr) override;
+    PduTypeHandlerQueue & getHandlerQueue() const;
+
+private:
+    SPtrIPacketHandler targetCallBackHandler;
+    UPtrPduTypeHandlerMap handlerQueue;
+};
+
+#endif // PDUTYPEFORWARDPACKETHANDLER_H

src/pdutypeforwardpackethandler_t.h

@@ -0,0 +1,21 @@
+#ifndef PDUTYPEFORWARDPACKETHANDLER_T_H
+#define PDUTYPEFORWARDPACKETHANDLER_T_H
+
+#include <vector>
+#include <memory>
+#include <tins/pdu.h>
+#include "IPacketHandler_t.h"
+
+class PduTypeForwardPacketHandler;
+typedef PduTypeForwardPacketHandler * PtrPduTypeForwardPacketHandler;
+typedef std::shared_ptr<PduTypeForwardPacketHandler> SPtrPduTypeForwardPacketHandler;
+typedef std::unique_ptr<PduTypeForwardPacketHandler> UPtrPduTypeForwardPacketHandler;
+typedef std::weak_ptr<PduTypeForwardPacketHandler> WPtrPduTypeForwardPacketHandler;
+
+typedef std::pair<Tins::PDU::PDUType, SPtrIPacketHandler> PduTypeHandlerMapEntry;
+typedef std::vector<PduTypeHandlerMapEntry> PduTypeHandlerQueue;
+typedef std::unique_ptr<PduTypeHandlerQueue> UPtrPduTypeHandlerMap;
+typedef std::shared_ptr<PduTypeHandlerQueue> SPtrPduTypeHandlerMap;
+typedef std::weak_ptr<PduTypeHandlerQueue> WPtrPduTypeHandlerMap;
+#endif // PDUTYPEFORWARDPACKETHANDLER_T_H
+

test/src/TestPduTypeForwardPaketHandler.cpp

@@ -0,0 +1,75 @@
+#include "fakeit.hpp"
+#include "IPacketHandler.h"
+#include "pdutypeforwardpackethandler.h"
+#include "tins/ethernetII.h"
+#include "tins/ip.h"
+#include "tins/ipv6.h"
+
+using namespace fakeit;
+
+namespace TestPduTypePacketForwardPacketHandler
+{
+    IPacketHandler * ptrTargetCallback = nullptr;
+    class MockPduTypeForwardIPacketHandler : public IPacketHandler
+    {
+    public:
+        int callCount = 0;
+        virtual bool handle(IN const Tins::PDU & pdu, IN IPacketHandler *  callBackHandler) override
+        {
+            callCount++;
+            REQUIRE(ptrTargetCallback != nullptr);
+            REQUIRE(ptrTargetCallback == callBackHandler);
+            return callBackHandler->handle(pdu, nullptr);
+        }
+    };
+
+
+    class MockPduTypeForwardCallBackIPacketHandler : public IPacketHandler
+    {
+    public:
+        int callCount = 0;
+        virtual bool handle(IN const Tins::PDU & pdu, IN IPacketHandler *  callBackHandler) override
+        {
+            callCount++;
+            return true;
+        }
+    };
+}
+
+TEST_CASE( "test PduTypeForwardPacketHandler", "[PduTypeForwardPacketHandler]" )
+{
+    SPtrIPacketHandler sptrTargetCallBackHandler = std::make_shared<TestPduTypePacketForwardPacketHandler::MockPduTypeForwardCallBackIPacketHandler>();
+    TestPduTypePacketForwardPacketHandler::ptrTargetCallback = sptrTargetCallBackHandler.get();
+    SPtrIPacketHandler sptrTargetHandler = std::make_shared<TestPduTypePacketForwardPacketHandler::MockPduTypeForwardIPacketHandler>();
+    Mock<IPacketHandler> mockCallCallbackHandler;
+    Fake(Method(mockCallCallbackHandler, handle));
+    SPtrPduTypeForwardPacketHandler sptrPduTypeForwardHandler = std::make_shared<PduTypeForwardPacketHandler>(sptrTargetCallBackHandler);
+    Tins::EthernetII pkt = Tins::EthernetII("11:22:33:44:55:66", "66:55:44:33:22:11");
+    REQUIRE(sptrPduTypeForwardHandler->handle(pkt, &mockCallCallbackHandler.get()) == false);
+    Verify(Method(mockCallCallbackHandler, handle)).Never();
+    REQUIRE(((TestPduTypePacketForwardPacketHandler::MockPduTypeForwardCallBackIPacketHandler *)sptrTargetCallBackHandler.get())->callCount == 0);
+    REQUIRE(((TestPduTypePacketForwardPacketHandler::MockPduTypeForwardIPacketHandler *)sptrTargetHandler.get())->callCount == 0);
+
+
+    sptrPduTypeForwardHandler->getHandlerQueue().push_back(PduTypeHandlerMapEntry(Tins::PDU::ETHERNET_II,sptrTargetHandler));
+    REQUIRE(sptrPduTypeForwardHandler->handle(pkt, &mockCallCallbackHandler.get()) == true);
+    Verify(Method(mockCallCallbackHandler, handle)).Never();
+    REQUIRE(((TestPduTypePacketForwardPacketHandler::MockPduTypeForwardCallBackIPacketHandler *)sptrTargetCallBackHandler.get())->callCount == 1);
+    REQUIRE(((TestPduTypePacketForwardPacketHandler::MockPduTypeForwardIPacketHandler *)sptrTargetHandler.get())->callCount == 1);
+
+    Tins::IP pkt2 = Tins::IP("1.1.1.1", "2.2.2.2");
+    SPtrIPacketHandler sptrTargetHandler2 = std::make_shared<TestPduTypePacketForwardPacketHandler::MockPduTypeForwardIPacketHandler>();
+    sptrPduTypeForwardHandler->getHandlerQueue().push_back(PduTypeHandlerMapEntry(Tins::PDU::IP, sptrTargetHandler2));
+    REQUIRE(sptrPduTypeForwardHandler->handle(pkt2, &mockCallCallbackHandler.get()) == true);
+    Verify(Method(mockCallCallbackHandler, handle)).Never();
+    REQUIRE(((TestPduTypePacketForwardPacketHandler::MockPduTypeForwardCallBackIPacketHandler *)sptrTargetCallBackHandler.get())->callCount == 2);
+    REQUIRE(((TestPduTypePacketForwardPacketHandler::MockPduTypeForwardIPacketHandler *)sptrTargetHandler.get())->callCount == 1);
+    REQUIRE(((TestPduTypePacketForwardPacketHandler::MockPduTypeForwardIPacketHandler *)sptrTargetHandler2.get())->callCount == 1);
+
+    Tins::IPv6 pkt3 = Tins::IPv6("1::1", "2::2");
+    REQUIRE(sptrPduTypeForwardHandler->handle(pkt3, &mockCallCallbackHandler.get()) == false);
+    Verify(Method(mockCallCallbackHandler, handle)).Never();
+    REQUIRE(((TestPduTypePacketForwardPacketHandler::MockPduTypeForwardCallBackIPacketHandler *)sptrTargetCallBackHandler.get())->callCount == 2);
+    REQUIRE(((TestPduTypePacketForwardPacketHandler::MockPduTypeForwardIPacketHandler *)sptrTargetHandler.get())->callCount == 1);
+    REQUIRE(((TestPduTypePacketForwardPacketHandler::MockPduTypeForwardIPacketHandler *)sptrTargetHandler2.get())->callCount == 1);
+}

test/src/TestTinsNetworkCard.cpp

@@ -80,11 +80,4 @@ TEST_CASE( "test send and receive Packet", "[TinsNetworkInterfaceCard_SendRec]"
     ptrPacketSniffer->stopListen();
     sniffThread3.join();
     REQUIRE(TestTinsNetworkInterfaceCard::foundPduCount == 4);
-	/*REQUIRE(handler.handle(pkt, nullptr) == false);
-	REQUIRE(handler.handle(pkt, &mockHandler.get()) == true);
-	Verify(Method(mockHandler, handle)).Once();
-
-	pkt = Tins::EthernetII("11:22:33:44:55:66", "66:55:44:33:22:11") / Tins::IP("1.2.3.4", "4.3.2.1") / Tins::TCP();
-	REQUIRE(handler.handle(pkt, &mockHandler.get()) == true);
-	Verify(Method(mockHandler, handle)).Twice();*/
 }