From 008f67e1f1c5e890f0d85872b098555e5cbfcd2a Mon Sep 17 00:00:00 2001 From: stubbfel Date: Fri, 26 May 2017 18:58:42 +0200 Subject: [PATCH] add pdutypeforwardhander --- .gitignore | 1 + CMakeLists.txt | 2 +- lib/libtins | 2 +- src/AbstractRouter.cpp | 2 +- src/IRouter.h | 1 + src/IpVersionRouter.cpp | 5 +- src/IpVersionRouter.h | 2 +- src/Main.cpp | 22 +++++- src/pdutypeforwardpackethandler.cpp | 37 ++++++++++ src/pdutypeforwardpackethandler.h | 23 +++++++ src/pdutypeforwardpackethandler_t.h | 21 ++++++ test/src/TestPduTypeForwardPaketHandler.cpp | 75 +++++++++++++++++++++ test/src/TestTinsNetworkCard.cpp | 7 -- 13 files changed, 187 insertions(+), 13 deletions(-) create mode 100644 src/pdutypeforwardpackethandler.cpp create mode 100644 src/pdutypeforwardpackethandler.h create mode 100644 src/pdutypeforwardpackethandler_t.h create mode 100644 test/src/TestPduTypeForwardPaketHandler.cpp diff --git a/.gitignore b/.gitignore index fda28a9..8e088c3 100644 --- a/.gitignore +++ b/.gitignore @@ -3,6 +3,7 @@ # project test/vm projectfiles +CMakeLists.txt.user ### C++ ### # Prerequisites diff --git a/CMakeLists.txt b/CMakeLists.txt index 1950770..d9d5212 100644 --- a/CMakeLists.txt +++ b/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) diff --git a/lib/libtins b/lib/libtins index 7977ce6..7d087e6 160000 --- a/lib/libtins +++ b/lib/libtins @@ -1 +1 @@ -Subproject commit 7977ce6fc39918f62a39a2872d14e3fdb5508db6 +Subproject commit 7d087e6fb88a7c5532daea41e9b49871ad9b0816 diff --git a/src/AbstractRouter.cpp b/src/AbstractRouter.cpp index ba9c7f3..2bcb21e 100644 --- a/src/AbstractRouter.cpp +++ b/src/AbstractRouter.cpp @@ -6,5 +6,5 @@ AbstractRouter::AbstractRouter() } AbstractRouter::~AbstractRouter() { - //dtor + //dtore } diff --git a/src/IRouter.h b/src/IRouter.h index 79aa844..ec7d0a5 100644 --- a/src/IRouter.h +++ b/src/IRouter.h @@ -1,6 +1,7 @@ #ifndef IROUTER_H #define IROUTER_H +#include "IRouter_t.h" #include "IPacketHandler.h" interface IRouter: IPacketHandler diff --git a/src/IpVersionRouter.cpp b/src/IpVersionRouter.cpp index 51fccb4..d4adb29 100644 --- a/src/IpVersionRouter.cpp +++ b/src/IpVersionRouter.cpp @@ -3,8 +3,11 @@ #include #include #include "INetworkInterfaceCard.h" -IpVersionRouter::IpVersionRouter() + +IpVersionRouter::IpVersionRouter(SPtrINetworkInterfaceCard netv4Card, SPtrINetworkInterfaceCard netv6Card) { + ipv4Card = netv4Card; + ipv6Card = netv6Card; } IpVersionRouter::~IpVersionRouter() diff --git a/src/IpVersionRouter.h b/src/IpVersionRouter.h index 0dd668c..71eee11 100644 --- a/src/IpVersionRouter.h +++ b/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; diff --git a/src/Main.cpp b/src/Main.cpp index 1cd6f0b..79ac236 100644 --- a/src/Main.cpp +++ b/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 +#include int main() { + SPtrTinsNetworkInterfaceCard ipv4Netcard = std::make_shared("eth0"); + SPtrTinsNetworkInterfaceCard ipv6Netcard = std::make_shared("eth1"); + Tins::IPv6Address prefix("1::"); + SPtrIPacketHandler ip4ToIp6Handler = std::make_shared(prefix); + SPtrIPacketHandler ip6ToIp4Handler = std::make_shared(); + SPtrIRouter router = std::make_shared(ipv4Netcard, ipv6Netcard); + SPtrIPacketHandler nat4to6ForwardHandler = std::make_shared(ip4ToIp6Handler, router); + SPtrIPacketHandler nat6to4ForwardHandler = std::make_shared(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(); } diff --git a/src/pdutypeforwardpackethandler.cpp b/src/pdutypeforwardpackethandler.cpp new file mode 100644 index 0000000..26db8da --- /dev/null +++ b/src/pdutypeforwardpackethandler.cpp @@ -0,0 +1,37 @@ +#include "pdutypeforwardpackethandler.h" +#include + +PduTypeForwardPacketHandler::PduTypeForwardPacketHandler( SPtrIPacketHandler forwardToCallBackHandler) : AbstractPacketHandler() +{ + handlerQueue = std::make_unique(); + 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(entryType); + if (ptrFindPdu == nullptr) + { + continue; + } + + SPtrIPacketHandler targetHandler = entry.second; + return targetHandler->handle(pdu, targetCallBackHandler.get()); + } + + return false; +} + +PduTypeHandlerQueue &PduTypeForwardPacketHandler::getHandlerQueue() const +{ + return *handlerQueue; +} + diff --git a/src/pdutypeforwardpackethandler.h b/src/pdutypeforwardpackethandler.h new file mode 100644 index 0000000..8c20cea --- /dev/null +++ b/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 diff --git a/src/pdutypeforwardpackethandler_t.h b/src/pdutypeforwardpackethandler_t.h new file mode 100644 index 0000000..9a40594 --- /dev/null +++ b/src/pdutypeforwardpackethandler_t.h @@ -0,0 +1,21 @@ +#ifndef PDUTYPEFORWARDPACKETHANDLER_T_H +#define PDUTYPEFORWARDPACKETHANDLER_T_H + +#include +#include +#include +#include "IPacketHandler_t.h" + +class PduTypeForwardPacketHandler; +typedef PduTypeForwardPacketHandler * PtrPduTypeForwardPacketHandler; +typedef std::shared_ptr SPtrPduTypeForwardPacketHandler; +typedef std::unique_ptr UPtrPduTypeForwardPacketHandler; +typedef std::weak_ptr WPtrPduTypeForwardPacketHandler; + +typedef std::pair PduTypeHandlerMapEntry; +typedef std::vector PduTypeHandlerQueue; +typedef std::unique_ptr UPtrPduTypeHandlerMap; +typedef std::shared_ptr SPtrPduTypeHandlerMap; +typedef std::weak_ptr WPtrPduTypeHandlerMap; +#endif // PDUTYPEFORWARDPACKETHANDLER_T_H + diff --git a/test/src/TestPduTypeForwardPaketHandler.cpp b/test/src/TestPduTypeForwardPaketHandler.cpp new file mode 100644 index 0000000..7a53379 --- /dev/null +++ b/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::ptrTargetCallback = sptrTargetCallBackHandler.get(); + SPtrIPacketHandler sptrTargetHandler = std::make_shared(); + Mock mockCallCallbackHandler; + Fake(Method(mockCallCallbackHandler, handle)); + SPtrPduTypeForwardPacketHandler sptrPduTypeForwardHandler = std::make_shared(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(); + 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); +} diff --git a/test/src/TestTinsNetworkCard.cpp b/test/src/TestTinsNetworkCard.cpp index 4956e65..1b8d905 100644 --- a/test/src/TestTinsNetworkCard.cpp +++ b/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();*/ }