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"
namespace otonat
{
namespace otonat {
NatMap::NatMap(): NatMap(Tins::NetworkInterface::all())
{
//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;
NatMap::NatMap() : NatMap(Tins::NetworkInterface::all()) {
//ctor
}
switch(pdu->pdu_type())
{
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;
NatMap::NatMap(NetworkInterfaceList interfaceList) : interfaces(interfaceList) {
}
handlePdu(const_cast<Tins::PDU *>(pdu->inner_pdu()));
}
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);
NatMap::~NatMap() {
//dtor
}
modifyIp->src_addr(transSrcAttr);
}
NatMap::NatMap(const NatMap& other) : interfaces(other.interfaces) {
operator=(other);
}
Tins::IPv4Address NatMap::InsertOrUdpateTranslateIpAddress(const Tins::IPv4Address & originIp, NetworkInterfaceList & interfaceList)
{
// calc translated ip address for first up and not same interfaces
for (NetworkInterfaceList::iterator interfaceIter = interfaceList.begin() ; interfaceIter != interfaceList.end(); ++interfaceIter)
{
// insert or update translated ip address
const Tins::NetworkInterface::Info & interfaceInfo = interfaceIter->info();
if (!interfaceInfo.is_up)
{
continue;
NatMap& NatMap::operator=(const NatMap& rhs) {
if (this == &rhs) return *this; // handle self assignment
interfaces = rhs.interfaces;
arpMap = rhs.arpMap;
transMap = rhs.transMap;
incommingPduQueue = rhs.incommingPduQueue;
outgoingPduQueue = rhs.outgoingPduQueue;
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) {
Tins::PDU * pduCopy = pdu->clone();
if (pdu == NULL) {
return;
}
Tins::IPv4Range range = calcIpRange(interfaceInfo);//networkInterfaceIpRangeMap[interfaceInfo.ip_addr];
if (range.contains(originIp))
{
continue;
Tins::ARP * arp = pduCopy->find_pdu<Tins::ARP>();
if (arp != 0) {
handleArp(arp);
return;
}
return InsertOrUdpateTranslateIpAddress(originIp, interfaceInfo);
Tins::IP * ip = pduCopy->find_pdu<Tins::IP>();
if (ip != 0) {
handleIp(ip);
}
}
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::iterator transIpIter = transMap.find(transAddr);
if (transIpIter != transMap.end())
{
transMap[transAddr] = originIp;
}
else
{
transMap.insert(IPv4AddressEntry(transAddr,originIp));
void NatMap::handleIp(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
}
}
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*/)
{
return;
}
// set translated dst address
modifyIp->dst_addr(transIp);
// 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;
IpAdressMacMap arpMap;
IpAdressMap transMap;
PduQueue pduQueue;
PduQueue incommingPduQueue;
PduQueue outgoingPduQueue;
void handlePdu(const Tins::PDU * pdu);
static const Tins::IPv4Address mapIPv4Address(const Tins::IPv4Address & ip, const Tins::NetworkInterface::Info & interfaceInfo);
static const Tins::IPv4Range calcIpRange(const Tins::NetworkInterface::Info & interfaceInfo);
protected:
private:
void handleIp(const Tins::IP * ip);
void handleArp(const Tins::ARP * arp);
void handleIp(Tins::IP * ip);
void handleArp(Tins::ARP * arp);
Tins::IPv4Address InsertOrUdpateTranslateIpAddress(const Tins::IPv4Address & originIp, const Tins::NetworkInterface::Info & interfaceInfo);
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;
};
}

20
tests/nattest.cpp
View File

@@ -6,7 +6,7 @@
*/
#include "nattest.h"
#include <iostream>
CPPUNIT_TEST_SUITE_REGISTRATION(nattest);
@@ -65,9 +65,23 @@ void nattest::testIpCalcEth2() {
}
void nattest::testTranslateIp() {
Tins::EthernetII eth = Tins::EthernetII() / Tins::IP() / Tins::TCP();
otonat::NatMap natMap = otonat::NatMap();
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();
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);
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() {