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

uadd tests

Browse Source
This commit is contained in:
stubbfel
2015-08-20 00:53:19 +02:00
parent d88274f9b5
commit 1dceb0b6cb
3 changed files with 135 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files

254
src/map/natmap.cpp
View File

@@ -1,162 +1,134 @@
#include "natmap.h" #include "natmap.h"
namespace otonat namespace otonat {
{
NatMap::NatMap(): NatMap(Tins::NetworkInterface::all()) NatMap::NatMap() : NatMap(Tins::NetworkInterface::all()) {
{ //ctor
//ctor
}
NatMap::NatMap(NetworkInterfaceList interfaceList) : interfaces(interfaceList), arpMap(), transMap(), pduQueue(), zeroIp()
{
}
NatMap::~NatMap()
{
//dtor
}
NatMap::NatMap(const NatMap& other) : interfaces(other.interfaces), arpMap(), transMap(), pduQueue(), zeroIp()
{
//copy ctor
}
NatMap& NatMap::operator=(const NatMap& rhs)
{
if (this == &rhs) return *this; // handle self assignment
interfaces = rhs.interfaces;
arpMap = rhs.arpMap;
transMap = rhs.transMap;
pduQueue = rhs.pduQueue;
return *this;
}
const Tins::IPv4Address NatMap::mapIPv4Address(const Tins::IPv4Address & ip, const Tins::NetworkInterface::Info & interfaceInfo)
{
const uint32_t & netmask = interfaceInfo.netmask;
const uint32_t & interfaceIp = interfaceInfo.ip_addr;
const uint32_t networkStartIp = interfaceIp & netmask;
const uint32_t resultIp = (ip & ~netmask) | networkStartIp;
return Tins::IPv4Address(resultIp);
}
const Tins::IPv4Range NatMap::calcIpRange(const Tins::NetworkInterface::Info & interfaceInfo)
{
return Tins::IPv4Range::from_mask(interfaceInfo.ip_addr, interfaceInfo.netmask);
}
void NatMap::handlePdu(const Tins::PDU * pdu)
{
if (pdu == NULL)
{
return;
} }
switch(pdu->pdu_type()) NatMap::NatMap(NetworkInterfaceList interfaceList) : interfaces(interfaceList) {
{
case Tins::PDU::ARP:
handleArp(static_cast<const Tins::ARP *>(pdu));
break;
case Tins::PDU::IP:
handleIp(static_cast<const Tins::IP *>(pdu));
return;
default:
break;
} }
handlePdu(const_cast<Tins::PDU *>(pdu->inner_pdu())); NatMap::~NatMap() {
} //dtor
void NatMap::handleIp(const Tins::IP * ip)
{
IpAdressMap::iterator transIpIter = transMap.find(ip->dst_addr());
if (transIpIter != transMap.end())
{
// handle know traslation ip
TranslateIpPacket(ip, transIpIter->second);
}
else
{
// Determine Traslation Ip
}
}
void NatMap::TranslateIpPacket(const Tins::IP * ip, const Tins::IPv4Address & transIp)
{
// copy ip packet, for modifaktion
Tins::IP * modifyIp = ip->clone();
// set translated dst address
modifyIp->dst_addr(transIp);
// translate src adress
const Tins::IPv4Address & originSrc = ip->src_addr();
IpAdressMap::iterator transIpIter = transMap.find(originSrc);
Tins::IPv4Address transSrcAttr;
if (transIpIter != transMap.end())
{
// set translated src address
transSrcAttr = transIpIter->second;
}
else
{
transSrcAttr = InsertOrUdpateTranslateIpAddress(originSrc, interfaces);
} }
modifyIp->src_addr(transSrcAttr); NatMap::NatMap(const NatMap& other) : interfaces(other.interfaces) {
} operator=(other);
}
Tins::IPv4Address NatMap::InsertOrUdpateTranslateIpAddress(const Tins::IPv4Address & originIp, NetworkInterfaceList & interfaceList) NatMap& NatMap::operator=(const NatMap& rhs) {
{ if (this == &rhs) return *this; // handle self assignment
// calc translated ip address for first up and not same interfaces
for (NetworkInterfaceList::iterator interfaceIter = interfaceList.begin() ; interfaceIter != interfaceList.end(); ++interfaceIter) interfaces = rhs.interfaces;
{ arpMap = rhs.arpMap;
// insert or update translated ip address transMap = rhs.transMap;
const Tins::NetworkInterface::Info & interfaceInfo = interfaceIter->info(); incommingPduQueue = rhs.incommingPduQueue;
if (!interfaceInfo.is_up) outgoingPduQueue = rhs.outgoingPduQueue;
{ return *this;
continue; }
const Tins::IPv4Address NatMap::mapIPv4Address(const Tins::IPv4Address & ip, const Tins::NetworkInterface::Info & interfaceInfo) {
const uint32_t & netmask = interfaceInfo.netmask;
const uint32_t & interfaceIp = interfaceInfo.ip_addr;
const uint32_t networkStartIp = interfaceIp & netmask;
const uint32_t resultIp = (ip & ~netmask) | networkStartIp;
return Tins::IPv4Address(resultIp);
}
const Tins::IPv4Range NatMap::calcIpRange(const Tins::NetworkInterface::Info & interfaceInfo) {
return Tins::IPv4Range::from_mask(interfaceInfo.ip_addr, interfaceInfo.netmask);
}
void NatMap::handlePdu(const Tins::PDU * pdu) {
Tins::PDU * pduCopy = pdu->clone();
if (pdu == NULL) {
return;
} }
Tins::IPv4Range range = calcIpRange(interfaceInfo);//networkInterfaceIpRangeMap[interfaceInfo.ip_addr]; Tins::ARP * arp = pduCopy->find_pdu<Tins::ARP>();
if (range.contains(originIp)) if (arp != 0) {
{ handleArp(arp);
continue; return;
} }
return InsertOrUdpateTranslateIpAddress(originIp, interfaceInfo); Tins::IP * ip = pduCopy->find_pdu<Tins::IP>();
if (ip != 0) {
handleIp(ip);
}
} }
return zeroIp; void NatMap::handleIp(Tins::IP * ip) {
} IpAdressMap::iterator transIpIter = transMap.find(ip->dst_addr());
if (transIpIter != transMap.end()) {
Tins::IPv4Address NatMap::InsertOrUdpateTranslateIpAddress(const Tins::IPv4Address & originIp, const Tins::NetworkInterface::Info & interfaceInfo) // handle know traslation ip
{ TranslateIpPacket(ip, transIpIter->second);
// translated ip address } else {
Tins::IPv4Address transAddr = mapIPv4Address(originIp, interfaceInfo); // Determine Traslation Ip
}
// insert forward translation
transMap.insert(IPv4AddressEntry(originIp, transAddr));
// insert or update backward translation
IpAdressMap::iterator transIpIter = transMap.find(transAddr);
if (transIpIter != transMap.end())
{
transMap[transAddr] = originIp;
}
else
{
transMap.insert(IPv4AddressEntry(transAddr,originIp));
} }
return transAddr; void NatMap::TranslateIpPacket(Tins::IP * ip, const Tins::IPv4Address & transIp) {
} // copy ip packet, for modifaktion
Tins::IP * modifyIp = ip->clone();
void NatMap::handleArp(const Tins::ARP * /*arp*/) // set translated dst address
{ modifyIp->dst_addr(transIp);
return;
}
// translate src adress
const Tins::IPv4Address & originSrc = ip->src_addr();
IpAdressMap::const_iterator transIpIter = transMap.find(originSrc);
Tins::IPv4Address transSrcAttr;
if (transIpIter != transMap.end()) {
// set translated src address
transSrcAttr = transIpIter->second;
} else {
transSrcAttr = InsertOrUdpateTranslateIpAddress(originSrc, interfaces);
}
modifyIp->src_addr(transSrcAttr);
outgoingPduQueue.push(modifyIp);
}
Tins::IPv4Address NatMap::InsertOrUdpateTranslateIpAddress(const Tins::IPv4Address & originIp, NetworkInterfaceList & interfaceList) {
// calc translated ip address for first up and not same interfaces
for (const Tins::NetworkInterface & interface : interfaceList) {
// insert or update translated ip address
const Tins::NetworkInterface::Info & interfaceInfo = interface.info();
if (!interfaceInfo.is_up) {
continue;
}
Tins::IPv4Range range = calcIpRange(interfaceInfo); //networkInterfaceIpRangeMap[interfaceInfo.ip_addr];
if (range.contains(originIp)) {
continue;
}
return InsertOrUdpateTranslateIpAddress(originIp, interfaceInfo);
}
return zeroIp;
}
Tins::IPv4Address NatMap::InsertOrUdpateTranslateIpAddress(const Tins::IPv4Address & originIp, const Tins::NetworkInterface::Info & interfaceInfo) {
// translated ip address
Tins::IPv4Address transAddr = mapIPv4Address(originIp, interfaceInfo);
// insert forward translation
transMap.insert(IPv4AddressEntry(originIp, transAddr));
// insert or update backward translation
IpAdressMap::const_iterator transIpIter = transMap.find(transAddr);
if (transIpIter != transMap.end()) {
transMap[transAddr] = originIp;
} else {
transMap.insert(IPv4AddressEntry(transAddr, originIp));
}
return transAddr;
}
void NatMap::handleArp(Tins::ARP * /*arp*/) {
return;
}
} }

11
src/map/natmap.h
View File

@@ -26,21 +26,20 @@ public:
NetworkInterfaceList interfaces; NetworkInterfaceList interfaces;
IpAdressMacMap arpMap; IpAdressMacMap arpMap;
IpAdressMap transMap; IpAdressMap transMap;
PduQueue pduQueue; PduQueue incommingPduQueue;
PduQueue outgoingPduQueue;
void handlePdu(const Tins::PDU * pdu); void handlePdu(const Tins::PDU * pdu);
static const Tins::IPv4Address mapIPv4Address(const Tins::IPv4Address & ip, const Tins::NetworkInterface::Info & interfaceInfo); static const Tins::IPv4Address mapIPv4Address(const Tins::IPv4Address & ip, const Tins::NetworkInterface::Info & interfaceInfo);
static const Tins::IPv4Range calcIpRange(const Tins::NetworkInterface::Info & interfaceInfo); static const Tins::IPv4Range calcIpRange(const Tins::NetworkInterface::Info & interfaceInfo);
protected: protected:
private: private:
void handleIp(const Tins::IP * ip); void handleIp(Tins::IP * ip);
void handleArp(const Tins::ARP * arp); void handleArp(Tins::ARP * arp);
Tins::IPv4Address InsertOrUdpateTranslateIpAddress(const Tins::IPv4Address & originIp, const Tins::NetworkInterface::Info & interfaceInfo); Tins::IPv4Address InsertOrUdpateTranslateIpAddress(const Tins::IPv4Address & originIp, const Tins::NetworkInterface::Info & interfaceInfo);
Tins::IPv4Address InsertOrUdpateTranslateIpAddress(const Tins::IPv4Address & originIp, NetworkInterfaceList & interfaceList); Tins::IPv4Address InsertOrUdpateTranslateIpAddress(const Tins::IPv4Address & originIp, NetworkInterfaceList & interfaceList);
void TranslateIpPacket(const Tins::IP * ip, const Tins::IPv4Address & transIp); void TranslateIpPacket(Tins::IP * ip, const Tins::IPv4Address & transIp);
Tins::IPv4Address zeroIp; Tins::IPv4Address zeroIp;
}; };
} }

20
tests/nattest.cpp
View File

@@ -6,7 +6,7 @@
*/ */
#include "nattest.h" #include "nattest.h"
#include <iostream>
CPPUNIT_TEST_SUITE_REGISTRATION(nattest); CPPUNIT_TEST_SUITE_REGISTRATION(nattest);
@@ -65,9 +65,23 @@ void nattest::testIpCalcEth2() {
} }
void nattest::testTranslateIp() { void nattest::testTranslateIp() {
Tins::EthernetII eth = Tins::EthernetII() / Tins::IP() / Tins::TCP(); Tins::EthernetII eth = Tins::EthernetII("00:00:00:00:00:01" ,"00:00:00:00:00:02") / Tins::IP("172.27.0.20", "172.16.3.55") / Tins::TCP();
otonat::NatMap natMap = otonat::NatMap(); Tins::EthernetII eth2 = Tins::EthernetII("00:00:00:00:00:01" ,"00:00:00:00:00:03") / Tins::IP("172.27.0.20", "172.17.3.55") / Tins::TCP();
Tins::NetworkInterface net1("lo:0");
Tins::NetworkInterface net2("lo:1");
otonat::NatMap::NetworkInterfaceList list;
list.push_back(net1);
list.push_back(net2);
otonat::NatMap natMap = otonat::NatMap(list);
natMap.handlePdu(&eth); natMap.handlePdu(&eth);
CPPUNIT_ASSERT(natMap.outgoingPduQueue.empty());
natMap.transMap.insert(otonat::NatMap::IPv4AddressEntry(Tins::IPv4Address("172.27.0.20"), Tins::IPv4Address("10.0.0.20")));
natMap.handlePdu(&eth);
CPPUNIT_ASSERT(natMap.outgoingPduQueue.size()== 1);
const Tins::PDU * result = natMap.outgoingPduQueue.front();
std::cout << "outgoingip: " << result->rfind_pdu<Tins::IP>().src_addr() << std::endl;
natMap.outgoingPduQueue.pop();
CPPUNIT_ASSERT(natMap.outgoingPduQueue.empty());
} }
void nattest::testNatInterfaces() { void nattest::testNatInterfaces() {