Auf Branch develop

zum Commit vorgemerkte Änderungen:
	geändert:       src/AbstractRouter.h
	neue Datei:     src/ArpToNdpPacketHandler.cpp
	neue Datei:     src/ArpToNdpPacketHandler.h
	neue Datei:     src/INetworkInterfaceCard_t.h
	neue Datei:     src/Ip4Packet_t.h
	geändert:       src/Ip6Packet_t.h
	neue Datei:     src/IpVersionRouter.cpp
	neue Datei:     src/IpVersionRouter.h

src/AbstractRouter.h

@@ -1,9 +1,9 @@
 #ifndef ABSTRACTROUTER_H
 #define ABSTRACTROUTER_H
 
-#include "INetworkInterfaceCard.h"
+#include "IRouter.h"
 
-class AbstractRouter: public INetworkInterfaceCard
+class AbstractRouter: public IRouter
 {
 public:
 protected:

src/ArpToNdpPacketHandler.cpp

@@ -0,0 +1,92 @@
+#include "ArpToNdpPacketHandler.h"
+#include <tins/ethernetII.h>
+#include <tins/arp.h>
+#include <tins/icmpv6.h>
+#include <tins/ipv6.h>
+#include <tins/ip_address.h>
+#include <tins/ipv6_address.h>
+#include "IpAddressTranslator.h"
+
+ArpToNdpPacketHandler::ArpToNdpPacketHandler(const Tins::IPv6Address & newPrefix)
+{
+	prefix = std::make_unique<Tins::IPv6Address>(newPrefix);
+	ndpPrefix = std::make_unique<Tins::IPv6Address>("FF02:0:0:0:0:1:FF");
+	ndpMask = std::make_unique<Tins::IPv4Address>("255.0.0.0");
+}
+
+ArpToNdpPacketHandler::~ArpToNdpPacketHandler()
+{
+}
+
+bool ArpToNdpPacketHandler::handle(IN const Tins::PDU & pdu, IN IPacketHandler * callBackHandler)
+{
+	// callback handvet requeried
+	if (callBackHandler == nullptr)
+	{
+		return false;
+	}
+
+	// get ipv4 packet
+	const Tins::ARP * arpPdu = pdu.find_pdu<Tins::ARP>();
+	if(arpPdu == nullptr)
+	{
+		return false;
+	}
+
+	// convert ipv4 addresses to ipv6 addresses
+	uint32_t ndpMaskField = *ndpMask;
+	uint32_t targetMaskield = arpPdu->target_ip_addr();
+	uint32_t foo = ndpMaskField | targetMaskield;
+	UPtrIPv6Address srcIp6Address = std::make_unique<Tins::IPv6Address>(*prefix);
+	UPtrIPv6Address dstIp6Address = std::make_unique<Tins::IPv6Address>(*ndpPrefix);
+	UPtrIPv6Address targetIp6Address = std::make_unique<Tins::IPv6Address>(*prefix);
+	IpAddressTranslator::toIpv6Address(arpPdu->sender_ip_addr(), *srcIp6Address);
+	IpAddressTranslator::toIpv6Address(Tins::IPv4Address(foo), *dstIp6Address);
+
+	// create ip4 pdu
+	std::unique_ptr<const Tins::IPv6> ipv6Pdu = std::make_unique<const Tins::IPv6>(*dstIp6Address,*srcIp6Address);
+	std::unique_ptr<Tins::ICMPv6> ndpPdu;
+
+    switch (arpPdu->opcode())
+    {
+    case Tins::ARP::REQUEST:
+        ndpPdu = std::make_unique<Tins::ICMPv6>(Tins::ICMPv6::NEIGHBOUR_SOLICIT);
+		break;
+    case Tins::ARP::REPLY:
+        ndpPdu = std::make_unique<Tins::ICMPv6>(Tins::ICMPv6::NEIGHBOUR_ADVERT);
+		break;
+    default:
+        return false;
+    }
+
+	ndpPdu->target_addr(*targetIp6Address);
+	// create forwarding frame
+	std::unique_ptr<Tins::EthernetII> ptrForwardEthPdu = std::make_unique<Tins::EthernetII>();
+	Tins::EthernetII & forwardEthPdu = *ptrForwardEthPdu;
+
+	// copy src and dst mac address
+	const Tins::EthernetII * ethPdu = pdu.find_pdu<Tins::EthernetII>();
+	if(ethPdu != nullptr)
+	{
+		// @todo to set multicast
+		forwardEthPdu.src_addr(ethPdu->src_addr());
+		forwardEthPdu.dst_addr(ethPdu->dst_addr());
+	}
+
+	forwardEthPdu /= *ipv6Pdu;
+	forwardEthPdu /= *ndpPdu;
+
+
+	// forward frame
+	return callBackHandler->handle(forwardEthPdu, this);
+}
+
+const Tins::IPv6Address & ArpToNdpPacketHandler::getPrefix() const
+{
+	return *prefix;
+}
+
+void ArpToNdpPacketHandler::setPrefix(const Tins::IPv6Address & newPrefix)
+{
+	*prefix = newPrefix;
+}

src/ArpToNdpPacketHandler.h

@@ -0,0 +1,25 @@
+#ifndef ARPTONDPPACKETHANDLER_H
+#define ARPTONDPPACKETHANDLER_H
+
+#include "AbstractPacketHandler.h"
+#include "IPacketHandler_t.h"
+#include "Ip6Packet_t.h"
+#include "Ip4Packet_t.h"
+
+class ArpToNdpPacketHandler : public AbstractPacketHandler
+{
+public:
+
+	ArpToNdpPacketHandler(const Tins::IPv6Address & prefix);
+	virtual ~ArpToNdpPacketHandler();
+
+	virtual bool handle(IN const Tins::PDU & pdu, IN IPacketHandler *  callBackHandler = nullptr) override;
+
+	const Tins::IPv6Address & getPrefix() const;
+	void setPrefix(const Tins::IPv6Address & newPrefix);
+private:
+	UPtrIPv6Address prefix;
+	UPtrIPv6Address ndpPrefix;
+	UPtrIPv4Address ndpMask;
+};
+#endif

src/INetworkInterfaceCard_t.h

@@ -0,0 +1,13 @@
+#ifndef INETWORKINTERFACECARD_T_H
+#define INETWORKINTERFACECARD_T_H
+
+
+#include <memory>
+#include "Main_t.h"
+
+interface IPacketHandler;
+
+
+interface INetworkInterfaceCard;
+typedef std::shared_ptr<INetworkInterfaceCard> SPtrINetworkInterfaceCard;
+#endif

src/Ip4Packet_t.h

@@ -0,0 +1,12 @@
+#ifndef IP4PACKET_T_H
+#define IP4PACKET_T_H
+
+#include <memory>
+
+namespace Tins
+{
+	class IPv4Address;
+}
+
+typedef std::unique_ptr<Tins::IPv4Address> UPtrIPv4Address;
+#endif

src/Ip6Packet_t.h

@@ -9,4 +9,5 @@ namespace Tins
 }
 
 typedef std::unique_ptr<Tins::IPv6Address> UPtrIPv6Address;
+
 #endif

src/IpVersionRouter.cpp

@@ -0,0 +1,35 @@
+#include "IpVersionRouter.h"
+#include <tins/arp.h>
+#include <tins/ip.h>
+#include <tins/ipv6.h>
+#include "INetworkInterfaceCard.h"
+IpVersionRouter::IpVersionRouter()
+{
+}
+
+IpVersionRouter::~IpVersionRouter()
+{
+}
+
+bool IpVersionRouter::handle(IN const Tins::PDU & pdu, IN IPacketHandler * /* callBackHandler*/)
+{
+	const Tins::IPv6 * ipv6Pdu = pdu.find_pdu<Tins::IPv6>();
+	if(ipv6Pdu != nullptr)
+	{
+		ipv6Card->sendPacket(pdu);
+		return true;
+	}
+
+	const Tins::IP * ipv4Pdu = pdu.find_pdu<Tins::IP>();
+	if(ipv4Pdu == nullptr)
+	{
+		const Tins::ARP * arpPdu = pdu.find_pdu<Tins::ARP>();
+		if(arpPdu == nullptr)
+		{
+			return false;
+		}
+	}
+
+	ipv4Card->sendPacket(pdu);
+	return true;
+}

src/IpVersionRouter.h

@@ -0,0 +1,20 @@
+#ifndef IPVERSIONROUTER_H
+#define IPVERSIONROUTER_H
+
+#include "AbstractRouter.h"
+#include "INetworkInterfaceCard_t.h"
+
+class IpVersionRouter: public AbstractRouter
+{
+public:
+	IpVersionRouter();
+	virtual ~IpVersionRouter();
+	virtual bool handle(IN const Tins::PDU & pdu, IN IPacketHandler *  callBackHandler = nullptr)  override;
+
+private:
+
+	SPtrINetworkInterfaceCard ipv6Card;
+	SPtrINetworkInterfaceCard ipv4Card;
+};
+
+#endif // ABSTRACTROUTER_H