Implements a generic network protocol that routes generic datagrams through the network. More...

#include <GenericNetworkProtocol.h>

Inheritance diagram for inet::GenericNetworkProtocol:

Classes
struct	QueuedDatagramForHook
	Represents an GenericDatagram, queued by a Hook. More...

Public Member Functions
	GenericNetworkProtocol ()

	~GenericNetworkProtocol ()

virtual void	registerHook (int priority, IHook *hook) override
	Adds the provided hook to the list of registered hooks that will be called by the network layer when it processes datagrams. More...

virtual void	unregisterHook (int priority, IHook *hook) override
	Removes the provided hook from the list of registered hooks. More...

virtual void	dropQueuedDatagram (const INetworkDatagram *datagram) override
	Requests the network layer to drop the datagram, because it's no longer needed. More...

virtual void	reinjectQueuedDatagram (const INetworkDatagram *datagram) override
	Requests the network layer to restart the processing of the datagram. More...

Public Member Functions inherited from inet::QueueBase
	QueueBase ()

Public Member Functions inherited from inet::AbstractQueue
	AbstractQueue ()

virtual	~AbstractQueue ()

Public Member Functions inherited from inet::INetfilter
virtual	~INetfilter ()

Public Member Functions inherited from inet::INetworkProtocol
virtual	~INetworkProtocol ()

Protected Types
typedef std::multimap< int, IHook * >	HookList

typedef std::list< QueuedDatagramForHook >	DatagramQueueForHooks

Protected Member Functions
virtual const InterfaceEntry *	getSourceInterfaceFrom (cPacket *packet)

virtual void	refreshDisplay () const override

virtual void	handlePacketFromNetwork (GenericDatagram *datagram)
	Handle GenericDatagram messages arriving from lower layer. More...

virtual void	handleMessageFromHL (cPacket *packet)
	Handle messages (typically packets to be send in Generic) from transport or ICMP. More...

virtual void	routePacket (GenericDatagram datagram, const InterfaceEntry destIE, const L3Address &nextHop, bool fromHL)
	Performs routing. More...

virtual void	routeMulticastPacket (GenericDatagram datagram, const InterfaceEntry destIE, const InterfaceEntry *fromIE)
	Forwards packets to all multicast destinations, using sendDatagramToOutput(). More...

virtual GenericDatagram *	encapsulate (cPacket transportPacket, const InterfaceEntry &destIE)
	Encapsulate packet coming from higher layers into GenericDatagram, using the control info attached to the packet. More...

virtual cPacket *	decapsulate (GenericDatagram *datagram)
	Decapsulate and return encapsulated packet after attaching GenericNetworkProtocolControlInfo. More...

virtual void	sendDatagramToHL (GenericDatagram *datagram)
	Send datagrams up to the higher layers. More...

virtual void	sendDatagramToOutput (GenericDatagram datagram, const InterfaceEntry ie, L3Address nextHop)
	Last TTL check, then send datagram on the given interface. More...

virtual void	datagramPreRouting (GenericDatagram datagram, const InterfaceEntry inIE, const InterfaceEntry *destIE, const L3Address &nextHop)

virtual void	datagramLocalIn (GenericDatagram datagram, const InterfaceEntry inIE)

virtual void	datagramLocalOut (GenericDatagram datagram, const InterfaceEntry destIE, const L3Address &nextHop)

virtual IHook::Result	datagramPreRoutingHook (GenericDatagram datagram, const InterfaceEntry inIE, const InterfaceEntry *&outIE, L3Address &nextHop)

virtual IHook::Result	datagramForwardHook (GenericDatagram datagram, const InterfaceEntry inIE, const InterfaceEntry *&outIE, L3Address &nextHop)

virtual IHook::Result	datagramPostRoutingHook (GenericDatagram datagram, const InterfaceEntry inIE, const InterfaceEntry *&outIE, L3Address &nextHop)

virtual IHook::Result	datagramLocalInHook (GenericDatagram datagram, const InterfaceEntry inIE)

virtual IHook::Result	datagramLocalOutHook (GenericDatagram datagram, const InterfaceEntry &outIE, L3Address &nextHop)

virtual void	initialize () override
	Initialization. More...

virtual void	handleMessage (cMessage *message) override
	Handle message. More...

virtual void	endService (cPacket *packet) override
	Processing of generic datagrams. More...

Protected Member Functions inherited from inet::QueueBase
virtual void	arrival (cPacket *msg) override
	Functions to (re)define behaviour. More...

virtual cPacket *	arrivalWhenIdle (cPacket *msg) override
	Called when a message arrives at the module when the queue is empty. More...

virtual simtime_t	startService (cPacket *msg) override
	Called when a message starts service, and should return the service time. More...

Protected Member Functions inherited from inet::AbstractQueue
virtual cPacket *	cancelService ()
	If a message is under service, aborts its service and returns the message. More...

Protected Attributes
IInterfaceTable *	interfaceTable

GenericRoutingTable *	routingTable

IARP *	arp

int	queueOutBaseGateId

int	defaultHopLimit

ProtocolMapping	mapping

HookList	hooks

DatagramQueueForHooks	queuedDatagramsForHooks

int	numLocalDeliver

int	numDropped

int	numUnroutable

int	numForwarded

Protected Attributes inherited from inet::QueueBase
simtime_t	delay

Protected Attributes inherited from inet::AbstractQueue
cPacketQueue	queue
	The queue. More...

Detailed Description

Implements a generic network protocol that routes generic datagrams through the network.

Routing decisions are based on a generic routing table, but it also supports the netfilter interface to allow routing protocols to kick in. It doesn't provide datagram fragmentation and reassembling.

Member Typedef Documentation

typedef std::list<QueuedDatagramForHook> inet::GenericNetworkProtocol::DatagramQueueForHooks

protected

typedef std::multimap<int, IHook *> inet::GenericNetworkProtocol::HookList

protected

Constructor & Destructor Documentation

inet::GenericNetworkProtocol::GenericNetworkProtocol ( )

                                                :
         interfaceTable(nullptr),
         routingTable(nullptr),
         arp(nullptr),
         queueOutBaseGateId(-1),
         defaultHopLimit(-1),
         numLocalDeliver(0),
         numDropped(0),
         numUnroutable(0),
         numForwarded(0)
 {
 }

inet::GenericNetworkProtocol::~GenericNetworkProtocol ( )

 {
     for (auto & elem : queuedDatagramsForHooks) {
         delete elem.datagram;
     }
     queuedDatagramsForHooks.clear();
 }

Member Function Documentation

INetfilter::IHook::Result inet::GenericNetworkProtocol::datagramForwardHook	(	GenericDatagram *	datagram,
		const InterfaceEntry *	inIE,
		const InterfaceEntry *&	outIE,
		L3Address &	nextHop
	)

protectedvirtual

 {
     for (auto & elem : hooks) {
         IHook::Result r = elem.second->datagramForwardHook(datagram, inIE, outIE, nextHop);
         switch (r) {
             case IHook::ACCEPT:
                 break;    // continue iteration
 
             case IHook::DROP:
                 delete datagram;
                 return r;
 
             case IHook::QUEUE:
                 queuedDatagramsForHooks.push_back(QueuedDatagramForHook(datagram, inIE, outIE, nextHop, INetfilter::IHook::FORWARD));
                 return r;
 
             case IHook::STOLEN:
                 return r;
 
             default:
                 throw cRuntimeError("Unknown Hook::Result value: %d", (int)r);
         }
     }
     return IHook::ACCEPT;
 }

void inet::GenericNetworkProtocol::datagramLocalIn	(	GenericDatagram *	datagram,
		const InterfaceEntry *	inIE
	)

protectedvirtual

Referenced by reinjectQueuedDatagram().

 {
     sendDatagramToHL(datagram);
 }

INetfilter::IHook::Result inet::GenericNetworkProtocol::datagramLocalInHook	(	GenericDatagram *	datagram,
		const InterfaceEntry *	inIE
	)

protectedvirtual

Referenced by routePacket().

 {
     L3Address address;
     for (auto & elem : hooks) {
         IHook::Result r = elem.second->datagramLocalInHook(datagram, inIE);
         switch (r) {
             case IHook::ACCEPT:
                 break;    // continue iteration
 
             case IHook::DROP:
                 delete datagram;
                 return r;
 
             case IHook::QUEUE:
                 queuedDatagramsForHooks.push_back(QueuedDatagramForHook(datagram, inIE, nullptr, address, INetfilter::IHook::LOCALIN));
                 return r;
 
             case IHook::STOLEN:
                 return r;
 
             default:
                 throw cRuntimeError("Unknown Hook::Result value: %d", (int)r);
         }
     }
     return IHook::ACCEPT;
 }

void inet::GenericNetworkProtocol::datagramLocalOut	(	GenericDatagram *	datagram,
		const InterfaceEntry *	destIE,
		const L3Address &	nextHop
	)

protectedvirtual

Referenced by handleMessageFromHL(), and reinjectQueuedDatagram().

 {
     // route packet
     if (!datagram->getDestinationAddress().isMulticast())
         routePacket(datagram, destIE, nextHop, true);
     else
         routeMulticastPacket(datagram, destIE, nullptr);
 }

INetfilter::IHook::Result inet::GenericNetworkProtocol::datagramLocalOutHook	(	GenericDatagram *	datagram,
		const InterfaceEntry *&	outIE,
		L3Address &	nextHop
	)

protectedvirtual

Referenced by handleMessageFromHL().

 {
     for (auto & elem : hooks) {
         IHook::Result r = elem.second->datagramLocalOutHook(datagram, outIE, nextHop);
         switch (r) {
             case IHook::ACCEPT:
                 break;    // continue iteration
 
             case IHook::DROP:
                 delete datagram;
                 return r;
 
             case IHook::QUEUE:
                 queuedDatagramsForHooks.push_back(QueuedDatagramForHook(datagram, nullptr, outIE, nextHop, INetfilter::IHook::LOCALOUT));
                 return r;
 
             case IHook::STOLEN:
                 return r;
 
             default:
                 throw cRuntimeError("Unknown Hook::Result value: %d", (int)r);
         }
     }
     return IHook::ACCEPT;
 }

INetfilter::IHook::Result inet::GenericNetworkProtocol::datagramPostRoutingHook	(	GenericDatagram *	datagram,
		const InterfaceEntry *	inIE,
		const InterfaceEntry *&	outIE,
		L3Address &	nextHop
	)

protectedvirtual

 {
     for (auto & elem : hooks) {
         IHook::Result r = elem.second->datagramPostRoutingHook(datagram, inIE, outIE, nextHop);
         switch (r) {
             case IHook::ACCEPT:
                 break;    // continue iteration
 
             case IHook::DROP:
                 delete datagram;
                 return r;
 
             case IHook::QUEUE:
                 queuedDatagramsForHooks.push_back(QueuedDatagramForHook(datagram, inIE, outIE, nextHop, INetfilter::IHook::POSTROUTING));
                 return r;
 
             case IHook::STOLEN:
                 return r;
 
             default:
                 throw cRuntimeError("Unknown Hook::Result value: %d", (int)r);
         }
     }
     return IHook::ACCEPT;
 }

void inet::GenericNetworkProtocol::datagramPreRouting	(	GenericDatagram *	datagram,
		const InterfaceEntry *	inIE,
		const InterfaceEntry *	destIE,
		const L3Address &	nextHop
	)

protectedvirtual

Referenced by handlePacketFromNetwork(), and reinjectQueuedDatagram().

 {
     // route packet
     if (!datagram->getDestinationAddress().isMulticast())
         routePacket(datagram, destIE, nextHop, false);
     else
         routeMulticastPacket(datagram, destIE, inIE);
 }

INetfilter::IHook::Result inet::GenericNetworkProtocol::datagramPreRoutingHook	(	GenericDatagram *	datagram,
		const InterfaceEntry *	inIE,
		const InterfaceEntry *&	outIE,
		L3Address &	nextHop
	)

protectedvirtual

Referenced by handlePacketFromNetwork().

 {
     for (auto & elem : hooks) {
         IHook::Result r = elem.second->datagramPreRoutingHook(datagram, inIE, outIE, nextHop);
         switch (r) {
             case IHook::ACCEPT:
                 break;    // continue iteration
 
             case IHook::DROP:
                 delete datagram;
                 return r;
 
             case IHook::QUEUE:
                 if (datagram->getOwner() != this)
                     throw cRuntimeError("Model error: netfilter hook changed the owner of queued datagram '%s'", datagram->getFullName());
                 queuedDatagramsForHooks.push_back(QueuedDatagramForHook(datagram, inIE, nullptr, nextHop, INetfilter::IHook::PREROUTING));
                 return r;
 
             case IHook::STOLEN:
                 return r;
 
             default:
                 throw cRuntimeError("Unknown Hook::Result value: %d", (int)r);
         }
     }
     return IHook::ACCEPT;
 }

cPacket * inet::GenericNetworkProtocol::decapsulate ( GenericDatagram * datagram )

protectedvirtual

Decapsulate and return encapsulated packet after attaching GenericNetworkProtocolControlInfo.

Referenced by sendDatagramToHL().

 {
     // decapsulate transport packet
     const InterfaceEntry *fromIE = getSourceInterfaceFrom(datagram);
     cPacket *packet = datagram->decapsulate();
 
     // create and fill in control info
     GenericNetworkProtocolControlInfo *controlInfo = new GenericNetworkProtocolControlInfo();
     controlInfo->setProtocol(datagram->getTransportProtocol());
     controlInfo->setSourceAddress(datagram->getSourceAddress());
     controlInfo->setDestinationAddress(datagram->getDestinationAddress());
     controlInfo->setInterfaceId(fromIE ? fromIE->getInterfaceId() : -1);
     controlInfo->setHopLimit(datagram->getHopLimit());
 
     // attach control info
     packet->setControlInfo(controlInfo);
 
     return packet;
 }

void inet::GenericNetworkProtocol::dropQueuedDatagram ( const INetworkDatagram * daragram )

overridevirtual

Requests the network layer to drop the datagram, because it's no longer needed.

This function may be used by a reactive routing protocol when it cancels the route discovery process.

Implements inet::INetfilter.

 {
     Enter_Method("dropDatagram()");
     for (auto iter = queuedDatagramsForHooks.begin(); iter != queuedDatagramsForHooks.end(); iter++) {
         if (iter->datagram == datagram) {
             delete datagram;
             queuedDatagramsForHooks.erase(iter);
             return;
         }
     }
 }

GenericDatagram * inet::GenericNetworkProtocol::encapsulate	(	cPacket *	transportPacket,
		const InterfaceEntry *&	destIE
	)

protectedvirtual

Encapsulate packet coming from higher layers into GenericDatagram, using the control info attached to the packet.

Referenced by handleMessageFromHL().

 {
     GenericNetworkProtocolControlInfo *controlInfo = check_and_cast<GenericNetworkProtocolControlInfo *>(transportPacket->removeControlInfo());
     GenericDatagram *datagram = new GenericDatagram(transportPacket->getName());
 //    datagram->setByteLength(HEADER_BYTES); //TODO parameter
     datagram->encapsulate(transportPacket);
 
     // set source and destination address
     L3Address dest = controlInfo->getDestinationAddress();
     datagram->setDestinationAddress(dest);
 
     // Generic_MULTICAST_IF option, but allow interface selection for unicast packets as well
     destIE = interfaceTable->getInterfaceById(controlInfo->getInterfaceId());
 
     L3Address src = controlInfo->getSourceAddress();
 
     // when source address was given, use it; otherwise it'll get the address
     // of the outgoing interface after routing
     if (!src.isUnspecified()) {
         // if interface parameter does not match existing interface, do not send datagram
         if (routingTable->getInterfaceByAddress(src) == nullptr)
             throw cRuntimeError("Wrong source address %s in (%s)%s: no interface with such address",
                     src.str().c_str(), transportPacket->getClassName(), transportPacket->getFullName());
         datagram->setSourceAddress(src);
     }
 
     // set other fields
     short ttl;
     if (controlInfo->getHopLimit() > 0)
         ttl = controlInfo->getHopLimit();
     else if (false) //TODO: datagram->getDestinationAddress().isLinkLocalMulticast())
         ttl = 1;
     else
         ttl = defaultHopLimit;
 
     datagram->setHopLimit(ttl);
     datagram->setTransportProtocol(controlInfo->getProtocol());
 
     // setting GenericNetworkProtocol options is currently not supported
 
     delete controlInfo;
     return datagram;
 }

void inet::GenericNetworkProtocol::endService ( cPacket * packet )

overrideprotectedvirtual

Processing of generic datagrams.

Called when a datagram reaches the front of the queue.

Implements inet::AbstractQueue.

 {
     if (pk->getArrivalGate()->isName("transportIn"))
         handleMessageFromHL(pk);
     else {
         GenericDatagram *dgram = check_and_cast<GenericDatagram *>(pk);
         handlePacketFromNetwork(dgram);
     }
 }

const InterfaceEntry * inet::GenericNetworkProtocol::getSourceInterfaceFrom ( cPacket * packet )

protectedvirtual

Referenced by decapsulate(), handlePacketFromNetwork(), and routePacket().

 {
     cGate *g = msg->getArrivalGate();
     return g ? interfaceTable->getInterfaceByNetworkLayerGateIndex(g->getIndex()) : nullptr;
 }

void inet::GenericNetworkProtocol::handleMessage ( cMessage * message )

overrideprotectedvirtual

Handle message.

Reimplemented from inet::AbstractQueue.

 {
     if (dynamic_cast<RegisterTransportProtocolCommand *>(msg)) {
         RegisterTransportProtocolCommand *command = check_and_cast<RegisterTransportProtocolCommand *>(msg);
         mapping.addProtocolMapping(command->getProtocol(), msg->getArrivalGate()->getIndex());
         delete msg;
     }
     else
         QueueBase::handleMessage(msg);
 }

void inet::GenericNetworkProtocol::handleMessageFromHL ( cPacket * packet )

protectedvirtual

Handle messages (typically packets to be send in Generic) from transport or ICMP.

Invokes encapsulate(), then routePacket().

Referenced by endService().

 {
     // if no interface exists, do not send datagram
     if (interfaceTable->getNumInterfaces() == 0) {
         EV_INFO << "No interfaces exist, dropping packet\n";
         delete msg;
         return;
     }
 
     // encapsulate and send
     const InterfaceEntry *destIE;    // will be filled in by encapsulate()
     GenericDatagram *datagram = encapsulate(msg, destIE);
 
     L3Address nextHop;
     if (datagramLocalOutHook(datagram, destIE, nextHop) != IHook::ACCEPT)
         return;
 
     datagramLocalOut(datagram, destIE, nextHop);
 }

void inet::GenericNetworkProtocol::handlePacketFromNetwork ( GenericDatagram * datagram )

protectedvirtual

Handle GenericDatagram messages arriving from lower layer.

Decrements TTL, then invokes routePacket().

Referenced by endService().

 {
     if (datagram->hasBitError()) {
         //TODO discard
     }
 
     delete datagram->removeControlInfo();
 
     // hop counter decrement; FIXME but not if it will be locally delivered
     datagram->setHopLimit(datagram->getHopLimit() - 1);
 
     L3Address nextHop;
     const InterfaceEntry *inIE = getSourceInterfaceFrom(datagram);
     const InterfaceEntry *destIE = nullptr;
     if (datagramPreRoutingHook(datagram, inIE, destIE, nextHop) != IHook::ACCEPT)
         return;
 
     datagramPreRouting(datagram, inIE, destIE, nextHop);
 }

void inet::GenericNetworkProtocol::initialize ( )

overrideprotectedvirtual

Initialization.

Reimplemented from inet::QueueBase.

 {
     QueueBase::initialize();
 
     interfaceTable = getModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this);
     routingTable = getModuleFromPar<GenericRoutingTable>(par("routingTableModule"), this);
     arp = getModuleFromPar<IARP>(par("arpModule"), this);
 
     queueOutBaseGateId = gateSize("queueOut") == 0 ? -1 : gate("queueOut", 0)->getId();
     defaultHopLimit = par("hopLimit");
     numLocalDeliver = numDropped = numUnroutable = numForwarded = 0;
 
     WATCH(numLocalDeliver);
     WATCH(numDropped);
     WATCH(numUnroutable);
     WATCH(numForwarded);
 }

void inet::GenericNetworkProtocol::refreshDisplay ( ) const

overrideprotectedvirtual

 {
     char buf[80] = "";
     if (numForwarded > 0)
         sprintf(buf + strlen(buf), "fwd:%d ", numForwarded);
     if (numLocalDeliver > 0)
         sprintf(buf + strlen(buf), "up:%d ", numLocalDeliver);
     if (numDropped > 0)
         sprintf(buf + strlen(buf), "DROP:%d ", numDropped);
     if (numUnroutable > 0)
         sprintf(buf + strlen(buf), "UNROUTABLE:%d ", numUnroutable);
     getDisplayString().setTagArg("t", 0, buf);
 }

void inet::GenericNetworkProtocol::registerHook	(	int	priority,
		IHook *	hook
	)

overridevirtual

Adds the provided hook to the list of registered hooks that will be called by the network layer when it processes datagrams.

Implements inet::INetfilter.

 {
     Enter_Method("registerHook()");
     hooks.insert(std::pair<int, IHook *>(priority, hook));
 }

void inet::GenericNetworkProtocol::reinjectQueuedDatagram ( const INetworkDatagram * datagram )

overridevirtual

Requests the network layer to restart the processing of the datagram.

This function may be used by a reactive routing protocol when it completes the route discovery process.

Implements inet::INetfilter.

 {
     Enter_Method("reinjectDatagram()");
     for (auto iter = queuedDatagramsForHooks.begin(); iter != queuedDatagramsForHooks.end(); iter++) {
         if (iter->datagram == datagram) {
             GenericDatagram *datagram = iter->datagram;
             const InterfaceEntry *inIE = iter->inIE;
             const InterfaceEntry *outIE = iter->outIE;
             const L3Address& nextHop = iter->nextHop;
             INetfilter::IHook::Type hookType = iter->hookType;
             switch (hookType) {
                 case INetfilter::IHook::PREROUTING:
                     datagramPreRouting(datagram, inIE, outIE, nextHop);
                     break;
 
                 case INetfilter::IHook::LOCALIN:
                     datagramLocalIn(datagram, inIE);
                     break;
 
                 case INetfilter::IHook::LOCALOUT:
                     datagramLocalOut(datagram, outIE, nextHop);
                     break;
 
                 default:
                     throw cRuntimeError("Re-injection of datagram queued for this hook not implemented");
                     break;
             }
             queuedDatagramsForHooks.erase(iter);
             return;
         }
     }
 }

void inet::GenericNetworkProtocol::routeMulticastPacket	(	GenericDatagram *	datagram,
		const InterfaceEntry *	destIE,
		const InterfaceEntry *	fromIE
	)

protectedvirtual

Forwards packets to all multicast destinations, using sendDatagramToOutput().

Referenced by datagramLocalOut(), and datagramPreRouting().

 {
     L3Address destAddr = datagram->getDestinationAddress();
     // if received from the network...
     if (fromIE != nullptr) {
         // check for local delivery
         if (routingTable->isLocalMulticastAddress(destAddr))
             sendDatagramToHL(datagram);
 //
 //        // don't forward if GenericNetworkProtocol forwarding is off
 //        if (!rt->isGenericForwardingEnabled())
 //        {
 //            delete datagram;
 //            return;
 //        }
 //
 //        // don't forward if dest address is link-scope
 //        if (destAddr.isLinkLocalMulticast())
 //        {
 //            delete datagram;
 //            return;
 //        }
     }
     else {
         //TODO
         for (int i = 0; i < interfaceTable->getNumInterfaces(); ++i) {
             const InterfaceEntry *destIE = interfaceTable->getInterface(i);
             if (!destIE->isLoopback())
                 sendDatagramToOutput(datagram->dup(), destIE, datagram->getDestinationAddress());
         }
         delete datagram;
     }
 
 //    Address destAddr = datagram->getDestinationAddress();
 //    EV << "Routing multicast datagram `" << datagram->getName() << "' with dest=" << destAddr << "\n";
 //
 //    numMulticast++;
 //
 //    // DVMRP: process datagram only if sent locally or arrived on the shortest
 //    // route (provided routing table already contains srcAddr); otherwise
 //    // discard and continue.
 //    const InterfaceEntry *shortestPathIE = rt->getInterfaceForDestinationAddr(datagram->getSourceAddress());
 //    if (fromIE!=nullptr && shortestPathIE!=nullptr && fromIE!=shortestPathIE)
 //    {
 //        // FIXME count dropped
 //        EV << "Packet dropped.\n";
 //        delete datagram;
 //        return;
 //    }
 //
 //    // if received from the network...
 //    if (fromIE!=nullptr)
 //    {
 //        // check for local delivery
 //        if (rt->isLocalMulticastAddress(destAddr))
 //        {
 //            GenericDatagram *datagramCopy = datagram->dup();
 //
 //            // FIXME code from the MPLS model: set packet dest address to routerId (???)
 //            datagramCopy->setDestinationAddress(rt->getRouterId());
 //
 //            reassembleAndDeliver(datagramCopy);
 //        }
 //
 //        // don't forward if GenericNetworkProtocol forwarding is off
 //        if (!rt->isGenericForwardingEnabled())
 //        {
 //            delete datagram;
 //            return;
 //        }
 //
 //        // don't forward if dest address is link-scope
 //        if (destAddr.isLinkLocalMulticast())
 //        {
 //            delete datagram;
 //            return;
 //        }
 //
 //    }
 //
 //    // routed explicitly via Generic_MULTICAST_IF
 //    if (destIE!=nullptr)
 //    {
 //        ASSERT(datagram->getDestinationAddress().isMulticast());
 //
 //        EV << "multicast packet explicitly routed via output interface " << destIE->getName() << endl;
 //
 //        // set datagram source address if not yet set
 //        if (datagram->getSourceAddress().isUnspecified())
 //            datagram->setSourceAddress(destIE->ipv4Data()->getGenericAddress());
 //
 //        // send
 //        sendDatagramToOutput(datagram, destIE, datagram->getDestinationAddress());
 //
 //        return;
 //    }
 //
 //    // now: routing
 //    MulticastRoutes routes = rt->getMulticastRoutesFor(destAddr);
 //    if (routes.size()==0)
 //    {
 //        // no destination: delete datagram
 //        delete datagram;
 //    }
 //    else
 //    {
 //        // copy original datagram for multiple destinations
 //        for (unsigned int i=0; i<routes.size(); i++)
 //        {
 //            const InterfaceEntry *destIE = routes[i].interf;
 //
 //            // don't forward to input port
 //            if (destIE && destIE!=fromIE)
 //            {
 //                GenericDatagram *datagramCopy = datagram->dup();
 //
 //                // set datagram source address if not yet set
 //                if (datagramCopy->getSourceAddress().isUnspecified())
 //                    datagramCopy->setSourceAddress(destIE->ipv4Data()->getGenericAddress());
 //
 //                // send
 //                Address nextHop = routes[i].gateway;
 //                sendDatagramToOutput(datagramCopy, destIE, nextHop);
 //            }
 //        }
 //
 //        // only copies sent, delete original datagram
 //        delete datagram;
 //    }
 }

void inet::GenericNetworkProtocol::routePacket	(	GenericDatagram *	datagram,
		const InterfaceEntry *	destIE,
		const L3Address &	nextHop,
		bool	fromHL
	)

protectedvirtual

Performs routing.

Based on the routing decision, it dispatches to sendDatagramToHL() for local packets, to sendDatagramToOutput() for forwarded packets, to handleMulticastPacket() for multicast packets, or drops the packet if it's unroutable or forwarding is off.

Referenced by datagramLocalOut(), and datagramPreRouting().

 {
     // TBD add option handling code here
 
     L3Address destAddr = datagram->getDestinationAddress();
 
     EV_INFO << "Routing datagram `" << datagram->getName() << "' with dest=" << destAddr << ": ";
 
     // check for local delivery
     if (routingTable->isLocalAddress(destAddr)) {
         EV_INFO << "local delivery\n";
         if (datagram->getSourceAddress().isUnspecified())
             datagram->setSourceAddress(destAddr); // allows two apps on the same host to communicate
         numLocalDeliver++;
 
         if (datagramLocalInHook(datagram, getSourceInterfaceFrom(datagram)) != INetfilter::IHook::ACCEPT)
             return;
 
         sendDatagramToHL(datagram);
         return;
     }
 
     // if datagram arrived from input gate and Generic_FORWARD is off, delete datagram
     if (!fromHL && !routingTable->isForwardingEnabled()) {
         EV_INFO << "forwarding off, dropping packet\n";
         numDropped++;
         delete datagram;
         return;
     }
 
     // if output port was explicitly requested, use that, otherwise use GenericNetworkProtocol routing
     // TODO: see IPv4, using destIE here leaves nextHope unspecified
     L3Address nextHop;
     if (destIE && !requestedNextHop.isUnspecified()) {
         EV_DETAIL << "using manually specified output interface " << destIE->getName() << "\n";
         nextHop = requestedNextHop;
     }
     else {
         // use GenericNetworkProtocol routing (lookup in routing table)
         const GenericRoute *re = routingTable->findBestMatchingRoute(destAddr);
 
         // error handling: destination address does not exist in routing table:
         // throw packet away and continue
         if (re == nullptr) {
             EV_INFO << "unroutable, discarding packet\n";
             numUnroutable++;
             delete datagram;
             return;
         }
 
         // extract interface and next-hop address from routing table entry
         destIE = re->getInterface();
         nextHop = re->getNextHopAsGeneric();
     }
 
     // set datagram source address if not yet set
     if (datagram->getSourceAddress().isUnspecified())
         datagram->setSourceAddress(destIE->getGenericNetworkProtocolData()->getAddress());
 
     // default: send datagram to fragmentation
     EV_INFO << "output interface is " << destIE->getName() << ", next-hop address: " << nextHop << "\n";
     numForwarded++;
 
     sendDatagramToOutput(datagram, destIE, nextHop);
 }

void inet::GenericNetworkProtocol::sendDatagramToHL ( GenericDatagram * datagram )

protectedvirtual

Send datagrams up to the higher layers.

Referenced by datagramLocalIn(), routeMulticastPacket(), and routePacket().

 {
     int protocol = datagram->getTransportProtocol();
     int gateIndex = mapping.findOutputGateForProtocol(protocol);
     // check if the transportOut port are connected, otherwise discard the packet
     if (gateIndex >= 0) {
         cGate *outGate = gate("transportOut", gateIndex);
         if (outGate->isPathOK()) {
             // decapsulate and send on appropriate output gate
             cPacket *packet = decapsulate(datagram);
             delete datagram;
             send(packet, "transportOut", gateIndex);
             return;
         }
     }
 
     //TODO send an ICMP error: protocol unreachable
     delete datagram;
 }

void inet::GenericNetworkProtocol::sendDatagramToOutput	(	GenericDatagram *	datagram,
		const InterfaceEntry *	ie,
		L3Address	nextHop
	)

protectedvirtual

Last TTL check, then send datagram on the given interface.

Referenced by routeMulticastPacket(), and routePacket().

 {
     if (datagram->getByteLength() > ie->getMTU())
         throw cRuntimeError("datagram too large"); //TODO refine
 
     // hop counter check
     if (datagram->getHopLimit() <= 0) {
         EV_INFO << "datagram hopLimit reached zero, discarding\n";
         delete datagram;    //TODO stats counter???
         return;
     }
 
     if (!ie->isBroadcast()) {
         EV_DETAIL << "output interface " << ie->getName() << " is not broadcast, skipping ARP\n";
         send(datagram, queueOutBaseGateId + ie->getNetworkLayerGateIndex());
         return;
     }
 
     // determine what address to look up in ARP cache
     if (nextHop.isUnspecified()) {
         nextHop = datagram->getDestinationAddress();
         EV_WARN << "no next-hop address, using destination address " << nextHop << " (proxy ARP)\n";
     }
 
     // send out datagram to NIC, with control info attached
     MACAddress nextHopMAC = arp->resolveL3Address(nextHop, ie);
     if (nextHopMAC == MACAddress::UNSPECIFIED_ADDRESS) {
         throw cRuntimeError("ARP couldn't resolve the '%s' address", nextHop.str().c_str());
     }
     else {
         // add control info with MAC address
         Ieee802Ctrl *controlInfo = new Ieee802Ctrl();
         controlInfo->setDest(nextHopMAC);
         controlInfo->setEtherType(ETHERTYPE_INET_GENERIC);
         datagram->setControlInfo(controlInfo);
 
         // send out
         send(datagram, queueOutBaseGateId + ie->getNetworkLayerGateIndex());
     }
 }

void inet::GenericNetworkProtocol::unregisterHook	(	int	priority,
		IHook *	hook
	)

overridevirtual

Removes the provided hook from the list of registered hooks.

Implements inet::INetfilter.

 {
     Enter_Method("unregisterHook()");
     for (auto iter = hooks.begin(); iter != hooks.end(); iter++) {
         if ((iter->first == priority) && (iter->second == hook)) {
             hooks.erase(iter);
             return;
         }
     }
 }