inet::IPv4 Class Reference

Implements the IPv4 protocol. More...

#include <IPv4.h>

Inheritance diagram for inet::IPv4:

Classes
class	QueuedDatagramForHook
	Represents an IPv4Datagram, queued by a Hook. More...

Public Types
typedef std::map< IPv4Address, cPacketQueue >	PendingPackets

Public Member Functions
	IPv4 ()
virtual	~IPv4 ()
virtual void	registerHook (int priority, IHook *hook) override
	registers a Hook to be executed during datagram processing More...
virtual void	unregisterHook (int priority, IHook *hook) override
	unregisters a Hook to be executed during datagram processing More...
void	dropQueuedDatagram (const INetworkDatagram *datagram) override
	drop a previously queued datagram More...
void	reinjectQueuedDatagram (const INetworkDatagram *datagram) override
	re-injects a previously queued datagram More...
void	sendOnTransportOutGateByProtocolId (cPacket *packet, int protocolId)
	send packet on transportOut gate specified by protocolId More...
virtual bool	handleOperationStage (LifecycleOperation *operation, int stage, IDoneCallback *doneCallback) override
	ILifecycle method. More...
virtual void	receiveSignal (cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override
	cListener method 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::ILifecycle
virtual	~ILifecycle ()
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 const InterfaceEntry *	getShortestPathInterfaceToSource (IPv4Datagram *datagram)
virtual void	refreshDisplay () const override
void	arpResolutionCompleted (IARP::Notification *entry)
void	arpResolutionTimedOut (IARP::Notification *entry)
virtual IPv4Datagram *	encapsulate (cPacket *transportPacket, IPv4ControlInfo *controlInfo)
	Encapsulate packet coming from higher layers into IPv4Datagram, using the given control info. More...
virtual IPv4Datagram *	createIPv4Datagram (const char *name)
	Creates a blank IPv4 datagram. More...
virtual void	handleIncomingDatagram (IPv4Datagram *datagram, const InterfaceEntry *fromIE)
	Handle IPv4Datagram messages arriving from lower layer. More...
virtual void	preroutingFinish (IPv4Datagram *datagram, const InterfaceEntry *fromIE, const InterfaceEntry *destIE, IPv4Address nextHopAddr)
virtual void	handlePacketFromHL (cPacket *packet)
	Handle messages (typically packets to be send in IPv4) from transport or ICMP. More...
virtual void	handlePacketFromARP (cPacket *packet)
	TODO. More...
virtual void	datagramLocalOut (IPv4Datagram *datagram, const InterfaceEntry *destIE, IPv4Address nextHopAddr)
	Routes and sends datagram received from higher layers. More...
virtual void	handleIncomingARPPacket (ARPPacket *packet, const InterfaceEntry *fromIE)
	Handle incoming ARP packets by sending them over to ARP. More...
virtual void	handleIncomingICMP (ICMPMessage *packet)
	Handle incoming ICMP messages. More...
virtual void	routeUnicastPacket (IPv4Datagram *datagram, const InterfaceEntry *fromIE, const InterfaceEntry *destIE, IPv4Address requestedNextHopAddress)
	Performs unicast routing. More...
void	routeUnicastPacketFinish (IPv4Datagram *datagram, const InterfaceEntry *fromIE, const InterfaceEntry *destIE, IPv4Address nextHopAddr)
virtual void	routeLocalBroadcastPacket (IPv4Datagram *datagram, const InterfaceEntry *destIE)
	Broadcasts the datagram on the specified interface. More...
virtual const InterfaceEntry *	determineOutgoingInterfaceForMulticastDatagram (IPv4Datagram *datagram, const InterfaceEntry *multicastIFOption)
	Determines the output interface for the given multicast datagram. More...
virtual void	forwardMulticastPacket (IPv4Datagram *datagram, const InterfaceEntry *fromIE)
	Forwards packets to all multicast destinations, using fragmentAndSend(). More...
virtual void	reassembleAndDeliver (IPv4Datagram *datagram)
	Perform reassembly of fragmented datagrams, then send them up to the higher layers using sendToHL(). More...
virtual void	reassembleAndDeliverFinish (IPv4Datagram *datagram)
virtual cPacket *	decapsulate (IPv4Datagram *datagram)
	Decapsulate and return encapsulated packet after attaching IPv4ControlInfo. More...
virtual void	fragmentPostRouting (IPv4Datagram *datagram, const InterfaceEntry *ie, IPv4Address nextHopAddr)
	Call PostRouting Hook and continue with fragmentAndSend() if accepted. More...
virtual void	fragmentAndSend (IPv4Datagram *datagram, const InterfaceEntry *ie, IPv4Address nextHopAddr)
	Fragment packet if needed, then send it to the selected interface using sendDatagramToOutput(). More...
virtual void	sendDatagramToOutput (IPv4Datagram *datagram, const InterfaceEntry *ie, IPv4Address nextHopAddr)
	Send datagram on the given interface. More...
virtual MACAddress	resolveNextHopMacAddress (cPacket *packet, IPv4Address nextHopAddr, const InterfaceEntry *destIE)
virtual void	sendPacketToIeee802NIC (cPacket *packet, const InterfaceEntry *ie, const MACAddress &macAddress, int etherType)
virtual void	sendPacketToNIC (cPacket *packet, const InterfaceEntry *ie)
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleMessage (cMessage *msg) override
virtual void	endService (cPacket *packet) override
	Processing of IPv4 datagrams. More...
IHook::Result	datagramPreRoutingHook (INetworkDatagram *datagram, const InterfaceEntry *inIE, const InterfaceEntry *&outIE, L3Address &nextHopAddr)
	called before a packet arriving from the network is routed More...
IHook::Result	datagramForwardHook (INetworkDatagram *datagram, const InterfaceEntry *inIE, const InterfaceEntry *&outIE, L3Address &nextHopAddr)
	called before a packet arriving from the network is delivered via the network More...
IHook::Result	datagramPostRoutingHook (INetworkDatagram *datagram, const InterfaceEntry *inIE, const InterfaceEntry *&outIE, L3Address &nextHopAddr)
	called before a packet is delivered via the network More...
IHook::Result	datagramLocalInHook (INetworkDatagram *datagram, const InterfaceEntry *inIE)
	called before a packet arriving from the network is delivered locally More...
IHook::Result	datagramLocalOutHook (INetworkDatagram *datagram, const InterfaceEntry *&outIE, L3Address &nextHopAddr)
	called before a packet arriving locally is delivered More...
virtual bool	isNodeUp ()
virtual void	stop ()
virtual void	start ()
virtual void	flush ()
Protected Member Functions inherited from inet::QueueBase
virtual void	initialize () override
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
IIPv4RoutingTable *	rt = nullptr
IInterfaceTable *	ift = nullptr
IARP *	arp = nullptr
ICMP *	icmp = nullptr
cGate *	arpInGate = nullptr
cGate *	arpOutGate = nullptr
int	transportInGateBaseId = -1
int	queueOutGateBaseId = -1
int	defaultTimeToLive = -1
int	defaultMCTimeToLive = -1
simtime_t	fragmentTimeoutTime
bool	forceBroadcast = false
bool	useProxyARP = false
bool	isUp = false
long	curFragmentId = -1
IPv4FragBuf	fragbuf
simtime_t	lastCheckTime
ProtocolMapping	mapping
PendingPackets	pendingPackets
int	numMulticast = 0
int	numLocalDeliver = 0
int	numDropped = 0
int	numUnroutable = 0
int	numForwarded = 0
HookList	hooks
DatagramQueueForHooks	queuedDatagramsForHooks
Protected Attributes inherited from inet::QueueBase
simtime_t	delay
Protected Attributes inherited from inet::AbstractQueue
cPacketQueue	queue
	The queue. More...

Detailed Description

Implements the IPv4 protocol.

Member Typedef Documentation

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

protected

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

protected

typedef std::map<IPv4Address, cPacketQueue> inet::IPv4::PendingPackets

Constructor & Destructor Documentation

inet::IPv4::IPv4

(

)

           :
    isUp(true)
{
}

inet::IPv4::~IPv4 ( )

virtual

{
    flush();
}

Member Function Documentation

void inet::IPv4::arpResolutionCompleted ( IARP::Notification *  entry )

protected

Referenced by receiveSignal().

{
    if (entry->l3Address.getType() != L3Address::IPv4)
        return;
    auto it = pendingPackets.find(entry->l3Address.toIPv4());
    if (it != pendingPackets.end()) {
        cPacketQueue& packetQueue = it->second;
        EV << "ARP resolution completed for " << entry->l3Address << ". Sending " << packetQueue.getLength()
           << " waiting packets from the queue\n";

        while (!packetQueue.isEmpty()) {
            cPacket *msg = packetQueue.pop();
            EV << "Sending out queued packet " << msg << "\n";
            sendPacketToIeee802NIC(msg, entry->ie, entry->macAddress, ETHERTYPE_IPv4);
        }
        pendingPackets.erase(it);
    }
}

void inet::IPv4::arpResolutionTimedOut ( IARP::Notification *  entry )

protected

Referenced by receiveSignal().

{
    if (entry->l3Address.getType() != L3Address::IPv4)
        return;
    auto it = pendingPackets.find(entry->l3Address.toIPv4());
    if (it != pendingPackets.end()) {
        cPacketQueue& packetQueue = it->second;
        EV << "ARP resolution failed for " << entry->l3Address << ",  dropping " << packetQueue.getLength() << " packets\n";
        for (int i = 0; i < packetQueue.getLength(); i++) {
            auto packet = packetQueue.get(i);
            emit(LayeredProtocolBase::packetFromUpperDroppedSignal, packet);
        }
        packetQueue.clear();
        pendingPackets.erase(it);
    }
}

IPv4Datagram * inet::IPv4::createIPv4Datagram ( const char *  name )

protectedvirtual

Creates a blank IPv4 datagram.

Override when subclassing IPv4Datagram is needed

Referenced by encapsulate().

{
    return new IPv4Datagram(name);
}

INetfilter::IHook::Result inet::IPv4::datagramForwardHook ( INetworkDatagram *  datagram, const InterfaceEntry *  inIE, const InterfaceEntry *&  outIE, L3Address &  nextHopAddr  )

protected

called before a packet arriving from the network is delivered via the network

Referenced by routeUnicastPacket().

{
    for (auto & elem : hooks) {
        IHook::Result r = elem.second->datagramForwardHook(datagram, inIE, outIE, nextHopAddr);
        switch (r) {
            case INetfilter::IHook::ACCEPT:
                break;    // continue iteration

            case INetfilter::IHook::DROP:
                delete datagram;
                return r;

            case INetfilter::IHook::QUEUE:
                queuedDatagramsForHooks.push_back(QueuedDatagramForHook(dynamic_cast<IPv4Datagram *>(datagram), inIE, outIE, nextHopAddr.toIPv4(), INetfilter::IHook::FORWARD));
                return r;

            case INetfilter::IHook::STOLEN:
                return r;

            default:
                throw cRuntimeError("Unknown Hook::Result value: %d", (int)r);
        }
    }
    return INetfilter::IHook::ACCEPT;
}

INetfilter::IHook::Result inet::IPv4::datagramLocalInHook ( INetworkDatagram *  datagram, const InterfaceEntry *  inIE  )

protected

called before a packet arriving from the network is delivered locally

Referenced by reassembleAndDeliver().

{
    for (auto & elem : hooks) {
        IHook::Result r = elem.second->datagramLocalInHook(datagram, inIE);
        switch (r) {
            case INetfilter::IHook::ACCEPT:
                break;    // continue iteration

            case INetfilter::IHook::DROP:
                delete datagram;
                return r;

            case INetfilter::IHook::QUEUE: {
                IPv4Datagram *dgram = check_and_cast<IPv4Datagram *>(datagram);
                if (dgram->getOwner() != this)
                    throw cRuntimeError("Model error: netfilter hook changed the owner of queued datagram '%s'", dgram->getFullName());
                queuedDatagramsForHooks.push_back(QueuedDatagramForHook(dgram, inIE, nullptr, IPv4Address::UNSPECIFIED_ADDRESS, INetfilter::IHook::LOCALIN));
                return r;
            }

            case INetfilter::IHook::STOLEN:
                return r;

            default:
                throw cRuntimeError("Unknown Hook::Result value: %d", (int)r);
        }
    }
    return INetfilter::IHook::ACCEPT;
}

void inet::IPv4::datagramLocalOut ( IPv4Datagram *  datagram, const InterfaceEntry *  destIE, IPv4Address  nextHopAddr  )

protectedvirtual

Routes and sends datagram received from higher layers.

Invokes datagramLocalOutHook(), then routePacket().

Referenced by handlePacketFromHL(), and reinjectQueuedDatagram().

{
    IPv4ControlInfo *controlInfo = check_and_cast_nullable<IPv4ControlInfo *>(datagram->removeControlInfo());
    bool multicastLoop = true;
    if (controlInfo != nullptr) {
        multicastLoop = controlInfo->getMulticastLoop();
        delete controlInfo;
    }

    // send
    IPv4Address& destAddr = datagram->getDestAddress();

    EV_DETAIL << "Sending datagram " << datagram << " with destination = " << destAddr << "\n";

    if (datagram->getDestAddress().isMulticast()) {
        destIE = determineOutgoingInterfaceForMulticastDatagram(datagram, destIE);

        // loop back a copy
        if (multicastLoop && (!destIE || !destIE->isLoopback())) {
            const InterfaceEntry *loopbackIF = ift->getFirstLoopbackInterface();
            if (loopbackIF)
                fragmentPostRouting(datagram->dup(), loopbackIF, destAddr);
        }

        if (destIE) {
            numMulticast++;
            fragmentPostRouting(datagram, destIE, destAddr);
        }
        else {
            EV_ERROR << "No multicast interface, packet dropped\n";
            numUnroutable++;
            emit(LayeredProtocolBase::packetFromUpperDroppedSignal, datagram);
            delete datagram;
        }
    }
    else {    // unicast and broadcast
              // check for local delivery
        if (rt->isLocalAddress(destAddr)) {
            EV_INFO << "Delivering " << datagram << " locally.\n";
            if (destIE && !destIE->isLoopback()) {
                EV_DETAIL << "datagram destination address is local, ignoring destination interface specified in the control info\n";
                destIE = nullptr;
            }
            if (!destIE)
                destIE = ift->getFirstLoopbackInterface();
            ASSERT(destIE);
            routeUnicastPacket(datagram, nullptr, destIE, destAddr);
        }
        else if (destAddr.isLimitedBroadcastAddress() || rt->isLocalBroadcastAddress(destAddr))
            routeLocalBroadcastPacket(datagram, destIE);
        else
            routeUnicastPacket(datagram, nullptr, destIE, requestedNextHopAddress);
    }
}

INetfilter::IHook::Result inet::IPv4::datagramLocalOutHook ( INetworkDatagram *  datagram, const InterfaceEntry *&  outIE, L3Address &  nextHopAddr  )

protected

called before a packet arriving locally is delivered

Referenced by handlePacketFromHL().

{
    for (auto & elem : hooks) {
        IHook::Result r = elem.second->datagramLocalOutHook(datagram, outIE, nextHopAddr);
        switch (r) {
            case INetfilter::IHook::ACCEPT:
                break;    // continue iteration

            case INetfilter::IHook::DROP:
                delete datagram;
                return r;

            case INetfilter::IHook::QUEUE:
                queuedDatagramsForHooks.push_back(QueuedDatagramForHook(dynamic_cast<IPv4Datagram *>(datagram), nullptr, outIE, nextHopAddr.toIPv4(), INetfilter::IHook::LOCALOUT));
                return r;

            case INetfilter::IHook::STOLEN:
                return r;

            default:
                throw cRuntimeError("Unknown Hook::Result value: %d", (int)r);
        }
    }
    return INetfilter::IHook::ACCEPT;
}

INetfilter::IHook::Result inet::IPv4::datagramPostRoutingHook ( INetworkDatagram *  datagram, const InterfaceEntry *  inIE, const InterfaceEntry *&  outIE, L3Address &  nextHopAddr  )

protected

called before a packet is delivered via the network

Referenced by fragmentPostRouting().

{
    for (auto & elem : hooks) {
        IHook::Result r = elem.second->datagramPostRoutingHook(datagram, inIE, outIE, nextHopAddr);
        switch (r) {
            case INetfilter::IHook::ACCEPT:
                break;    // continue iteration

            case INetfilter::IHook::DROP:
                delete datagram;
                return r;

            case INetfilter::IHook::QUEUE:
                queuedDatagramsForHooks.push_back(QueuedDatagramForHook(dynamic_cast<IPv4Datagram *>(datagram), inIE, outIE, nextHopAddr.toIPv4(), INetfilter::IHook::POSTROUTING));
                return r;

            case INetfilter::IHook::STOLEN:
                return r;

            default:
                throw cRuntimeError("Unknown Hook::Result value: %d", (int)r);
        }
    }
    return INetfilter::IHook::ACCEPT;
}

INetfilter::IHook::Result inet::IPv4::datagramPreRoutingHook ( INetworkDatagram *  datagram, const InterfaceEntry *  inIE, const InterfaceEntry *&  outIE, L3Address &  nextHopAddr  )

protected

called before a packet arriving from the network is routed

Referenced by handleIncomingDatagram().

{
    for (auto & elem : hooks) {
        IHook::Result r = elem.second->datagramPreRoutingHook(datagram, inIE, outIE, nextHopAddr);
        switch (r) {
            case INetfilter::IHook::ACCEPT:
                break;    // continue iteration

            case INetfilter::IHook::DROP:
                delete datagram;
                return r;

            case INetfilter::IHook::QUEUE:
                queuedDatagramsForHooks.push_back(QueuedDatagramForHook(dynamic_cast<IPv4Datagram *>(datagram), inIE, outIE, nextHopAddr.toIPv4(), INetfilter::IHook::PREROUTING));
                return r;

            case INetfilter::IHook::STOLEN:
                return r;

            default:
                throw cRuntimeError("Unknown Hook::Result value: %d", (int)r);
        }
    }
    return INetfilter::IHook::ACCEPT;
}

cPacket * inet::IPv4::decapsulate ( IPv4Datagram *  datagram )

protectedvirtual

Decapsulate and return encapsulated packet after attaching IPv4ControlInfo.

Referenced by reassembleAndDeliverFinish().

{
    // decapsulate transport packet
    const InterfaceEntry *fromIE = getSourceInterfaceFrom(datagram);
    cPacket *packet = datagram->decapsulate();

    // create and fill in control info
    IPv4ControlInfo *controlInfo = new IPv4ControlInfo();
    controlInfo->setProtocol(datagram->getTransportProtocol());
    controlInfo->setSrcAddr(datagram->getSrcAddress());
    controlInfo->setDestAddr(datagram->getDestAddress());
    controlInfo->setTypeOfService(datagram->getTypeOfService());
    controlInfo->setInterfaceId(fromIE ? fromIE->getInterfaceId() : -1);
    controlInfo->setTimeToLive(datagram->getTimeToLive());

    // original IPv4 datagram might be needed in upper layers to send back ICMP error message
    controlInfo->setOrigDatagram(datagram);

    // attach control info
    packet->setControlInfo(controlInfo);

    return packet;
}

const InterfaceEntry * inet::IPv4::determineOutgoingInterfaceForMulticastDatagram ( IPv4Datagram *  datagram, const InterfaceEntry *  multicastIFOption  )

protectedvirtual

Determines the output interface for the given multicast datagram.

Referenced by datagramLocalOut().

{
    const InterfaceEntry *ie = nullptr;
    if (multicastIFOption) {
        ie = multicastIFOption;
        EV_DETAIL << "multicast packet routed by socket option via output interface " << ie->getName() << "\n";
    }
    if (!ie) {
        IPv4Route *route = rt->findBestMatchingRoute(datagram->getDestAddress());
        if (route)
            ie = route->getInterface();
        if (ie)
            EV_DETAIL << "multicast packet routed by routing table via output interface " << ie->getName() << "\n";
    }
    if (!ie) {
        ie = rt->getInterfaceByAddress(datagram->getSrcAddress());
        if (ie)
            EV_DETAIL << "multicast packet routed by source address via output interface " << ie->getName() << "\n";
    }
    if (!ie) {
        ie = ift->getFirstMulticastInterface();
        if (ie)
            EV_DETAIL << "multicast packet routed via the first multicast interface " << ie->getName() << "\n";
    }
    return ie;
}

void inet::IPv4::dropQueuedDatagram ( const INetworkDatagram *  datagram )

overridevirtual

drop a previously queued datagram

Implements inet::INetfilter.

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

IPv4Datagram * inet::IPv4::encapsulate ( cPacket *  transportPacket, IPv4ControlInfo *  controlInfo  )

protectedvirtual

Encapsulate packet coming from higher layers into IPv4Datagram, using the given control info.

Override if you subclassed controlInfo and/or want to add options etc to the datagram.

Referenced by handlePacketFromHL().

{
    IPv4Datagram *datagram = createIPv4Datagram(transportPacket->getName());
    datagram->setByteLength(IP_HEADER_BYTES);
    datagram->encapsulate(transportPacket);

    // set source and destination address
    IPv4Address dest = controlInfo->getDestAddr();
    datagram->setDestAddress(dest);

    IPv4Address src = controlInfo->getSrcAddr();

    // 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 (rt->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->setSrcAddress(src);
    }

    // set other fields
    datagram->setTypeOfService(controlInfo->getTypeOfService());

    datagram->setIdentification(curFragmentId++);
    datagram->setMoreFragments(false);
    datagram->setDontFragment(controlInfo->getDontFragment());
    datagram->setFragmentOffset(0);

    short ttl;
    if (controlInfo->getTimeToLive() > 0)
        ttl = controlInfo->getTimeToLive();
    else if (datagram->getDestAddress().isLinkLocalMulticast())
        ttl = 1;
    else if (datagram->getDestAddress().isMulticast())
        ttl = defaultMCTimeToLive;
    else
        ttl = defaultTimeToLive;
    datagram->setTimeToLive(ttl);
    datagram->setTransportProtocol(controlInfo->getProtocol());

    // setting IPv4 options is currently not supported

    return datagram;
}

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

overrideprotectedvirtual

Processing of IPv4 datagrams.

Called when a datagram reaches the front of the queue.

Implements inet::AbstractQueue.

Referenced by handleMessage().

{
    if (!isUp) {
        EV_ERROR << "IPv4 is down -- discarding message\n";
        delete packet;
        return;
    }
    if (packet->getArrivalGate()->isName("transportIn")) {    //TODO packet->getArrivalGate()->getBaseId() == transportInGateBaseId
        handlePacketFromHL(packet);
    }
    else if (packet->getArrivalGate() == arpInGate) {
        handlePacketFromARP(packet);
    }
    else {    // from network
        EV_INFO << "Received " << packet << " from network.\n";
        const InterfaceEntry *fromIE = getSourceInterfaceFrom(packet);
        if (auto arpPacket = dynamic_cast<ARPPacket *>(packet))
            handleIncomingARPPacket(arpPacket, fromIE);
        else if (auto dgram = dynamic_cast<IPv4Datagram *>(packet))
            handleIncomingDatagram(dgram, fromIE);
        else
            throw cRuntimeError(packet, "Unexpected packet type");
    }
}

void inet::IPv4::flush ( )

protectedvirtual

Referenced by stop(), and ~IPv4().

{
    delete cancelService();
    EV_DEBUG << "IPv4::flush(): packets in queue: " << queue.str() << endl;
    queue.clear();

    EV_DEBUG << "IPv4::flush(): pending packets:\n";
    for (auto & elem : pendingPackets) {
        EV_DEBUG << "IPv4::flush():    " << elem.first << ": " << elem.second.str() << endl;
        elem.second.clear();
    }
    pendingPackets.clear();

    EV_DEBUG << "IPv4::flush(): packets in hooks: " << queuedDatagramsForHooks.size() << endl;
    for (auto & elem : queuedDatagramsForHooks) {
        delete elem.datagram;
    }
    queuedDatagramsForHooks.clear();
}

void inet::IPv4::forwardMulticastPacket ( IPv4Datagram *  datagram, const InterfaceEntry *  fromIE  )

protectedvirtual

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

Referenced by preroutingFinish().

{
    ASSERT(fromIE);
    const IPv4Address& srcAddr = datagram->getSrcAddress();
    const IPv4Address& destAddr = datagram->getDestAddress();
    ASSERT(destAddr.isMulticast());
    ASSERT(!destAddr.isLinkLocalMulticast());

    EV_INFO << "Forwarding multicast datagram `" << datagram->getName() << "' with dest=" << destAddr << "\n";

    numMulticast++;

    const IPv4MulticastRoute *route = rt->findBestMatchingMulticastRoute(srcAddr, destAddr);
    if (!route) {
        EV_WARN << "Multicast route does not exist, try to add.\n";
        emit(NF_IPv4_NEW_MULTICAST, datagram);

        // read new record
        route = rt->findBestMatchingMulticastRoute(srcAddr, destAddr);

        if (!route) {
            EV_ERROR << "No route, packet dropped.\n";
            numUnroutable++;
            emit(LayeredProtocolBase::packetFromUpperDroppedSignal, datagram);
            delete datagram;
            return;
        }
    }

    if (route->getInInterface() && fromIE != route->getInInterface()->getInterface()) {
        EV_ERROR << "Did not arrive on input interface, packet dropped.\n";
        emit(NF_IPv4_DATA_ON_NONRPF, datagram);
        numDropped++;
        emit(LayeredProtocolBase::packetFromUpperDroppedSignal, datagram);
        delete datagram;
    }
    // backward compatible: no parent means shortest path interface to source (RPB routing)
    else if (!route->getInInterface() && fromIE != getShortestPathInterfaceToSource(datagram)) {
        EV_ERROR << "Did not arrive on shortest path, packet dropped.\n";
        numDropped++;
        emit(LayeredProtocolBase::packetFromUpperDroppedSignal, datagram);
        delete datagram;
    }
    else {
        emit(NF_IPv4_DATA_ON_RPF, datagram);    // forwarding hook

        numForwarded++;
        // copy original datagram for multiple destinations
        for (unsigned int i = 0; i < route->getNumOutInterfaces(); i++) {
            IPv4MulticastRoute::OutInterface *outInterface = route->getOutInterface(i);
            const InterfaceEntry *destIE = outInterface->getInterface();
            if (destIE != fromIE && outInterface->isEnabled()) {
                int ttlThreshold = destIE->ipv4Data()->getMulticastTtlThreshold();
                if (datagram->getTimeToLive() <= ttlThreshold)
                    EV_WARN << "Not forwarding to " << destIE->getName() << " (ttl treshold reached)\n";
                else if (outInterface->isLeaf() && !destIE->ipv4Data()->hasMulticastListener(destAddr))
                    EV_WARN << "Not forwarding to " << destIE->getName() << " (no listeners)\n";
                else {
                    EV_DETAIL << "Forwarding to " << destIE->getName() << "\n";
                    fragmentPostRouting(datagram->dup(), destIE, destAddr);
                }
            }
        }

        emit(NF_IPv4_MDATA_REGISTER, datagram);    // postRouting hook

        // only copies sent, delete original datagram
        delete datagram;
    }
}

void inet::IPv4::fragmentAndSend ( IPv4Datagram *  datagram, const InterfaceEntry *  ie, IPv4Address  nextHopAddr  )

protectedvirtual

Fragment packet if needed, then send it to the selected interface using sendDatagramToOutput().

Referenced by fragmentPostRouting(), and reinjectQueuedDatagram().

{
    // fill in source address
    if (datagram->getSrcAddress().isUnspecified())
        datagram->setSrcAddress(ie->ipv4Data()->getIPAddress());

    // hop counter check
    if (datagram->getTimeToLive() <= 0) {
        // drop datagram, destruction responsibility in ICMP
        emit(LayeredProtocolBase::packetFromUpperDroppedSignal, datagram);
        EV_WARN << "datagram TTL reached zero, sending ICMP_TIME_EXCEEDED\n";
        icmp->sendErrorMessage(datagram, -1    /*TODO*/, ICMP_TIME_EXCEEDED, 0);
        numDropped++;
        return;
    }

    int mtu = ie->getMTU();

    // send datagram straight out if it doesn't require fragmentation (note: mtu==0 means infinite mtu)
    if (mtu == 0 || datagram->getByteLength() <= mtu) {
        sendDatagramToOutput(datagram, ie, nextHopAddr);
        return;
    }

    // if "don't fragment" bit is set, throw datagram away and send ICMP error message
    if (datagram->getDontFragment()) {
        emit(LayeredProtocolBase::packetFromUpperDroppedSignal, datagram);
        EV_WARN << "datagram larger than MTU and don't fragment bit set, sending ICMP_DESTINATION_UNREACHABLE\n";
        icmp->sendErrorMessage(datagram, -1    /*TODO*/, ICMP_DESTINATION_UNREACHABLE,
                ICMP_DU_FRAGMENTATION_NEEDED);
        numDropped++;
        return;
    }

    // FIXME some IP options should not be copied into each fragment, check their COPY bit
    int headerLength = datagram->getHeaderLength();
    int payloadLength = datagram->getByteLength() - headerLength;
    int fragmentLength = ((mtu - headerLength) / 8) * 8;    // payload only (without header)
    int offsetBase = datagram->getFragmentOffset();
    if (fragmentLength <= 0)
        throw cRuntimeError("Cannot fragment datagram: MTU=%d too small for header size (%d bytes)", mtu, headerLength); // exception and not ICMP because this is likely a simulation configuration error, not something one wants to simulate

    int noOfFragments = (payloadLength + fragmentLength - 1) / fragmentLength;
    EV_DETAIL << "Breaking datagram into " << noOfFragments << " fragments\n";

    // create and send fragments
    std::string fragMsgName = datagram->getName();
    fragMsgName += "-frag";

    for (int offset = 0; offset < payloadLength; offset += fragmentLength) {
        bool lastFragment = (offset + fragmentLength >= payloadLength);
        // length equal to fragmentLength, except for last fragment;
        int thisFragmentLength = lastFragment ? payloadLength - offset : fragmentLength;

        // FIXME is it ok that full encapsulated packet travels in every datagram fragment?
        // should better travel in the last fragment only. Cf. with reassembly code!
        IPv4Datagram *fragment = datagram->dup();
        fragment->setName(fragMsgName.c_str());

        // "more fragments" bit is unchanged in the last fragment, otherwise true
        if (!lastFragment)
            fragment->setMoreFragments(true);

        fragment->setByteLength(headerLength + thisFragmentLength);
        fragment->setFragmentOffset(offsetBase + offset);

        sendDatagramToOutput(fragment, ie, nextHopAddr);
    }

    delete datagram;
}

void inet::IPv4::fragmentPostRouting ( IPv4Datagram *  datagram, const InterfaceEntry *  ie, IPv4Address  nextHopAddr  )

protectedvirtual

Call PostRouting Hook and continue with fragmentAndSend() if accepted.

Referenced by datagramLocalOut(), forwardMulticastPacket(), preroutingFinish(), routeLocalBroadcastPacket(), and routeUnicastPacketFinish().

{
    L3Address nextHop(nextHopAddr);
    if (datagramPostRoutingHook(datagram, getSourceInterfaceFrom(datagram), ie, nextHop) == INetfilter::IHook::ACCEPT)
        fragmentAndSend(datagram, ie, nextHop.toIPv4());
}

const InterfaceEntry * inet::IPv4::getShortestPathInterfaceToSource ( IPv4Datagram *  datagram )

protectedvirtual

Referenced by forwardMulticastPacket().

{
    return rt->getInterfaceForDestAddr(datagram->getSrcAddress());
}

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

protectedvirtual

Referenced by decapsulate(), endService(), fragmentPostRouting(), reassembleAndDeliver(), and reassembleAndDeliverFinish().

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

void inet::IPv4::handleIncomingARPPacket ( ARPPacket *  packet, const InterfaceEntry *  fromIE  )

protectedvirtual

Handle incoming ARP packets by sending them over to ARP.

Referenced by endService().

{
    // give it to the ARP module
    IMACProtocolControlInfo *ctrl = check_and_cast<IMACProtocolControlInfo *>(packet->getControlInfo());
    ctrl->setInterfaceId(fromIE->getInterfaceId());
    EV_INFO << "Sending " << packet << " to arp.\n";
    send(packet, arpOutGate);
}

void inet::IPv4::handleIncomingDatagram ( IPv4Datagram *  datagram, const InterfaceEntry *  fromIE  )

protectedvirtual

Handle IPv4Datagram messages arriving from lower layer.

Decrements TTL, then invokes routePacket().

Referenced by endService().

{
    ASSERT(datagram);
    ASSERT(fromIE);
    emit(LayeredProtocolBase::packetReceivedFromLowerSignal, datagram);

    //
    // "Prerouting"
    //

    // check for header biterror
    if (datagram->hasBitError()) {
        // probability of bit error in header = size of header / size of total message
        // (ignore bit error if in payload)
        double relativeHeaderLength = datagram->getHeaderLength() / (double)datagram->getByteLength();
        if (dblrand() <= relativeHeaderLength) {
            EV_WARN << "bit error found, sending ICMP_PARAMETER_PROBLEM\n";
            icmp->sendErrorMessage(datagram, fromIE->getInterfaceId(), ICMP_PARAMETER_PROBLEM, 0);
            return;
        }
    }

    // hop counter decrement
    datagram->setTimeToLive(datagram->getTimeToLive() - 1);

    EV_DETAIL << "Received datagram `" << datagram->getName() << "' with dest=" << datagram->getDestAddress() << "\n";

    const InterfaceEntry *destIE = nullptr;
    L3Address nextHop(IPv4Address::UNSPECIFIED_ADDRESS);
    if (datagramPreRoutingHook(datagram, fromIE, destIE, nextHop) == INetfilter::IHook::ACCEPT)
        preroutingFinish(datagram, fromIE, destIE, nextHop.toIPv4());
}

void inet::IPv4::handleIncomingICMP ( ICMPMessage *  packet )

protectedvirtual

Handle incoming ICMP messages.

Referenced by reassembleAndDeliverFinish().

{
    switch (packet->getType()) {
        case ICMP_REDIRECT:    // TODO implement redirect handling
        case ICMP_DESTINATION_UNREACHABLE:
        case ICMP_TIME_EXCEEDED:
        case ICMP_PARAMETER_PROBLEM: {
            // ICMP errors are delivered to the appropriate higher layer protocol
            IPv4Datagram *bogusPacket = check_and_cast<IPv4Datagram *>(packet->getEncapsulatedPacket());
            int protocol = bogusPacket->getTransportProtocol();
            int gateindex = mapping.getOutputGateForProtocol(protocol);
            send(packet, "transportOut", gateindex);
            emit(LayeredProtocolBase::packetSentToUpperSignal, packet);
            break;
        }

        default: {
            // all others are delivered to ICMP: ICMP_ECHO_REQUEST, ICMP_ECHO_REPLY,
            // ICMP_TIMESTAMP_REQUEST, ICMP_TIMESTAMP_REPLY, etc.
            int gateindex = mapping.getOutputGateForProtocol(IP_PROT_ICMP);
            send(packet, "transportOut", gateindex);
            emit(LayeredProtocolBase::packetSentToUpperSignal, packet);
            break;
        }
    }
}

void inet::IPv4::handleMessage ( cMessage *  msg )

overrideprotectedvirtual

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 if (!msg->isSelfMessage() && msg->getArrivalGate()->isName("arpIn"))
        endService(PK(msg));
    else
        QueueBase::handleMessage(msg);
}

bool inet::IPv4::handleOperationStage ( LifecycleOperation *  operation, int  stage, IDoneCallback *  doneCallback  )

overridevirtual

ILifecycle method.

Implements inet::ILifecycle.

{
    Enter_Method_Silent();
    if (dynamic_cast<NodeStartOperation *>(operation)) {
        if ((NodeStartOperation::Stage)stage == NodeStartOperation::STAGE_NETWORK_LAYER)
            start();
    }
    else if (dynamic_cast<NodeShutdownOperation *>(operation)) {
        if ((NodeShutdownOperation::Stage)stage == NodeShutdownOperation::STAGE_NETWORK_LAYER)
            stop();
    }
    else if (dynamic_cast<NodeCrashOperation *>(operation)) {
        if ((NodeCrashOperation::Stage)stage == NodeCrashOperation::STAGE_CRASH)
            stop();
    }
    return true;
}

void inet::IPv4::handlePacketFromARP ( cPacket *  packet )

protectedvirtual

TODO.

Referenced by endService().

{
    EV_INFO << "Received " << packet << " from arp.\n";
    // send out packet on the appropriate interface
    IMACProtocolControlInfo *ctrl = check_and_cast<IMACProtocolControlInfo *>(packet->getControlInfo());
    InterfaceEntry *destIE = ift->getInterfaceById(ctrl->getInterfaceId());
    sendPacketToNIC(packet, destIE);
}

void inet::IPv4::handlePacketFromHL ( cPacket *  packet )

protectedvirtual

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

Invokes encapsulate(), then routePacket().

Referenced by endService().

{
    EV_INFO << "Received " << packet << " from upper layer.\n";
    emit(LayeredProtocolBase::packetReceivedFromUpperSignal, packet);

    // if no interface exists, do not send datagram
    if (ift->getNumInterfaces() == 0) {
        EV_ERROR << "No interfaces exist, dropping packet\n";
        numDropped++;
        emit(LayeredProtocolBase::packetFromUpperDroppedSignal, packet);
        delete packet;
        return;
    }

    // encapsulate
    IPv4ControlInfo *controlInfo = check_and_cast<IPv4ControlInfo *>(packet->removeControlInfo());
    IPv4Datagram *datagram = encapsulate(packet, controlInfo);

    // extract requested interface and next hop
    const InterfaceEntry *destIE = controlInfo ? const_cast<const InterfaceEntry *>(ift->getInterfaceById(controlInfo->getInterfaceId())) : nullptr;

    if (controlInfo)
        datagram->setControlInfo(controlInfo); //FIXME ne rakjuk bele a cntrInfot!!!!! de kell :( kulonben a hook queue-ban elveszik a multicastloop flag

    // TODO:
    L3Address nextHopAddr(IPv4Address::UNSPECIFIED_ADDRESS);
    if (datagramLocalOutHook(datagram, destIE, nextHopAddr) == INetfilter::IHook::ACCEPT)
        datagramLocalOut(datagram, destIE, nextHopAddr.toIPv4());
}

void inet::IPv4::initialize ( int  stage )

overrideprotectedvirtual

{
    if (stage == INITSTAGE_LOCAL) {
        QueueBase::initialize();

        ift = getModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this);
        rt = getModuleFromPar<IIPv4RoutingTable>(par("routingTableModule"), this);
        arp = getModuleFromPar<IARP>(par("arpModule"), this);
        icmp = getModuleFromPar<ICMP>(par("icmpModule"), this);

        arpInGate = gate("arpIn");
        arpOutGate = gate("arpOut");
        transportInGateBaseId = gateBaseId("transportIn");
        queueOutGateBaseId = gateBaseId("queueOut");

        defaultTimeToLive = par("timeToLive");
        defaultMCTimeToLive = par("multicastTimeToLive");
        fragmentTimeoutTime = par("fragmentTimeout");
        forceBroadcast = par("forceBroadcast");
        useProxyARP = par("useProxyARP");

        curFragmentId = 0;
        lastCheckTime = 0;
        fragbuf.init(icmp);

        numMulticast = numLocalDeliver = numDropped = numUnroutable = numForwarded = 0;

        // NetFilter:
        hooks.clear();
        queuedDatagramsForHooks.clear();

        pendingPackets.clear();
        cModule *arpModule = check_and_cast<cModule *>(arp);
        arpModule->subscribe(IARP::completedARPResolutionSignal, this);
        arpModule->subscribe(IARP::failedARPResolutionSignal, this);

        WATCH(numMulticast);
        WATCH(numLocalDeliver);
        WATCH(numDropped);
        WATCH(numUnroutable);
        WATCH(numForwarded);
        WATCH_MAP(pendingPackets);
    }
    else if (stage == INITSTAGE_NETWORK_LAYER) {
        isUp = isNodeUp();
    }
}

bool inet::IPv4::isNodeUp ( )

protectedvirtual

Referenced by initialize().

{
    NodeStatus *nodeStatus = dynamic_cast<NodeStatus *>(findContainingNode(this)->getSubmodule("status"));
    return !nodeStatus || nodeStatus->getState() == NodeStatus::UP;
}

virtual int inet::IPv4::numInitStages ( ) const

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

void inet::IPv4::preroutingFinish ( IPv4Datagram *  datagram, const InterfaceEntry *  fromIE, const InterfaceEntry *  destIE, IPv4Address  nextHopAddr  )

protectedvirtual

Referenced by handleIncomingDatagram(), and reinjectQueuedDatagram().

{
    IPv4Address& destAddr = datagram->getDestAddress();

    // remove control info
    delete datagram->removeControlInfo();

    // route packet

    if (fromIE->isLoopback()) {
        reassembleAndDeliver(datagram);
    }
    else if (destAddr.isMulticast()) {
        // check for local delivery
        // Note: multicast routers will receive IGMP datagrams even if their interface is not joined to the group
        if (fromIE->ipv4Data()->isMemberOfMulticastGroup(destAddr) ||
            (rt->isMulticastForwardingEnabled() && datagram->getTransportProtocol() == IP_PROT_IGMP))
            reassembleAndDeliver(datagram->dup());
        else
            EV_WARN << "Skip local delivery of multicast datagram (input interface not in multicast group)\n";

        // don't forward if IP forwarding is off, or if dest address is link-scope
        if (!rt->isMulticastForwardingEnabled()) {
            EV_WARN << "Skip forwarding of multicast datagram (forwarding disabled)\n";
            delete datagram;
        }
        else if (destAddr.isLinkLocalMulticast()) {
            EV_WARN << "Skip forwarding of multicast datagram (packet is link-local)\n";
            delete datagram;
        }
        else if (datagram->getTimeToLive() == 0) {
            EV_WARN << "Skip forwarding of multicast datagram (TTL reached 0)\n";
            delete datagram;
        }
        else
            forwardMulticastPacket(datagram, fromIE);
    }
    else {
        const InterfaceEntry *broadcastIE = nullptr;

        // check for local delivery; we must accept also packets coming from the interfaces that
        // do not yet have an IP address assigned. This happens during DHCP requests.
        if (rt->isLocalAddress(destAddr) || fromIE->ipv4Data()->getIPAddress().isUnspecified()) {
            reassembleAndDeliver(datagram);
        }
        else if (destAddr.isLimitedBroadcastAddress() || (broadcastIE = rt->findInterfaceByLocalBroadcastAddress(destAddr))) {
            // broadcast datagram on the target subnet if we are a router
            if (broadcastIE && fromIE != broadcastIE && rt->isForwardingEnabled())
                fragmentPostRouting(datagram->dup(), broadcastIE, IPv4Address::ALLONES_ADDRESS);

            EV_INFO << "Broadcast received\n";
            reassembleAndDeliver(datagram);
        }
        else if (!rt->isForwardingEnabled()) {
            EV_WARN << "forwarding off, dropping packet\n";
            numDropped++;
            emit(LayeredProtocolBase::packetFromUpperDroppedSignal, datagram);
            delete datagram;
        }
        else
            routeUnicastPacket(datagram, fromIE, destIE, nextHopAddr);
    }
}

void inet::IPv4::reassembleAndDeliver ( IPv4Datagram *  datagram )

protectedvirtual

Perform reassembly of fragmented datagrams, then send them up to the higher layers using sendToHL().

Referenced by preroutingFinish().

{
    EV_INFO << "Delivering " << datagram << " locally.\n";

    if (datagram->getSrcAddress().isUnspecified())
        EV_WARN << "Received datagram '" << datagram->getName() << "' without source address filled in\n";

    // reassemble the packet (if fragmented)
    if (datagram->getFragmentOffset() != 0 || datagram->getMoreFragments()) {
        EV_DETAIL << "Datagram fragment: offset=" << datagram->getFragmentOffset()
                  << ", MORE=" << (datagram->getMoreFragments() ? "true" : "false") << ".\n";

        // erase timed out fragments in fragmentation buffer; check every 10 seconds max
        if (simTime() >= lastCheckTime + 10) {
            lastCheckTime = simTime();
            fragbuf.purgeStaleFragments(simTime() - fragmentTimeoutTime);
        }

        datagram = fragbuf.addFragment(datagram, simTime());
        if (!datagram) {
            EV_DETAIL << "No complete datagram yet.\n";
            return;
        }
        EV_DETAIL << "This fragment completes the datagram.\n";
    }

    if (datagramLocalInHook(datagram, getSourceInterfaceFrom(datagram)) != INetfilter::IHook::ACCEPT) {
        return;
    }

    reassembleAndDeliverFinish(datagram);
}

void inet::IPv4::reassembleAndDeliverFinish ( IPv4Datagram *  datagram )

protectedvirtual

Referenced by reassembleAndDeliver(), and reinjectQueuedDatagram().

{
    // decapsulate and send on appropriate output gate
    int protocol = datagram->getTransportProtocol();

    if (protocol == IP_PROT_ICMP) {
        // incoming ICMP packets are handled specially
        handleIncomingICMP(check_and_cast<ICMPMessage *>(decapsulate(datagram)));
        numLocalDeliver++;
    }
    else if (protocol == IP_PROT_IP) {
        // tunnelled IP packets are handled separately
        send(decapsulate(datagram), "preRoutingOut");    //FIXME There is no "preRoutingOut" gate in the IPv4 module.
    }
    else {
        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()) {
                cPacket *packet = decapsulate(datagram);
                send(packet, outGate);
                emit(LayeredProtocolBase::packetSentToUpperSignal, packet);
                numLocalDeliver++;
                return;
            }
        }

        EV_ERROR << "Transport protocol ID=" << protocol << " not connected, discarding packet\n";
        int inputInterfaceId = getSourceInterfaceFrom(datagram)->getInterfaceId();
        icmp->sendErrorMessage(datagram, inputInterfaceId, ICMP_DESTINATION_UNREACHABLE, ICMP_DU_PROTOCOL_UNREACHABLE);
    }
}

void inet::IPv4::receiveSignal ( cComponent *  source, simsignal_t  signalID, cObject *  obj, cObject *  details  )

overridevirtual

cListener method

{
    Enter_Method_Silent();

    if (signalID == IARP::completedARPResolutionSignal) {
        arpResolutionCompleted(check_and_cast<IARP::Notification *>(obj));
    }
    if (signalID == IARP::failedARPResolutionSignal) {
        arpResolutionTimedOut(check_and_cast<IARP::Notification *>(obj));
    }
}

void inet::IPv4::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 (numMulticast > 0)
        sprintf(buf + strlen(buf), "mcast:%d ", numMulticast);
    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::IPv4::registerHook ( int  priority, INetfilter::IHook *  hook  )

overridevirtual

registers a Hook to be executed during datagram processing

Implements inet::INetfilter.

Referenced by inet::CloudDelayerBase::initialize().

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

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

overridevirtual

re-injects a previously queued datagram

Implements inet::INetfilter.

Referenced by inet::CloudDelayerBase::handleMessage().

{
    Enter_Method("reinjectDatagram()");
    for (auto iter = queuedDatagramsForHooks.begin(); iter != queuedDatagramsForHooks.end(); iter++) {
        if (iter->datagram == datagram) {
            IPv4Datagram *datagram = iter->datagram;
            take(datagram);
            switch (iter->hookType) {
                case INetfilter::IHook::LOCALOUT:
                    datagramLocalOut(datagram, iter->outIE, iter->nextHopAddr);
                    break;

                case INetfilter::IHook::PREROUTING:
                    preroutingFinish(datagram, iter->inIE, iter->outIE, iter->nextHopAddr);
                    break;

                case INetfilter::IHook::POSTROUTING:
                    fragmentAndSend(datagram, iter->outIE, iter->nextHopAddr);
                    break;

                case INetfilter::IHook::LOCALIN:
                    reassembleAndDeliverFinish(datagram);
                    break;

                case INetfilter::IHook::FORWARD:
                    routeUnicastPacketFinish(datagram, iter->inIE, iter->outIE, iter->nextHopAddr);
                    break;

                default:
                    throw cRuntimeError("Unknown hook ID: %d", (int)(iter->hookType));
                    break;
            }
            queuedDatagramsForHooks.erase(iter);
            return;
        }
    }
}

MACAddress inet::IPv4::resolveNextHopMacAddress ( cPacket *  packet, IPv4Address  nextHopAddr, const InterfaceEntry *  destIE  )

protectedvirtual

Referenced by sendDatagramToOutput().

{
    if (nextHopAddr.isLimitedBroadcastAddress() || nextHopAddr == destIE->ipv4Data()->getNetworkBroadcastAddress()) {
        EV_DETAIL << "destination address is broadcast, sending packet to broadcast MAC address\n";
        return MACAddress::BROADCAST_ADDRESS;
    }

    if (nextHopAddr.isMulticast()) {
        MACAddress macAddr = MACAddress::makeMulticastAddress(nextHopAddr);
        EV_DETAIL << "destination address is multicast, sending packet to MAC address " << macAddr << "\n";
        return macAddr;
    }

    return arp->resolveL3Address(nextHopAddr, destIE);
}

void inet::IPv4::routeLocalBroadcastPacket ( IPv4Datagram *  datagram, const InterfaceEntry *  destIE  )

protectedvirtual

Broadcasts the datagram on the specified interface.

When destIE is nullptr, the datagram is broadcasted on each interface.

Referenced by datagramLocalOut().

{
    // The destination address is 255.255.255.255 or local subnet broadcast address.
    // We always use 255.255.255.255 as nextHopAddress, because it is recognized by ARP,
    // and mapped to the broadcast MAC address.
    if (destIE != nullptr) {
        fragmentPostRouting(datagram, destIE, IPv4Address::ALLONES_ADDRESS);
    }
    else if (forceBroadcast) {
        // forward to each interface including loopback
        for (int i = 0; i < ift->getNumInterfaces(); i++) {
            const InterfaceEntry *ie = ift->getInterface(i);
            fragmentPostRouting(datagram->dup(), ie, IPv4Address::ALLONES_ADDRESS);
        }
        delete datagram;
    }
    else {
        numDropped++;
        emit(LayeredProtocolBase::packetFromUpperDroppedSignal, datagram);
        delete datagram;
    }
}

void inet::IPv4::routeUnicastPacket ( IPv4Datagram *  datagram, const InterfaceEntry *  fromIE, const InterfaceEntry *  destIE, IPv4Address  requestedNextHopAddress  )

protectedvirtual

Performs unicast routing.

Based on the routing decision, it sends the datagram through the outgoing interface.

Referenced by datagramLocalOut(), and preroutingFinish().

{
    IPv4Address destAddr = datagram->getDestAddress();
    EV_INFO << "Routing " << datagram << " with destination = " << destAddr << ", ";

    IPv4Address nextHopAddr;
    // if output port was explicitly requested, use that, otherwise use IPv4 routing
    if (destIE) {
        EV_DETAIL << "using manually specified output interface " << destIE->getName() << "\n";
        // and nextHopAddr remains unspecified
        if (!requestedNextHopAddress.isUnspecified())
            nextHopAddr = requestedNextHopAddress;
        // special case ICMP reply
        else if (destIE->isBroadcast()) {
            // if the interface is broadcast we must search the next hop
            const IPv4Route *re = rt->findBestMatchingRoute(destAddr);
            if (re && re->getInterface() == destIE)
                nextHopAddr = re->getGateway();
        }
    }
    else {
        // use IPv4 routing (lookup in routing table)
        const IPv4Route *re = rt->findBestMatchingRoute(destAddr);
        if (re) {
            destIE = re->getInterface();
            nextHopAddr = re->getGateway();
        }
    }

    if (!destIE) {    // no route found
        EV_WARN << "unroutable, sending ICMP_DESTINATION_UNREACHABLE, dropping packet\n";
        numUnroutable++;
        emit(LayeredProtocolBase::packetFromUpperDroppedSignal, datagram);
        icmp->sendErrorMessage(datagram, fromIE ? fromIE->getInterfaceId() : -1, ICMP_DESTINATION_UNREACHABLE, 0);
    }
    else {    // fragment and send
        L3Address nextHop(nextHopAddr);
        if (fromIE != nullptr) {
            if (datagramForwardHook(datagram, fromIE, destIE, nextHop) != INetfilter::IHook::ACCEPT)
                return;
            nextHopAddr = nextHop.toIPv4();
        }

        routeUnicastPacketFinish(datagram, fromIE, destIE, nextHopAddr);
    }
}

void inet::IPv4::routeUnicastPacketFinish ( IPv4Datagram *  datagram, const InterfaceEntry *  fromIE, const InterfaceEntry *  destIE, IPv4Address  nextHopAddr  )

protected

Referenced by reinjectQueuedDatagram(), and routeUnicastPacket().

{
    EV_INFO << "output interface = " << destIE->getName() << ", next hop address = " << nextHopAddr << "\n";
    numForwarded++;
    fragmentPostRouting(datagram, destIE, nextHopAddr);
}

void inet::IPv4::sendDatagramToOutput ( IPv4Datagram *  datagram, const InterfaceEntry *  ie, IPv4Address  nextHopAddr  )

protectedvirtual

Send datagram on the given interface.

Referenced by fragmentAndSend().

{
    {
        bool isIeee802Lan = ie->isBroadcast() && !ie->getMacAddress().isUnspecified();    // we only need/can do ARP on IEEE 802 LANs
        if (!isIeee802Lan) {
            sendPacketToNIC(datagram, ie);
        }
        else {
            if (nextHopAddr.isUnspecified()) {
                IPv4InterfaceData *ipv4Data = ie->ipv4Data();
                IPv4Address destAddress = datagram->getDestAddress();
                if (IPv4Address::maskedAddrAreEqual(destAddress, ie->ipv4Data()->getIPAddress(), ipv4Data->getNetmask()))
                    nextHopAddr = destAddress;
                else if (useProxyARP) {
                    nextHopAddr = destAddress;
                    EV_WARN << "no next-hop address, using destination address " << nextHopAddr << " (proxy ARP)\n";
                }
                else {
                    throw cRuntimeError(datagram, "Cannot send datagram on broadcast interface: no next-hop address and Proxy ARP is disabled");
                }
            }

            MACAddress nextHopMacAddr;    // unspecified
            nextHopMacAddr = resolveNextHopMacAddress(datagram, nextHopAddr, ie);

            if (nextHopMacAddr.isUnspecified()) {
                EV_INFO << "Pending " << datagram << " to ARP resolution.\n";
                pendingPackets[nextHopAddr].insert(datagram);
            }
            else {
                ASSERT2(pendingPackets.find(nextHopAddr) == pendingPackets.end(), "IPv4-ARP error: nextHopAddr found in ARP table, but IPv4 queue for nextHopAddr not empty");
                sendPacketToIeee802NIC(datagram, ie, nextHopMacAddr, ETHERTYPE_IPv4);
            }
        }
    }
}

void inet::IPv4::sendOnTransportOutGateByProtocolId	(	cPacket *	packet,
		int	protocolId
	)

send packet on transportOut gate specified by protocolId

{
    int gateindex = mapping.getOutputGateForProtocol(protocolId);
    cGate *outGate = gate("transportOut", gateindex);
    send(packet, outGate);
    emit(LayeredProtocolBase::packetSentToUpperSignal, packet);
}

void inet::IPv4::sendPacketToIeee802NIC ( cPacket *  packet, const InterfaceEntry *  ie, const MACAddress &  macAddress, int  etherType  )

protectedvirtual

Referenced by arpResolutionCompleted(), and sendDatagramToOutput().

{
    // remove old control info
    delete packet->removeControlInfo();

    // add control info with MAC address
    Ieee802Ctrl *controlInfo = new Ieee802Ctrl();
    controlInfo->setDest(macAddress);
    controlInfo->setEtherType(etherType);
    packet->setControlInfo(controlInfo);

    sendPacketToNIC(packet, ie);
}

void inet::IPv4::sendPacketToNIC ( cPacket *  packet, const InterfaceEntry *  ie  )

protectedvirtual

Referenced by handlePacketFromARP(), sendDatagramToOutput(), and sendPacketToIeee802NIC().

{
    EV_INFO << "Sending " << packet << " to output interface = " << ie->getName() << ".\n";
    send(packet, queueOutGateBaseId + ie->getNetworkLayerGateIndex());
}

void inet::IPv4::start ( )

protectedvirtual

Referenced by handleOperationStage().

{
    ASSERT(queue.isEmpty());
    isUp = true;
}

void inet::IPv4::stop ( )

protectedvirtual

Referenced by handleOperationStage().

{
    isUp = false;
    flush();
}

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

overridevirtual

unregisters a Hook to be executed during datagram processing

Implements inet::INetfilter.

Referenced by inet::sctp::SCTPNatHook::finish(), inet::CloudDelayerBase::finish(), inet::CloudDelayerBase::~CloudDelayerBase(), and inet::sctp::SCTPNatHook::~SCTPNatHook().

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

Member Data Documentation

IARP* inet::IPv4::arp = nullptr

protected

Referenced by initialize(), and resolveNextHopMacAddress().

cGate* inet::IPv4::arpInGate = nullptr

protected

Referenced by endService(), and initialize().

cGate* inet::IPv4::arpOutGate = nullptr

protected

Referenced by handleIncomingARPPacket(), and initialize().

long inet::IPv4::curFragmentId = -1

protected

Referenced by encapsulate(), and initialize().

int inet::IPv4::defaultMCTimeToLive = -1

protected

Referenced by encapsulate(), and initialize().

int inet::IPv4::defaultTimeToLive = -1

protected

Referenced by encapsulate(), and initialize().

bool inet::IPv4::forceBroadcast = false

protected

Referenced by initialize(), and routeLocalBroadcastPacket().

IPv4FragBuf inet::IPv4::fragbuf

protected

Referenced by initialize(), and reassembleAndDeliver().

simtime_t inet::IPv4::fragmentTimeoutTime

protected

Referenced by initialize(), and reassembleAndDeliver().

HookList inet::IPv4::hooks

protected

Referenced by datagramForwardHook(), datagramLocalInHook(), datagramLocalOutHook(), datagramPostRoutingHook(), datagramPreRoutingHook(), initialize(), registerHook(), and unregisterHook().

ICMP* inet::IPv4::icmp = nullptr

protected

IInterfaceTable* inet::IPv4::ift = nullptr

protected

Referenced by datagramLocalOut(), determineOutgoingInterfaceForMulticastDatagram(), getSourceInterfaceFrom(), handlePacketFromARP(), handlePacketFromHL(), initialize(), and routeLocalBroadcastPacket().

bool inet::IPv4::isUp = false

protected

Referenced by endService(), initialize(), start(), and stop().

simtime_t inet::IPv4::lastCheckTime

protected

Referenced by initialize(), and reassembleAndDeliver().

ProtocolMapping inet::IPv4::mapping

protected

Referenced by handleIncomingICMP(), handleMessage(), reassembleAndDeliverFinish(), and sendOnTransportOutGateByProtocolId().

int inet::IPv4::numDropped = 0

protected

Referenced by forwardMulticastPacket(), fragmentAndSend(), handlePacketFromHL(), initialize(), preroutingFinish(), refreshDisplay(), and routeLocalBroadcastPacket().

int inet::IPv4::numForwarded = 0

protected

Referenced by forwardMulticastPacket(), initialize(), refreshDisplay(), and routeUnicastPacketFinish().

int inet::IPv4::numLocalDeliver = 0

protected

Referenced by initialize(), reassembleAndDeliverFinish(), and refreshDisplay().

int inet::IPv4::numMulticast = 0

protected

Referenced by datagramLocalOut(), forwardMulticastPacket(), initialize(), and refreshDisplay().

int inet::IPv4::numUnroutable = 0

protected

Referenced by datagramLocalOut(), forwardMulticastPacket(), initialize(), refreshDisplay(), and routeUnicastPacket().

PendingPackets inet::IPv4::pendingPackets

protected

Referenced by arpResolutionCompleted(), arpResolutionTimedOut(), flush(), initialize(), and sendDatagramToOutput().

DatagramQueueForHooks inet::IPv4::queuedDatagramsForHooks

protected

Referenced by datagramForwardHook(), datagramLocalInHook(), datagramLocalOutHook(), datagramPostRoutingHook(), datagramPreRoutingHook(), dropQueuedDatagram(), flush(), initialize(), and reinjectQueuedDatagram().

int inet::IPv4::queueOutGateBaseId = -1

protected

Referenced by initialize(), and sendPacketToNIC().

IIPv4RoutingTable* inet::IPv4::rt = nullptr

protected

Referenced by datagramLocalOut(), determineOutgoingInterfaceForMulticastDatagram(), encapsulate(), forwardMulticastPacket(), getShortestPathInterfaceToSource(), initialize(), preroutingFinish(), and routeUnicastPacket().

int inet::IPv4::transportInGateBaseId = -1

protected

Referenced by initialize().

bool inet::IPv4::useProxyARP = false

protected

Referenced by initialize(), and sendDatagramToOutput().

---

The documentation for this class was generated from the following files:

• IPv4.h
• IPv4.cc