stubbfel/1261Nat
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

add pdutypeforwardhander

Browse Source
This commit is contained in:
stubbfel
2017-05-26 18:58:42 +02:00
parent 131d57e808
commit 008f67e1f1
13 changed files with 187 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

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

2
CMakeLists.txt
View File

@@ -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)

2
lib/libtins

Submodule lib/libtins updated: 7977ce6fc3...7d087e6fb8

2
src/AbstractRouter.cpp
View File

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

1
src/IRouter.h
View File

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

5
src/IpVersionRouter.cpp
View File

@@ -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()

2
src/IpVersionRouter.h
View File

@@ -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;

22
src/Main.cpp
View File

@@ -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();
}

37
src/pdutypeforwardpackethandler.cpp Normal file
View File

@@ -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;
}

23
src/pdutypeforwardpackethandler.h Normal file
View File

@@ -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

21
src/pdutypeforwardpackethandler_t.h Normal file
View File

@@ -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

75
test/src/TestPduTypeForwardPaketHandler.cpp Normal file
View File

@@ -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);
}

7
test/src/TestTinsNetworkCard.cpp
View File

@@ -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();*/
}