#include <EigrpIpv6Pdm.h>

Inheritance diagram for inet::eigrp::EigrpIpv6Pdm:

Classes
struct	IPv6netPrefix

Public Member Functions
	EigrpIpv6Pdm ()

	~EigrpIpv6Pdm ()

virtual void	updateInterface (int interfaceId) override

void	addInterface (int ifaceId, int networkId, bool enabled) override
	Adds interface to EIGRP. More...

void	addInterface (int ifaceId, bool enabled) override
	Adds interface to EIGRP for IPv6. More...

EigrpNetwork< Ipv6Address > *	addNetwork (Ipv6Address address, Ipv6Address mask) override
	Adds new network to EigrpNetworkTable for routing. More...

void	setASNum (int asNum) override

int	getASNum () override

void	setKValues (const EigrpKValues &kValues) override

void	setMaximumPath (int maximumPath) override

void	setVariance (int variance) override

void	setHelloInt (int interval, int ifaceId) override

void	setHoldInt (int interval, int ifaceId) override

void	setSplitHorizon (bool shenabled, int ifaceId) override

void	setPassive (bool passive, int ifaceId) override

void	setStub (const EigrpStub &stub) override

void	setRouterId (Ipv4Address routerID) override
	Sets router ID. More...

void	setLoad (int load, int interfaceId) override

void	setBandwidth (int bandwith, int interfaceId) override

void	setDelay (int delay, int interfaceId) override

void	setReliability (int reliability, int interfaceId) override

void	sendUpdate (int destNeighbor, EigrpRoute< Ipv6Address > route, EigrpRouteSource< Ipv6Address > source, bool forcePoisonRev, const char *reason) override
	Sends update message to specified neighbor. More...

void	sendQuery (int destNeighbor, EigrpRoute< Ipv6Address > route, EigrpRouteSource< Ipv6Address > source, bool forcePoisonRev=false) override
	Sends query message to specified neighbor. More...

void	sendReply (EigrpRoute< Ipv6Address > route, int destNeighbor, EigrpRouteSource< Ipv6Address > source, bool forcePoisonRev=false, bool isUnreachable=false) override
	Sends reply message to specified neighbor. More...

EigrpRouteSource< Ipv6Address > *	updateRoute (EigrpRoute< Ipv6Address > route, uint64_t dmin, bool rtableChanged, bool removeUnreach=false) override
	Function finds successors to the destination network. More...

uint64_t	findRouteDMin (EigrpRoute< Ipv6Address > *route) override
	Returns minimal distance to destination network. More...

bool	hasFeasibleSuccessor (EigrpRoute< Ipv6Address > *route, uint64_t &resultDmin) override
	Determine whether there are Feasibles Successors for specified route. More...

EigrpRouteSource< Ipv6Address > *	getBestSuccessor (EigrpRoute< Ipv6Address > *route) override
	Returns best successor for specified network. More...

bool	setReplyStatusTable (EigrpRoute< Ipv6Address > route, EigrpRouteSource< Ipv6Address > source, bool forcePoisonRev, int neighCount, int stubCount) override
	Sets Reply Status Table for specified network. More...

bool	hasNeighborForUpdate (EigrpRouteSource< Ipv6Address > *source) override
	Returns tru if there are recipients for update message, else false. More...

void	setDelayedRemove (int neighId, EigrpRouteSource< Ipv6Address > *src) override
	After receiving Ack from neighbor with neighId will be route removed from TT. More...

void	sendUpdateToStubs (EigrpRouteSource< Ipv6Address > succ, EigrpRouteSource< Ipv6Address > oldSucc, EigrpRoute< Ipv6Address > *route) override
	Sends update message to all stub neighbors. More...

bool	addNetPrefix (const Ipv6Address &network, const short int prefixLen, const int ifaceId) override
	Adds information about IPv6 network prefix. More...

Public Member Functions inherited from inet::eigrp::IEigrpModule< Ipv6Address >
virtual	~IEigrpModule ()

Protected Types
typedef std::vector< Ipv6Route * >	RouteVector

typedef std::vector< EigrpMsgReq * >	RequestVector

typedef std::vector< IPv6netPrefix >	PrefixVector

Protected Member Functions
virtual void	initialize (int stage) override

virtual void	preDelete (cComponent *root) override

virtual void	handleMessage (cMessage *msg) override
	Multi-stage initialization. More...

virtual int	numInitStages () const override

virtual void	receiveSignal (cComponent source, simsignal_t signalID, cObject obj, cObject *details) override

void	printSentMsg (int routeCnt, Ipv6Address &destAddress, EigrpMsgReq *msgReq)

void	printRecvMsg (const EigrpMessage *msg, Ipv6Address &addr, int ifaceId)

EigrpTimer *	createTimer (char timerKind, void *context)
	Creates timer of specified type. More...

void	resetTimer (EigrpTimer *timer, int interval)
	Sets specified timer to given interval. More...

void	startHelloTimer (EigrpInterface *eigrpIface, simtime_t interval)
	Schedule hello timer to the specified interval. More...

void	cancelHoldTimer (EigrpNeighbor< Ipv6Address > *neigh)
	Stops Hold timer. More...

void	cancelHelloTimers ()
	Stops Hello Timers on all interfaces. More...

Packet *	createHelloPacket (int holdInt, EigrpKValues kValues, Ipv6Address &destAddress, EigrpMsgReq *msgReq)

Packet *	createAckPacket (Ipv6Address &destAddress, EigrpMsgReq *msgReq)

Packet *	createUpdatePacket (const Ipv6Address &destAddress, EigrpMsgReq *msgReq)

Packet *	createQueryPacket (Ipv6Address &destAddress, EigrpMsgReq *msgReq)

Packet *	createReplyPacket (Ipv6Address &destAddress, EigrpMsgReq *msgReq)

void	addMessageHeader (const Ptr< EigrpMessage > &msg, int opcode, EigrpMsgReq *msgReq)
	Adds ControlInfo for network layer module. More...

void	unlockRoutes (const EigrpMsgReq *msgReq)

void	createRouteTlv (EigrpMpIpv6Internal routeTlv, EigrpRoute< Ipv6Address > route, bool unreachable=false)

void	addRoutesToMsg (const Ptr< EigrpIpv6Message > &msg, const EigrpMsgReq *msgReq)
	Add routes from request to the message. More...

void	setRouteTlvMetric (EigrpWideMetricPar msgMetric, EigrpWideMetricPar rtMetric)

EigrpMsgReq *	createMsgReq (HeaderOpcode msgType, int destNeighbor, int destIface)
	Creates request for sending of EIGRP message for RTP. More...

void	processTimer (cMessage *msg)

void	processMsgFromNetwork (cMessage *msg)
	Process message from network layer. More...

void	processMsgFromRtp (cMessage *msg)
	Process message request from RTP. More...

void	processAckPacket (Packet pk, Ipv6Address &srcAddress, int ifaceId, EigrpNeighbor< Ipv6Address > neigh)

void	processHelloPacket (Packet pk, Ipv6Address &srcAddress, int ifaceId, EigrpNeighbor< Ipv6Address > neigh)

void	processUpdatePacket (Packet pk, Ipv6Address &srcAddress, int ifaceId, EigrpNeighbor< Ipv6Address > neigh)

void	processQueryPacket (Packet pk, Ipv6Address &srcAddress, int ifaceId, EigrpNeighbor< Ipv6Address > neigh)

void	processReplyPacket (Packet pk, Ipv6Address &srcAddress, int ifaceId, EigrpNeighbor< Ipv6Address > neigh)

EigrpRouteSource< Ipv6Address > *	processInterRoute (const EigrpMpIpv6Internal &tlv, Ipv6Address &nextHop, int sourceNeighId, EigrpInterface eigrpIface, bool notifyDual, bool *isSourceNew)
	Process route TLV. More...

void	sendAllEigrpPaths (EigrpInterface eigrpIface, EigrpNeighbor< Ipv6Address > neigh)
	Creates and sends message with all routes from routing table to specified neighbor. More...

void	processNewNeighbor (int ifaceId, Ipv6Address &srcAddress, const EigrpIpv6Hello *helloMessage)
	Creates relationship with neighbor. More...

int	checkNeighborshipRules (int ifaceId, int neighAsNum, Ipv6Address &neighAddr, const EigrpKValues &neighKValues)
	Checks neighborship rules. More...

EigrpNeighbor< Ipv6Address > *	createNeighbor (EigrpInterface *eigrpIface, Ipv6Address &address, uint16_t holdInt)
	Create record in the neighbor table and start hold timer. More...

void	removeNeighbor (EigrpNeighbor< Ipv6Address > *neigh)
	Removes neighbor from neighbor table and delete it. More...

void	disableInterface (NetworkInterface iface, EigrpInterface eigrpIface)
	Remove interface from EIGRP interface table. More...

void	enableInterface (EigrpInterface *eigrpIface)
	Add interface to the EIGRP interface table and notifies DUAL. More...

EigrpInterface *	getInterfaceById (int ifaceId)
	Returns EIGRP interface (enabled or disabled) or nullptr. More...

EigrpInterface *	addInterfaceToEigrp (int ifaceId, bool enabled)
	Creates interface and inserts it to the table. More...

void	processIfaceStateChange (NetworkInterface *iface)

void	processIfaceConfigChange (EigrpInterface *eigrpIface)

void	processRTRouteDel (const cObject *details)

Ipv6Address	getNextHopAddr (const Ipv6Address &nextHopAddr, Ipv6Address &senderAddr)
	Returns next hop address. More...

bool	getDestIpAddress (int destNeigh, Ipv6Address *resultAddress)
	Returns IP address for sending EIGRP message. More...

bool	removeRouteFromRT (EigrpRouteSource< Ipv6Address > successor, IRoute::SourceType removedRtSrc)

Ipv6Route *	createRTRoute (EigrpRouteSource< Ipv6Address > *successor)

bool	installRouteToRT (EigrpRoute< Ipv6Address > route, EigrpRouteSource< Ipv6Address > source, uint64_t dmin, Ipv6Route *rtEntry)
	Updates existing route in the routing table or creates new one. More...

bool	isRTSafeForAdd (EigrpRoute< Ipv6Address > *route, unsigned int eigrpAd)
	Returns true, if routing table does not contain route with given address, mask and smaller administrative distance. More...

void	setRTRouteMetric (Ipv6Route *route, uint64_t metric)
	Changes metric of route in routing table. More...

bool	removeOldSuccessor (EigrpRouteSource< Ipv6Address > source, EigrpRoute< Ipv6Address > route)
	Removes route from routing table and changes old successor's record in topology table. More...

void	msgToAllIfaces (int destination, HeaderOpcode msgType, EigrpRouteSource< Ipv6Address > *source, bool forcePoisonRev, bool forceUnreachable)
	Records request to send message to all neighbors. More...

void	msgToIface (HeaderOpcode msgType, EigrpRouteSource< Ipv6Address > source, EigrpInterface eigrpIface, bool forcePoisonRev=false, bool forceUnreachable=false)
	Creates request for sending message on specified interface. More...

void	flushMsgRequests ()
	Sends all message requests to RTP. More...

EigrpMsgReq *	pushMsgRouteToQueue (HeaderOpcode msgType, int ifaceId, int neighId, const EigrpMsgRoute &msgRt)
	Insert route into the queue with requests. More...

bool	applySplitHorizon (EigrpInterface destInterface, EigrpRouteSource< Ipv6Address > source, EigrpRoute< Ipv6Address > *route)

bool	applyStubToUpdate (EigrpRouteSource< Ipv6Address > *src)
	Apply stub configuration to the route in outgoing Update message. More...

bool	applyStubToQuery (EigrpInterface *eigrpIface, int numOfNeigh)
	Apply stub configuration to the route in outgoing Query message. More...

Ipv6Route *	findRoute (const Ipv6Address &prefix, int prefixLength)

Ipv6Route *	findRoute (const Ipv6Address &prefix, int prefixLength, const Ipv6Address &nexthop)

Protected Attributes
cModule *	host = nullptr

const int64_t	sizeOfMsg = 20

const char *	SPLITTER_OUTGW
	Output gateway to the EIGRP Splitter module. More...

const char *	RTP_OUTGW
	Output gateway to the RTP module. More...

const Ipv6Address	EIGRP_IPV6_MULT
	Multicast address for EIGRP messages. More...

EigrpKValues	KVALUES_MAX
	K-values (from K1 to K5) are set to max. More...

const Ipv6Address	EIGRP_SELF_ADDR
	Next hop address 0.0.0.0 (self address) More...

EigrpRouteSource< Ipv6Address > *	oldsource = nullptr
	Latest route change. More...

int	asNum
	Autonomous system number. More...

EigrpKValues	kValues
	K-values for calculation of metric. More...

int	maximumPath
	Maximum number of parallel routes that EIGRP will support. More...

int	variance
	Parameter for unequal cost load balancing. More...

unsigned int	adminDistInt
	Administrative distance. More...

bool	useClassicMetric
	Use classic metric computation or wide metric computation. More...

int	ribScale
	Scaling factor for Wide metric. More...

bool	eigrpStubEnabled
	True when EIGRP stub is on. More...

EigrpStub	eigrpStub
	EIGRP stub configuration. More...

ModuleRefByPar< IInterfaceTable >	ift

ModuleRefByPar< Ipv6RoutingTable >	rt

EigrpDual< Ipv6Address > *	eigrpDual

EigrpMetricHelper *	eigrpMetric

EigrpInterfaceTable *	eigrpIft
	Table with enabled EIGRP interfaces. More...

EigrpDisabledInterfaces *	eigrpIftDisabled
	Disabled EIGRP interfaces. More...

EigrpNeighborTable< Ipv6Address > *	eigrpNt
	Table with EIGRP neighbors. More...

EigrpTopologyTable< Ipv6Address > *	eigrpTt
	Topology table. More...

EigrpNetworkTable< Ipv6Address > *	routingForNetworks
	Networks included in EIGRP. More...

RequestVector	reqQueue
	Requests for sending EIGRP messages from DUAL. More...

PrefixVector	netPrefixes

Additional Inherited Members
Static Public Attributes inherited from inet::eigrp::IEigrpPdm< Ipv6Address >
static const int	UNSPEC_RECEIVER
	Unspecified address of receiver - all neighbors. More...

static const int	STUB_RECEIVER
	All stub neighbors. More...

static const int	CONNECTED_ROUTE

static const int	UNSPEC_SENDER
	Unspecified address of sender - input event source. More...

static const bool	RT_UNREACHABLE

Member Typedef Documentation

◆ PrefixVector

typedef std::vector<IPv6netPrefix> inet::eigrp::EigrpIpv6Pdm::PrefixVector

protected

◆ RequestVector

typedef std::vector<EigrpMsgReq *> inet::eigrp::EigrpIpv6Pdm::RequestVector

protected

◆ RouteVector

typedef std::vector<Ipv6Route *> inet::eigrp::EigrpIpv6Pdm::RouteVector

protected

Constructor & Destructor Documentation

◆ EigrpIpv6Pdm()

inet::eigrp::EigrpIpv6Pdm::EigrpIpv6Pdm ( )

                            : EIGRP_IPV6_MULT(Ipv6Address("FF02::A"))
 {
     SPLITTER_OUTGW = "splitterOut";
     RTP_OUTGW = "rtpOut";
  
     KVALUES_MAX.K1 = KVALUES_MAX.K2 = KVALUES_MAX.K3 = KVALUES_MAX.K4 = KVALUES_MAX.K5 = KVALUES_MAX.K6 = 255;
  
     asNum = -1;
     maximumPath = 4;
     variance = 1;
     adminDistInt = 90;
     useClassicMetric = true;
     ribScale = 128;
  
     kValues.K1 = kValues.K3 = 1;
     kValues.K2 = kValues.K4 = kValues.K5 = kValues.K6 = 0;
  
     eigrpStubEnabled = false;
 }

◆ ~EigrpIpv6Pdm()

inet::eigrp::EigrpIpv6Pdm::~EigrpIpv6Pdm ( )

 {
     delete this->routingForNetworks;
     delete this->eigrpIftDisabled;
     delete this->eigrpDual;
     delete this->eigrpMetric;
 }

Member Function Documentation

◆ addInterface() [1/2]

void inet::eigrp::EigrpIpv6Pdm::addInterface	(	int	interfaceId,
		bool	enabled
	)

inlineoverridevirtual

Adds interface to EIGRP for IPv6.

Parameters

interfaceId	ID of interface
enabled	state of interface in EIGRP process, enabled or disabled

Implements inet::eigrp::IEigrpModule< Ipv6Address >.

298 { addInterfaceToEigrp(ifaceId, enabled); }

◆ addInterface() [2/2]

void inet::eigrp::EigrpIpv6Pdm::addInterface	(	int	interfaceId,
		int	networkId,
		bool	enabled
	)

inlineoverridevirtual

Adds interface to EIGRP.

Parameters

interfaceId	ID of interface
networkID	ID of network in EigrpNetworkTable

Implements inet::eigrp::IEigrpModule< Ipv6Address >.

297 { /* useful only for IPv4 */ }

◆ addInterfaceToEigrp()

EigrpInterface * inet::eigrp::EigrpIpv6Pdm::addInterfaceToEigrp	(	int	ifaceId,
		bool	enabled
	)

protected

Creates interface and inserts it to the table.

 {
     NetworkInterface *iface = ift->getInterfaceById(ifaceId);
     // create EIGRP interface
     EigrpInterface *eigrpIface = nullptr;
  
     eigrpIface = getInterfaceById(ifaceId); // search for existing iface
  
     if (eigrpIface == nullptr) { // iface not found -> create new
         eigrpIface = new EigrpInterface(iface, EigrpNetworkTable<Ipv6Address>::UNSPEC_NETID, false);
     }
  
     if (enabled) {
         enableInterface(eigrpIface);
         startHelloTimer(eigrpIface, simTime() + uniform(0, 1));
     }
     else {
         eigrpIftDisabled->addInterface(eigrpIface);
     }
  
     return eigrpIface;
 }

Referenced by setHelloInt(), setHoldInt(), setPassive(), and setSplitHorizon().

◆ addMessageHeader()

void inet::eigrp::EigrpIpv6Pdm::addMessageHeader	(	const Ptr< EigrpMessage > &	msg,
		int	opcode,
		EigrpMsgReq *	msgReq
	)

protected

Adds ControlInfo for network layer module.

 {
     msg->setOpcode(opcode);
     msg->setAsNum(this->asNum);
     msg->setInit(msgReq->getInit());
     msg->setEot(msgReq->getEot());
     msg->setRs(msgReq->getRs());
     msg->setCr(msgReq->getCr());
 }

Referenced by createAckPacket(), createHelloPacket(), createQueryPacket(), createReplyPacket(), and createUpdatePacket().

◆ addNetPrefix()

bool inet::eigrp::EigrpIpv6Pdm::addNetPrefix	(	const Ipv6Address &	network,
		const short int	prefixLen,
		const int	ifaceId
	)

overridevirtual

Adds information about IPv6 network prefix.

Parameters

network	network prefix
prefixLen	length of network prefix
ifaceId	ID of interface contains network prefix

Returns: True if successfully added, otherwise false (e.g. same IPv6 prefix on different interfaces)

Note: Checks duplicates

Implements inet::eigrp::IEigrpModule< Ipv6Address >.

 {
     PrefixVector::iterator it;
  
     for (it = netPrefixes.begin(); it != netPrefixes.end(); ++it) { // through all known prefixes search same prefix
         if (it->network == network && it->prefixLength == prefixLen) { // found same prefix
             if (it->ifaceId == ifaceId) { // belonging to same interface = more than one IPv6 addresses from same prefix on interface = ok -> already added
                 return true;
             }
             else { // same prefix on different interfaces = bad -> do not add
                 return false;
             }
         }
     }
  
     // Add new prefix
     IPv6netPrefix newprefix;
     newprefix.network = network;
     newprefix.prefixLength = prefixLen;
     newprefix.ifaceId = ifaceId;
     this->netPrefixes.push_back(newprefix);
  
 //    EV_DEBUG << "Added prefix: " << this->netPrefixes.back().network << "/" << this->netPrefixes.back().prefixLength << " on iface " << this->netPrefixes.back().ifaceId << endl;
  
     return true;
 }

◆ addNetwork()

EigrpNetwork< Ipv6Address > * inet::eigrp::EigrpIpv6Pdm::addNetwork	(	Ipv6Address	address,
		Ipv6Address	mask
	)

overridevirtual

Adds new network to EigrpNetworkTable for routing.

Implements inet::eigrp::IEigrpModule< Ipv6Address >.

 {
     return routingForNetworks->addNetwork(address, mask);
 }

Referenced by enableInterface().

◆ addRoutesToMsg()

void inet::eigrp::EigrpIpv6Pdm::addRoutesToMsg	(	const Ptr< EigrpIpv6Message > &	msg,
		const EigrpMsgReq *	msgReq
	)

protected

Add routes from request to the message.

 {
     // Add routes to the message
     int reqCnt = msgReq->getRoutesArraySize();
     EigrpRouteSource<Ipv6Address> *source = nullptr;
     EigrpRoute<Ipv6Address> *route = nullptr;
  
     msg->setInterRoutesArraySize(reqCnt);
     for (int i = 0; i < reqCnt; i++) {
         EigrpMpIpv6Internal routeTlv;
         EigrpMsgRoute req = msgReq->getRoutes(i);
  
         if ((source = eigrpTt->findRouteById(req.sourceId)) == nullptr) { // Route was removed (only for sent Update messages to stub routers)
             route = eigrpTt->findRouteInfoById(req.routeId);
             ASSERT(route != nullptr);
         }
         else {
             route = source->getRouteInfo();
         }
         routeTlv.routerID = req.originator;
         createRouteTlv(&routeTlv, route, req.unreachable);
  
         msg->setInterRoutes(i, routeTlv);
  
 #ifdef EIGRP_DEBUG
         EV_DEBUG << "     route: " << routeTlv.destAddress << "/" << getNetmaskLength(routeTlv.destMask);
         EV_DEBUG << " originator: " << routeTlv.routerID;
         if (eigrpMetric->isParamMaximal(routeTlv.metric)) EV_DEBUG << " (unreachable) ";
         EV_DEBUG << ", bw: " << routeTlv.metric.bandwidth;
         EV_DEBUG << ", dly: " << routeTlv.metric.delay;
         EV_DEBUG << ", hopcnt: " << (int)routeTlv.metric.hopCount;
         EV_DEBUG << endl;
 #endif
     }
 }

Referenced by createQueryPacket(), createReplyPacket(), and createUpdatePacket().

◆ applySplitHorizon()

bool inet::eigrp::EigrpIpv6Pdm::applySplitHorizon	(	EigrpInterface *	destInterface,
		EigrpRouteSource< Ipv6Address > *	source,
		EigrpRoute< Ipv6Address > *	route
	)

protected

Returns: true, if Split Horizon rule is met for the route, otherwise false.

 {
     if (route->getNumSucc() <= 1) // Only 1 successor, check its interface ID (source is always successor)
         return destInterface->getInterfaceId() == source->getIfaceId();
     else // There is more than 1 successor. Is any of them on the interface?
         return eigrpTt->getBestSuccessorByIf(route, destInterface->getInterfaceId()) != nullptr;
 }

Referenced by msgToIface(), sendAllEigrpPaths(), and setReplyStatusTable().

◆ applyStubToQuery()

bool inet::eigrp::EigrpIpv6Pdm::applyStubToQuery	(	EigrpInterface *	eigrpIface,
		int	numOfNeigh
	)

protected

Apply stub configuration to the route in outgoing Query message.

Returns: true, if stub setting limits sending of the route, otherwise false

 {
     if (this->eigrpStubEnabled)
         return false; // Send Query to all neighbors
     if (numOfNeigh == eigrpIface->getNumOfStubs())
         return true; // Do not send Query to stub router
     return false;
 }

Referenced by msgToAllIfaces().

◆ applyStubToUpdate()

bool inet::eigrp::EigrpIpv6Pdm::applyStubToUpdate ( EigrpRouteSource< Ipv6Address > * src )

protected

Apply stub configuration to the route in outgoing Update message.

Returns: true, if stub setting limits sending of the route, otherwise false

 {
     if (this->eigrpStub.recvOnlyRt)
         return true; // Do not send any route
  
     // Send only specified type of route
     else if (this->eigrpStub.connectedRt && src->getNexthopId() == EigrpNeighbor<Ipv6Address>::UNSPEC_ID)
         return false;
     else if (this->eigrpStub.redistributedRt && src->isRedistributed())
         return false;
     else if (this->eigrpStub.summaryRt && src->isSummary())
         return false;
     else if (this->eigrpStub.staticRt && src->isRedistributed())
         return false;
  
     // TODO leakMapRt
  
     return true;
 }

Referenced by sendAllEigrpPaths(), and sendUpdate().

◆ cancelHelloTimers()

void inet::eigrp::EigrpIpv6Pdm::cancelHelloTimers ( )

protected

Stops Hello Timers on all interfaces.

 {
     EigrpInterface *iface;
     EigrpTimer *timer;
  
     int cnt = this->eigrpIft->getNumInterfaces();
     for (int i = 0; i < cnt; i++) {
         iface = this->eigrpIft->getInterface(i);
  
         if ((timer = iface->getHelloTimer()) != nullptr) {
             if (timer->isScheduled()) {
                 timer->getOwner();
                 cancelEvent(timer);
             }
  
             iface->setHelloTimerPtr(nullptr);
             delete timer;
         }
     }
  
     cnt = this->eigrpIftDisabled->getNumInterfaces();
     for (int i = 0; i < cnt; i++) {
         iface = this->eigrpIftDisabled->getInterface(i);
  
         if ((timer = iface->getHelloTimer()) != nullptr) {
             if (timer->isScheduled()) {
                 timer->getOwner();
                 cancelEvent(timer);
             }
  
             iface->setHelloTimerPtr(nullptr);
             delete timer;
         }
     }
 }

Referenced by preDelete().

◆ cancelHoldTimer()

void inet::eigrp::EigrpIpv6Pdm::cancelHoldTimer ( EigrpNeighbor< Ipv6Address > * neigh )

protected

Stops Hold timer.

 {
     EigrpTimer *timer;
  
     if ((timer = neigh->getHoldTimer()) != nullptr) {
         if (timer->isScheduled()) {
             timer->getOwner();
             cancelEvent(timer);
         }
     }
 }

Referenced by removeNeighbor().

◆ checkNeighborshipRules()

int inet::eigrp::EigrpIpv6Pdm::checkNeighborshipRules	(	int	ifaceId,
		int	neighAsNum,
		Ipv6Address &	neighAddr,
		const EigrpKValues &	neighKValues
	)

protected

Checks neighborship rules.

Parameters

ifaceId ID of interface where the neighbor is connected.

Returns: returns code from enumeration eigrp::UserMsgCodes.

 {
     Ipv6Address ifaceAddr, ifaceMask;
  
     if (this->eigrpIft->findInterfaceById(ifaceId) == nullptr) { // EIGRP must be enabled on interface
         return eigrp::M_DISABLED_ON_IF;
     }
     else if (this->asNum != neighAsNum) { // AS numbers must be equal
         return eigrp::M_NEIGH_BAD_AS;
     }
     else if (!(this->kValues == neighKValues)) { // K-values must be same
         return eigrp::M_NEIGH_BAD_KVALUES;
     }
     else {
         // check, if the neighbor uses as source address Link-local address
         if (neighAddr.getScope() != Ipv6Address::LINK) { // source address is not Link-local address -> bad
             return eigrp::M_NEIGH_BAD_SUBNET;
         }
     }
  
     return eigrp::M_OK;
 }

Referenced by processNewNeighbor().

◆ createAckPacket()

Packet * inet::eigrp::EigrpIpv6Pdm::createAckPacket	(	Ipv6Address &	destAddress,
		EigrpMsgReq *	msgReq
	)

protected

 {
     const auto& msg = makeShared<EigrpIpv6Ack>();
     addMessageHeader(msg, EIGRP_HELLO_MSG, msgReq);
     msg->setAckNum(msgReq->getAckNumber());
 //    addCtrInfo(msg, msgReq->getDestInterface(), destAddress);
  
     msg->setChunkLength(B(sizeOfMsg));
  
     Packet *packet = new Packet();
     packet->insertAtBack(msg);
     return packet;
 }

Referenced by processMsgFromRtp().

◆ createHelloPacket()

Packet * inet::eigrp::EigrpIpv6Pdm::createHelloPacket	(	int	holdInt,
		EigrpKValues	kValues,
		Ipv6Address &	destAddress,
		EigrpMsgReq *	msgReq
	)

protected

 {
  
     const auto& msg = makeShared<EigrpIpv6Hello>();
     EigrpTlvParameter paramTlv;
  
     addMessageHeader(msg, EIGRP_HELLO_MSG, msgReq);
  
     // Add parameter type TLV
     paramTlv.holdTimer = holdInt;
     paramTlv.kValues = kValues;
     msg->setParameterTlv(paramTlv);
  
     // Add stub TLV
     if (this->eigrpStubEnabled) {
         EigrpTlvStub stubTlv;
         stubTlv.stub = this->eigrpStub;
         msg->setStubTlv(stubTlv);
     }
  
     msg->setChunkLength(B(sizeOfMsg + 12));
  
     Packet *packet = new Packet();
     packet->insertAtBack(msg);
     return packet;
 }

Referenced by processMsgFromRtp().

◆ createMsgReq()

EigrpMsgReq * inet::eigrp::EigrpIpv6Pdm::createMsgReq	(	HeaderOpcode	msgType,
		int	destNeighbor,
		int	destIface
	)

protected

Creates request for sending of EIGRP message for RTP.

 {
     EigrpMsgReq *msgReq = new EigrpMsgReq(eigrp::UserMsgs[msgType]);
  
     msgReq->setOpcode(msgType);
     msgReq->setDestNeighbor(destNeighbor);
     msgReq->setDestInterface(destIface);
  
     return msgReq;
 }

Referenced by processHelloPacket(), processNewNeighbor(), processTimer(), pushMsgRouteToQueue(), and sendAllEigrpPaths().

◆ createNeighbor()

EigrpNeighbor< Ipv6Address > * inet::eigrp::EigrpIpv6Pdm::createNeighbor	(	EigrpInterface *	eigrpIface,
		Ipv6Address &	address,
		uint16_t	holdInt
	)

protected

Create record in the neighbor table and start hold timer.

 {
     // Create record in the neighbor table
     EigrpNeighbor<Ipv6Address> *neigh = new EigrpNeighbor<Ipv6Address>(eigrpIface->getInterfaceId(), eigrpIface->getInterfaceName(), address);
     EigrpTimer *holdt = createTimer(EIGRP_HOLD_TIMER, neigh);
     neigh->setHoldTimer(holdt);
     neigh->setHoldInt(holdInt);
     eigrpNt->addNeighbor(neigh);
     // Start Hold timer
     scheduleAt(simTime() + holdInt, holdt);
  
     eigrpIface->incNumOfNeighbors();
  
     return neigh;
 }

Referenced by processNewNeighbor().

◆ createQueryPacket()

Packet * inet::eigrp::EigrpIpv6Pdm::createQueryPacket	(	Ipv6Address &	destAddress,
		EigrpMsgReq *	msgReq
	)

protected

 {
     const auto& msg = makeShared<EigrpIpv6Query>();
     int routeCnt = msgReq->getRoutesArraySize();
  
     addMessageHeader(msg, EIGRP_QUERY_MSG, msgReq);
     msg->setAckNum(msgReq->getAckNumber());
     msg->setSeqNum(msgReq->getSeqNumber());
  
     // Add route TLV
     if (routeCnt > 0) addRoutesToMsg(msg, msgReq);
  
     msg->setChunkLength(B(sizeOfMsg + routeCnt * 68));
  
     Packet *packet = new Packet();
     packet->insertAtBack(msg);
     return packet;
 }

Referenced by processMsgFromRtp().

◆ createReplyPacket()

Packet * inet::eigrp::EigrpIpv6Pdm::createReplyPacket	(	Ipv6Address &	destAddress,
		EigrpMsgReq *	msgReq
	)

protected

 {
     const auto& msg = makeShared<EigrpIpv6Reply>();
     int routeCnt = msgReq->getRoutesArraySize();
  
     addMessageHeader(msg, EIGRP_REPLY_MSG, msgReq);
     msg->setAckNum(msgReq->getAckNumber());
     msg->setSeqNum(msgReq->getSeqNumber());
  
     // Add route TLV
     if (routeCnt > 0) {
         addRoutesToMsg(msg, msgReq);
         unlockRoutes(msgReq); // Locked RouteInfos are unlocked and can be removed
     }
  
     msg->setChunkLength(B(sizeOfMsg + routeCnt * 68));
  
     Packet *packet = new Packet();
     packet->insertAtBack(msg);
     return packet;
 }

Referenced by processMsgFromRtp().

◆ createRouteTlv()

void inet::eigrp::EigrpIpv6Pdm::createRouteTlv	(	EigrpMpIpv6Internal *	routeTlv,
		EigrpRoute< Ipv6Address > *	route,
		bool	unreachable = `false`
	)

protected

 {
     EigrpWideMetricPar rtMetric = route->getRdPar();
     routeTlv->destAddress = route->getRouteAddress();
     routeTlv->destMask = route->getRouteMask();
     routeTlv->nextHop = Ipv6Address::UNSPECIFIED_ADDRESS;
     setRouteTlvMetric(&routeTlv->metric, &rtMetric);
     if (unreachable) {
         routeTlv->metric.delay = EigrpMetricHelper::DELAY_INF;
         routeTlv->metric.bandwidth = EigrpMetricHelper::BANDWIDTH_INF;
     }
 }

Referenced by addRoutesToMsg().

◆ createRTRoute()

Ipv6Route * inet::eigrp::EigrpIpv6Pdm::createRTRoute ( EigrpRouteSource< Ipv6Address > * successor )

protected

 {
     EigrpRoute<Ipv6Address> *route = successor->getRouteInfo();
 //    ANSAIPv6Route *rtEntry = new ANSAIPv6Route(route->getRouteAddress(), getNetmaskLength(route->getRouteMask()), IPv6Route::ROUTING_PROT);
     Ipv6Route *rtEntry = new Ipv6Route(route->getRouteAddress(), getNetmaskLength(route->getRouteMask()), IRoute::EIGRP);
     rtEntry->setInterface(ift->getInterfaceById(successor->getIfaceId()));
     rtEntry->setNextHop(successor->getNextHop());
     setRTRouteMetric(rtEntry, successor->getMetric());
  
     // Set protocol source and AD
     if (successor->isInternal()) {
 //        rtEntry->setSourceType(IPv6Route::EIGRP);
         rtEntry->setAdminDist(Ipv6Route::dEIGRPInternal);
     }
     else {
 //        rtEntry->setRoutingProtocolSource(ANSAIPv6Route::pEIGRPext);
         rtEntry->setAdminDist(Ipv6Route::dEIGRPExternal);
     }
     return rtEntry;
 }

Referenced by installRouteToRT().

◆ createTimer()

EigrpTimer * inet::eigrp::EigrpIpv6Pdm::createTimer	(	char	timerKind,
		void *	context
	)

protected

Creates timer of specified type.

 {
     EigrpTimer *timer = new EigrpTimer();
     timer->setTimerKind(timerKind);
     timer->setContextPointer(context);
  
     return timer;
 }

Referenced by createNeighbor(), and startHelloTimer().

◆ createUpdatePacket()

Packet * inet::eigrp::EigrpIpv6Pdm::createUpdatePacket	(	const Ipv6Address &	destAddress,
		EigrpMsgReq *	msgReq
	)

protected

 {
     const auto& msg = makeShared<EigrpIpv6Update>();
     int routeCnt = msgReq->getRoutesArraySize();
  
     addMessageHeader(msg, EIGRP_UPDATE_MSG, msgReq);
     msg->setAckNum(msgReq->getAckNumber());
     msg->setSeqNum(msgReq->getSeqNumber());
  
     // Add route TLV
     if (routeCnt > 0) addRoutesToMsg(msg, msgReq);
  
     msg->setChunkLength(B(sizeOfMsg + routeCnt * 68));
  
     Packet *packet = new Packet();
     packet->insertAtBack(msg);
     return packet;
 }

Referenced by processMsgFromRtp().

◆ disableInterface()

void inet::eigrp::EigrpIpv6Pdm::disableInterface	(	NetworkInterface *	iface,
		EigrpInterface *	eigrpIface
	)

protected

Remove interface from EIGRP interface table.

Removes all neighbors on the interface.

 {
     EigrpTimer *hellot;
     EigrpNeighbor<Ipv6Address> *neigh;
     EigrpRouteSource<Ipv6Address> *source;
     int neighCount;
     int ifaceId = eigrpIface->getInterfaceId();
  
     EV_DEBUG << "EIGRP disabled on interface " << eigrpIface->getName() << "(" << ifaceId << ")" << endl;
  
     if (!eigrpIface->isPassive()) {
         // Unregister multicast address
         Ipv6InterfaceData *ipv6int = iface->getProtocolDataForUpdate<Ipv6InterfaceData>();
         ipv6int->leaveMulticastGroup(EIGRP_IPV6_MULT);
         ipv6int->removeAddress(EIGRP_IPV6_MULT);
     }
  
 //    iface->ipv6Data()->leaveMulticastGroup(EIGRP_IPV6_MULT);
 //    iface->ipv6Data()->removeAddress(EIGRP_IPV6_MULT);
  
     // stop hello timer
     if ((hellot = eigrpIface->getHelloTimer()) != nullptr)
         cancelEvent(hellot);
  
     std::set<int>::iterator it;
     EigrpNetwork<Ipv6Address> *eigrpnet = nullptr;
  
     for (it = eigrpIface->getNetworksIdsBegin(); it != eigrpIface->getNetworksIdsEnd(); ++it) {
         eigrpnet = routingForNetworks->findNetworkById(*it);
         source = eigrpTt->findRoute(eigrpnet->getAddress(), eigrpnet->getMask(), EigrpNeighbor<Ipv6Address>::UNSPEC_ID);
         ASSERT(source != nullptr);
         // Notify DUAL about event
         eigrpDual->processEvent(EigrpDual<Ipv6Address>::INTERFACE_DOWN, source, EigrpNeighbor<Ipv6Address>::UNSPEC_ID, false);
     }
  
     eigrpIface->clearNetworkIds();
  
     // Remove interface from EIGRP interface table (must be there)
     if (eigrpIface->isEnabled()) {
         eigrpIft->removeInterface(eigrpIface);
         eigrpIftDisabled->addInterface(eigrpIface);
         eigrpIface->setEnabling(false);
     }
  
     // Delete all neighbors on the interface
     neighCount = eigrpNt->getNumNeighbors();
     for (int i = 0; i < neighCount; i++) {
         neigh = eigrpNt->getNeighbor(i);
         if (neigh->getIfaceId() == ifaceId) {
             removeNeighbor(neigh);
         }
     }
  
     flushMsgRequests();
     eigrpTt->purgeTable();
 }

Referenced by processIfaceStateChange().

◆ enableInterface()

void inet::eigrp::EigrpIpv6Pdm::enableInterface ( EigrpInterface * eigrpIface )

protected

Add interface to the EIGRP interface table and notifies DUAL.

 {
     int ifaceId = eigrpIface->getInterfaceId();
     EigrpRouteSource<Ipv6Address> *src;
     EigrpWideMetricPar metricPar;
     bool isSourceNew;
  
     EV_DEBUG << "EIGRP enabled on interface " << eigrpIface->getName() << "(" << ifaceId << ")" << endl;
  
     // Move interface to EIGRP interface table
     if (!eigrpIface->isEnabled()) {
         eigrpIftDisabled->removeInterface(eigrpIface);
         eigrpIft->addInterface(eigrpIface);
         eigrpIface->setEnabling(true);
     }
  
     // Register multicast address on interface      //TODO - should be passive interface joined in multicast group?
 //    IPv6InterfaceData *ifaceIpv6 = ift->getInterfaceById(ifaceId)->ipv6Data();
     //ifaceIpv6->joinMulticastGroup(EIGRP_IPV6_MULT); //join to group FF02::A, optionally
     //ifaceIpv6->assignAddress(EIGRP_IPV6_MULT, false, 0, 0); //add group address to interface, mandatory
  
     Ipv6InterfaceData *ipv6int = ift->getInterfaceById(ifaceId)->getProtocolDataForUpdate<Ipv6InterfaceData>();
     ipv6int->joinMulticastGroup(EIGRP_IPV6_MULT);
     ipv6int->assignAddress(EIGRP_IPV6_MULT, false, 0, 0);
  
     PrefixVector::iterator it;
     EigrpNetwork<Ipv6Address> *eigrpnet = nullptr;
     Ipv6Address network;
     Ipv6Address mask;
  
     for (it = netPrefixes.begin(); it != netPrefixes.end(); ++it) { // through all known prefixes search prefixes belonging to enabling interface
         if (it->ifaceId == ifaceId) { // found prefix belonging to interface
             network = it->network;
             mask = Ipv6Address(0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff).getPrefix(it->prefixLength);
  
             eigrpnet = addNetwork(network, mask);
  
             if (eigrpnet) { // successfully added to EigrpNetworkTable -> tie with interface
                 eigrpIface->insertToNetworksIds(eigrpnet->getNetworkId()); // pak predelat na protected a pridat metody
             }
  
             // Create route
             src = eigrpTt->findOrCreateRoute(network, mask, eigrpTt->getRouterId(), eigrpIface, EigrpNeighbor<Ipv6Address>::UNSPEC_ID, &isSourceNew);
             ASSERT(isSourceNew == true);
             // Compute metric
             metricPar = eigrpMetric->getParam(eigrpIface);
             src->setMetricParams(metricPar);
             uint64_t metric = eigrpMetric->computeClassicMetric(metricPar, this->kValues);
             src->setMetric(metric);
  
             // Notify DUAL about event
             eigrpDual->processEvent(EigrpDual<Ipv6Address>::INTERFACE_UP, src, EigrpNeighbor<Ipv6Address>::UNSPEC_ID, isSourceNew);
         }
     }
  
     flushMsgRequests();
     eigrpTt->purgeTable();
 }

Referenced by addInterfaceToEigrp(), and processIfaceStateChange().

◆ findRoute() [1/2]

Ipv6Route * inet::eigrp::EigrpIpv6Pdm::findRoute	(	const Ipv6Address &	prefix,
		int	prefixLength
	)

protected

                           {
     Ipv6Route *route = nullptr;
  
     for (int i = 0; i < rt->getNumRoutes(); i++) {
         auto it = rt->getRoute(i);
  
         if (it->getDestPrefix() == prefix && it->getPrefixLength() == prefixLength) {
             route = it;
             break;
         }
     }
  
     return route;
 }

Referenced by isRTSafeForAdd(), processIfaceStateChange(), removeRouteFromRT(), and updateRoute().

◆ findRoute() [2/2]

Ipv6Route * inet::eigrp::EigrpIpv6Pdm::findRoute	(	const Ipv6Address &	prefix,
		int	prefixLength,
		const Ipv6Address &	nexthop
	)

protected

                                     {
     Ipv6Route *route = nullptr;
     for (int i = 0; i < rt->getNumRoutes(); i++) {
         auto it = rt->getRoute(i);
         if (it->getDestPrefix() == prefix && it->getPrefixLength() == prefixLength && it->getNextHop() == nexthop) {
             route = it;
             break;
         }
     }
     return route;
 }

◆ findRouteDMin()

uint64_t inet::eigrp::EigrpIpv6Pdm::findRouteDMin ( EigrpRoute< Ipv6Address > * route )

inlineoverridevirtual

Returns minimal distance to destination network.

Implements inet::eigrp::IEigrpPdm< Ipv6Address >.

321 { return eigrpTt->findRouteDMin(route); }

◆ flushMsgRequests()

void inet::eigrp::EigrpIpv6Pdm::flushMsgRequests ( )

protected

Sends all message requests to RTP.

 {
     RequestVector::iterator it;
     Ipv6Address destAddress;
  
     // Send Query
     for (it = reqQueue.begin(); it != reqQueue.end(); it++) {
         if ((*it)->getOpcode() == EIGRP_QUERY_MSG) {
             // Check if interface exists
             if (eigrpIft->findInterfaceById((*it)->getDestInterface()) == nullptr)
                 continue;
             else
                 send(*it, RTP_OUTGW);
         }
     }
  
     // Send other messages
     for (it = reqQueue.begin(); it != reqQueue.end(); it++) {
         // Check if interface exists
         if (eigrpIft->findInterfaceById((*it)->getDestInterface()) == nullptr) {
             delete *it; // Discard request
             continue;
         }
  
         if ((*it)->getOpcode() != EIGRP_QUERY_MSG)
             send(*it, RTP_OUTGW);
     }
  
     reqQueue.clear();
 }

Referenced by disableInterface(), enableInterface(), processHelloPacket(), processIfaceConfigChange(), processQueryPacket(), processReplyPacket(), processTimer(), and processUpdatePacket().

◆ getASNum()

int inet::eigrp::EigrpIpv6Pdm::getASNum ( )

inlineoverridevirtual

Implements inet::eigrp::IEigrpModule< Ipv6Address >.

301 { return this->asNum; }

◆ getBestSuccessor()

EigrpRouteSource<Ipv6Address>* inet::eigrp::EigrpIpv6Pdm::getBestSuccessor ( EigrpRoute< Ipv6Address > * route )

inlineoverridevirtual

Returns best successor for specified network.

Implements inet::eigrp::IEigrpPdm< Ipv6Address >.

323 { return eigrpTt->getBestSuccessor(route); }

◆ getDestIpAddress()

bool inet::eigrp::EigrpIpv6Pdm::getDestIpAddress	(	int	destNeigh,
		Ipv6Address *	resultAddress
	)

protected

Returns IP address for sending EIGRP message.

 {
     EigrpNeighbor<Ipv6Address> *neigh = nullptr;
     const uint32_t *addr = nullptr;
  
     if (destNeigh == EigrpNeighbor<Ipv6Address>::UNSPEC_ID) { // destination neighbor unset -> use multicast
         addr = EIGRP_IPV6_MULT.words();
         resultAddress->set(addr[0], addr[1], addr[2], addr[3]);
     }
     else { // destination neighbor set -> use unicast
         if ((neigh = eigrpNt->findNeighborById(destNeigh)) == nullptr)
             return false;
         addr = neigh->getIPAddress().words();
         resultAddress->set(addr[0], addr[1], addr[2], addr[3]);
     }
  
     return true;
 }

Referenced by processMsgFromRtp().

◆ getInterfaceById()

EigrpInterface * inet::eigrp::EigrpIpv6Pdm::getInterfaceById ( int ifaceId )

protected

Returns EIGRP interface (enabled or disabled) or nullptr.

 {
     EigrpInterface *iface;
  
     if ((iface = eigrpIft->findInterfaceById(ifaceId)) != nullptr)
         return iface;
     else
         return eigrpIftDisabled->findInterface(ifaceId);
 }

Referenced by addInterfaceToEigrp(), processIfaceStateChange(), receiveSignal(), removeNeighbor(), setHelloInt(), setHoldInt(), setPassive(), and setSplitHorizon().

◆ getNextHopAddr()

Ipv6Address inet::eigrp::EigrpIpv6Pdm::getNextHopAddr	(	const Ipv6Address &	nextHopAddr,
		Ipv6Address &	senderAddr
	)

inlineprotected

Returns next hop address.

If next hop in message is 0.0.0.0, then next hop must be replaced by IP address of sender.

227 { return (nextHopAddr.isUnspecified()) ? senderAddr : nextHopAddr; }

Referenced by processInterRoute(), and processUpdatePacket().

◆ handleMessage()

void inet::eigrp::EigrpIpv6Pdm::handleMessage ( cMessage * msg )

overrideprotectedvirtual

Multi-stage initialization.

 {
     if (msg->isSelfMessage()) { // Timer
         this->processTimer(msg);
     }
     else { // EIGRP message
  
         if (strcmp(msg->getArrivalGate()->getBaseName(), "splitterIn") == 0) {
             processMsgFromNetwork(msg);
             delete msg;
             msg = nullptr;
         }
         else if (strcmp(msg->getArrivalGate()->getBaseName(), "rtpIn") == 0) {
             processMsgFromRtp(msg);
             delete msg;
             msg = nullptr;
         }
     }
 }

◆ hasFeasibleSuccessor()

bool inet::eigrp::EigrpIpv6Pdm::hasFeasibleSuccessor	(	EigrpRoute< Ipv6Address > *	route,
		uint64_t &	resultDmin
	)

inlineoverridevirtual

Determine whether there are Feasibles Successors for specified route.

Parameters

resultDmin return parameter with minimal distance to the destination.

Implements inet::eigrp::IEigrpPdm< Ipv6Address >.

322 { return eigrpTt->hasFeasibleSuccessor(route, resultDmin); }

◆ hasNeighborForUpdate()

bool inet::eigrp::EigrpIpv6Pdm::hasNeighborForUpdate ( EigrpRouteSource< Ipv6Address > * source )

overridevirtual

Returns tru if there are recipients for update message, else false.

Implements inet::eigrp::IEigrpPdm< Ipv6Address >.

 {
     int ifaceCnt = this->eigrpIft->getNumInterfaces();
     EigrpInterface *eigrpIface;
  
     for (int i = 0; i < ifaceCnt; i++) {
         eigrpIface = eigrpIft->getInterface(i);
  
         // Do not apply Split Horizon rule
         if (eigrpIface != nullptr && eigrpIface->getNumOfNeighbors() > 0) {
             return true;
         }
     }
  
     return false;
 }

◆ initialize()

void inet::eigrp::EigrpIpv6Pdm::initialize ( int stage )

overrideprotectedvirtual

 {
     cSimpleModule::initialize(stage);
  
     if (stage == INITSTAGE_LOCAL) {
         host = getContainingNode(this);
  
         ift.reference(this, "interfaceTableModule", true);
         rt.reference(this, "routingTableModule", true);
     }
  
     if (stage == INITSTAGE_ROUTING_PROTOCOLS) {
         eigrpIft = check_and_cast<EigrpInterfaceTable *>(getModuleByPath("^.eigrpInterfaceTable6"));
         eigrpNt = check_and_cast<EigrpIpv6NeighborTable *>(getModuleByPath("^.eigrpIpv6NeighborTable"));
         eigrpTt = check_and_cast<EigrpIpv6TopologyTable *>(getModuleByPath("^.eigrpIpv6TopologyTable"));
  
         this->eigrpIftDisabled = new EigrpDisabledInterfaces();
         this->routingForNetworks = new EigrpNetworkTable<Ipv6Address>();
         this->eigrpDual = new EigrpDual<Ipv6Address>(this);
         this->eigrpMetric = new EigrpMetricHelper();
  
         EigrpDeviceConfigurator conf(par("configData"), ift);
         conf.loadEigrpIPv6Config(this);
  
         // moved to splitter
 //        registerService(Protocol::eigrp, nullptr, gate("splitterIn"));
 //        registerProtocol(Protocol::eigrp, gate("splitterOut"), nullptr);
  
         WATCH_PTRVECTOR(*routingForNetworks->getAllNetworks());
         WATCH(asNum);
         WATCH(kValues.K1);
         WATCH(kValues.K2);
         WATCH(kValues.K3);
         WATCH(kValues.K4);
         WATCH(kValues.K5);
         WATCH(kValues.K6);
         WATCH(maximumPath);
         WATCH(variance);
         WATCH(eigrpStub.connectedRt);
         WATCH(eigrpStub.leakMapRt);
         WATCH(eigrpStub.recvOnlyRt);
         WATCH(eigrpStub.redistributedRt);
         WATCH(eigrpStub.staticRt);
         WATCH(eigrpStub.summaryRt);
  
         host->subscribe(interfaceStateChangedSignal, this);
         host->subscribe(interfaceConfigChangedSignal, this);
         host->subscribe(routeDeletedSignal, this);
     }
 }

◆ installRouteToRT()

bool inet::eigrp::EigrpIpv6Pdm::installRouteToRT	(	EigrpRoute< Ipv6Address > *	route,
		EigrpRouteSource< Ipv6Address > *	source,
		uint64_t	dmin,
		Ipv6Route *	rtEntry
	)

protected

Updates existing route in the routing table or creates new one.

 {
     Ipv6Route *ansaRtEntry = rtEntry;
     bool rtableChanged = false;
  
     //if (rtEntry != nullptr && (ansaRtEntry = dynamic_cast<ANSAIPv6Route *>(rtEntry)) != nullptr)
     if (ansaRtEntry != nullptr) {
         //if (ansaRtEntry->getRoutingProtocolSource() != ANSAIPv4Route::pEIGRP)
         if (ansaRtEntry->getSourceType() != IRoute::EIGRP)
             return rtableChanged; // Do not add route to RT
         else if ((unsigned int)ansaRtEntry->getMetric() != source->getMetric()) { // Update EIGRP route in RT
             EV_DEBUG << "EIGRP: Update EIGRP route " << route->getRouteAddress() << " via " << source->getNextHop() << " in RT" << endl;
             setRTRouteMetric(ansaRtEntry, source->getMetric());
         }
     }
     else { // Insert new route to RT
         EV_DEBUG << "EIGRP: add EIGRP route " << route->getRouteAddress() << " via " << source->getNextHop() << " to RT" << endl;
         ansaRtEntry = createRTRoute(source);
 //        rt->prepareForAddRoute(ansaRtEntry);    // Do not check safety (already checked)
         rt->addRoutingProtocolRoute(ansaRtEntry);
  
         rtableChanged = true;
     }
  
     return rtableChanged;
 }

Referenced by updateRoute().

◆ isRTSafeForAdd()

bool inet::eigrp::EigrpIpv6Pdm::isRTSafeForAdd	(	EigrpRoute< Ipv6Address > *	route,
		unsigned int	eigrpAd
	)

protected

Returns true, if routing table does not contain route with given address, mask and smaller administrative distance.

 {
     Ipv6Route *routeInTable = findRoute(route->getRouteAddress(), getNetmaskLength(route->getRouteMask()));
     Ipv6Route *ansaRoute = nullptr;
  
     if (routeInTable == nullptr)
         return true; // Route not found
  
     ansaRoute = routeInTable;
     if (ansaRoute != nullptr) { // AnsaIPv4Route use own AD attribute
         if (ansaRoute->getAdminDist() < eigrpAd)
             return false;
         return true;
     }
     if (ansaRoute == nullptr && routeInTable->getAdminDist() == Ipv6Route::dUnknown)
         return false; // Connected route has AD = 255 (dUnknown) in IPv4Route
     if (routeInTable != nullptr && routeInTable->getAdminDist() < eigrpAd)
         return false; // Other IPv4Route with right AD
     return true;
 }

Referenced by updateRoute().

◆ msgToAllIfaces()

void inet::eigrp::EigrpIpv6Pdm::msgToAllIfaces	(	int	destination,
		HeaderOpcode	msgType,
		EigrpRouteSource< Ipv6Address > *	source,
		bool	forcePoisonRev,
		bool	forceUnreachable
	)

protected

Records request to send message to all neighbors.

 {
     EigrpInterface *eigrpIface;
     int ifCount = eigrpIft->getNumInterfaces();
     int numOfNeigh;
  
     for (int i = 0; i < ifCount; i++) {
         eigrpIface = eigrpIft->getInterface(i);
  
         // Send message only to interface with stub neighbor
         if (destination == IEigrpPdm::STUB_RECEIVER && eigrpIface->getNumOfStubs() == 0)
             continue;
  
         if ((numOfNeigh = eigrpIface->getNumOfNeighbors()) > 0) {
             if (msgType == EIGRP_QUERY_MSG) {
                 if (!applyStubToQuery(eigrpIface, numOfNeigh))
                     msgToIface(msgType, source, eigrpIface, forcePoisonRev);
                 // Else do not send Query to stub router (skip the route on interface)
             }
             else
                 msgToIface(msgType, source, eigrpIface, forcePoisonRev, forceUnreachable);
         }
     }
 }

Referenced by sendQuery(), and sendUpdate().

◆ msgToIface()

void inet::eigrp::EigrpIpv6Pdm::msgToIface	(	HeaderOpcode	msgType,
		EigrpRouteSource< Ipv6Address > *	source,
		EigrpInterface *	eigrpIface,
		bool	forcePoisonRev = `false`,
		bool	forceUnreachable = `false`
	)

protected

Creates request for sending message on specified interface.

 {
     EigrpNeighbor<Ipv6Address> *neigh = nullptr;
     EigrpMsgRoute msgRt;
     int ifaceId, destNeigh = 0;
  
     if (eigrpIface->isSplitHorizonEn() && applySplitHorizon(eigrpIface, source, source->getRouteInfo())) {
         if (forcePoisonRev) { // Apply Poison Reverse instead of Split Horizon
             msgRt.unreachable = true;
         }
         else // Apply Split Horizon rule - do not send route to the interface
             return;
     }
  
     msgRt.sourceId = source->getSourceId();
     msgRt.routeId = source->getRouteId();
     msgRt.originator = source->getOriginator();
     msgRt.invalid = false;
  
     // Get destination interface ID and destination neighbor ID
     ifaceId = eigrpIface->getInterfaceId();
     if (ift->getInterfaceById(ifaceId)->isMulticast()) { // Multicast
         destNeigh = IEigrpPdm::UNSPEC_RECEIVER;
     }
     else { // Unicast
         if (neigh == nullptr)
             neigh = eigrpNt->getFirstNeighborOnIf(ifaceId);
         destNeigh = neigh->getNeighborId();
     }
  
     pushMsgRouteToQueue(msgType, ifaceId, destNeigh, msgRt);
 }

Referenced by msgToAllIfaces().

◆ numInitStages()

virtual int inet::eigrp::EigrpIpv6Pdm::numInitStages ( ) const

inlineoverrideprotectedvirtual

96 { return NUM_INIT_STAGES; }

◆ preDelete()

void inet::eigrp::EigrpIpv6Pdm::preDelete ( cComponent * root )

overrideprotectedvirtual

 {
     cancelHelloTimers();
 }

◆ printRecvMsg()

void inet::eigrp::EigrpIpv6Pdm::printRecvMsg	(	const EigrpMessage *	msg,
		Ipv6Address &	addr,
		int	ifaceId
	)

protected

 {
     EV_DEBUG << "EIGRP: received " << eigrp::UserMsgs[msg->getOpcode()];
     if (msg->getOpcode() == EIGRP_HELLO_MSG && msg->getAckNum() > 0)
         EV_DEBUG << " (ack) ";
     EV_DEBUG << " message from " << addr << " on IF " << ifaceId;
  
     EV_DEBUG << ", flags: ";
     if (msg->getInit()) EV_DEBUG << "init";
     else if (msg->getEot()) EV_DEBUG << "eot";
     else if (msg->getCr()) EV_DEBUG << "cr";
     else if (msg->getRs()) EV_DEBUG << "rs";
  
     EV_DEBUG << ", seq num:" << msg->getSeqNum();
     EV_DEBUG << ", ack num:" << msg->getAckNum();
     EV_DEBUG << endl;
 }

Referenced by processAckPacket(), processHelloPacket(), processQueryPacket(), processReplyPacket(), and processUpdatePacket().

◆ printSentMsg()

void inet::eigrp::EigrpIpv6Pdm::printSentMsg	(	int	routeCnt,
		Ipv6Address &	destAddress,
		EigrpMsgReq *	msgReq
	)

protected

 {
     int type = msgReq->getOpcode();
  
     EV_DEBUG << "EIGRP: send " << eigrp::UserMsgs[type];
     if (type == EIGRP_HELLO_MSG) {
         if (msgReq->getAckNumber() > 0)
             EV_DEBUG << " (ack) ";
         else if (msgReq->getGoodbyeMsg() == true)
             EV_DEBUG << " (goodbye) ";
     }
  
     EV_DEBUG << " message to " << destAddress << " on IF " << msgReq->getDestInterface();
  
     // Print flags
     EV_DEBUG << ", flags: ";
     if (msgReq->getInit()) EV_DEBUG << "init";
     else if (msgReq->getEot()) EV_DEBUG << "eot";
     else if (msgReq->getCr()) EV_DEBUG << "cr";
     else if (msgReq->getRs()) EV_DEBUG << "rs";
  
     if (type != EIGRP_HELLO_MSG) EV_DEBUG << ", route count: " << routeCnt;
     EV_DEBUG << ", seq num:" << msgReq->getSeqNumber();
     EV_DEBUG << ", ack num:" << msgReq->getAckNumber();
     EV_DEBUG << endl;
 }

Referenced by processMsgFromRtp().

◆ processAckPacket()

void inet::eigrp::EigrpIpv6Pdm::processAckPacket	(	Packet *	pk,
		Ipv6Address &	srcAddress,
		int	ifaceId,
		EigrpNeighbor< Ipv6Address > *	neigh
	)

protected

 {
     const EigrpIpv6Ack *ack = staticPtrCast<const EigrpIpv6Ack>(pk->peekAtFront<EigrpIpv6Ack>()).get();
     printRecvMsg(ack, srcAddress, ifaceId);
     if (neigh->isStateUp() == false) {
         // If neighbor is "pending", then change its state to "up"
         neigh->setStateUp(true);
         // Send all EIGRP paths from routing table to sender
         sendAllEigrpPaths(eigrpIft->findInterfaceById(ifaceId), neigh);
     }
  
     if (neigh->getRoutesForDeletion()) { // Remove unreachable routes waiting for Ack from neighbor
         eigrpTt->delayedRemove(neigh->getNeighborId());
         neigh->setRoutesForDeletion(false);
     }
 }

Referenced by processMsgFromNetwork().

◆ processHelloPacket()

void inet::eigrp::EigrpIpv6Pdm::processHelloPacket	(	Packet *	pk,
		Ipv6Address &	srcAddress,
		int	ifaceId,
		EigrpNeighbor< Ipv6Address > *	neigh
	)

protected

 {
     const EigrpIpv6Hello *hello = staticPtrCast<const EigrpIpv6Hello>(pk->peekAtFront<EigrpIpv6Hello>()).get();
 //    EigrpIpv6Hello *hello = check_and_cast<EigrpIpv6Hello *>(msg);
  
     EigrpTlvParameter tlvParam = hello->getParameterTlv();
  
     printRecvMsg(hello, srcAddress, ifaceId);
  
     if (tlvParam.kValues == KVALUES_MAX) { // Received Goodbye message, remove neighbor
         if (neigh != nullptr) {
             EV_DEBUG << "     interface goodbye received" << endl;
             EV_DEBUG << "EIGRP neighbor " << srcAddress << " is down, interface goodbye received" << endl;
             removeNeighbor(neigh);
             flushMsgRequests();
             eigrpTt->purgeTable();
         }
     }
     else if (neigh == nullptr) { // New neighbor
         processNewNeighbor(ifaceId, srcAddress, hello);
     }
     else { // neighbor exists, its state is "up" or "pending"
         // Check K-values
         if (!(tlvParam.kValues == this->kValues)) { // Not satisfied
             EV_DEBUG << "EIGRP neighbor " << srcAddress << " is down, " << eigrp::UserMsgs[eigrp::M_NEIGH_BAD_KVALUES] << endl;
             removeNeighbor(neigh);
             flushMsgRequests();
             eigrpTt->purgeTable();
  
             // send Goodbye message and reset Hello timer
             EigrpInterface *iface = this->eigrpIft->findInterfaceById(ifaceId);
             resetTimer(iface->getHelloTimer(), iface->getHelloInt() - 0.5);
             EigrpMsgReq *msgReq = createMsgReq(EIGRP_HELLO_MSG, EigrpNeighbor<Ipv6Address>::UNSPEC_ID, ifaceId);
             msgReq->setGoodbyeMsg(true);
             send(msgReq, RTP_OUTGW);
         }
         else if (tlvParam.holdTimer != neigh->getHoldInt()) // Save Hold interval
             neigh->setHoldInt(tlvParam.holdTimer);
     }
 }

Referenced by processMsgFromNetwork().

◆ processIfaceConfigChange()

void inet::eigrp::EigrpIpv6Pdm::processIfaceConfigChange ( EigrpInterface * eigrpIface )

protected

 {
     EigrpRouteSource<Ipv6Address> *source;
     int routeCount = eigrpTt->getNumRoutes();
     int ifaceId = eigrpIface->getInterfaceId();
     EigrpWideMetricPar ifParam = eigrpMetric->getParam(eigrpIface);
     EigrpWideMetricPar newParam;
     uint64_t metric;
  
     // Update routes through the interface
     for (int i = 0; i < routeCount; i++) {
         source = eigrpTt->getRoute(i);
         if (source->getIfaceId() == ifaceId && source->isValid()) {
             // Update metric of source
             if (source->getNexthopId() == EigrpNeighbor<Ipv6Address>::UNSPEC_ID) { // connected route
                 source->setMetricParams(ifParam);
                 metric = eigrpMetric->computeClassicMetric(ifParam, this->kValues);
                 source->setMetric(metric);
             }
             else {
                 newParam = eigrpMetric->adjustParam(ifParam, source->getRdParams());
                 source->setMetricParams(newParam);
                 metric = eigrpMetric->computeClassicMetric(newParam, this->kValues);
                 source->setMetric(metric);
             }
  
             // Notify DUAL about event
             eigrpDual->processEvent(EigrpDual<Ipv6Address>::RECV_UPDATE, source, source->getNexthopId(), false);
         }
     }
  
     flushMsgRequests();
     eigrpTt->purgeTable();
 }

Referenced by receiveSignal().

◆ processIfaceStateChange()

void inet::eigrp::EigrpIpv6Pdm::processIfaceStateChange ( NetworkInterface * iface )

protected

 {
     EigrpInterface *eigrpIface;
     int ifaceId = iface->getInterfaceId();
  
     if (iface->isUp()) { // an interface goes up
  
         // add directly-connected routes to RT
         PrefixVector::iterator it;
  
         for (it = netPrefixes.begin(); it != netPrefixes.end(); ++it) { // through all known prefixes search prefixes belong to this interface
             if (it->ifaceId == ifaceId) { // belonging to same interface -> add
                 if (findRoute(it->network, it->prefixLength, Ipv6Address::UNSPECIFIED_ADDRESS) == nullptr) { // route is not in RT -> add
                     rt->addStaticRoute(it->network, it->prefixLength, ifaceId, Ipv6Address::UNSPECIFIED_ADDRESS, 0);
                 }
             }
         }
  
         if ((eigrpIface = getInterfaceById(ifaceId)) != nullptr) { // interface is included in EIGRP process
             if (!eigrpIface->isEnabled()) { // interface disabled -> enable
                 enableInterface(eigrpIface);
                 startHelloTimer(eigrpIface, simTime() + eigrpIface->getHelloInt() - 0.5);
             }
         }
     }
     else if (!iface->isUp() || !iface->hasCarrier()) { // an interface goes down
  
         // delete all directly-connected routes from RT
         Ipv6Route *route = nullptr;
         for (int i = 0; i < rt->getNumRoutes(); ++i) {
             route = rt->getRoute(i);
  
             if (route->getInterface()->getInterfaceId() == ifaceId && route->getNextHop() == Ipv6Address::UNSPECIFIED_ADDRESS && route->getDestPrefix() != Ipv6Address::LINKLOCAL_PREFIX) { // Found Directly-connected (no link-local) route on interface -> remove
                 rt->removeRoute(route);
             }
         }
  
         eigrpIface = this->eigrpIft->findInterfaceById(ifaceId);
         if (eigrpIface != nullptr && eigrpIface->isEnabled()) {
             disableInterface(iface, eigrpIface);
         }
     }
 }

Referenced by receiveSignal().

◆ processInterRoute()

EigrpRouteSource< Ipv6Address > * inet::eigrp::EigrpIpv6Pdm::processInterRoute	(	const EigrpMpIpv6Internal &	tlv,
		Ipv6Address &	srcAddr,
		int	sourceNeighId,
		EigrpInterface *	eigrpIface,
		bool *	notifyDual,
		bool *	isSourceNew
	)

protected

Process route TLV.

Parameters

neigh Neighbor which is next hop for a route in TLV.

 {
     Ipv6Address nextHop = getNextHopAddr(tlv.nextHop, srcAddr);
     EigrpNeighbor<Ipv6Address> *nextHopNeigh = eigrpNt->findNeighbor(nextHop);
     EigrpRouteSource<Ipv6Address> *src;
     EigrpWideMetricPar newParam, oldParam, oldNeighParam;
     EigrpWideMetricPar ifParam = eigrpMetric->getParam(eigrpIface);
  
     // Find route or create one (route source is identified by ID of the next hop - not by ID of sender)
     src = eigrpTt->findOrCreateRoute(tlv.destAddress, tlv.destMask, tlv.routerID, eigrpIface, nextHopNeigh->getNeighborId(), isSourceNew);
  
     // Compare old and new neighbor's parameters
     oldNeighParam = src->getRdParams();
     if (*isSourceNew || !eigrpMetric->compareParameters(tlv.metric, oldNeighParam, this->kValues)) {
         // Compute reported distance (must be there)
         uint64_t metric = eigrpMetric->computeClassicMetric(tlv.metric, this->kValues);
         src->setRdParams(tlv.metric);
         src->setRd(metric);
  
         // Get new metric parameters
         newParam = eigrpMetric->adjustParam(ifParam, tlv.metric);
         // Get old metric parameters for comparison
         oldParam = src->getMetricParams();
  
         if (!eigrpMetric->compareParameters(newParam, oldParam, this->kValues)) {
             // Set source of route
             if (*isSourceNew)
                 src->setNextHop(nextHop);
             src->setMetricParams(newParam);
             // Compute metric
             metric = eigrpMetric->computeClassicMetric(newParam, this->kValues);
             src->setMetric(metric);
             *notifyDual = true;
         }
     }
  
     return src;
 }

Referenced by processQueryPacket(), processReplyPacket(), and processUpdatePacket().

◆ processMsgFromNetwork()

void inet::eigrp::EigrpIpv6Pdm::processMsgFromNetwork ( cMessage * msg )

protected

Process message from network layer.

 {
     Packet *packet = check_and_cast<Packet *>(msg);
  
     auto protocol = packet->getTag<PacketProtocolTag>()->getProtocol();
     if (protocol != &Protocol::eigrp) {
         delete msg;
         return;
     }
  
     Ipv6Address srcAddr = packet->getTag<L3AddressInd>()->getSrcAddress().toIpv6();
     int ifaceId = packet->getTag<InterfaceInd>()->getInterfaceId();
     cMessage *msgDup = nullptr;
  
     NetworkInterface::State status = ift->getInterfaceById(ifaceId)->getState();
     if (status == NetworkInterface::DOWN || status == NetworkInterface::GOING_UP) { // message received on DOWN or GOING_UP iface -> ignore
         EV_DEBUG << "Received message on DOWN interface - message ignored" << endl;
         return;
     }
  
     const auto& pk = packet->peekAtFront<EigrpMessage>();
     int8_t opcode = pk->getOpcode();
  
 #ifdef EIGRP_DEBUG
     EigrpInterface *eigrpIface = eigrpIft->findInterfaceById(ifaceId);
     ASSERT(eigrpIface != nullptr);
     ASSERT(!eigrpIface->isPassive());
 #endif
  
     // Find neighbor if exists
     EigrpNeighbor<Ipv6Address> *neigh;
     if ((neigh = eigrpNt->findNeighbor(srcAddr)) != nullptr) { // Reset hold timer
         resetTimer(neigh->getHoldTimer(), neigh->getHoldInt());
     }
  
     // Send message to RTP (message must be duplicated)
     msgDup = msg->dup();
     send(msgDup, RTP_OUTGW);
  
     switch (opcode) {
         case EIGRP_HELLO_MSG:
             if (pk->getAckNum() > 0)
                 processAckPacket(packet, srcAddr, ifaceId, neigh);
             else
                 processHelloPacket(packet, srcAddr, ifaceId, neigh);
             break;
         case EIGRP_UPDATE_MSG:
             processUpdatePacket(packet, srcAddr, ifaceId, neigh);
             break;
         case EIGRP_QUERY_MSG:
             processQueryPacket(packet, srcAddr, ifaceId, neigh);
             break;
         case EIGRP_REPLY_MSG:
             processReplyPacket(packet, srcAddr, ifaceId, neigh);
             break;
         default:
             if (neigh != nullptr)
                 EV_DEBUG << "EIGRP: Received message of unknown type, skipped" << endl;
             else
                 EV_DEBUG << "EIGRP: Received message from " << srcAddr << " that is not neighbor, skipped" << endl;
             break;
     }
 }

Referenced by handleMessage().

◆ processMsgFromRtp()

void inet::eigrp::EigrpIpv6Pdm::processMsgFromRtp ( cMessage * msg )

protected

Process message request from RTP.

 {
     EigrpMsgReq *msgReq = check_and_cast<EigrpMsgReq *>(msg);
     int routeCnt = msgReq->getRoutesArraySize();
     Ipv6Address destAddress;
     int destIface = msgReq->getDestInterface();
     EigrpInterface *eigrpIface = eigrpIft->findInterfaceById(destIface);
  
     Packet *pk;
  
 #ifdef EIGRP_DEBUG
     ASSERT(eigrpIface != nullptr && !eigrpIface->isPassive());
 #endif
  
     if (!getDestIpAddress(msgReq->getDestNeighbor(), &destAddress) || eigrpIface == nullptr) { // Discard message request
         return;
     }
  
     // Print message information
     printSentMsg(routeCnt, destAddress, msgReq);
  
     // Create EIGRP message
     switch (msgReq->getOpcode()) {
         case EIGRP_HELLO_MSG:
             if (msgReq->getGoodbyeMsg() == true) { // Goodbye message
                 pk = createHelloPacket(eigrpIface->getHoldInt(), this->KVALUES_MAX, destAddress, msgReq);
                 pk->setName("EIGRP_HELLO_MSG");
             }
             else if (msgReq->getAckNumber() > 0) { // Ack message
                 pk = createAckPacket(destAddress, msgReq);
                 pk->setName("EIGRP_ACK_MSG");
             }
             else { // Hello message
                 pk = createHelloPacket(eigrpIface->getHoldInt(), this->kValues, destAddress, msgReq);
                 pk->setName("EIGRP_HELLO_MSG");
             }
             break;
  
         case EIGRP_UPDATE_MSG:
             pk = createUpdatePacket(destAddress, msgReq);
             pk->setName("EIGRP_UPDATE_MSG");
             break;
  
         case EIGRP_QUERY_MSG:
  
             pk = createQueryPacket(destAddress, msgReq);
             pk->setName("EIGRP_QUERY_MSG");
             break;
  
         case EIGRP_REPLY_MSG:
             pk = createReplyPacket(destAddress, msgReq);
             pk->setName("EIGRP_REPLY_MSG");
             break;
  
         default:
             ASSERT(false);
             return;
             break;
     }
  
     // Send message to network
     pk->addTagIfAbsent<PacketProtocolTag>()->setProtocol(&Protocol::eigrp);
     pk->addTagIfAbsent<InterfaceReq>()->setInterfaceId(destIface);
     pk->addTagIfAbsent<L3AddressReq>()->setDestAddress(destAddress);
     pk->addTagIfAbsent<DispatchProtocolReq>()->setProtocol(&Protocol::ipv6);
     pk->addTagIfAbsent<L3AddressReq>()->setSrcAddress(ift->getInterfaceById(destIface)->getProtocolData<Ipv6InterfaceData>()->getLinkLocalAddress());
     pk->addTagIfAbsent<HopLimitReq>()->setHopLimit(1);
     send(pk, SPLITTER_OUTGW);
 }

Referenced by handleMessage().

◆ processNewNeighbor()

void inet::eigrp::EigrpIpv6Pdm::processNewNeighbor	(	int	ifaceId,
		Ipv6Address &	srcAddress,
		const EigrpIpv6Hello *	helloMessage
	)

protected

Creates relationship with neighbor.

Parameters

srcAddress	address of the neighbor
ifaceId	ID of interface where the neighbor is connected

 {
     EigrpMsgReq *msgReqUpdate = nullptr, *msgReqHello = nullptr;
     EigrpNeighbor<Ipv6Address> *neigh;
     EigrpInterface *iface = eigrpIft->findInterfaceById(ifaceId);
     EigrpTlvParameter paramTlv = rcvMsg->getParameterTlv();
     EigrpStub stubConf = rcvMsg->getStubTlv().stub;
     int ecode; // Code of user message
  
     // Check rules for establishing neighborship
     if ((ecode = checkNeighborshipRules(ifaceId, rcvMsg->getAsNum(), srcAddress,
             paramTlv.kValues)) != eigrp::M_OK)
     {
         EV_DEBUG << "EIGRP can't create neighborship with " << srcAddress << ", " << eigrp::UserMsgs[ecode] << endl;
  
         if (ecode == eigrp::M_NEIGH_BAD_KVALUES) { // Send Goodbye message and reset Hello timer
             resetTimer(iface->getHelloTimer(), iface->getHelloInt() - 0.5);
             msgReqHello = createMsgReq(EIGRP_HELLO_MSG, EigrpNeighbor<Ipv6Address>::UNSPEC_ID, ifaceId);
             msgReqHello->setGoodbyeMsg(true);
             send(msgReqHello, RTP_OUTGW);
         }
         return;
     }
  
     EV_DEBUG << "Neighbor " << srcAddress << " is up, new adjacency" << endl;
  
     neigh = createNeighbor(iface, srcAddress, paramTlv.holdTimer);
  
     if (stubConf.connectedRt || stubConf.leakMapRt || stubConf.recvOnlyRt || stubConf.redistributedRt || stubConf.staticRt || stubConf.summaryRt) { // Process stub configuration
         neigh->setStubEnable(true);
         neigh->setStubConf(stubConf);
         iface->incNumOfStubs();
         eigrpNt->incStubCount();
     }
  
     // Reply with Hello message and reset Hello timer
     resetTimer(iface->getHelloTimer(), iface->getHelloInt() - 0.5);
     msgReqHello = createMsgReq(EIGRP_HELLO_MSG, EigrpNeighbor<Ipv6Address>::UNSPEC_ID, ifaceId);
     send(msgReqHello, RTP_OUTGW);
  
     // Send Update with INIT flag
     msgReqUpdate = createMsgReq(EIGRP_UPDATE_MSG, neigh->getNeighborId(), neigh->getIfaceId());
     msgReqUpdate->setInit(true);
     send(msgReqUpdate, RTP_OUTGW);
 }

Referenced by processHelloPacket().

◆ processQueryPacket()

void inet::eigrp::EigrpIpv6Pdm::processQueryPacket	(	Packet *	pk,
		Ipv6Address &	srcAddress,
		int	ifaceId,
		EigrpNeighbor< Ipv6Address > *	neigh
	)

protected

 {
  
     const EigrpIpv6Query *query = staticPtrCast<const EigrpIpv6Query>(pk->peekAtFront<EigrpIpv6Query>()).get();
  
     EigrpInterface *eigrpIface = eigrpIft->findInterfaceById(ifaceId);
     EigrpRouteSource<Ipv6Address> *src = nullptr;
     bool notifyDual, isSourceNew;
  
     printRecvMsg(query, srcAddress, ifaceId);
  
     int cnt = query->getInterRoutesArraySize();
 #ifdef EIGRP_DEBUG
     EV_DEBUG << "     Route count:" << cnt << endl;
 #endif
  
     for (int i = 0; i < cnt; i++) {
         src = processInterRoute(query->getInterRoutes(i), srcAddress, neigh->getNeighborId(), eigrpIface, &notifyDual, &isSourceNew);
         src->getRouteInfo()->incrementRefCnt(); // RouteInto cannot be removed while processing Query and generating Reply
  
         // Always notify DUAL
         eigrpDual->processEvent(EigrpDual<Ipv6Address>::RECV_QUERY, src, neigh->getNeighborId(), isSourceNew);
     }
     flushMsgRequests();
     eigrpTt->purgeTable();
 }

Referenced by processMsgFromNetwork().

◆ processReplyPacket()

void inet::eigrp::EigrpIpv6Pdm::processReplyPacket	(	Packet *	pk,
		Ipv6Address &	srcAddress,
		int	ifaceId,
		EigrpNeighbor< Ipv6Address > *	neigh
	)

protected

 {
     const EigrpIpv6Reply *reply = staticPtrCast<const EigrpIpv6Reply>(pk->peekAtFront<EigrpIpv6Reply>()).get();
  
     EigrpInterface *eigrpIface = eigrpIft->findInterfaceById(ifaceId);
     EigrpRouteSource<Ipv6Address> *src;
     bool notifyDual, isSourceNew;
  
     printRecvMsg(reply, srcAddress, ifaceId);
  
     int cnt = reply->getInterRoutesArraySize();
 #ifdef EIGRP_DEBUG
     EV_DEBUG << "     Route count:" << cnt << endl;
 #endif
  
     for (int i = 0; i < cnt; i++) {
         src = processInterRoute(reply->getInterRoutes(i), srcAddress, neigh->getNeighborId(), eigrpIface, &notifyDual, &isSourceNew);
         // Always notify DUAL
         eigrpDual->processEvent(EigrpDual<Ipv6Address>::RECV_REPLY, src, neigh->getNeighborId(), isSourceNew);
     }
     flushMsgRequests();
     eigrpTt->purgeTable();
 }

Referenced by processMsgFromNetwork().

◆ processRTRouteDel()

void inet::eigrp::EigrpIpv6Pdm::processRTRouteDel ( const cObject * details )

protected

 {
     if (dynamic_cast<const Ipv6Route *>(details) == nullptr) {
         return; // route is not Ipv6
     }
     const Ipv6Route *changedRt = check_and_cast<const Ipv6Route *>(details);
 //    ANSAIPv6Route *changedAnsaRt = dynamic_cast<ANSAIPv6Route *>(changedRt);
     const Ipv6Route *changedAnsaRt = changedRt;
     unsigned adminDist;
     EigrpRouteSource<Ipv6Address> *source = nullptr;
  
     if (changedAnsaRt != nullptr)
         adminDist = changedAnsaRt->getAdminDist();
     else
         adminDist = changedRt->getAdminDist();
  
 #ifdef EIGRP_DEBUG
 //    EV_DEBUG << "EIGRP: received notification about deletion of route in RT with AD=" << adminDist << endl;
 #endif
  
     if (adminDist == this->adminDistInt) { // Deletion of EIGRP internal route
         source = eigrpTt->findRoute(changedRt->getDestPrefix(), makeNetmask(changedRt->getPrefixLength()), changedRt->getNextHop());
         if (source == nullptr) {
             ASSERT(false);
             EV_DEBUG << "EIGRP: removed EIGRP route from RT, not found corresponding route source in TT" << endl;
             return;
         }
  
         if (source == oldsource)
             return;
         else
             oldsource = source;
  
         if (source->isSuccessor()) {
             if (!source->getRouteInfo()->isActive()) { // Process route in DUAL (no change of metric)
                 this->eigrpDual->processEvent(EigrpDual<Ipv6Address>::LOST_ROUTE, source, IEigrpPdm::UNSPEC_SENDER, false);
             }
         }
         // Else do nothing - EIGRP itself removed route from RT
     }
     else { // Deletion of non EIGRP route
  
     }
 }

Referenced by receiveSignal().

◆ processTimer()

void inet::eigrp::EigrpIpv6Pdm::processTimer ( cMessage * msg )

protected

 {
     EigrpTimer *timer = check_and_cast<EigrpTimer *>(msg);
     EigrpInterface *eigrpIface = nullptr;
     EigrpNeighbor<Ipv6Address> *neigh = nullptr;
     cObject *contextBasePtr = nullptr;
     EigrpMsgReq *msgReq = nullptr;
     int ifaceId = -1;
  
     switch (timer->getTimerKind()) {
         case EIGRP_HELLO_TIMER:
             // get interface that belongs to timer
             contextBasePtr = (cObject *)timer->getContextPointer();
             eigrpIface = check_and_cast<EigrpInterface *>(contextBasePtr);
  
             // schedule Hello timer
             scheduleAt(simTime() + eigrpIface->getHelloInt() - 0.5, timer);
  
             // send Hello message
             msgReq = createMsgReq(EIGRP_HELLO_MSG, EigrpNeighbor<Ipv6Address>::UNSPEC_ID, eigrpIface->getInterfaceId());
             send(msgReq, RTP_OUTGW);
             break;
  
         case EIGRP_HOLD_TIMER:
             // get neighbor from context
             contextBasePtr = (cObject *)timer->getContextPointer();
             neigh = check_and_cast<EigrpNeighbor<Ipv6Address> *>(contextBasePtr);
             ifaceId = neigh->getIfaceId();
  
             // remove neighbor
             EV_DEBUG << "Neighbor " << neigh->getIPAddress() << " is down, holding time expired" << endl;
             removeNeighbor(neigh);
             neigh = nullptr;
             flushMsgRequests();
             eigrpTt->purgeTable();
  
             // Send goodbye and restart Hello timer
             eigrpIface = eigrpIft->findInterfaceById(ifaceId);
             resetTimer(eigrpIface->getHelloTimer(), eigrpIface->getHelloInt() - 0.5);
             msgReq = createMsgReq(EIGRP_HELLO_MSG, EigrpNeighbor<Ipv6Address>::UNSPEC_ID, ifaceId);
             msgReq->setGoodbyeMsg(true);
             send(msgReq, RTP_OUTGW);
             break;
  
         default:
             EV_DEBUG << "Timer with unknown kind was skipped" << endl;
             delete timer;
             timer = nullptr;
             break;
     }
 }

Referenced by handleMessage().

◆ processUpdatePacket()

void inet::eigrp::EigrpIpv6Pdm::processUpdatePacket	(	Packet *	pk,
		Ipv6Address &	srcAddress,
		int	ifaceId,
		EigrpNeighbor< Ipv6Address > *	neigh
	)

protected

 {
     const EigrpIpv6Update *update = staticPtrCast<const EigrpIpv6Update>(pk->peekAtFront<EigrpIpv6Update>()).get();
  
     EigrpInterface *eigrpIface = eigrpIft->findInterfaceById(ifaceId);
     EigrpRouteSource<Ipv6Address> *src;
     bool skipRoute, notifyDual, isSourceNew;
  
     printRecvMsg(update, srcAddress, ifaceId);
  
     if (neigh->isStateUp() == false && update->getAckNum() != 0) { // First ack from neighbor
         // If neighbor is "pending", then change its state to "up"
         neigh->setStateUp(true);
         // Send all EIGRP paths from routing table to sender
         sendAllEigrpPaths(eigrpIface, neigh);
     }
  
     if (update->getInit()) { // Request to send all paths from routing table
         if (neigh->isStateUp() == true) {
             sendAllEigrpPaths(eigrpIface, neigh);
         }
     }
     else if (neigh->isStateUp()) { // Neighbor is "up", forward message to DUAL
         int cnt = update->getInterRoutesArraySize();
 #ifdef EIGRP_DEBUG
         EV_DEBUG << "     Route count:" << cnt << endl;
 #endif
  
         for (int i = 0; i < cnt; i++) {
             skipRoute = false;
             notifyDual = false;
             EigrpMpIpv6Internal tlv = update->getInterRoutes(i);
  
             if (tlv.routerID == eigrpTt->getRouterId() || eigrpMetric->isParamMaximal(tlv.metric)) { // Route with RID is equal to RID of router or tlv is unreachable route
                 Ipv6Address nextHop = getNextHopAddr(tlv.nextHop, srcAddress);
                 if (eigrpTt->findRoute(tlv.destAddress, tlv.destMask, nextHop) == nullptr)
                     skipRoute = true; // Route is not found in TT -> discard route
             }
  
             if (skipRoute) { // Discard route
                 EV_DEBUG << "EIGRP: discard route " << tlv.destAddress << endl;
             }
             else { // process route
                 src = processInterRoute(tlv, srcAddress, neigh->getNeighborId(), eigrpIface, &notifyDual, &isSourceNew);
                 if (notifyDual)
                     eigrpDual->processEvent(EigrpDual<Ipv6Address>::RECV_UPDATE, src, neigh->getNeighborId(), isSourceNew);
                 else
                     EV_DEBUG << "EIGRP: route " << tlv.destAddress << " is not processed by DUAL, no change of metric" << endl;
             }
         }
         flushMsgRequests();
         eigrpTt->purgeTable();
     }
 //     else ignore message");
 }

Referenced by processMsgFromNetwork().

◆ pushMsgRouteToQueue()

EigrpMsgReq * inet::eigrp::EigrpIpv6Pdm::pushMsgRouteToQueue	(	HeaderOpcode	msgType,
		int	ifaceId,
		int	neighId,
		const EigrpMsgRoute &	msgRt
	)

protected

Insert route into the queue with requests.

 {
     EigrpMsgReq *request = nullptr;
     RequestVector::iterator it;
  
     // Find or create message
     for (it = reqQueue.begin(); it != reqQueue.end(); it++) {
         if ((*it)->getDestInterface() == ifaceId && (*it)->getOpcode() == msgType) {
             request = *it;
             break;
         }
     }
     if (request == nullptr) { // Create new request
         request = createMsgReq(msgType, neighId, ifaceId);
         request->setRoutesArraySize(1);
         request->setRoutes(0, msgRt);
         reqQueue.push_back(request);
     }
     else { // Use existing request
         int rtSize = request->getRoutesArraySize();
         int index;
         if ((index = request->findMsgRoute(msgRt.routeId)) >= 0) { // Use existing route
             if (msgRt.unreachable)
                 request->getRoutesForUpdate(index).unreachable = true;
         }
         else { // Add route to request
             request->setRoutesArraySize(rtSize + 1);
             request->setRoutes(rtSize, msgRt);
         }
     }
  
     return request;
 }

Referenced by msgToIface(), and sendReply().

◆ receiveSignal()

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

overrideprotectedvirtual

 {
     Enter_Method("%s", cComponent::getSignalName(signalID));
  
     if (signalID == interfaceStateChangedSignal) {
         NetworkInterfaceChangeDetails *ifcecd = check_and_cast<NetworkInterfaceChangeDetails *>(obj);
         processIfaceStateChange(ifcecd->getNetworkInterface());
     }
     else if (signalID == interfaceConfigChangedSignal) {
         NetworkInterfaceChangeDetails *ifcecd = check_and_cast<NetworkInterfaceChangeDetails *>(obj);
         NetworkInterface *iface = ifcecd->getNetworkInterface();
         EigrpInterface *eigrpIface = getInterfaceById(iface->getInterfaceId());
         double ifParam;
  
         if (eigrpIface == nullptr)
             return;
  
         ifParam = iface->getDatarate();
         if (ifParam != 0 && ifParam != eigrpIface->getInterfaceDatarate()) { // Bandwidth
             eigrpIface->setInterfaceDatarate(ifParam);
             if (eigrpIface->isEnabled())
                 processIfaceConfigChange(eigrpIface);
         }
     }
     else if (signalID == routeDeletedSignal) {
         processRTRouteDel(obj);
     }
 }

◆ removeNeighbor()

void inet::eigrp::EigrpIpv6Pdm::removeNeighbor ( EigrpNeighbor< Ipv6Address > * neigh )

protected

Removes neighbor from neighbor table and delete it.

Notifies DUAL about event.

 {
     EigrpRouteSource<Ipv6Address> *source = nullptr;
     EigrpRoute<Ipv6Address> *route = nullptr;
     // Find interface (enabled/disabled)
     EigrpInterface *eigrpIface = getInterfaceById(neigh->getIfaceId());
  
     int nextHopId = neigh->getNeighborId();
     int ifaceId = neigh->getIfaceId();
     const char *ifaceName = neigh->getIfaceName();
     int routeId;
  
     cancelHoldTimer(neigh);
     // Remove neighbor from NT
     this->eigrpNt->removeNeighbor(neigh);
     eigrpIface->decNumOfNeighbors();
     if (neigh->isStubEnabled()) {
         eigrpIface->decNumOfStubs();
         eigrpNt->decStubCount();
     }
     delete neigh;
     neigh = nullptr;
  
     for (int i = 0; i < eigrpTt->getNumRouteInfo(); i++) { // Process routes that go via this neighbor
         route = eigrpTt->getRouteInfo(i);
         routeId = route->getRouteId();
         // Note: TT can not contain two or more records with the same network address and next hop address
         source = eigrpTt->findRouteByNextHop(routeId, nextHopId);
  
 #ifdef EIGRP_DEBUG
         EV_DEBUG << "EIGRP: Destination: " << route->getRouteAddress() << "/" << getNetmaskLength(route->getRouteMask()) << ", active " << route->isActive() << endl;
 #endif
  
         if (route->isActive()) {
             if (source == nullptr) { // Create dummy source for active route (instead of Reply)
 #ifdef EIGRP_DEBUG
                 EV_DEBUG << "     Create dummy route " << route->getRouteAddress() << " via <unspecified> for deletion of reply status handle" << endl;
 #endif
                 source = new EigrpRouteSource<Ipv6Address>(ifaceId, ifaceName, nextHopId, routeId, route);
                 eigrpTt->addRoute(source);
                 eigrpDual->processEvent(EigrpDual<Ipv6Address>::NEIGHBOR_DOWN, source, nextHopId, true);
             }
             else
                 eigrpDual->processEvent(EigrpDual<Ipv6Address>::NEIGHBOR_DOWN, source, nextHopId, false);
         }
         else { // Notify DUAL about event
             if (source != nullptr)
                 eigrpDual->processEvent(EigrpDual<Ipv6Address>::NEIGHBOR_DOWN, source, nextHopId, false);
         }
     }
  
     // Do not flush messages in transmit queue
 }

Referenced by disableInterface(), processHelloPacket(), and processTimer().

◆ removeOldSuccessor()

bool inet::eigrp::EigrpIpv6Pdm::removeOldSuccessor	(	EigrpRouteSource< Ipv6Address > *	source,
		EigrpRoute< Ipv6Address > *	route
	)

protected

Removes route from routing table and changes old successor's record in topology table.

 {
 //    ANSAIPv4Route::RoutingProtocolSource srcProto = ANSAIPv4Route::pUnknown;
     IRoute::SourceType srcProto = IRoute::UNKNOWN;
     bool rtFound, rtableChanged = false;
  
     // To distinguish the route deleted by EIGRP in ReceiveChangeNotification method
     source->setSuccessor(false);
  
     rtFound = removeRouteFromRT(source, &srcProto);
 #ifdef EIGRP_DEBUG
 //    EV_DEBUG << "EIGRP: removing old successor: rt found: " << rtFound << " src: " << srcProto << endl;
 #endif
  
 //    if (!rtFound || (rtFound && (srcProto == ANSAIPv6Route::pEIGRP || srcProto == ANSAIPv6Route::pEIGRPext)))
     if (!rtFound || (rtFound && (srcProto == IRoute::EIGRP))) {
         if (route->getSuccessor() == source)
             route->setSuccessor(nullptr);
         rtableChanged = true;
     }
     else // Route from other sources can not be removed, do not change Successor's record in TT
         source->setSuccessor(true);
  
     return rtableChanged;
 }

Referenced by updateRoute().

◆ removeRouteFromRT()

bool inet::eigrp::EigrpIpv6Pdm::removeRouteFromRT	(	EigrpRouteSource< Ipv6Address > *	source,
		IRoute::SourceType *	removedRtSrc
	)

protected

Returns: if route is found in routing table then returns true.

 {
     EigrpRoute<Ipv6Address> *route = source->getRouteInfo();
     Ipv6Route *rtEntry = findRoute(route->getRouteAddress(), getNetmaskLength(route->getRouteMask()), source->getNextHop());
 //    ANSAIPv6Route *ansaRtEntry = dynamic_cast<ANSAIPv6Route *>(rtEntry);
     Ipv6Route *ansaRtEntry = rtEntry;
     if (ansaRtEntry != nullptr) {
         *removedRtSrc = ansaRtEntry->getSourceType();
         //if (*removedRtSrc == ANSAIPv6Route::pEIGRP)
         if (ansaRtEntry->getSourceType() == IRoute::EIGRP) {
             EV_DEBUG << "EIGRP: delete route " << route->getRouteAddress() << " via " << source->getNextHop() << " from RT" << endl;
             delete rt->removeRoute(rtEntry);
         }
     }
     else {
 #ifdef EIGRP_DEBUG
         EV_DEBUG << "EIGRP: EIGRP route " << route->getRouteAddress() << " via " << source->getNextHop() << " can not be removed, not found in RT" << endl;
 #endif
     }
     return rtEntry != nullptr;
 }

Referenced by removeOldSuccessor().

◆ resetTimer()

void inet::eigrp::EigrpIpv6Pdm::resetTimer	(	EigrpTimer *	timer,
		int	interval
	)

inlineprotected

Sets specified timer to given interval.

111 { cancelEvent(timer); scheduleAt(simTime() + interval /*- uniform(0,0.4)*/, timer); }

Referenced by processHelloPacket(), processMsgFromNetwork(), processNewNeighbor(), and processTimer().

◆ sendAllEigrpPaths()

void inet::eigrp::EigrpIpv6Pdm::sendAllEigrpPaths	(	EigrpInterface *	eigrpIface,
		EigrpNeighbor< Ipv6Address > *	neigh
	)

protected

Creates and sends message with all routes from routing table to specified neighbor.

 {
     int routeCnt = eigrpTt->getNumRouteInfo();
     int addedRoutes = 0; // Number of routes in message
     EigrpRoute<Ipv6Address> *route;
     EigrpRouteSource<Ipv6Address> *source;
     EigrpMsgReq *msgReq = createMsgReq(EIGRP_UPDATE_MSG, neigh->getNeighborId(), neigh->getIfaceId());
  
     msgReq->setRoutesArraySize(routeCnt);
  
     for (int i = 0; i < routeCnt; i++) {
         route = eigrpTt->getRouteInfo(i);
         if (route->isActive())
             continue;
  
         if ((source = eigrpTt->getBestSuccessor(route)) != nullptr) {
             if (this->eigrpStubEnabled && applyStubToUpdate(source))
                 continue; // Apply stub settings to the route
             if (eigrpIface->isSplitHorizonEn() && applySplitHorizon(eigrpIface, source, route))
                 continue; // Apply Split Horizon rule
  
             EigrpMsgRoute routeReq;
             routeReq.sourceId = source->getSourceId();
             routeReq.routeId = source->getRouteId();
             routeReq.originator = source->getOriginator();
             routeReq.invalid = false;
             msgReq->setRoutes(addedRoutes /* not variable i */, routeReq);
             addedRoutes++;
         }
     }
  
     if (addedRoutes < routeCnt) // reduce size of array
         msgReq->setRoutesArraySize(addedRoutes);
  
     msgReq->setEot(true);
  
     send(msgReq, RTP_OUTGW);
 }

Referenced by processAckPacket(), and processUpdatePacket().

◆ sendQuery()

void inet::eigrp::EigrpIpv6Pdm::sendQuery	(	int	destNeighbor,
		EigrpRoute< Ipv6Address > *	route,
		EigrpRouteSource< Ipv6Address > *	source,
		bool	forcePoisonRev = `false`
	)

overridevirtual

Sends query message to specified neighbor.

Parameters

destNeighbor	ID of destination neighbor. If parameter is set to 0 then sends message to all neighbors.
route	route network
source	route
forcePoisonRev	apply Poison Reverse instead of Split Horizon to the route.

Implements inet::eigrp::IEigrpPdm< Ipv6Address >.

 {
     bool forceUnreachable = false;
  
     EV_DEBUG << "DUAL: send Query message about " << route->getRouteAddress() << " to all neighbors" << endl;
  
     if (this->eigrpStubEnabled)
         forceUnreachable = true; // Send Query with infinite metric to all neighbors
     else {
         if (this->eigrpNt->getStubCount() > 0) { // Apply Poison Reverse instead of Split Horizon rule
             forcePoisonRev = true;
         }
     }
  
     msgToAllIfaces(destNeighbor, EIGRP_QUERY_MSG, source, forcePoisonRev, forceUnreachable);
 }

◆ sendReply()

void inet::eigrp::EigrpIpv6Pdm::sendReply	(	EigrpRoute< Ipv6Address > *	route,
		int	destNeighbor,
		EigrpRouteSource< Ipv6Address > *	source,
		bool	forcePoisonRev = `false`,
		bool	isUnreachable = `false`
	)

overridevirtual

Sends reply message to specified neighbor.

Parameters

route	route network
destNeighbor	ID of destination neighbor.
source	route
forcePoisonRev	apply Poison Reverse rule to the route
isUnreachable	route in message will have inf metric (regardless of Poisson Reverse)

Implements inet::eigrp::IEigrpPdm< Ipv6Address >.

 {
     EigrpMsgRoute msgRt;
     EigrpNeighbor<Ipv6Address> *neigh = eigrpNt->findNeighborById(destNeighbor);
  
     EV_DEBUG << "DUAL: send Reply message about " << route->getRouteAddress() << endl;
     if (neigh == nullptr)
         return;
  
     msgRt.invalid = false;
     msgRt.sourceId = source->getSourceId();
     msgRt.routeId = source->getRouteId();
     msgRt.originator = source->getOriginator();
     msgRt.unreachable = isUnreachable;
  
     if (this->eigrpStubEnabled)
         msgRt.unreachable = true; // Stub router always reply with infinite metric
  
     // Apply Poison Reverse (instead of Split Horizon)
     if (!isUnreachable && eigrpIft->findInterfaceById(neigh->getIfaceId())->isSplitHorizonEn()) { // Poison Reverse is enabled when Split Horizon is enabled
         // Note: destNeighbor is also neighbor that sent Query
         if (forcePoisonRev)
             msgRt.unreachable = true;
     }
  
     pushMsgRouteToQueue(EIGRP_REPLY_MSG, neigh->getIfaceId(), neigh->getNeighborId(), msgRt);
 }

◆ sendUpdate()

void inet::eigrp::EigrpIpv6Pdm::sendUpdate	(	int	destNeighbor,
		EigrpRoute< Ipv6Address > *	route,
		EigrpRouteSource< Ipv6Address > *	source,
		bool	forcePoisonRev,
		const char *	reason
	)

overridevirtual

Sends update message to specified neighbor.

Parameters

destNeighbor	ID of destination neighbor. If parameter is set to 0 then sends message to all neighbors.
route	route network
source	route
forcePoisonRev	force poison reverse rule instead of split horizon
reason	text description for user.

Implements inet::eigrp::IEigrpPdm< Ipv6Address >.

 {
     EV_DEBUG << "DUAL: send Update message about " << route->getRouteAddress() << " to all neighbors, " << reason << endl;
     if (this->eigrpStubEnabled && applyStubToUpdate(source)) {
         EV_DEBUG << "     Stub routing applied, message will not be sent" << endl;
         return;
     }
     msgToAllIfaces(destNeighbor, EIGRP_UPDATE_MSG, source, forcePoisonRev, false);
 }

Referenced by sendUpdateToStubs().

◆ sendUpdateToStubs()

void inet::eigrp::EigrpIpv6Pdm::sendUpdateToStubs	(	EigrpRouteSource< Ipv6Address > *	succ,
		EigrpRouteSource< Ipv6Address > *	oldSucc,
		EigrpRoute< Ipv6Address > *	route
	)

overridevirtual

Sends update message to all stub neighbors.

Implements inet::eigrp::IEigrpPdm< Ipv6Address >.

 {
     if (!this->eigrpStubEnabled && eigrpNt->getStubCount() > 0) {
         if (succ == nullptr) { // Send old successor
             // Route will be removed after router receives Ack from neighbor
             if (oldSucc->isUnreachable()) {
                 route->setUpdateSent(true);
                 route->setNumSentMsgs(route->getNumSentMsgs() + 1);
             }
             sendUpdate(IEigrpPdm::STUB_RECEIVER, route, oldSucc, true, "notify stubs about change");
         }
         else // Send successor
             sendUpdate(IEigrpPdm::STUB_RECEIVER, route, succ, true, "notify stubs about change");
     }
 }

◆ setASNum()

void inet::eigrp::EigrpIpv6Pdm::setASNum ( int asNum )

inlineoverridevirtual

Implements inet::eigrp::IEigrpModule< Ipv6Address >.

300 { this->asNum = asNum; }

◆ setBandwidth()

void inet::eigrp::EigrpIpv6Pdm::setBandwidth	(	int	bandwith,
		int	interfaceId
	)

inlineoverridevirtual

Implements inet::eigrp::IEigrpModule< Ipv6Address >.

312 { this->eigrpIft->findInterfaceById(interfaceId)->setBandwidth(bandwith); }

◆ setDelay()

void inet::eigrp::EigrpIpv6Pdm::setDelay	(	int	delay,
		int	interfaceId
	)

inlineoverridevirtual

Implements inet::eigrp::IEigrpModule< Ipv6Address >.

313 { this->eigrpIft->findInterfaceById(interfaceId)->setDelay(delay); }

◆ setDelayedRemove()

void inet::eigrp::EigrpIpv6Pdm::setDelayedRemove	(	int	neighId,
		EigrpRouteSource< Ipv6Address > *	src
	)

overridevirtual

After receiving Ack from neighbor with neighId will be route removed from TT.

Parameters

neighId	ID of neighbor
src	route

Implements inet::eigrp::IEigrpPdm< Ipv6Address >.

 {
     EigrpNeighbor<Ipv6Address> *neigh = eigrpNt->findNeighborById(neighId);
  
     ASSERT(neigh != nullptr);
     neigh->setRoutesForDeletion(true);
     src->setDelayedRemove(neighId);
     src->setValid(true); // Can not be invalid
  
 #ifdef EIGRP_DEBUG
     EV_DEBUG << "DUAL: route via " << src->getNextHop() << " will be removed from TT after receiving Ack from neighbor" << endl;
 #endif
 }

◆ setHelloInt()

void inet::eigrp::EigrpIpv6Pdm::setHelloInt	(	int	interval,
		int	ifaceId
	)

overridevirtual

Implements inet::eigrp::IEigrpModule< Ipv6Address >.

 {
     EigrpInterface *iface = getInterfaceById(ifaceId);
     if (iface == nullptr)
         iface = addInterfaceToEigrp(ifaceId, false);
     iface->setHelloInt(interval);
 }

◆ setHoldInt()

void inet::eigrp::EigrpIpv6Pdm::setHoldInt	(	int	interval,
		int	ifaceId
	)

overridevirtual

Implements inet::eigrp::IEigrpModule< Ipv6Address >.

 {
     EigrpInterface *iface = getInterfaceById(ifaceId);
     if (iface == nullptr)
         iface = addInterfaceToEigrp(ifaceId, false);
     iface->setHoldInt(interval);
 }

◆ setKValues()

void inet::eigrp::EigrpIpv6Pdm::setKValues ( const EigrpKValues & kValues )

inlineoverridevirtual

Implements inet::eigrp::IEigrpModule< Ipv6Address >.

302 { this->kValues = kValues; }

◆ setLoad()

void inet::eigrp::EigrpIpv6Pdm::setLoad	(	int	load,
		int	interfaceId
	)

inlineoverridevirtual

Implements inet::eigrp::IEigrpModule< Ipv6Address >.

311 { this->eigrpIft->findInterfaceById(interfaceId)->setLoad(load); }

◆ setMaximumPath()

void inet::eigrp::EigrpIpv6Pdm::setMaximumPath ( int maximumPath )

inlineoverridevirtual

Implements inet::eigrp::IEigrpModule< Ipv6Address >.

303 { this->maximumPath = maximumPath; }

◆ setPassive()

void inet::eigrp::EigrpIpv6Pdm::setPassive	(	bool	passive,
		int	ifaceId
	)

overridevirtual

Implements inet::eigrp::IEigrpModule< Ipv6Address >.

 {
     EigrpInterface *eigrpIface = getInterfaceById(ifaceId);
  
     if (eigrpIface == nullptr)
         eigrpIface = addInterfaceToEigrp(ifaceId, false);
     else if (eigrpIface->isEnabled()) { // Disable sending and receiving of messages
         NetworkInterface *iface = ift->getInterfaceById(ifaceId);
  
         Ipv6InterfaceData *ipv6int = iface->getProtocolDataForUpdate<Ipv6InterfaceData>();
         ipv6int->leaveMulticastGroup(EIGRP_IPV6_MULT);
  
 //        iface->ipv6Data()->leaveMulticastGroup(EIGRP_IPV6_MULT);
  
         /*
         if(iface->ipv6Data()->hasAddress(EIGRP_IPV6_MULT))
         {
             iface->ipv6Data()->removeAddress(EIGRP_IPV6_MULT);
         }
          */
  
         if (ipv6int->hasAddress(EIGRP_IPV6_MULT)) {
             ipv6int->removeAddress(EIGRP_IPV6_MULT);
         }
  
         // Stop and delete hello timer
         EigrpTimer *hellot = eigrpIface->getHelloTimer();
         if (hellot != nullptr) {
             cancelEvent(hellot);
             delete hellot;
             eigrpIface->setHelloTimerPtr(nullptr);
         }
     }
     // Else do nothing (interface is not part of EIGRP)
  
     eigrpIface->setPassive(passive);
 }

◆ setReliability()

void inet::eigrp::EigrpIpv6Pdm::setReliability	(	int	reliability,
		int	interfaceId
	)

inlineoverridevirtual

Implements inet::eigrp::IEigrpModule< Ipv6Address >.

314 { this->eigrpIft->findInterfaceById(interfaceId)->setReliability(reliability); }

◆ setReplyStatusTable()

bool inet::eigrp::EigrpIpv6Pdm::setReplyStatusTable	(	EigrpRoute< Ipv6Address > *	route,
		EigrpRouteSource< Ipv6Address > *	source,
		bool	forcePoisonRev,
		int *	neighCount,
		int *	stubCount
	)

overridevirtual

Sets Reply Status Table for specified network.

Parameters

route	route network
forcePoisonRev	use Poison Reverse instead of Split Horizon
neighCount	number of all neighbors.
stubCount	number of stub neighbors.

Implements inet::eigrp::IEigrpPdm< Ipv6Address >.

 {
     int neighTotalCount = eigrpNt->getNumNeighbors();
     EigrpNeighbor<Ipv6Address> *neigh;
     EigrpInterface *eigrpIface = nullptr;
  
     for (int i = 0; i < neighTotalCount; i++) {
         neigh = eigrpNt->getNeighbor(i);
         if ((eigrpIface = eigrpIft->findInterfaceById(neigh->getIfaceId())) == nullptr)
             continue; // The interface has been removed
  
         // Apply stub routing
         if (!this->eigrpStubEnabled) {
             if (neigh->isStubEnabled()) {
                 (*stubCount)++;
                 (*neighCount)++;
                 continue; // Non stub router can not send Query to stub router
             }
  
             if (this->eigrpNt->getStubCount() > 0) { // Apply Poison Reverse instead of Split Horizon rule
                 forcePoisonRev = true;
             }
         }
  
         // Apply Split Horizon and Poison Reverse
         if (eigrpIface->isSplitHorizonEn() && applySplitHorizon(eigrpIface, source, route)) {
             if (forcePoisonRev) { // Apply Poison Reverse instead of Split Horizon
                 route->setReplyStatus(neigh->getNeighborId());
             }
             else
                 continue; // Do not send route
         }
         else
             route->setReplyStatus(neigh->getNeighborId());
  
         (*neighCount)++;
     }
  
     return route->getReplyStatusSum() > 0;
 }

◆ setRouterId()

void inet::eigrp::EigrpIpv6Pdm::setRouterId ( Ipv4Address routerID )

inlineoverridevirtual

Sets router ID.

Parameters

routerID EIGRP process routerID, represented as IPv4 address

Implements inet::eigrp::IEigrpModule< Ipv6Address >.

310 { this->eigrpTt->setRouterId(routerID); }

◆ setRouteTlvMetric()

void inet::eigrp::EigrpIpv6Pdm::setRouteTlvMetric	(	EigrpWideMetricPar *	msgMetric,
		EigrpWideMetricPar *	rtMetric
	)

protected

 {
     msgMetric->bandwidth = rtMetric->bandwidth;
     msgMetric->delay = rtMetric->delay;
     msgMetric->hopCount = rtMetric->hopCount;
     msgMetric->load = rtMetric->load;
     msgMetric->mtu = rtMetric->mtu;
     msgMetric->offset = 0; // TODO
     msgMetric->priority = 0; // TODO
     msgMetric->reliability = rtMetric->reliability;
 }

Referenced by createRouteTlv().

◆ setRTRouteMetric()

void inet::eigrp::EigrpIpv6Pdm::setRTRouteMetric	(	Ipv6Route *	route,
		uint64_t	metric
	)

inlineprotected

Changes metric of route in routing table.

For wide metric uses scale.

248 { if (!useClassicMetric) { metric = metric / ribScale; } route->setMetric(metric); }

Referenced by createRTRoute(), and installRouteToRT().

◆ setSplitHorizon()

void inet::eigrp::EigrpIpv6Pdm::setSplitHorizon	(	bool	shenabled,
		int	ifaceId
	)

overridevirtual

Implements inet::eigrp::IEigrpModule< Ipv6Address >.

 {
     EigrpInterface *iface = getInterfaceById(ifaceId);
     if (iface == nullptr)
         iface = addInterfaceToEigrp(ifaceId, false);
     iface->setSplitHorizon(shenabled);
 }

◆ setStub()

void inet::eigrp::EigrpIpv6Pdm::setStub ( const EigrpStub & stub )

inlineoverridevirtual

Implements inet::eigrp::IEigrpModule< Ipv6Address >.

309 { this->eigrpStub = stub; this->eigrpStubEnabled = true; }

◆ setVariance()

void inet::eigrp::EigrpIpv6Pdm::setVariance ( int variance )

inlineoverridevirtual

Implements inet::eigrp::IEigrpModule< Ipv6Address >.

304 { this->variance = variance; }

◆ startHelloTimer()

void inet::eigrp::EigrpIpv6Pdm::startHelloTimer	(	EigrpInterface *	eigrpIface,
		simtime_t	interval
	)

protected

Schedule hello timer to the specified interval.

 {
     EigrpTimer *hellot;
  
     // Start Hello timer on interface
     if (!eigrpIface->isPassive()) {
         if ((hellot = eigrpIface->getHelloTimer()) == nullptr) {
             hellot = createTimer(EIGRP_HELLO_TIMER, eigrpIface);
             eigrpIface->setHelloTimerPtr(hellot);
         }
  
         scheduleAt(interval, hellot);
     }
 }

Referenced by addInterfaceToEigrp(), and processIfaceStateChange().

◆ unlockRoutes()

void inet::eigrp::EigrpIpv6Pdm::unlockRoutes ( const EigrpMsgReq * msgReq )

protected

 {
     int reqCnt = msgReq->getRoutesArraySize();
     EigrpRoute<Ipv6Address> *route = nullptr;
  
     for (int i = 0; i < reqCnt; i++) {
         EigrpMsgRoute req = msgReq->getRoutes(i);
         route = eigrpTt->findRouteInfoById(req.routeId);
  
         ASSERT(route != nullptr);
         route->decrementRefCnt();
  
         if (route->getRefCnt() < 1) { // Route would have been removed be removed if wasn't locked
             delete eigrpTt->removeRouteInfo(route);
         }
     }
 }

Referenced by createReplyPacket().

◆ updateInterface()

virtual void inet::eigrp::EigrpIpv6Pdm::updateInterface ( int interfaceId )

inlineoverridevirtual

Implements inet::eigrp::IEigrpModule< Ipv6Address >.

296 { processIfaceConfigChange(this->eigrpIft->findInterfaceById(interfaceId)); }

◆ updateRoute()

EigrpRouteSource< Ipv6Address > * inet::eigrp::EigrpIpv6Pdm::updateRoute	(	EigrpRoute< Ipv6Address > *	route,
		uint64_t	dmin,
		bool *	rtableChanged,
		bool	removeUnreach = `false`
	)

overridevirtual

Function finds successors to the destination network.

Parameters

route	destination network
dmin	minimal distance to the destination
rtableChanged	return parameter, true if occurs change in the routing table
removeUnreach	invalidate unreachable sources of the route.

Returns: pointer to successor or nullptr.

Implements inet::eigrp::IEigrpPdm< Ipv6Address >.

 {
     EigrpRouteSource<Ipv6Address> *source = nullptr, *bestSuccessor = nullptr;
     Ipv6Route *rtEntry = nullptr;
     int routeNum = eigrpTt->getNumRoutes();
     int routeId = route->getRouteId();
     int pathsInRT = 0; // Number of paths in RT (equal to number of successors)
     int sourceCounter = 0; // Number of route sources
     uint64_t routeFd = route->getFd();
  
     EV_DEBUG << "EIGRP: Search successor for route " << route->getRouteAddress() << ", FD is " << route->getFd() << endl;
  
     for (int i = 0; i < routeNum; i++) {
         source = eigrpTt->getRoute(i);
         if (source->getRouteId() != routeId || !source->isValid())
             continue;
  
         sourceCounter++;
  
         if (source->getRd() < routeFd /* FC, use this FD (not dmin) */ &&
             source->getMetric() <= dmin * this->variance && pathsInRT < this->maximumPath) /* Load Balancing */
         {
             EV_DEBUG << "     successor " << source->getNextHop() << " (" << source->getMetric() << "/" << source->getRd() << ")" << endl;
  
             if ((rtEntry = findRoute(route->getRouteAddress(), getNetmaskLength(route->getRouteMask()), source->getNextHop())) == nullptr)
                 if (!isRTSafeForAdd(route, adminDistInt)) { // In RT exists route with smaller AD, do not mark the route source as successor
                     source->setSuccessor(false);
                     EV_DEBUG << "           route can not be added into RT, there is route with smaller AD" << endl;
                     continue; // Skip the route
                 }
  
             if (installRouteToRT(route, source, dmin, rtEntry))
                 *rtableChanged = true;
  
             pathsInRT++;
             source->setSuccessor(true);
         }
         else if (source->isSuccessor()) { // Remove old successor from RT
             if (removeOldSuccessor(source, route))
                 *rtableChanged = true;
         }
  
         if (removeUnreach && source->isUnreachable() && source->getDelayedRemove() == 0 && source->isValid()) { // Invalidate unreachable routes in TT
             source->setValid(false);
             EV_DEBUG << "     invalidate route via " << source->getNextHop() << " in TT" << endl;
         }
     }
  
     route->setNumSucc(pathsInRT);
  
     if ((bestSuccessor = eigrpTt->getBestSuccessor(route)) != nullptr) { // Update route with best Successor
         if (dmin < routeFd) // Set only if there is a successor
             route->setFd(dmin);
         route->setDij(dmin);
         route->setRdPar(bestSuccessor->getMetricParams());
         route->setSuccessor(bestSuccessor);
  
         if (sourceCounter == 1) { // Set FD of route to Successor metric (according to Cisco EIGRP implementation)
             route->setFd(bestSuccessor->getMetric());
         }
     }
     else
         route->setSuccessor(nullptr);
  
     return bestSuccessor;
 }

Member Data Documentation

◆ adminDistInt

unsigned int inet::eigrp::EigrpIpv6Pdm::adminDistInt

protected

Administrative distance.

Referenced by EigrpIpv6Pdm(), processRTRouteDel(), and updateRoute().

◆ asNum

int inet::eigrp::EigrpIpv6Pdm::asNum

protected

Autonomous system number.

Referenced by addMessageHeader(), checkNeighborshipRules(), EigrpIpv6Pdm(), and initialize().

◆ EIGRP_IPV6_MULT

const Ipv6Address inet::eigrp::EigrpIpv6Pdm::EIGRP_IPV6_MULT

protected

Multicast address for EIGRP messages.

Referenced by disableInterface(), enableInterface(), getDestIpAddress(), and setPassive().

◆ EIGRP_SELF_ADDR

const Ipv6Address inet::eigrp::EigrpIpv6Pdm::EIGRP_SELF_ADDR

protected

Next hop address 0.0.0.0 (self address)

◆ eigrpDual

EigrpDual<Ipv6Address>* inet::eigrp::EigrpIpv6Pdm::eigrpDual

protected

Referenced by disableInterface(), enableInterface(), initialize(), processIfaceConfigChange(), processQueryPacket(), processReplyPacket(), processRTRouteDel(), processUpdatePacket(), removeNeighbor(), and ~EigrpIpv6Pdm().

◆ eigrpIft

EigrpInterfaceTable* inet::eigrp::EigrpIpv6Pdm::eigrpIft

protected

◆ eigrpIftDisabled

EigrpDisabledInterfaces* inet::eigrp::EigrpIpv6Pdm::eigrpIftDisabled

protected

Disabled EIGRP interfaces.

Referenced by addInterfaceToEigrp(), cancelHelloTimers(), disableInterface(), enableInterface(), getInterfaceById(), initialize(), and ~EigrpIpv6Pdm().

◆ eigrpMetric

EigrpMetricHelper* inet::eigrp::EigrpIpv6Pdm::eigrpMetric

protected

Referenced by addRoutesToMsg(), enableInterface(), initialize(), processIfaceConfigChange(), processInterRoute(), processUpdatePacket(), and ~EigrpIpv6Pdm().

◆ eigrpNt

EigrpNeighborTable<Ipv6Address>* inet::eigrp::EigrpIpv6Pdm::eigrpNt

protected

Table with EIGRP neighbors.

Referenced by createNeighbor(), disableInterface(), getDestIpAddress(), initialize(), msgToIface(), processInterRoute(), processMsgFromNetwork(), processNewNeighbor(), removeNeighbor(), sendQuery(), sendReply(), sendUpdateToStubs(), setDelayedRemove(), and setReplyStatusTable().

◆ eigrpStub

EigrpStub inet::eigrp::EigrpIpv6Pdm::eigrpStub

protected

EIGRP stub configuration.

Referenced by applyStubToUpdate(), createHelloPacket(), and initialize().

◆ eigrpStubEnabled

bool inet::eigrp::EigrpIpv6Pdm::eigrpStubEnabled

protected

True when EIGRP stub is on.

Referenced by applyStubToQuery(), createHelloPacket(), EigrpIpv6Pdm(), sendAllEigrpPaths(), sendQuery(), sendReply(), sendUpdate(), sendUpdateToStubs(), and setReplyStatusTable().

◆ eigrpTt

EigrpTopologyTable<Ipv6Address>* inet::eigrp::EigrpIpv6Pdm::eigrpTt

protected

Topology table.

Referenced by addRoutesToMsg(), applySplitHorizon(), disableInterface(), enableInterface(), initialize(), processAckPacket(), processHelloPacket(), processIfaceConfigChange(), processInterRoute(), processQueryPacket(), processReplyPacket(), processRTRouteDel(), processTimer(), processUpdatePacket(), removeNeighbor(), sendAllEigrpPaths(), unlockRoutes(), and updateRoute().

◆ host

cModule* inet::eigrp::EigrpIpv6Pdm::host = nullptr

protected

Referenced by initialize().

◆ ift

ModuleRefByPar<IInterfaceTable> inet::eigrp::EigrpIpv6Pdm::ift

protected

Referenced by addInterfaceToEigrp(), createRTRoute(), enableInterface(), initialize(), msgToIface(), processMsgFromNetwork(), processMsgFromRtp(), and setPassive().

◆ kValues

EigrpKValues inet::eigrp::EigrpIpv6Pdm::kValues

protected

K-values for calculation of metric.

Referenced by checkNeighborshipRules(), createHelloPacket(), EigrpIpv6Pdm(), enableInterface(), initialize(), processIfaceConfigChange(), and processInterRoute().

◆ KVALUES_MAX

EigrpKValues inet::eigrp::EigrpIpv6Pdm::KVALUES_MAX

protected

K-values (from K1 to K5) are set to max.

Referenced by EigrpIpv6Pdm(), and processHelloPacket().

◆ maximumPath

int inet::eigrp::EigrpIpv6Pdm::maximumPath

protected

Maximum number of parallel routes that EIGRP will support.

Referenced by EigrpIpv6Pdm(), initialize(), and updateRoute().

◆ netPrefixes

PrefixVector inet::eigrp::EigrpIpv6Pdm::netPrefixes

protected

Referenced by addNetPrefix(), enableInterface(), and processIfaceStateChange().

◆ oldsource

EigrpRouteSource<Ipv6Address>* inet::eigrp::EigrpIpv6Pdm::oldsource = nullptr

protected

Latest route change.

Referenced by processRTRouteDel().

◆ reqQueue

RequestVector inet::eigrp::EigrpIpv6Pdm::reqQueue

protected

Requests for sending EIGRP messages from DUAL.

Referenced by flushMsgRequests(), and pushMsgRouteToQueue().

◆ ribScale

int inet::eigrp::EigrpIpv6Pdm::ribScale

protected

Scaling factor for Wide metric.

Referenced by EigrpIpv6Pdm().

◆ routingForNetworks

EigrpNetworkTable<Ipv6Address>* inet::eigrp::EigrpIpv6Pdm::routingForNetworks

protected

Networks included in EIGRP.

Referenced by addNetwork(), disableInterface(), initialize(), and ~EigrpIpv6Pdm().

◆ rt

ModuleRefByPar<Ipv6RoutingTable> inet::eigrp::EigrpIpv6Pdm::rt

protected

Referenced by findRoute(), initialize(), installRouteToRT(), processIfaceStateChange(), and removeRouteFromRT().

◆ RTP_OUTGW

const char* inet::eigrp::EigrpIpv6Pdm::RTP_OUTGW

protected

Output gateway to the RTP module.

Referenced by EigrpIpv6Pdm(), flushMsgRequests(), processHelloPacket(), processMsgFromNetwork(), processNewNeighbor(), processTimer(), and sendAllEigrpPaths().

◆ sizeOfMsg

const int64_t inet::eigrp::EigrpIpv6Pdm::sizeOfMsg = 20

protected

Referenced by createAckPacket(), createHelloPacket(), createQueryPacket(), createReplyPacket(), and createUpdatePacket().

◆ SPLITTER_OUTGW

const char* inet::eigrp::EigrpIpv6Pdm::SPLITTER_OUTGW

protected

Output gateway to the EIGRP Splitter module.

Referenced by EigrpIpv6Pdm(), and processMsgFromRtp().

◆ useClassicMetric

bool inet::eigrp::EigrpIpv6Pdm::useClassicMetric

protected

Use classic metric computation or wide metric computation.

Referenced by EigrpIpv6Pdm().

◆ variance

int inet::eigrp::EigrpIpv6Pdm::variance

protected

Parameter for unequal cost load balancing.

Referenced by EigrpIpv6Pdm(), and initialize().

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

Classes

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Additional Inherited Members

Member Typedef Documentation

◆ PrefixVector

◆ RequestVector

◆ RouteVector

Constructor & Destructor Documentation

◆ EigrpIpv6Pdm()

◆ ~EigrpIpv6Pdm()

Member Function Documentation

◆ addInterface() [1/2]

◆ addInterface() [2/2]

◆ addInterfaceToEigrp()

◆ addMessageHeader()

◆ addNetPrefix()

◆ addNetwork()

◆ addRoutesToMsg()

◆ applySplitHorizon()

◆ applyStubToQuery()

◆ applyStubToUpdate()

◆ cancelHelloTimers()

◆ cancelHoldTimer()

◆ checkNeighborshipRules()

◆ createAckPacket()

◆ createHelloPacket()

◆ createMsgReq()

◆ createNeighbor()

◆ createQueryPacket()

◆ createReplyPacket()

◆ createRouteTlv()

◆ createRTRoute()

◆ createTimer()

◆ createUpdatePacket()

◆ disableInterface()

◆ enableInterface()

◆ findRoute() [1/2]

◆ findRoute() [2/2]

◆ findRouteDMin()

◆ flushMsgRequests()

◆ getASNum()

◆ getBestSuccessor()

◆ getDestIpAddress()

◆ getInterfaceById()

◆ getNextHopAddr()

◆ handleMessage()

◆ hasFeasibleSuccessor()

◆ hasNeighborForUpdate()

◆ initialize()

◆ installRouteToRT()

◆ isRTSafeForAdd()

◆ msgToAllIfaces()

◆ msgToIface()

◆ numInitStages()

◆ preDelete()

◆ printRecvMsg()

◆ printSentMsg()

◆ processAckPacket()

◆ processHelloPacket()

◆ processIfaceConfigChange()

◆ processIfaceStateChange()

◆ processInterRoute()

◆ processMsgFromNetwork()

◆ processMsgFromRtp()

◆ processNewNeighbor()

◆ processQueryPacket()

◆ processReplyPacket()

◆ processRTRouteDel()

◆ processTimer()

◆ processUpdatePacket()

◆ pushMsgRouteToQueue()

◆ receiveSignal()

◆ removeNeighbor()

◆ removeOldSuccessor()

◆ removeRouteFromRT()

◆ resetTimer()

◆ sendAllEigrpPaths()