refactor methods

src/map/natmap.cpp

@@ -8,7 +8,7 @@ NatMap::NatMap(): NatMap(Tins::NetworkInterface::all())
     //ctor
 }
 
-NatMap::NatMap(std::vector<Tins::NetworkInterface> interfaceList) : interfaces(interfaceList)
+NatMap::NatMap(NetworkInterfaceList interfaceList) : interfaces(interfaceList), arpMap(), transMap(), pduQueue(), zeroIp()
 {
 }
 
@@ -17,7 +17,7 @@ NatMap::~NatMap()
     //dtor
 }
 
-NatMap::NatMap(const NatMap& other) : interfaces(other.interfaces)
+NatMap::NatMap(const NatMap& other) : interfaces(other.interfaces), arpMap(), transMap(), pduQueue(), zeroIp()
 {
     //copy ctor
 }
@@ -27,6 +27,9 @@ 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;
 }
 
@@ -39,4 +42,121 @@ const Tins::IPv4Address NatMap::mapIPv4Address(const Tins::IPv4Address & ip, con
     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())
+    {
+    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()));
+}
+
+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);
+}
+
+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;
+        }
+
+        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::iterator transIpIter = transMap.find(transAddr);
+    if (transIpIter != transMap.end())
+    {
+        transMap[transAddr] = originIp;
+    }
+    else
+    {
+        transMap.insert(IPv4AddressEntry(transAddr,originIp));
+    }
+
+    return transAddr;
+}
+
+void NatMap::handleArp(const Tins::ARP * /*arp*/)
+{
+    return;
+}
+
 }

src/map/natmap.h

@@ -2,6 +2,8 @@
 #define NATMAP_H
 
 #include <vector>
+#include <map>
+#include <queue>
 #include <tins/tins.h>
 
 namespace otonat
@@ -9,18 +11,37 @@ namespace otonat
 class NatMap
 {
 public:
+    typedef std::vector<Tins::NetworkInterface> NetworkInterfaceList;
+    typedef std::queue<const Tins::PDU *> PduQueue;
+    typedef std::pair<Tins::IPv4Address,Tins::IPv4Address> IPv4AddressEntry;
+    typedef std::map<Tins::IPv4Address, Tins::HWAddress<6>> IpAdressMacMap;
+    typedef std::map<Tins::IPv4Address, Tins::IPv4Address> IpAdressMap;
+
+
     NatMap();
-    NatMap(std::vector<Tins::NetworkInterface> interfaceList);
+    NatMap(NetworkInterfaceList interfaceList);
     virtual ~NatMap();
     NatMap(const NatMap& other);
     NatMap& operator=(const NatMap& other);
-    std::vector<Tins::NetworkInterface> interfaces;
+    NetworkInterfaceList interfaces;
+    IpAdressMacMap arpMap;
+    IpAdressMap transMap;
+    PduQueue pduQueue;
+    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);
+    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);
+    Tins::IPv4Address zeroIp;
 };
 }