inet::GlobalArp Class Reference

This class provides an IArp implementation whithout exchanging packets. More...

#include <GlobalArp.h>

Inheritance diagram for inet::GlobalArp:

Classes
class	ArpCacheEntry

Public Types
typedef std::map< L3Address, ArpCacheEntry * >	ArpCache

Public Member Functions
	GlobalArp ()
virtual	~GlobalArp ()
virtual int	numInitStages () const override
Public Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual	~OperationalMixin ()
	}@ More...
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()
Public Member Functions inherited from inet::IArp
virtual	~IArp ()

Static Public Member Functions
static MacAddress	toMulticastMacAddress (Ipv4Address address)
static MacAddress	toMulticastMacAddress (Ipv6Address address)

Protected Member Functions
void	ensureCacheEntry (const L3Address &address, const NetworkInterface *networkInterface)
MacAddress	mapUnicastAddress (L3Address address)
Protected Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual int	numInitStages () const override
virtual void	refreshDisplay () const override
virtual void	handleMessage (cMessage *msg) override
virtual void	handleMessageWhenDown (cMessage *msg)
virtual bool	handleOperationStage (LifecycleOperation *operation, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual State	getInitialOperationalState () const
	Returns initial operational state: OPERATING or NOT_OPERATING. More...
virtual void	handleActiveOperationTimeout (cMessage *message)
virtual bool	isUp () const
	utility functions More...
virtual bool	isDown () const
virtual void	setOperationalState (State newState)
virtual void	scheduleOperationTimeout (simtime_t timeout)
virtual void	setupActiveOperation (LifecycleOperation *operation, IDoneCallback *doneCallback, State)
virtual void	delayActiveOperationFinish (simtime_t timeout)
virtual void	startActiveOperationExtraTime (simtime_t delay=SIMTIME_ZERO)
virtual void	startActiveOperationExtraTimeOrFinish (simtime_t extraTime)
virtual void	finishActiveOperation ()

Protected Attributes
ModuleRefByPar< IInterfaceTable >	interfaceTable
L3Address::AddressType	addressType = static_cast<L3Address::AddressType>(-1)
Protected Attributes inherited from inet::OperationalMixin< cSimpleModule >
State	operationalState
simtime_t	lastChange
Operation	activeOperation
cMessage *	activeOperationTimeout
cMessage *	activeOperationExtraTimer

Static Protected Attributes
static ArpCache	globalArpCache
static int	globalArpCacheRefCnt = 0

IArp implementation
virtual void	initialize (int stage) override
virtual void	handleMessageWhenUp (cMessage *msg) override
virtual void	handleSelfMessage (cMessage *msg)
virtual void	handlePacket (Packet *packet)
virtual bool	isInitializeStage (int stage) const override
virtual bool	isModuleStartStage (int stage) const override
virtual bool	isModuleStopStage (int stage) const override
virtual void	handleStartOperation (LifecycleOperation *operation) override
virtual void	handleStopOperation (LifecycleOperation *operation) override
virtual void	handleCrashOperation (LifecycleOperation *operation) override
virtual L3Address	getL3AddressFor (const MacAddress &addr) const override
	Returns the Layer 3 address for the given MAC address. More...
virtual MacAddress	resolveL3Address (const L3Address &address, const NetworkInterface *networkInterface) override
	Tries to resolve the given network address to a MAC address. More...
virtual void	receiveSignal (cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override

Additional Inherited Members
Static Public Attributes inherited from inet::IArp
static const simsignal_t	arpResolutionInitiatedSignal = cComponent::registerSignal("arpResolutionInitiated")
	Signals used to publish ARP state changes. More...
static const simsignal_t	arpResolutionCompletedSignal = cComponent::registerSignal("arpResolutionCompleted")
static const simsignal_t	arpResolutionFailedSignal = cComponent::registerSignal("arpResolutionFailed")
Protected Types inherited from inet::OperationalMixin< cSimpleModule >
enum	State

Detailed Description

This class provides an IArp implementation whithout exchanging packets.

Member Typedef Documentation

ArpCache

typedef std::map<L3Address, ArpCacheEntry *> inet::GlobalArp::ArpCache

Constructor & Destructor Documentation

GlobalArp()

inet::GlobalArp::GlobalArp

(

)

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

~GlobalArp()

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

ensureCacheEntry()

void inet::GlobalArp::ensureCacheEntry ( const L3Address &  address, const NetworkInterface *  networkInterface  )

protected

{
    auto it = globalArpCache.find(address);
    if (it == globalArpCache.end()) {
        ArpCacheEntry *entry = new ArpCacheEntry();
        entry->owner = this;
        entry->networkInterface = networkInterface;
        auto where = globalArpCache.insert(globalArpCache.begin(), std::make_pair(address, entry));
        ASSERT(where->second == entry);
    }
}

Referenced by initialize().

getL3AddressFor()

L3Address inet::GlobalArp::getL3AddressFor ( const MacAddress &  ) const

overridevirtual

Returns the Layer 3 address for the given MAC address.

If it is not available (not in the cache, pending resolution, or already expired), UNSPECIFIED_ADDRESS is returned.

Implements inet::IArp.

{
    Enter_Method("getL3AddressFor");
    switch (addressType) {
#ifdef INET_WITH_IPv4
        case L3Address::IPv4: {
            if (macAddress.isUnspecified())
                return Ipv4Address::UNSPECIFIED_ADDRESS;
            for (ArpCache::const_iterator it = globalArpCache.begin(); it != globalArpCache.end(); it++)
                if (it->second->networkInterface->getMacAddress() == macAddress && it->first.getType() == L3Address::IPv4)
                    return it->first;
            return Ipv4Address::UNSPECIFIED_ADDRESS;
        }
#endif
#ifdef INET_WITH_IPv6
        case L3Address::IPv6: {
            if (macAddress.isUnspecified())
                return Ipv6Address::UNSPECIFIED_ADDRESS;
            for (ArpCache::const_iterator it = globalArpCache.begin(); it != globalArpCache.end(); it++)
                if (it->second->networkInterface->getMacAddress() == macAddress && it->first.getType() == L3Address::IPv6)
                    return it->first;
            return Ipv4Address::UNSPECIFIED_ADDRESS;
        }
#endif
        case L3Address::MAC:
            return L3Address(macAddress);
        case L3Address::MODULEID: {
            if (macAddress.isUnspecified())
                return ModuleIdAddress();
            for (ArpCache::const_iterator it = globalArpCache.begin(); it != globalArpCache.end(); it++)
                if (it->second->networkInterface->getMacAddress() == macAddress && it->first.getType() == L3Address::MODULEID)
                    return it->first;
            return ModuleIdAddress();
        }
        case L3Address::MODULEPATH: {
            if (macAddress.isUnspecified())
                return ModulePathAddress();
            for (ArpCache::const_iterator it = globalArpCache.begin(); it != globalArpCache.end(); it++)
                if (it->second->networkInterface->getMacAddress() == macAddress && it->first.getType() == L3Address::MODULEPATH)
                    return it->first;
            return ModulePathAddress();
        }
        default:
            throw cRuntimeError("Unknown address type");
    }
}

handleCrashOperation()

void inet::GlobalArp::handleCrashOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
}

handleMessageWhenUp()

void inet::GlobalArp::handleMessageWhenUp ( cMessage *  msg )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    if (msg->isSelfMessage())
        handleSelfMessage(msg);
    else
        handlePacket(check_and_cast<Packet *>(msg));
}

handlePacket()

void inet::GlobalArp::handlePacket ( Packet *  packet )

protectedvirtual

{
    EV << "Packet " << packet << " arrived, dropping it\n";
    delete packet;
}

Referenced by handleMessageWhenUp().

handleSelfMessage()

void inet::GlobalArp::handleSelfMessage ( cMessage *  msg )

protectedvirtual

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

Referenced by handleMessageWhenUp().

handleStartOperation()

void inet::GlobalArp::handleStartOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
}

handleStopOperation()

void inet::GlobalArp::handleStopOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
}

initialize()

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

overrideprotectedvirtual

Reimplemented from inet::OperationalMixin< cSimpleModule >.

{
    OperationalBase::initialize(stage);
 
    if (stage == INITSTAGE_LOCAL) {
        const char *addressTypeString = par("addressType");
        if (!strcmp(addressTypeString, "ipv4"))
            addressType = L3Address::IPv4;
        else if (!strcmp(addressTypeString, "ipv6"))
            addressType = L3Address::IPv6;
        else if (!strcmp(addressTypeString, "mac"))
            addressType = L3Address::MAC;
        else if (!strcmp(addressTypeString, "modulepath"))
            addressType = L3Address::MODULEPATH;
        else if (!strcmp(addressTypeString, "moduleid"))
            addressType = L3Address::MODULEID;
        else
            throw cRuntimeError("Unknown address type");
        WATCH_PTRMAP(globalArpCache);
    }
    else if (stage == INITSTAGE_NETWORK_LAYER) {
        interfaceTable.reference(this, "interfaceTableModule", true);
        // register our addresses in the global cache
        for (int i = 0; i < interfaceTable->getNumInterfaces(); i++) {
            NetworkInterface *networkInterface = interfaceTable->getInterface(i);
            if (!networkInterface->isLoopback()) {
#ifdef INET_WITH_IPv4
                if (auto ipv4Data = networkInterface->findProtocolData<Ipv4InterfaceData>()) {
                    Ipv4Address ipv4Address = ipv4Data->getIPAddress();
                    if (!ipv4Address.isUnspecified())
                        ensureCacheEntry(ipv4Address, networkInterface);
                }
#endif
#ifdef INET_WITH_IPv6
                if (auto ipv6Data = networkInterface->findProtocolData<Ipv6InterfaceData>()) {
                    Ipv6Address ipv6Address = ipv6Data->getLinkLocalAddress();
                    if (!ipv6Address.isUnspecified())
                        ensureCacheEntry(ipv6Address, networkInterface);
                }
#endif
#ifdef INET_WITH_NEXTHOP
                if (auto genericData = networkInterface->findProtocolData<NextHopInterfaceData>()) {
                    L3Address address = genericData->getAddress();
                    if (!address.isUnspecified())
                        ensureCacheEntry(address, networkInterface);
                }
#endif
            }
        }
        cModule *node = findContainingNode(this);
        if (node != nullptr) {
            node->subscribe(interfaceIpv4ConfigChangedSignal, this);
            node->subscribe(interfaceIpv6ConfigChangedSignal, this);
        }
    }
}

isInitializeStage()

virtual bool inet::GlobalArp::isInitializeStage ( int  stage ) const

inlineoverrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{ return stage == INITSTAGE_NETWORK_LAYER; }

isModuleStartStage()

virtual bool inet::GlobalArp::isModuleStartStage ( int  stage ) const

inlineoverrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{ return stage == ModuleStartOperation::STAGE_NETWORK_LAYER; }

isModuleStopStage()

virtual bool inet::GlobalArp::isModuleStopStage ( int  stage ) const

inlineoverrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{ return stage == ModuleStopOperation::STAGE_NETWORK_LAYER; }

mapUnicastAddress()

MacAddress inet::GlobalArp::mapUnicastAddress ( L3Address  address )

protected

{
    switch (address.getType()) {
#ifdef INET_WITH_IPv4
        case L3Address::IPv4: {
            Ipv4Address ipv4Address = address.toIpv4();
            auto it = globalArpCache.find(ipv4Address);
            if (it != globalArpCache.end())
                return it->second->networkInterface->getMacAddress();
            throw cRuntimeError("GlobalArp does not support dynamic address resolution");
            return MacAddress::UNSPECIFIED_ADDRESS;
        }
#endif
#ifdef INET_WITH_IPv6
        case L3Address::IPv6: {
            Ipv6Address ipv6Address = address.toIpv6();
            auto it = globalArpCache.find(ipv6Address);
            if (it != globalArpCache.end())
                return it->second->networkInterface->getMacAddress();
            throw cRuntimeError("GlobalArp does not support dynamic address resolution");
            return MacAddress::UNSPECIFIED_ADDRESS;
        }
#endif
        case L3Address::MAC:
            return address.toMac();
        case L3Address::MODULEID: {
            auto networkInterface = check_and_cast<NetworkInterface *>(getSimulation()->getModule(address.toModuleId().getId()));
            return networkInterface->getMacAddress();
        }
        case L3Address::MODULEPATH: {
            auto networkInterface = check_and_cast<NetworkInterface *>(getSimulation()->getModule(address.toModulePath().getId()));
            return networkInterface->getMacAddress();
        }
        default:
            throw cRuntimeError("Unknown address type");
    }
}

Referenced by resolveL3Address().

numInitStages()

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

inlineoverridevirtual

{ return NUM_INIT_STAGES; }

receiveSignal()

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

overridevirtual

{
    Enter_Method("%s", cComponent::getSignalName(signalID));
 
    // host associated. Link is up. Change the state to init.
    if (signalID == interfaceIpv4ConfigChangedSignal || signalID == interfaceIpv6ConfigChangedSignal) {
        const NetworkInterfaceChangeDetails *iecd = check_and_cast<const NetworkInterfaceChangeDetails *>(obj);
        NetworkInterface *networkInterface = iecd->getNetworkInterface();
        if (networkInterface->isLoopback())
            return;
        auto it = globalArpCache.begin();
        ArpCacheEntry *entry = nullptr;
#ifdef INET_WITH_IPv4
        if (signalID == interfaceIpv4ConfigChangedSignal) {
            for (; it != globalArpCache.end(); ++it) {
                if (it->second->networkInterface == networkInterface && it->first.getType() == L3Address::IPv4)
                    break;
            }
            if (it == globalArpCache.end()) {
                auto ipv4Data = networkInterface->findProtocolData<Ipv4InterfaceData>();
                if (!ipv4Data || 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->networkInterface = networkInterface;
            }
            else {
                // actualize
                entry = it->second;
                ASSERT(entry->owner == this);
                globalArpCache.erase(it);
                auto ipv4Data = networkInterface->findProtocolData<Ipv4InterfaceData>();
                if (!ipv4Data || ipv4Data->getIPAddress().isUnspecified()) {
                    delete entry;
                    return; // if the address is not defined it isn't included in the global cache
                }
            }
            Ipv4Address ipv4Address = networkInterface->getProtocolData<Ipv4InterfaceData>()->getIPAddress();
            auto where = globalArpCache.insert(globalArpCache.begin(), std::make_pair(ipv4Address, entry));
            ASSERT(where->second == entry);
        }
        else
#endif
#ifdef INET_WITH_IPv6
        if (signalID == interfaceIpv6ConfigChangedSignal) {
            for (; it != globalArpCache.end(); ++it) {
                if (it->second->networkInterface == networkInterface && it->first.getType() == L3Address::IPv6)
                    break;
            }
            if (it == globalArpCache.end()) {
                auto ipv6Data = networkInterface->findProtocolData<Ipv6InterfaceData>();
                if (ipv6Data == nullptr || ipv6Data->getLinkLocalAddress().isUnspecified())
                    return; // if the address is not defined it isn't included in the global cache
                entry = new ArpCacheEntry();
                entry->owner = this;
                entry->networkInterface = networkInterface;
            }
            else {
                // actualize
                entry = it->second;
                ASSERT(entry->owner == this);
                globalArpCache.erase(it);
                auto ipv6Data = networkInterface->findProtocolData<Ipv6InterfaceData>();
                if (ipv6Data == nullptr || ipv6Data->getLinkLocalAddress().isUnspecified()) {
                    delete entry;
                    return; // if the address is not defined it isn't included in the global cache
                }
            }
            Ipv6Address ipv6Address = networkInterface->getProtocolData<Ipv6InterfaceData>()->getLinkLocalAddress();
            auto where = globalArpCache.insert(globalArpCache.begin(), std::make_pair(ipv6Address, entry));
            ASSERT(where->second == entry);
        }
        else
#endif
        {}
    }
    else
        throw cRuntimeError("Unknown signal");
}

resolveL3Address()

MacAddress inet::GlobalArp::resolveL3Address ( const L3Address &  address, const NetworkInterface *  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("resolveL3Address");
    if (address.isUnicast())
        return mapUnicastAddress(address);
    else if (address.isMulticast())
        return address.mapToMulticastMacAddress();
    else if (address.isBroadcast())
        return MacAddress::BROADCAST_ADDRESS;
    throw cRuntimeError("Address must be one of unicast, multicast, or broadcast");
}

toMulticastMacAddress() [1/2]

static MacAddress inet::GlobalArp::toMulticastMacAddress ( Ipv4Address  address )

static

toMulticastMacAddress() [2/2]

static MacAddress inet::GlobalArp::toMulticastMacAddress ( Ipv6Address  address )

static

Member Data Documentation

addressType

L3Address::AddressType inet::GlobalArp::addressType = static_cast<L3Address::AddressType>(-1)

protected

Referenced by getL3AddressFor(), and initialize().

globalArpCache

GlobalArp::ArpCache inet::GlobalArp::globalArpCache

staticprotected

Referenced by ensureCacheEntry(), getL3AddressFor(), GlobalArp(), initialize(), mapUnicastAddress(), receiveSignal(), and ~GlobalArp().

globalArpCacheRefCnt

int inet::GlobalArp::globalArpCacheRefCnt = 0

staticprotected

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

interfaceTable

ModuleRefByPar<IInterfaceTable> inet::GlobalArp::interfaceTable

protected

Referenced by initialize().

---

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

• GlobalArp.h
• GlobalArp.cc