inet::Arp Class Reference

ARP implementation. More...

#include <Arp.h>

Inheritance diagram for inet::Arp:

Classes
class	ArpCacheEntry

Public Types
typedef std::map< Ipv4Address, ArpCacheEntry * >	ArpCache
typedef std::vector< cMessage * >	MsgPtrVector

Public Member Functions
	Arp ()
virtual	~Arp ()
virtual int	numInitStages () const override
void	sendArpGratuitous (const NetworkInterface *ie, MacAddress srcAddr, Ipv4Address ipAddr, ArpOpcode opCode=ARP_REQUEST)
void	sendArpProbe (const NetworkInterface *ie, MacAddress srcAddr, Ipv4Address probedAddr)
virtual MacAddress	resolveL3Address (const L3Address &address, const NetworkInterface *ie) override
	IArp implementation. More...
virtual L3Address	getL3AddressFor (const MacAddress &addr) const override
	Returns the Layer 3 address for the given MAC address. More...
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 ()

Protected Member Functions
MacAddress	mapMulticastAddress (Ipv4Address addr)
virtual void	initialize (int stage) override
virtual void	handleMessageWhenUp (cMessage *msg) override
virtual void	finish () override
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 void	flush ()
virtual void	initiateArpResolution (Ipv4Address ipv4Address, ArpCacheEntry *entry)
virtual void	sendArpRequest (const NetworkInterface *ie, Ipv4Address ipAddress)
virtual void	requestTimedOut (cMessage *selfmsg)
virtual bool	addressRecognized (Ipv4Address destAddr, NetworkInterface *ie)
virtual void	processArpPacket (Packet *packet)
virtual void	updateArpCache (ArpCacheEntry *entry, const MacAddress &macAddress)
virtual MacAddress	resolveMacAddressForArpReply (const NetworkInterface *ie, const ArpPacket *arp)
virtual void	dumpArpPacket (const ArpPacket *arp)
virtual void	refreshDisplay () const override
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
simtime_t	retryTimeout
int	retryCount = 0
simtime_t	cacheTimeout
std::string	proxyArpInterfaces = ""
long	numResolutions = 0
long	numFailedResolutions = 0
long	numRequestsSent = 0
long	numRepliesSent = 0
cPatternMatcher	proxyArpInterfacesMatcher
ArpCache	arpCache
ModuleRefByPar< IInterfaceTable >	ift
ModuleRefByPar< IIpv4RoutingTable >	rt
Protected Attributes inherited from inet::OperationalMixin< cSimpleModule >
State	operationalState
simtime_t	lastChange
Operation	activeOperation
cMessage *	activeOperationTimeout
cMessage *	activeOperationExtraTimer

Static Protected Attributes
static simsignal_t	arpRequestSentSignal = registerSignal("arpRequestSent")
static simsignal_t	arpReplySentSignal = registerSignal("arpReplySent")

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

ARP implementation.

Member Typedef Documentation

ArpCache

typedef std::map<Ipv4Address, ArpCacheEntry *> inet::Arp::ArpCache

MsgPtrVector

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

Constructor & Destructor Documentation

Arp()

inet::Arp::Arp

(

)

{
}

~Arp()

inet::Arp::~Arp ( )

virtual

{
    for (auto& elem : arpCache)
        delete elem.second;
}

Member Function Documentation

addressRecognized()

bool inet::Arp::addressRecognized ( Ipv4Address  destAddr, NetworkInterface *  ie  )

protectedvirtual

{
    if (rt->isLocalAddress(destAddr))
        return true;
    else {
        // if proxy ARP is enables in interface ie
        if (proxyArpInterfacesMatcher.matches(ie->getInterfaceName())) {
            // if we can route this packet, and the output port is
            // different from this one, then say yes
            NetworkInterface *rtie = rt->getInterfaceForDestAddr(destAddr);
            return rtie != nullptr && rtie != ie;
        }
        else
            return false;
    }
}

Referenced by processArpPacket().

dumpArpPacket()

void inet::Arp::dumpArpPacket ( const ArpPacket *  arp )

protectedvirtual

{
    EV_DETAIL << (arp->getOpcode() == ARP_REQUEST ? "ARP_REQ" : arp->getOpcode() == ARP_REPLY ? "ARP_REPLY" : "unknown type")
              << "  src=" << arp->getSrcIpAddress() << " / " << arp->getSrcMacAddress()
              << "  dest=" << arp->getDestIpAddress() << " / " << arp->getDestMacAddress() << "\n";
}

Referenced by processArpPacket().

finish()

void inet::Arp::finish ( )

overrideprotectedvirtual

{
}

flush()

void inet::Arp::flush ( )

protectedvirtual

{
    while (!arpCache.empty()) {
        auto i = arpCache.begin();
        ArpCacheEntry *entry = i->second;
        cancelAndDelete(entry->timer);
        entry->timer = nullptr;
        delete entry;
        arpCache.erase(i);
    }
}

Referenced by handleCrashOperation(), and handleStopOperation().

getL3AddressFor()

L3Address inet::Arp::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");
 
    if (macAddr.isUnspecified())
        return Ipv4Address::UNSPECIFIED_ADDRESS;
 
    simtime_t now = simTime();
    for (const auto& elem : arpCache)
        if (elem.second->macAddress == macAddr && elem.second->lastUpdate + cacheTimeout >= now)
            return elem.first;
 
    return Ipv4Address::UNSPECIFIED_ADDRESS;
}

handleCrashOperation()

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

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    flush();
}

handleMessageWhenUp()

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

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    if (msg->isSelfMessage()) {
        requestTimedOut(msg);
    }
    else {
        Packet *packet = check_and_cast<Packet *>(msg);
        processArpPacket(packet);
    }
}

handleStartOperation()

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

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    ASSERT(arpCache.empty());
}

handleStopOperation()

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

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    flush();
}

initialize()

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

overrideprotectedvirtual

Reimplemented from inet::OperationalMixin< cSimpleModule >.

{
    OperationalBase::initialize(stage);
 
    if (stage == INITSTAGE_LOCAL) {
        retryTimeout = par("retryTimeout");
        retryCount = par("retryCount");
        cacheTimeout = par("cacheTimeout");
        proxyArpInterfaces = par("proxyArpInterfaces").stdstringValue();
 
        proxyArpInterfacesMatcher.setPattern(proxyArpInterfaces.c_str(), false, true, false);
 
        // init statistics
        numRequestsSent = numRepliesSent = 0;
        numResolutions = numFailedResolutions = 0;
        WATCH(numRequestsSent);
        WATCH(numRepliesSent);
        WATCH(numResolutions);
        WATCH(numFailedResolutions);
 
        WATCH_PTRMAP(arpCache);
    }
    else if (stage == INITSTAGE_NETWORK_LAYER) {
        ift.reference(this, "interfaceTableModule", true);
        rt.reference(this, "routingTableModule", true);
        registerService(Protocol::arp, gate("netwIn"), gate("netwOut"));
        registerProtocol(Protocol::arp, gate("ifOut"), gate("ifIn"));
    }
}

initiateArpResolution()

void inet::Arp::initiateArpResolution ( Ipv4Address  ipv4Address, ArpCacheEntry *  entry  )

protectedvirtual

{
    entry->pending = true;
    entry->numRetries = 0;
    entry->lastUpdate = SIMTIME_ZERO;
    entry->macAddress = MacAddress::UNSPECIFIED_ADDRESS;
    entry->ipv4Address = nextHopAddr;
    sendArpRequest(entry->ie, nextHopAddr);
 
    // start timer
    cMessage *msg = entry->timer = new cMessage("ARP timeout");
    msg->setContextPointer(entry);
    scheduleAfter(retryTimeout, msg);
 
    numResolutions++;
    Notification signal(nextHopAddr, MacAddress::UNSPECIFIED_ADDRESS, entry->ie);
    emit(arpResolutionInitiatedSignal, &signal);
}

Referenced by resolveL3Address().

isInitializeStage()

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

inlineoverrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{ return stage == INITSTAGE_NETWORK_LAYER; }

isModuleStartStage()

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

inlineoverrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{ return stage == ModuleStartOperation::STAGE_NETWORK_LAYER; }

isModuleStopStage()

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

inlineoverrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{ return stage == ModuleStopOperation::STAGE_NETWORK_LAYER; }

mapMulticastAddress()

MacAddress inet::Arp::mapMulticastAddress ( Ipv4Address  addr )

protected

numInitStages()

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

inlineoverridevirtual

{ return NUM_INIT_STAGES; }

processArpPacket()

void inet::Arp::processArpPacket ( Packet *  packet )

protectedvirtual

{
    EV_INFO << "Received " << packet << " from network protocol.\n";
    const auto& arp = packet->peekAtFront<ArpPacket>();
    dumpArpPacket(arp.get());
 
    // extract input port
    NetworkInterface *ie = ift->getInterfaceById(packet->getTag<InterfaceInd>()->getInterfaceId());
 
    //
    // Recipe a'la RFC 826:
    //
    // ?Do I have the hardware type in ar$hrd?
    // Yes: (almost definitely)
    //   [optionally check the hardware length ar$hln]
    //   ?Do I speak the protocol in ar$pro?
    //   Yes:
    //     [optionally check the protocol length ar$pln]
    //     Merge_flag := false
    //     If the pair <protocol type, sender protocol address> is
    //         already in my translation table, update the sender
    //         hardware address field of the entry with the new
    //         information in the packet and set Merge_flag to true.
    //     ?Am I the target protocol address?
    //     Yes:
    //       If Merge_flag is false, add the triplet <protocol type,
    //           sender protocol address, sender hardware address> to
    //           the translation table.
    //       ?Is the opcode ares_op$REQUEST?  (NOW look at the opcode!!)
    //       Yes:
    //         Swap hardware and protocol fields, putting the local
    //             hardware and protocol addresses in the sender fields.
    //         Set the ar$op field to ares_op$REPLY
    //         Send the packet to the (new) target hardware address on
    //             the same hardware on which the request was received.
    //
 
    MacAddress srcMacAddress = arp->getSrcMacAddress();
    Ipv4Address srcIpAddress = arp->getSrcIpAddress();
 
    if (srcMacAddress.isUnspecified())
        throw cRuntimeError("wrong ARP packet: source MAC address is empty");
    if (srcIpAddress.isUnspecified())
        throw cRuntimeError("wrong ARP packet: source IPv4 address is empty");
 
    bool mergeFlag = false;
    // "If ... sender protocol address is already in my translation table"
    auto it = arpCache.find(srcIpAddress);
    if (it != arpCache.end()) {
        // "update the sender hardware address field"
        ArpCacheEntry *entry = it->second;
        updateArpCache(entry, srcMacAddress);
        mergeFlag = true;
    }
 
    // "?Am I the target protocol address?"
    // if Proxy ARP is enabled, we also have to reply if we're a router to the dest IPv4 address
    if (addressRecognized(arp->getDestIpAddress(), ie)) {
        // "If Merge_flag is false, add the triplet protocol type, sender
        // protocol address, sender hardware address to the translation table"
        if (!mergeFlag) {
            ArpCacheEntry *entry;
            if (it != arpCache.end()) {
                entry = it->second;
            }
            else {
                entry = new ArpCacheEntry();
                arpCache.insert(arpCache.begin(), std::make_pair(srcIpAddress, entry));
                entry->ipv4Address = srcIpAddress;
                entry->ie = ie;
 
                entry->pending = false;
                entry->timer = nullptr;
                entry->numRetries = 0;
            }
            updateArpCache(entry, srcMacAddress);
        }
 
        // "?Is the opcode ares_op$REQUEST?  (NOW look at the opcode!!)"
        switch (arp->getOpcode()) {
            case ARP_REQUEST: {
                EV_DETAIL << "Packet was ARP REQUEST, sending REPLY\n";
                MacAddress myMACAddress = resolveMacAddressForArpReply(ie, arp.get());
                if (myMACAddress.isUnspecified()) {
                    delete packet;
                    return;
                }
 
                Ipv4Address myIPAddress = ie->getProtocolData<Ipv4InterfaceData>()->getIPAddress();
 
                // "Swap hardware and protocol fields", etc.
                const auto& arpReply = makeShared<ArpPacket>();
                Ipv4Address origDestAddress = arp->getDestIpAddress();
                arpReply->setDestIpAddress(srcIpAddress);
                arpReply->setDestMacAddress(srcMacAddress);
                arpReply->setSrcIpAddress(origDestAddress);
                arpReply->setSrcMacAddress(myMACAddress);
                arpReply->setOpcode(ARP_REPLY);
                Packet *outPk = new Packet("arpREPLY");
                outPk->insertAtFront(arpReply);
                outPk->addTag<MacAddressReq>()->setDestAddress(srcMacAddress);
                outPk->addTag<InterfaceReq>()->setInterfaceId(ie->getInterfaceId());
                if (ie->getProtocol() != nullptr)
                    outPk->addTag<DispatchProtocolReq>()->setProtocol(ie->getProtocol());
                else
                    outPk->removeTagIfPresent<DispatchProtocolReq>();
                outPk->addTag<PacketProtocolTag>()->setProtocol(&Protocol::arp);
 
                // send out
                EV_INFO << "Sending " << outPk << " to network protocol.\n";
                emit(arpReplySentSignal, outPk);
                send(outPk, "ifOut");
                numRepliesSent++;
                break;
            }
 
            case ARP_REPLY: {
                EV_DETAIL << "Discarding packet\n";
                break;
            }
 
            case ARP_RARP_REQUEST:
                throw cRuntimeError("RARP request received: RARP is not supported");
 
            case ARP_RARP_REPLY:
                throw cRuntimeError("RARP reply received: RARP is not supported");
 
            default:
                throw cRuntimeError("Unsupported opcode %d in received ARP packet", arp->getOpcode());
        }
    }
    else {
        // address not recognized
        EV_INFO << "IPv4 address " << arp->getDestIpAddress() << " not recognized, dropping ARP packet\n";
    }
    delete packet;
}

Referenced by handleMessageWhenUp().

refreshDisplay()

void inet::Arp::refreshDisplay ( ) const

overrideprotectedvirtual

{
    OperationalBase::refreshDisplay();
 
    std::stringstream os;
 
    os << "size:" << arpCache.size() << " sent:" << numRequestsSent << "\n"
       << "repl:" << numRepliesSent << " fail:" << numFailedResolutions;
 
    getDisplayString().setTagArg("t", 0, os.str().c_str());
}

requestTimedOut()

void inet::Arp::requestTimedOut ( cMessage *  selfmsg )

protectedvirtual

{
    ArpCacheEntry *entry = (ArpCacheEntry *)selfmsg->getContextPointer();
    entry->numRetries++;
    if (entry->numRetries < retryCount) {
        // retry
        Ipv4Address nextHopAddr = entry->ipv4Address;
        EV_INFO << "ARP request for " << nextHopAddr << " timed out, resending\n";
        sendArpRequest(entry->ie, nextHopAddr);
        scheduleAfter(retryTimeout, selfmsg);
        return;
    }
 
    delete selfmsg;
 
    // max retry count reached: ARP failure.
    // throw out entry from cache
    EV << "ARP timeout, max retry count " << retryCount << " for " << entry->ipv4Address << " reached.\n";
    Notification signal(entry->ipv4Address, MacAddress::UNSPECIFIED_ADDRESS, entry->ie);
    emit(arpResolutionFailedSignal, &signal);
    arpCache.erase(entry->ipv4Address);
    delete entry;
    numFailedResolutions++;
}

Referenced by handleMessageWhenUp().

resolveL3Address()

MacAddress inet::Arp::resolveL3Address ( const L3Address &  address, const NetworkInterface *  ie  )

overridevirtual

IArp implementation.

Implements inet::IArp.

{
    Enter_Method("resolveMACAddress(%s,%s)", address.str().c_str(), ie->getInterfaceName());
 
    Ipv4Address addr = address.toIpv4();
    auto it = arpCache.find(addr);
    if (it == arpCache.end()) {
        // no cache entry: launch ARP request
        ArpCacheEntry *entry = new ArpCacheEntry();
        entry->owner = this;
        arpCache.insert(arpCache.begin(), std::make_pair(addr, entry));
        entry->ipv4Address = addr;
        entry->ie = ie;
 
        EV << "Starting ARP resolution for " << addr << "\n";
        initiateArpResolution(addr, entry);
        return MacAddress::UNSPECIFIED_ADDRESS;
    }
    else if (it->second->pending) {
        // an ARP request is already pending for this address
        EV << "ARP resolution for " << addr << " is already pending\n";
        return MacAddress::UNSPECIFIED_ADDRESS;
    }
    else if (it->second->lastUpdate + cacheTimeout >= simTime()) {
        return it->second->macAddress;
    }
    else {
        EV << "ARP cache entry for " << addr << " expired, starting new ARP resolution\n";
        ArpCacheEntry *entry = it->second;
        entry->ie = ie; // routing table may have changed
        initiateArpResolution(addr, entry);
    }
    return MacAddress::UNSPECIFIED_ADDRESS;
}

resolveMacAddressForArpReply()

MacAddress inet::Arp::resolveMacAddressForArpReply ( const NetworkInterface *  ie, const ArpPacket *  arp  )

protectedvirtual

{
    return ie->getMacAddress();
}

Referenced by processArpPacket().

sendArpGratuitous()

void inet::Arp::sendArpGratuitous	(	const NetworkInterface *	ie,
		MacAddress	srcAddr,
		Ipv4Address	ipAddr,
		ArpOpcode	opCode = ARP_REQUEST
	)

{
    Enter_Method("sendArpGratuitous");
 
    // both must be set
    ASSERT(!srcAddr.isUnspecified());
    ASSERT(!ipAddr.isUnspecified());
 
    // fill out everything in ARP Request packet except dest MAC address
    Packet *packet = new Packet("arpGrt");
    const auto& arp = makeShared<ArpPacket>();
    arp->setOpcode(opCode);
    arp->setSrcMacAddress(srcAddr);
    arp->setSrcIpAddress(ipAddr);
    arp->setDestIpAddress(ipAddr);
    arp->setDestMacAddress(MacAddress::BROADCAST_ADDRESS);
    packet->insertAtFront(arp);
 
    auto macAddrReq = packet->addTag<MacAddressReq>();
    macAddrReq->setSrcAddress(srcAddr);
    macAddrReq->setDestAddress(MacAddress::BROADCAST_ADDRESS);
    packet->addTag<InterfaceReq>()->setInterfaceId(ie->getInterfaceId());
    if (ie->getProtocol() != nullptr)
        packet->addTag<DispatchProtocolReq>()->setProtocol(ie->getProtocol());
    else
        packet->removeTagIfPresent<DispatchProtocolReq>();
    packet->addTag<PacketProtocolTag>()->setProtocol(&Protocol::arp);
 
    ArpCacheEntry *entry = new ArpCacheEntry();
    arpCache.insert(arpCache.begin(), std::make_pair(ipAddr, entry));
    entry->ipv4Address = ipAddr;
    entry->ie = ie;
 
    entry->pending = false;
    entry->timer = nullptr;
    entry->numRetries = 0;
 
    entry->lastUpdate = simTime();
    // updateARPCache(entry, srcAddr); //FIXME
 
    // send out
    send(packet, "ifOut");
}

sendArpProbe()

void inet::Arp::sendArpProbe	(	const NetworkInterface *	ie,
		MacAddress	srcAddr,
		Ipv4Address	probedAddr
	)

{
    Enter_Method("sendArpProbe");
 
    // both must be set
    ASSERT(!srcAddr.isUnspecified());
    ASSERT(!probedAddr.isUnspecified());
 
    Packet *packet = new Packet("arpProbe");
    const auto& arp = makeShared<ArpPacket>();
    arp->setOpcode(ARP_REQUEST);
    arp->setSrcMacAddress(srcAddr);
    arp->setSrcIpAddress(Ipv4Address::UNSPECIFIED_ADDRESS);
    arp->setDestIpAddress(probedAddr);
    arp->setDestMacAddress(MacAddress::UNSPECIFIED_ADDRESS);
    packet->insertAtFront(arp);
 
    auto macAddrReq = packet->addTag<MacAddressReq>();
    macAddrReq->setSrcAddress(srcAddr);
    macAddrReq->setDestAddress(MacAddress::BROADCAST_ADDRESS);
    packet->addTag<InterfaceReq>()->setInterfaceId(ie->getInterfaceId());
    if (ie->getProtocol() != nullptr)
        packet->addTag<DispatchProtocolReq>()->setProtocol(ie->getProtocol());
    else
        packet->removeTagIfPresent<DispatchProtocolReq>();
    packet->addTag<PacketProtocolTag>()->setProtocol(&Protocol::arp);
 
    // send out
    send(packet, "ifOut");
}

sendArpRequest()

void inet::Arp::sendArpRequest ( const NetworkInterface *  ie, Ipv4Address  ipAddress  )

protectedvirtual

{
    // find our own IPv4 address and MAC address on the given interface
    MacAddress myMACAddress = ie->getMacAddress();
    Ipv4Address myIPAddress = ie->getProtocolData<Ipv4InterfaceData>()->getIPAddress();
 
    // both must be set
    ASSERT(!myMACAddress.isUnspecified());
    ASSERT(!myIPAddress.isUnspecified());
 
    // fill out everything in ARP Request packet except dest MAC address
    Packet *packet = new Packet("arpREQ");
    const auto& arp = makeShared<ArpPacket>();
    arp->setOpcode(ARP_REQUEST);
    arp->setSrcMacAddress(myMACAddress);
    arp->setSrcIpAddress(myIPAddress);
    arp->setDestIpAddress(ipAddress);
    packet->insertAtFront(arp);
 
    packet->addTag<MacAddressReq>()->setDestAddress(MacAddress::BROADCAST_ADDRESS);
    packet->addTag<InterfaceReq>()->setInterfaceId(ie->getInterfaceId());
    if (ie->getProtocol() != nullptr)
        packet->addTag<DispatchProtocolReq>()->setProtocol(ie->getProtocol());
    else
        packet->removeTagIfPresent<DispatchProtocolReq>();
    packet->addTag<PacketProtocolTag>()->setProtocol(&Protocol::arp);
 
    // send out
    EV_INFO << "Sending " << packet << " to network protocol.\n";
    emit(arpRequestSentSignal, packet);
    send(packet, "ifOut");
    numRequestsSent++;
}

Referenced by initiateArpResolution(), and requestTimedOut().

updateArpCache()

void inet::Arp::updateArpCache ( ArpCacheEntry *  entry, const MacAddress &  macAddress  )

protectedvirtual

{
    EV_DETAIL << "Updating ARP cache entry: " << entry->ipv4Address << " <--> " << macAddress << "\n";
 
    // update entry
    if (entry->pending) {
        entry->pending = false;
        cancelAndDelete(entry->timer);
        entry->timer = nullptr;
        entry->numRetries = 0;
    }
    entry->macAddress = macAddress;
    entry->lastUpdate = simTime();
    Notification signal(entry->ipv4Address, macAddress, entry->ie);
    emit(arpResolutionCompletedSignal, &signal);
}

Referenced by processArpPacket().

Member Data Documentation

arpCache

ArpCache inet::Arp::arpCache

protected

Referenced by flush(), getL3AddressFor(), handleStartOperation(), initialize(), processArpPacket(), refreshDisplay(), requestTimedOut(), resolveL3Address(), sendArpGratuitous(), and ~Arp().

arpReplySentSignal

simsignal_t inet::Arp::arpReplySentSignal = registerSignal("arpReplySent")

staticprotected

Referenced by processArpPacket().

arpRequestSentSignal

simsignal_t inet::Arp::arpRequestSentSignal = registerSignal("arpRequestSent")

staticprotected

Referenced by sendArpRequest().

cacheTimeout

simtime_t inet::Arp::cacheTimeout

protected

Referenced by getL3AddressFor(), initialize(), and resolveL3Address().

ift

ModuleRefByPar<IInterfaceTable> inet::Arp::ift

protected

Referenced by initialize(), and processArpPacket().

numFailedResolutions

long inet::Arp::numFailedResolutions = 0

protected

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

numRepliesSent

long inet::Arp::numRepliesSent = 0

protected

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

numRequestsSent

long inet::Arp::numRequestsSent = 0

protected

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

numResolutions

long inet::Arp::numResolutions = 0

protected

Referenced by initialize(), and initiateArpResolution().

proxyArpInterfaces

std::string inet::Arp::proxyArpInterfaces = ""

protected

Referenced by initialize().

proxyArpInterfacesMatcher

cPatternMatcher inet::Arp::proxyArpInterfacesMatcher

protected

Referenced by addressRecognized(), and initialize().

retryCount

int inet::Arp::retryCount = 0

protected

Referenced by initialize(), and requestTimedOut().

retryTimeout

simtime_t inet::Arp::retryTimeout

protected

Referenced by initialize(), initiateArpResolution(), and requestTimedOut().

rt

ModuleRefByPar<IIpv4RoutingTable> inet::Arp::rt

protected

Referenced by addressRecognized(), and initialize().

---

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

• Arp.h
• Arp.cc