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


virtual MACAddress	resolveL3Address (const L3Address &address, const InterfaceEntry *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::IARP
virtual	~IARP ()

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

Protected Member Functions
MACAddress	mapMulticastAddress (IPv4Address addr)

virtual void	initialize (int stage) override

virtual void	handleMessage (cMessage *msg) override

virtual void	handleMessageWhenDown (cMessage *msg)

virtual bool	handleOperationStage (LifecycleOperation operation, int stage, IDoneCallback doneCallback) override
	Perform one stage of a lifecycle operation. More...

virtual void	finish () override

virtual bool	isNodeUp ()

virtual void	stop ()

virtual void	start ()

virtual void	flush ()

virtual void	sendPacketToNIC (cMessage msg, const InterfaceEntry ie, const MACAddress &macAddress, int etherType)

virtual void	initiateARPResolution (ARPCacheEntry *entry)

virtual void	sendARPRequest (const InterfaceEntry *ie, IPv4Address ipAddress)

virtual void	requestTimedOut (cMessage *selfmsg)

virtual bool	addressRecognized (IPv4Address destAddr, InterfaceEntry *ie)

virtual void	processARPPacket (ARPPacket *arp)

virtual void	updateARPCache (ARPCacheEntry *entry, const MACAddress &macAddress)

virtual void	dumpARPPacket (ARPPacket *arp)

virtual void	refreshDisplay () const override

Protected Attributes
simtime_t	retryTimeout

int	retryCount = 0

simtime_t	cacheTimeout

bool	respondToProxyARP = false

bool	isUp = false

long	numResolutions = 0

long	numFailedResolutions = 0

long	numRequestsSent = 0

long	numRepliesSent = 0

ARPCache	arpCache

cGate *	netwOutGate = nullptr

IInterfaceTable *	ift = nullptr

IIPv4RoutingTable *	rt = nullptr

Static Protected Attributes
static simsignal_t	sentReqSignal = registerSignal("sentReq")

static simsignal_t	sentReplySignal = registerSignal("sentReply")

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<IPv4Address, ARPCacheEntry *> inet::ARP::ARPCache

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

Constructor & Destructor Documentation

inet::ARP::ARP ( )

55 {

56 }

inet::ARP::~ARP ( )

virtual

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

Member Function Documentation

bool inet::ARP::addressRecognized	(	IPv4Address	destAddr,
		InterfaceEntry *	ie
	)

protectedvirtual

Referenced by processARPPacket().

 {
     if (rt->isLocalAddress(destAddr)) {
         return true;
     }
     else if (respondToProxyARP) {
         // respond to Proxy ARP request: if we can route this packet (and the
         // output port is different from this one), say yes
         InterfaceEntry *rtie = rt->getInterfaceForDestAddr(destAddr);
         return rtie != nullptr && rtie != ie;
     }
     else {
         return false;
     }
 }

void inet::ARP::dumpARPPacket ( ARPPacket * arp )

protectedvirtual

Referenced by processARPPacket().

 {
     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";
 }

void inet::ARP::finish ( )

overrideprotectedvirtual

89 {

90 }

void inet::ARP::flush ( )

protectedvirtual

Referenced by stop().

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

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_Silent();
 
     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;
 }

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

overrideprotectedvirtual

 {
     if (!isUp) {
         handleMessageWhenDown(msg);
         return;
     }
 
     if (msg->isSelfMessage()) {
         requestTimedOut(msg);
     }
     else {
         ARPPacket *arp = check_and_cast<ARPPacket *>(msg);
         processARPPacket(arp);
     }
 }

void inet::ARP::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_WARN << "Protocol is turned off, dropping '" << msg->getName() << "' message\n";
     delete msg;
 }

bool inet::ARP::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::ARP::initialize ( int stage )

overrideprotectedvirtual

 {
     cSimpleModule::initialize(stage);
 
     if (stage == INITSTAGE_LOCAL) {
         retryTimeout = par("retryTimeout");
         retryCount = par("retryCount");
         cacheTimeout = par("cacheTimeout");
         respondToProxyARP = par("respondToProxyARP");
 
         netwOutGate = gate("netwOut");
 
         // 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_3) {    // IP addresses should be available
         ift = getModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this);
         rt = getModuleFromPar<IIPv4RoutingTable>(par("routingTableModule"), this);
 
         isUp = isNodeUp();
     }
 }

void inet::ARP::initiateARPResolution ( ARPCacheEntry * entry )

protectedvirtual

Referenced by resolveL3Address().

 {
     IPv4Address nextHopAddr = entry->myIter->first;
     entry->pending = true;
     entry->numRetries = 0;
     entry->lastUpdate = SIMTIME_ZERO;
     entry->macAddress = MACAddress::UNSPECIFIED_ADDRESS;
     sendARPRequest(entry->ie, nextHopAddr);
 
     // start timer
     cMessage *msg = entry->timer = new cMessage("ARP timeout");
     msg->setContextPointer(entry);
     scheduleAt(simTime() + retryTimeout, msg);
 
     numResolutions++;
     Notification signal(nextHopAddr, MACAddress::UNSPECIFIED_ADDRESS, entry->ie);
     emit(initiatedARPResolutionSignal, &signal);
 }

bool inet::ARP::isNodeUp ( )

protectedvirtual

Referenced by initialize().

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

MACAddress inet::ARP::mapMulticastAddress ( IPv4Address addr )

protected

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

inlineoverridevirtual

95 { return NUM_INIT_STAGES; }

inet::NUM_INIT_STAGES

The number of initialization stages.

Definition: InitStages.h:116

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

protectedvirtual

Referenced by handleMessage().

 {
     EV_INFO << "Received " << arp << " from network protocol.\n";
     dumpARPPacket(arp);
 
     // extract input port
     IMACProtocolControlInfo *ctrl = check_and_cast<IMACProtocolControlInfo *>(arp->removeControlInfo());
     InterfaceEntry *ie = ift->getInterfaceById(ctrl->getInterfaceId());
     delete ctrl;
 
     //
     // 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();
                 auto where = arpCache.insert(arpCache.begin(), std::make_pair(srcIPAddress, entry));
                 entry->myIter = where;
                 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";
 
                 // find our own IPv4 address and MAC address on the given interface
                 MACAddress myMACAddress = ie->getMacAddress();
                 IPv4Address myIPAddress = ie->ipv4Data()->getIPAddress();
 
                 // "Swap hardware and protocol fields", etc.
                 arp->setName("arpREPLY");
                 IPv4Address origDestAddress = arp->getDestIPAddress();
                 arp->setDestIPAddress(srcIPAddress);
                 arp->setDestMACAddress(srcMACAddress);
                 arp->setSrcIPAddress(origDestAddress);
                 arp->setSrcMACAddress(myMACAddress);
                 arp->setOpcode(ARP_REPLY);
                 delete arp->removeControlInfo();
                 sendPacketToNIC(arp, ie, srcMACAddress, ETHERTYPE_ARP);
                 numRepliesSent++;
                 emit(sentReplySignal, 1L);
                 break;
             }
 
             case ARP_REPLY: {
                 EV_DETAIL << "Discarding packet\n";
                 delete arp;
                 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 arp;
     }
 }

void inet::ARP::refreshDisplay ( ) const

overrideprotectedvirtual

 {
     std::stringstream os;
 
     os << arpCache.size() << " cache entries\nsent req:" << numRequestsSent
        << " repl:" << numRepliesSent << " fail:" << numFailedResolutions;
 
     getDisplayString().setTagArg("t", 0, os.str().c_str());
 }

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

protectedvirtual

Referenced by handleMessage().

 {
     ARPCacheEntry *entry = (ARPCacheEntry *)selfmsg->getContextPointer();
     entry->numRetries++;
     if (entry->numRetries < retryCount) {
         // retry
         IPv4Address nextHopAddr = entry->myIter->first;
         EV_INFO << "ARP request for " << nextHopAddr << " timed out, resending\n";
         sendARPRequest(entry->ie, nextHopAddr);
         scheduleAt(simTime() + 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->myIter->first << " reached.\n";
     Notification signal(entry->myIter->first, MACAddress::UNSPECIFIED_ADDRESS, entry->ie);
     emit(failedARPResolutionSignal, &signal);
     arpCache.erase(entry->myIter);
     delete entry;
     numFailedResolutions++;
 }

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

overridevirtual

IARP implementation.

Implements inet::IARP.

 {
     Enter_Method("resolveMACAddress(%s,%s)", address.str().c_str(), ie->getName());
 
     IPv4Address addr = address.toIPv4();
     ARPCache::const_iterator it = arpCache.find(addr);
     if (it == arpCache.end()) {
         // no cache entry: launch ARP request
         ARPCacheEntry *entry = new ARPCacheEntry();
         entry->owner = this;
         auto where = arpCache.insert(arpCache.begin(), std::make_pair(addr, entry));
         entry->myIter = where;    // note: "inserting a new element into a map does not invalidate iterators that point to existing elements"
         entry->ie = ie;
 
         EV << "Starting ARP resolution for " << addr << "\n";
         initiateARPResolution(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(entry);
     }
     return MACAddress::UNSPECIFIED_ADDRESS;
 }

void inet::ARP::sendARPRequest	(	const InterfaceEntry *	ie,
		IPv4Address	ipAddress
	)

protectedvirtual

Referenced by initiateARPResolution(), and requestTimedOut().

 {
     // find our own IPv4 address and MAC address on the given interface
     MACAddress myMACAddress = ie->getMacAddress();
     IPv4Address myIPAddress = ie->ipv4Data()->getIPAddress();
 
     // both must be set
     ASSERT(!myMACAddress.isUnspecified());
     ASSERT(!myIPAddress.isUnspecified());
 
     // fill out everything in ARP Request packet except dest MAC address
     ARPPacket *arp = new ARPPacket("arpREQ");
     arp->setByteLength(ARP_HEADER_BYTES);
     arp->setOpcode(ARP_REQUEST);
     arp->setSrcMACAddress(myMACAddress);
     arp->setSrcIPAddress(myIPAddress);
     arp->setDestIPAddress(ipAddress);
 
     sendPacketToNIC(arp, ie, MACAddress::BROADCAST_ADDRESS, ETHERTYPE_ARP);
     numRequestsSent++;
     emit(sentReqSignal, 1L);
 }

void inet::ARP::sendPacketToNIC	(	cMessage *	msg,
		const InterfaceEntry *	ie,
		const MACAddress &	macAddress,
		int	etherType
	)

protectedvirtual

Referenced by processARPPacket(), and sendARPRequest().

 {
     // add control info with MAC address
     Ieee802Ctrl *controlInfo = new Ieee802Ctrl();
     controlInfo->setDest(macAddress);
     controlInfo->setEtherType(etherType);
     controlInfo->setInterfaceId(ie->getInterfaceId());
     msg->setControlInfo(controlInfo);
 
     // send out
     EV_INFO << "Sending " << msg << " to network protocol.\n";
     send(msg, netwOutGate);
 }

void inet::ARP::start ( )

protectedvirtual

Referenced by handleOperationStage().

 {
     ASSERT(arpCache.empty());
     isUp = true;
 }

void inet::ARP::stop ( )

protectedvirtual

Referenced by handleOperationStage().

 {
     isUp = false;
     flush();
 }

void inet::ARP::updateARPCache	(	ARPCacheEntry *	entry,
		const MACAddress &	macAddress
	)

protectedvirtual

Referenced by processARPPacket().

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