add pdutypeforwardhander

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
+