inet::GlobalARP Class Reference

ARP implementation. More...

#include <GlobalARP.h>

Inheritance diagram for inet::GlobalARP:

Classes
class	ARPCacheEntry

Public Types
typedef std::map< L3Address, ARPCacheEntry * >	ARPCache
typedef std::vector< cMessage * >	MsgPtrVector

Public Member Functions
	GlobalARP ()
virtual	~GlobalARP ()
virtual int	numInitStages () const override
virtual void	receiveSignal (cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override
virtual L3Address	getL3AddressFor (const MACAddress &addr) const override
	IARPCache implementation. More...
virtual MACAddress	resolveL3Address (const L3Address &address, const InterfaceEntry *ie) override
	Tries to resolve the given network address to a MAC address. More...
Public Member Functions inherited from inet::IARP
virtual	~IARP ()
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()

Protected Member Functions
MACAddress	mapMulticastAddress (L3Address addr)
virtual void	initialize (int stage) override
virtual void	handleMessage (cMessage *msg) override
virtual bool	handleOperationStage (LifecycleOperation *operation, int stage, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual void	finish () override
virtual void	processSelfMessage (cMessage *msg)
virtual void	handleMessageWhenDown (cMessage *msg)
virtual bool	isNodeUp ()
virtual void	stop ()
virtual void	start ()
virtual void	processARPPacket (ARPPacket *arp)

Protected Attributes
bool	isUp = false
IInterfaceTable *	ift = nullptr
IIPv4RoutingTable *	rt = nullptr

Static Protected Attributes
static ARPCache	globalArpCache
static int	globalArpCacheRefCnt = 0

Additional Inherited Members
Static Public Attributes inherited from inet::IARP
static const simsignal_t	initiatedARPResolutionSignal = cComponent::registerSignal("initiatedARPResolution")
	Signals used to publish ARP state changes. More...
static const simsignal_t	completedARPResolutionSignal = cComponent::registerSignal("completedARPResolution")
static const simsignal_t	failedARPResolutionSignal = cComponent::registerSignal("failedARPResolution")

Detailed Description

ARP implementation.

Member Typedef Documentation

typedef std::map<L3Address, ARPCacheEntry *> inet::GlobalARP::ARPCache

typedef std::vector<cMessage *> inet::GlobalARP::MsgPtrVector

Constructor & Destructor Documentation

inet::GlobalARP::GlobalARP

(

)

{
    if (++globalArpCacheRefCnt == 1) {
        if (!globalArpCache.empty())
            throw cRuntimeError("Global ARP cache not empty, model error in previous run?");
    }

    ift = nullptr;
    rt = nullptr;
}

inet::GlobalARP::~GlobalARP ( )

virtual

{
    --globalArpCacheRefCnt;
    // delete my entries from the globalArpCache
    for (auto it = globalArpCache.begin(); it != globalArpCache.end(); ) {
        if (it->second->owner == this) {
            auto cur = it++;
            delete cur->second;
            globalArpCache.erase(cur);
        }
        else
            ++it;
    }
}

Member Function Documentation

void inet::GlobalARP::finish ( )

overrideprotectedvirtual

{
}

L3Address inet::GlobalARP::getL3AddressFor ( const MACAddress &  addr ) const

overridevirtual

IARPCache implementation.

Implements inet::IARP.

{
    Enter_Method_Silent();

    if (macAddr.isUnspecified())
        return IPv4Address::UNSPECIFIED_ADDRESS;

    for (ARPCache::const_iterator it = globalArpCache.begin(); it != globalArpCache.end(); it++)
        if (it->second->macAddress == macAddr && it->first.getType() == L3Address::IPv4)
            return it->first.toIPv4();


    return IPv4Address::UNSPECIFIED_ADDRESS;
}

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

overrideprotectedvirtual

{
    if (!isUp) {
        handleMessageWhenDown(msg);
        return;
    }

    if (msg->isSelfMessage())
        processSelfMessage(msg);
    else
        processARPPacket(check_and_cast<ARPPacket *>(msg));
}

void inet::GlobalARP::handleMessageWhenDown ( cMessage *  msg )

protectedvirtual

Referenced by handleMessage().

{
    if (msg->isSelfMessage())
        throw cRuntimeError("Model error: self msg '%s' received when protocol is down", msg->getName());
    EV_ERROR << "Protocol is turned off, dropping '" << msg->getName() << "' message\n";
    delete msg;
}

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

overrideprotectedvirtual

Perform one stage of a lifecycle operation.

Processing may be done entirely within this method, or may be a longer process that involves nonzero simulation time or several events, and is triggered by this method call.

Return value: true = "done"; false = "not yet done, will invoke doneCallback when done"

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();
    }
    else {
        throw cRuntimeError("Unsupported operation '%s'", operation->getClassName());
    }
    return true;
}

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

overrideprotectedvirtual

{
    cSimpleModule::initialize(stage);

    if (stage == INITSTAGE_LOCAL) {
        WATCH_PTRMAP(globalArpCache);
    }
    else if (stage == INITSTAGE_NETWORK_LAYER_3) {    // IP addresses should be available
        ift = getModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this);
        rt = getModuleFromPar<IIPv4RoutingTable>(par("routingTableModule"), this);

        isUp = isNodeUp();

        // register our addresses in the global cache
        for (int i = 0; i < ift->getNumInterfaces(); i++) {
            InterfaceEntry *ie = ift->getInterface(i);
            if (ie->isLoopback())
                continue;
            if (!ie->ipv4Data())
                continue;
            IPv4Address nextHopAddr = ie->ipv4Data()->getIPAddress();
            if (nextHopAddr.isUnspecified())
                continue; // if the address is not defined it isn't included in the global cache
            // check if the entry exist
            auto it = globalArpCache.find(nextHopAddr);
            if (it != globalArpCache.end())
                continue;
            ARPCacheEntry *entry = new ARPCacheEntry();
            entry->owner = this;
            entry->ie = ie;
            entry->macAddress = ie->getMacAddress();

            auto where = globalArpCache.insert(globalArpCache.begin(), std::make_pair(nextHopAddr, entry));
            ASSERT(where->second == entry);
            entry->myIter = where;    // note: "inserting a new element into a map does not invalidate iterators that point to existing elements"
        }
        cModule *host = findContainingNode(this);
        if (host != nullptr)
            host->subscribe(NF_INTERFACE_IPv4CONFIG_CHANGED, this);
    }
}

bool inet::GlobalARP::isNodeUp ( )

protectedvirtual

Referenced by initialize().

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

MACAddress inet::GlobalARP::mapMulticastAddress ( L3Address  addr )

protected

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

inlineoverridevirtual

{ return NUM_INIT_STAGES; }

void inet::GlobalARP::processARPPacket ( ARPPacket *  arp )

protectedvirtual

Referenced by handleMessage().

{
    EV << "ARP packet " << arp << " arrived, dropped\n";
    delete arp;
}

void inet::GlobalARP::processSelfMessage ( cMessage *  msg )

protectedvirtual

Referenced by handleMessage().

{
    throw cRuntimeError("Model error: unexpected self message");
}

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

overridevirtual

{
    Enter_Method_Silent();
    // host associated. Link is up. Change the state to init.
    if (signalID == NF_INTERFACE_IPv4CONFIG_CHANGED) {
        const InterfaceEntryChangeDetails *iecd = check_and_cast<const InterfaceEntryChangeDetails *>(obj);
        InterfaceEntry *ie = iecd->getInterfaceEntry();
        // rebuild the arp cache
        if (ie->isLoopback())
            return;
        auto it = globalArpCache.begin();
        for ( ; it != globalArpCache.end(); ++it) {
            if (it->second->ie == ie)
                break;
        }
        ARPCacheEntry *entry = nullptr;
        if (it == globalArpCache.end()) {
            if (!ie->ipv4Data() || ie->ipv4Data()->getIPAddress().isUnspecified())
                return; // if the address is not defined it isn't included in the global cache
            entry = new ARPCacheEntry();
            entry->owner = this;
            entry->ie = ie;
        }
        else {
            // actualize
            entry = it->second;
            ASSERT(entry->owner == this);
            globalArpCache.erase(it);
            if (!ie->ipv4Data() || ie->ipv4Data()->getIPAddress().isUnspecified()) {
                delete entry;
                return;    // if the address is not defined it isn't included in the global cache
            }
        }
        entry->macAddress = ie->getMacAddress();
        IPv4Address ipAddr = ie->ipv4Data()->getIPAddress();
        auto where = globalArpCache.insert(globalArpCache.begin(), std::make_pair(ipAddr, entry));
        ASSERT(where->second == entry);
        entry->myIter = where;    // note: "inserting a new element into a map does not invalidate iterators that point to existing elements"
    }
}

MACAddress inet::GlobalARP::resolveL3Address ( const L3Address &  address, const InterfaceEntry *  ie  )

overridevirtual

Tries to resolve the given network address to a MAC address.

If the MAC address is not yet resolved it returns an unspecified address and starts an address resolution procedure. A signal is emitted when the address resolution procedure terminates.

Implements inet::IARP.

{
    Enter_Method_Silent();

    IPv4Address addr = address.toIPv4();
    ARPCache::const_iterator it = globalArpCache.find(addr);
    if (it != globalArpCache.end())
        return it->second->macAddress;

    throw cRuntimeError("GlobalARP does not support dynamic address resolution");
    return MACAddress::UNSPECIFIED_ADDRESS;
}

void inet::GlobalARP::start ( )

protectedvirtual

Referenced by handleOperationStage().

{
    isUp = true;
}

void inet::GlobalARP::stop ( )

protectedvirtual

Referenced by handleOperationStage().

{
    isUp = false;
}

Member Data Documentation

GlobalARP::ARPCache inet::GlobalARP::globalArpCache

staticprotected

Referenced by getL3AddressFor(), GlobalARP(), initialize(), receiveSignal(), resolveL3Address(), and ~GlobalARP().

int inet::GlobalARP::globalArpCacheRefCnt = 0

staticprotected

Referenced by GlobalARP(), and ~GlobalARP().

IInterfaceTable* inet::GlobalARP::ift = nullptr

protected

Referenced by GlobalARP(), and initialize().

bool inet::GlobalARP::isUp = false

protected

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

IIPv4RoutingTable* inet::GlobalARP::rt = nullptr

protected

Referenced by GlobalARP(), and initialize().

---

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

• GlobalARP.h
• GlobalARP.cc