All OSPF classes are in this namespace. More...

#include <Ospfv2Router.h>

Public Member Functions
	Router (cSimpleModule containingModule, IInterfaceTable ift, IIpv4RoutingTable *rt)
	Constructor. More...

virtual	~Router ()
	Destructor. More...

void	setRouterID (RouterId id)

RouterId	getRouterID () const

void	setRFC1583Compatibility (bool compatibility)

bool	getRFC1583Compatibility () const

unsigned long	getAreaCount () const

std::vector< AreaId >	getAreaIds ()

MessageHandler *	getMessageHandler ()

unsigned long	getASExternalLSACount () const

AsExternalLsa *	getASExternalLSA (unsigned long i)

const AsExternalLsa *	getASExternalLSA (unsigned long i) const

bool	getASBoundaryRouter () const

unsigned long	getRoutingTableEntryCount () const

Ospfv2RoutingTableEntry *	getRoutingTableEntry (unsigned long i)

const Ospfv2RoutingTableEntry *	getRoutingTableEntry (unsigned long i) const

void	addRoutingTableEntry (Ospfv2RoutingTableEntry *entry)

void	addWatches ()
	Adds OMNeT++ watches for the routerID, the list of Areas and the list of AS External LSAs. More...

void	addArea (Ospfv2Area *area)
	Adds a new Area to the Area list. More...

Ospfv2Area *	getAreaByID (AreaId areaID)
	Returns the pointer to the Area identified by the input areaID, if it's on the Area list, nullptr otherwise. More...

Ospfv2Area *	getAreaByAddr (Ipv4Address address)
	Returns the Area pointer from the Area list which contains the input Ipv4 address, nullptr if there's no such area connected to the Router. More...

Ospfv2Interface *	getNonVirtualInterface (unsigned char ifIndex)
	Returns the pointer of the physical Interface identified by the input interface index, nullptr if the Router doesn't have such an interface. More...

bool	installLSA (const Ospfv2Lsa *lsa, AreaId areaID=BACKBONE_AREAID)
	Installs a new LSA into the Router database. More...

Ospfv2Lsa *	findLSA (Ospfv2LsaType lsaType, LsaKeyType lsaKey, AreaId areaID)
	Find the LSA identified by the input lsaKey in the database. More...

void	ageDatabase ()
	Ages the LSAs in the Router's database. More...

bool	hasAnyNeighborInStates (int states) const
	Returns true if any Neighbor on any Interface in any of the Router's Areas is in any of the input states, false otherwise. More...

void	removeFromAllRetransmissionLists (LsaKeyType lsaKey)
	Removes all LSAs from all Neighbor's retransmission lists which are identified by the input lsaKey. More...

bool	isOnAnyRetransmissionList (LsaKeyType lsaKey) const
	Returns true if there's at least one LSA on any Neighbor's retransmission list identified by the input lsaKey, false otherwise. More...

bool	floodLSA (const Ospfv2Lsa lsa, AreaId areaID=BACKBONE_AREAID, Ospfv2Interface intf=nullptr, Neighbor *neighbor=nullptr)
	Floods out the input lsa on a set of Interfaces. More...

bool	isLocalAddress (Ipv4Address address) const
	Returns true if the input Ipv4 address falls into any of the Router's Areas' configured Ipv4 address ranges, false otherwise. More...

bool	hasAddressRange (const Ipv4AddressRange &addressRange) const
	Returns true if one of the Router's Areas the same Ipv4 address range configured as the input Ipv4 address range, false otherwise. More...

bool	isDestinationUnreachable (Ospfv2Lsa *lsa) const
	Returns true if the destination described by the input lsa is in the routing table, false otherwise. More...

Ospfv2RoutingTableEntry *	lookup (Ipv4Address destination, std::vector< Ospfv2RoutingTableEntry * > *table=nullptr) const
	Do a lookup in either the input OSPF routing table, or if it's nullptr then in the Router's own routing table. More...

void	rebuildRoutingTable ()
	Rebuilds the routing table from scratch(based on the LSA database). More...

bool	deleteRoute (Ospfv2RoutingTableEntry *entry)

Ipv4AddressRange	getContainingAddressRange (const Ipv4AddressRange &addressRange, bool *advertise=nullptr) const
	Scans through the router's areas' preconfigured address ranges and returns the one containing the input addressRange. More...

Ipv4Route *	getDefaultRoute ()
	get the default route in the routing table. More...

void	updateExternalRoute (Ipv4Address networkAddress, const Ospfv2AsExternalLsaContents &externalRouteContents, int ifIndex=-1)
	Stores information on an AS External Route in externalRoutes and intalls(or updates) a new AsExternalLsa into the database. More...

void	addExternalRouteInIPTable (Ipv4Address networkAddress, const Ospfv2AsExternalLsaContents &externalRouteContents, int ifIndex)
	Add an AS External Route in IPRoutingTable. More...

void	removeExternalRoute (Ipv4Address networkAddress)
	Removes an AS External Route from the database. More...

Ospfv2RoutingTableEntry *	getPreferredEntry (const Ospfv2Lsa &lsa, bool skipSelfOriginated, std::vector< Ospfv2RoutingTableEntry * > *fromRoutingTable=nullptr)
	Selects the preferred routing table entry for the input LSA(which is either an AsExternalLsa or a SummaryLsa) according to the algorithm defined in RFC2328 Section 16.4. More...

Private Member Functions
bool	installASExternalLSA (const Ospfv2AsExternalLsa *lsa)
	Installs a new AS External LSA into the Router's database. More...

AsExternalLsa *	findASExternalLSA (LsaKeyType lsaKey)
	Find the AS External LSA identified by the input lsaKey in the database. More...

const AsExternalLsa *	findASExternalLSA (LsaKeyType lsaKey) const
	Find the AS External LSA identified by the input lsaKey in the database. More...

AsExternalLsa *	originateASExternalLSA (AsExternalLsa *lsa)
	Originates a new AS External LSA based on the input lsa. More...

LinkStateId	getUniqueLinkStateID (const Ipv4AddressRange &destination, Metric destinationCost, AsExternalLsa *&lsaToReoriginate, bool externalMetricIsType2=false) const
	Generates a unique LinkStateId for a given destination. More...

void	calculateASExternalRoutes (std::vector< Ospfv2RoutingTableEntry * > &newRoutingTable)
	Calculate the AS External Routes from the ASExternalLSAs in the database. More...

void	notifyAboutRoutingTableChanges (std::vector< Ospfv2RoutingTableEntry * > &oldRoutingTable)
	After a routing table rebuild the changes in the routing table are identified and new SummaryLSAs are originated or old ones are flooded out in each area as necessary. More...

bool	hasRouteToASBoundaryRouter (const std::vector< Ospfv2RoutingTableEntry * > &inRoutingTable, RouterId routerID) const
	Returns true if there is a route to the AS Boundary Router identified by asbrRouterID in the input inRoutingTable, false otherwise. More...

std::vector< Ospfv2RoutingTableEntry * >	getRoutesToASBoundaryRouter (const std::vector< Ospfv2RoutingTableEntry * > &fromRoutingTable, RouterId routerID) const
	Returns an std::vector of routes leading to the AS Boundary Router identified by asbrRouterID from the input fromRoutingTable. More...

void	pruneASBoundaryRouterEntries (std::vector< Ospfv2RoutingTableEntry * > &asbrEntries) const
	Prunes the input std::vector of RoutingTableEntries according to the RFC2328 Section 16.4.1. More...

Ospfv2RoutingTableEntry *	selectLeastCostRoutingEntry (std::vector< Ospfv2RoutingTableEntry * > &entries) const
	Selects the least cost RoutingTableEntry from the input std::vector of RoutingTableEntries. More...

void	printAsExternalLsa ()

bool	isDirectRoute (Ospfv2RoutingTableEntry &entry)

Private Attributes
IInterfaceTable *	ift = nullptr

IIpv4RoutingTable *	rt = nullptr

RouterId	routerID
	The router ID assigned by the IP layer. More...

std::map< AreaId, Ospfv2Area * >	areasByID
	A map of the contained areas with the AreaId as key. More...

std::vector< Ospfv2Area * >	areas
	A list of the contained areas. More...

std::map< LsaKeyType, AsExternalLsa *, LsaKeyType_Less >	asExternalLSAsByID
	A map of the ASExternalLSAs advertised by this router. More...

std::vector< AsExternalLsa * >	asExternalLSAs
	A list of the ASExternalLSAs advertised by this router. More...

std::map< Ipv4Address, Ospfv2AsExternalLsaContents >	externalRoutes
	A map of the external route advertised by this router. More...

cMessage *	ageTimer
	Database age timer - fires every second. More...

std::vector< Ospfv2RoutingTableEntry * >	ospfRoutingTable
	The OSPF routing table - contains more information than the one in the IP layer. More...

MessageHandler *	messageHandler
	The message dispatcher class. More...

bool	rfc1583Compatibility
	Decides whether to handle the preferred routing table entry to an AS boundary router as defined in RFC1583 or not. More...

Detailed Description

All OSPF classes are in this namespace.

Represents the full OSPF data structure as laid out in RFC2328.

Constructor & Destructor Documentation

◆ Router()

inet::ospfv2::Router::Router	(	cSimpleModule *	containingModule,
		IInterfaceTable *	ift,
		IIpv4RoutingTable *	rt
	)

Constructor.

Initializes internal variables, adds a MessageHandler and starts the Database Age timer.

                                                                                            :
     ift(ift),
     rt(rt),
     routerID(rt->getRouterId()),
     rfc1583Compatibility(false)
 {
     messageHandler = new MessageHandler(this, containingModule);
     ageTimer = new cMessage("Router::DatabaseAgeTimer", DATABASE_AGE_TIMER);
     ageTimer->setContextPointer(this);
     messageHandler->startTimer(ageTimer, 1.0);
 }

◆ ~Router()

inet::ospfv2::Router::~Router ( )

virtual

Destructor.

Clears all LSA lists and kills the Database Age timer.

 {
     long areaCount = areas.size();
     for (long i = 0; i < areaCount; i++) {
         delete areas[i];
     }
     long lsaCount = asExternalLSAs.size();
     for (long j = 0; j < lsaCount; j++) {
         delete asExternalLSAs[j];
     }
     long routeCount = ospfRoutingTable.size();
     for (long k = 0; k < routeCount; k++) {
         delete ospfRoutingTable[k];
     }
     messageHandler->clearTimer(ageTimer);
     delete ageTimer;
     delete messageHandler;
 }

Member Function Documentation

◆ addArea()

void inet::ospfv2::Router::addArea ( Ospfv2Area * area )

Adds a new Area to the Area list.

Parameters

area	[in] The Area to add.

 {
     area->setRouter(this);
     areasByID[area->getAreaID()] = area;
     areas.push_back(area);
 }

Referenced by inet::ospfv2::Ospfv2ConfigReader::loadAreaFromXML().

◆ addExternalRouteInIPTable()

void inet::ospfv2::Router::addExternalRouteInIPTable	(	Ipv4Address	networkAddress,
		const Ospfv2AsExternalLsaContents &	externalRouteContents,
		int	ifIndex
	)

Add an AS External Route in IPRoutingTable.

Parameters

networkAddress	[in] The external route's network address.
externalRouteContents	[in] Route configuration data for the external route.
ifIndex	[in]

 {
     // add the external route to the Ipv4 routing table if it was not added by another module
     bool inRoutingTable = false;
     for (int32_t i = 1; i < rt->getNumRoutes(); i++) {
         const Ipv4Route *entry = rt->getRoute(i);
         if ((entry->getDestination() == networkAddress)
             && (entry->getNetmask() == externalRouteContents.getNetworkMask())) // TODO is it enough?
         {
             inRoutingTable = true;
             break;
         }
     }
  
     if (!inRoutingTable) {
         Ipv4Route *entry = new Ipv4Route();
         entry->setDestination(networkAddress);
         entry->setNetmask(externalRouteContents.getNetworkMask());
         entry->setInterface(ift->getInterfaceById(ifIndex));
         entry->setSourceType(IRoute::OSPF);
         entry->setMetric(OSPFv2_BGP_DEFAULT_COST);
         rt->addRoute(entry);
     }
 }

◆ addRoutingTableEntry()

void inet::ospfv2::Router::addRoutingTableEntry ( Ospfv2RoutingTableEntry * entry )

inline

76 { ospfRoutingTable.push_back(entry); }

◆ addWatches()

void inet::ospfv2::Router::addWatches ( )

Adds OMNeT++ watches for the routerID, the list of Areas and the list of AS External LSAs.

 {
     WATCH(routerID);
     WATCH_PTRVECTOR(areas);
     WATCH_PTRVECTOR(asExternalLSAs);
     WATCH_PTRVECTOR(ospfRoutingTable);
 }

Referenced by inet::ospfv2::Ospfv2::createOspfRouter().

◆ ageDatabase()

void inet::ospfv2::Router::ageDatabase ( )

Ages the LSAs in the Router's database.

This method is called on every firing of the DATABASE_AGE_TIMER(every second).

See also: RFC2328 Section 14.

 {
     long lsaCount = asExternalLSAs.size();
     bool shouldRebuildRoutingTable = false;
  
     for (long i = 0; i < lsaCount; i++) {
         unsigned short lsAge = asExternalLSAs[i]->getHeader().getLsAge();
         bool selfOriginated = (asExternalLSAs[i]->getHeader().getAdvertisingRouter() == routerID);
         bool unreachable = isDestinationUnreachable(asExternalLSAs[i]);
         AsExternalLsa *lsa = asExternalLSAs[i];
  
         if ((selfOriginated && (lsAge < (LS_REFRESH_TIME - 1))) || (!selfOriginated && (lsAge < (MAX_AGE - 1)))) {
             lsa->getHeaderForUpdate().setLsAge(lsAge + 1);
             if ((lsAge + 1) % CHECK_AGE == 0) {
                 if (!lsa->validateLSChecksum()) {
                     EV_ERROR << "Invalid LS checksum. Memory error detected!\n";
                 }
             }
             lsa->incrementInstallTime();
         }
         if (selfOriginated && (lsAge == (LS_REFRESH_TIME - 1))) {
             if (unreachable) {
                 lsa->getHeaderForUpdate().setLsAge(MAX_AGE);
                 floodLSA(lsa, BACKBONE_AREAID);
                 lsa->incrementInstallTime();
             }
             else {
                 long sequenceNumber = lsa->getHeader().getLsSequenceNumber();
                 if (sequenceNumber == MAX_SEQUENCE_NUMBER) {
                     lsa->getHeaderForUpdate().setLsAge(MAX_AGE);
                     floodLSA(lsa, BACKBONE_AREAID);
                     lsa->incrementInstallTime();
                 }
                 else {
                     AsExternalLsa *newLSA = originateASExternalLSA(lsa);
  
                     newLSA->getHeaderForUpdate().setLsSequenceNumber(sequenceNumber + 1);
                     shouldRebuildRoutingTable |= lsa->update(newLSA);
                     delete newLSA;
  
                     floodLSA(lsa, BACKBONE_AREAID);
                 }
             }
         }
         if (!selfOriginated && (lsAge == MAX_AGE - 1)) {
             lsa->getHeaderForUpdate().setLsAge(MAX_AGE);
             floodLSA(lsa, BACKBONE_AREAID);
             lsa->incrementInstallTime();
         }
         if (lsAge == MAX_AGE) {
             LsaKeyType lsaKey;
  
             lsaKey.linkStateID = lsa->getHeader().getLinkStateID();
             lsaKey.advertisingRouter = lsa->getHeader().getAdvertisingRouter();
  
             if (!isOnAnyRetransmissionList(lsaKey) &&
                 !hasAnyNeighborInStates(Neighbor::EXCHANGE_STATE | Neighbor::LOADING_STATE))
             {
                 if (!selfOriginated || unreachable) {
                     asExternalLSAsByID.erase(lsaKey);
                     delete lsa;
                     asExternalLSAs[i] = nullptr;
                     shouldRebuildRoutingTable = true;
                 }
                 else {
                     if (lsa->getPurgeable()) {
                         asExternalLSAsByID.erase(lsaKey);
                         delete lsa;
                         asExternalLSAs[i] = nullptr;
                         shouldRebuildRoutingTable = true;
                     }
                     else {
                         AsExternalLsa *newLSA = originateASExternalLSA(lsa);
                         long sequenceNumber = lsa->getHeader().getLsSequenceNumber();
  
                         newLSA->getHeaderForUpdate().setLsSequenceNumber((sequenceNumber == MAX_SEQUENCE_NUMBER) ? INITIAL_SEQUENCE_NUMBER : sequenceNumber + 1);
                         shouldRebuildRoutingTable |= lsa->update(newLSA);
                         delete newLSA;
  
                         floodLSA(lsa, BACKBONE_AREAID);
                     }
                 }
             }
         }
     }
  
     auto it = asExternalLSAs.begin();
     while (it != asExternalLSAs.end()) {
         if ((*it) == nullptr) {
             it = asExternalLSAs.erase(it);
         }
         else {
             it++;
         }
     }
  
     for (uint32_t j = 0; j < areas.size(); j++)
         areas[j]->ageDatabase();
  
     messageHandler->startTimer(ageTimer, 1.0);
  
     if (shouldRebuildRoutingTable) {
         rebuildRoutingTable();
     }
 }

Referenced by inet::ospfv2::MessageHandler::handleTimer().

◆ calculateASExternalRoutes()

void inet::ospfv2::Router::calculateASExternalRoutes ( std::vector< Ospfv2RoutingTableEntry * > & newRoutingTable )

private

Calculate the AS External Routes from the ASExternalLSAs in the database.

Parameters

newRoutingTable [in/out] Push the new RoutingTableEntries into this routing table, and also use this for path calculations.

See also: RFC2328 Section 16.4.

 {
     // see RFC 2328 16.4.
  
     printAsExternalLsa();
  
     for (uint32_t i = 0; i < asExternalLSAs.size(); i++) {
         AsExternalLsa *currentLSA = asExternalLSAs[i];
         const Ospfv2LsaHeader& currentHeader = currentLSA->getHeader();
         unsigned short externalCost = currentLSA->getContents().getExternalTOSInfo(0).routeCost;
         RouterId originatingRouter = currentHeader.getAdvertisingRouter();
  
         Ospfv2RoutingTableEntry *preferredEntry = getPreferredEntry(*currentLSA, true, &newRoutingTable);
         if (!preferredEntry)
             continue;
  
         Ipv4Address destination = currentHeader.getLinkStateID() & currentLSA->getContents().getNetworkMask();
  
         Metric preferredCost = preferredEntry->getCost();
         Ospfv2RoutingTableEntry *destinationEntry = lookup(destination, &newRoutingTable); // (5)
         if (destinationEntry == nullptr) {
             bool type2ExternalMetric = currentLSA->getContents().getExternalTOSInfo(0).E_ExternalMetricType;
             Ospfv2RoutingTableEntry *newEntry = new Ospfv2RoutingTableEntry(ift);
  
             newEntry->setDestination(destination);
             newEntry->setNetmask(currentLSA->getContents().getNetworkMask());
             newEntry->setArea(preferredEntry->getArea());
             newEntry->setPathType(type2ExternalMetric ? Ospfv2RoutingTableEntry::TYPE2_EXTERNAL : Ospfv2RoutingTableEntry::TYPE1_EXTERNAL);
             if (type2ExternalMetric) {
                 newEntry->setCost(preferredCost);
                 newEntry->setType2Cost(externalCost);
             }
             else {
                 newEntry->setCost(preferredCost + externalCost);
             }
             newEntry->setDestinationType(Ospfv2RoutingTableEntry::NETWORK_DESTINATION);
             newEntry->setOptionalCapabilities(currentHeader.getLsOptions());
             newEntry->setLinkStateOrigin(currentLSA);
  
             for (unsigned int j = 0; j < preferredEntry->getNextHopCount(); j++) {
                 NextHop nextHop = preferredEntry->getNextHop(j);
                 if (!nextHop.hopAddress.isUnspecified()) {
                     nextHop.advertisingRouter = originatingRouter;
                     newEntry->addNextHop(nextHop);
                 }
             }
  
             newRoutingTable.push_back(newEntry);
         }
         else {
             Ospfv2RoutingTableEntry::RoutingPathType destinationPathType = destinationEntry->getPathType();
             bool type2ExternalMetric = currentLSA->getContents().getExternalTOSInfo(0).E_ExternalMetricType;
             unsigned int nextHopCount = preferredEntry->getNextHopCount();
  
             if ((destinationPathType == Ospfv2RoutingTableEntry::INTRAAREA) ||
                 (destinationPathType == Ospfv2RoutingTableEntry::INTERAREA)) // (6) (a)
             {
                 continue;
             }
  
             if (((destinationPathType == Ospfv2RoutingTableEntry::TYPE1_EXTERNAL) &&
                  (type2ExternalMetric)) ||
                 ((destinationPathType == Ospfv2RoutingTableEntry::TYPE2_EXTERNAL) &&
                  (type2ExternalMetric) &&
                  (destinationEntry->getType2Cost() < externalCost))) // (6) (b)
             {
                 continue;
             }
  
             Ospfv2RoutingTableEntry *destinationPreferredEntry = getPreferredEntry(*(destinationEntry->getLinkStateOrigin()), false, &newRoutingTable);
             if ((!rfc1583Compatibility) &&
                 (destinationPreferredEntry->getPathType() == Ospfv2RoutingTableEntry::INTRAAREA) &&
                 (destinationPreferredEntry->getArea() != BACKBONE_AREAID) &&
                 ((preferredEntry->getPathType() != Ospfv2RoutingTableEntry::INTRAAREA) ||
                  (preferredEntry->getArea() == BACKBONE_AREAID)))
             {
                 continue;
             }
  
             if ((((destinationPathType == Ospfv2RoutingTableEntry::TYPE1_EXTERNAL) &&
                   (!type2ExternalMetric) &&
                   (destinationEntry->getCost() < preferredCost + externalCost))) ||
                 ((destinationPathType == Ospfv2RoutingTableEntry::TYPE2_EXTERNAL) &&
                  (type2ExternalMetric) &&
                  (destinationEntry->getType2Cost() == externalCost) &&
                  (destinationPreferredEntry->getCost() < preferredCost)))
             {
                 continue;
             }
  
             if (((destinationPathType == Ospfv2RoutingTableEntry::TYPE1_EXTERNAL) &&
                  (!type2ExternalMetric) &&
                  (destinationEntry->getCost() == (preferredCost + externalCost))) ||
                 ((destinationPathType == Ospfv2RoutingTableEntry::TYPE2_EXTERNAL) &&
                  (type2ExternalMetric) &&
                  (destinationEntry->getType2Cost() == externalCost) &&
                  (destinationPreferredEntry->getCost() == preferredCost))) // equal cost
             {
                 for (unsigned int j = 0; j < nextHopCount; j++) {
                     // TODO merge next hops, not add
                     NextHop nextHop = preferredEntry->getNextHop(j);
                     if (!nextHop.hopAddress.isUnspecified()) {
                         nextHop.advertisingRouter = originatingRouter;
                         destinationEntry->addNextHop(nextHop);
                     }
                 }
                 continue;
             }
  
             // LSA is better
             destinationEntry->setArea(preferredEntry->getArea());
             destinationEntry->setPathType(type2ExternalMetric ? Ospfv2RoutingTableEntry::TYPE2_EXTERNAL : Ospfv2RoutingTableEntry::TYPE1_EXTERNAL);
             if (type2ExternalMetric) {
                 destinationEntry->setCost(preferredCost);
                 destinationEntry->setType2Cost(externalCost);
             }
             else {
                 destinationEntry->setCost(preferredCost + externalCost);
             }
             destinationEntry->setDestinationType(Ospfv2RoutingTableEntry::NETWORK_DESTINATION);
             destinationEntry->setOptionalCapabilities(currentHeader.getLsOptions());
             destinationEntry->clearNextHops();
  
             for (unsigned int j = 0; j < nextHopCount; j++) {
                 NextHop nextHop = preferredEntry->getNextHop(j);
                 if (!nextHop.hopAddress.isUnspecified()) {
                     nextHop.advertisingRouter = originatingRouter;
                     destinationEntry->addNextHop(nextHop);
                 }
             }
         }
     }
 }

Referenced by rebuildRoutingTable().

◆ deleteRoute()

bool inet::ospfv2::Router::deleteRoute ( Ospfv2RoutingTableEntry * entry )

 {
     auto i = find(ospfRoutingTable, entry);
     if (i != ospfRoutingTable.end()) {
         delete *i;
         ospfRoutingTable.erase(i);
         return true;
     }
     return false;
 }

Referenced by inet::ospfv2::Ospfv2::handleInterfaceDown().

◆ findASExternalLSA() [1/2]

AsExternalLsa * inet::ospfv2::Router::findASExternalLSA ( LsaKeyType lsaKey )

private

Find the AS External LSA identified by the input lsaKey in the database.

Parameters

lsaKey [in] Look for the AS External LSA which is identified by this key.

Returns: The pointer to the AS External LSA if it was found, nullptr otherwise.

 {
     auto lsaIt = asExternalLSAsByID.find(lsaKey);
     return (lsaIt != asExternalLSAsByID.end()) ? lsaIt->second : nullptr;
 }

Referenced by findLSA(), and getUniqueLinkStateID().

◆ findASExternalLSA() [2/2]

const AsExternalLsa * inet::ospfv2::Router::findASExternalLSA ( LsaKeyType lsaKey ) const

private

Find the AS External LSA identified by the input lsaKey in the database.

Parameters

lsaKey [in] Look for the AS External LSA which is identified by this key.

Returns: The const pointer to the AS External LSA if it was found, nullptr otherwise.

 {
     auto lsaIt = asExternalLSAsByID.find(lsaKey);
     return (lsaIt != asExternalLSAsByID.end()) ? lsaIt->second : nullptr;
 }

◆ findLSA()

Ospfv2Lsa * inet::ospfv2::Router::findLSA	(	Ospfv2LsaType	lsaType,
		LsaKeyType	lsaKey,
		AreaId	areaID
	)

Find the LSA identified by the input lsaKey in the database.

Parameters

lsaType	[in] Look for an LSA of this type.
lsaKey	[in] Look for the LSA which is identified by this key.
areaID	[in] In case of Router, Network and Summary LSAs, look in the Area's database identified by this parameter.

Returns: The pointer to the LSA if it was found, nullptr otherwise.

 {
     switch (lsaType) {
         case ROUTERLSA_TYPE: {
             auto areaIt = areasByID.find(areaID);
             if (areaIt != areasByID.end()) {
                 return areaIt->second->findRouterLSA(lsaKey.linkStateID);
             }
         }
         break;
  
         case NETWORKLSA_TYPE: {
             auto areaIt = areasByID.find(areaID);
             if (areaIt != areasByID.end()) {
                 return areaIt->second->findNetworkLSA(lsaKey.linkStateID);
             }
         }
         break;
  
         case SUMMARYLSA_NETWORKS_TYPE:
         case SUMMARYLSA_ASBOUNDARYROUTERS_TYPE: {
             auto areaIt = areasByID.find(areaID);
             if (areaIt != areasByID.end()) {
                 return areaIt->second->findSummaryLSA(lsaKey);
             }
         }
         break;
  
         case AS_EXTERNAL_LSA_TYPE: {
             return findASExternalLSA(lsaKey);
         }
         break;
  
         default:
             ASSERT(false);
             break;
     }
     return nullptr;
 }

Referenced by inet::ospfv2::DatabaseDescriptionHandler::processDDPacket(), inet::ospfv2::LinkStateRequestHandler::processPacket(), and inet::ospfv2::LinkStateUpdateHandler::processPacket().

◆ floodLSA()

bool inet::ospfv2::Router::floodLSA	(	const Ospfv2Lsa *	lsa,
		AreaId	areaID = `BACKBONE_AREAID`,
		Ospfv2Interface *	intf = `nullptr`,
		Neighbor *	neighbor = `nullptr`
	)

Floods out the input lsa on a set of Interfaces.

See also: RFC2328 Section 13.3.

Parameters

lsa	[in] The LSA to be flooded out.
areaID	[in] If the lsa is a Router, Network or Summary LSA, then flood it only in this Area.
intf	[in] The Interface this LSA arrived on.
neighbor	[in] The Nieghbor this LSA arrived from.

Returns: True if the LSA was floooded back out on the receiving Interface, false otherwise.

 {
     bool floodedBackOut = false;
  
     if (lsa != nullptr) {
         if (lsa->getHeader().getLsType() == AS_EXTERNAL_LSA_TYPE) {
             for (uint32_t i = 0; i < areas.size(); i++) {
                 if (areas[i]->getExternalRoutingCapability()) {
                     if (areas[i]->floodLSA(lsa, intf, neighbor)) {
                         floodedBackOut = true;
                     }
                 }
                 /* RFC 2328, Section 3.6: In order to take advantage of the OSPF stub area support,
                     default routing must be used in the stub area.  This is
                     accomplished as follows.  One or more of the stub area's area
                     border routers must advertise a default route into the stub area
                     via summary-LSAs.  These summary defaults are flooded throughout
                     the stub area, but no further.
                  */
                 else {
                     SummaryLsa *summaryLsa = areas[i]->originateSummaryLSA_Stub();
                     if (areas[i]->floodLSA(summaryLsa, intf, neighbor)) {
                         floodedBackOut = true;
                     }
                 }
             }
         }
         else {
             auto areaIt = areasByID.find(areaID);
             if (areaIt != areasByID.end()) {
                 floodedBackOut = areaIt->second->floodLSA(lsa, intf, neighbor);
             }
         }
     }
  
     return floodedBackOut;
 }

Referenced by ageDatabase(), installASExternalLSA(), notifyAboutRoutingTableChanges(), inet::ospfv2::LinkStateUpdateHandler::processPacket(), removeExternalRoute(), and updateExternalRoute().

◆ getAreaByAddr()

Ospfv2Area * inet::ospfv2::Router::getAreaByAddr ( Ipv4Address address )

Returns the Area pointer from the Area list which contains the input Ipv4 address, nullptr if there's no such area connected to the Router.

Parameters

address [in] The Ipv4 address whose containing Area we're looking for.

 {
     long areaCount = areas.size();
  
     for (long i = 0; i < areaCount; i++) {
         if (areas[i]->containsAddress(address))
             return areas[i];
     }
  
     return nullptr;
 }

◆ getAreaByID()

Ospfv2Area * inet::ospfv2::Router::getAreaByID ( AreaId areaID )

Returns the pointer to the Area identified by the input areaID, if it's on the Area list, nullptr otherwise.

Parameters

areaID [in] The Area identifier.

 {
     auto areaIt = areasByID.find(areaID);
     return (areaIt != areasByID.end()) ? areaIt->second : nullptr;
 }

Referenced by inet::ospfv2::Ospfv2Area::calculateShortestPathTree(), inet::ospfv2::Ospfv2::handleInterfaceDown(), inet::ospfv2::Ospfv2ConfigReader::loadHostRoute(), inet::ospfv2::Ospfv2ConfigReader::loadInterfaceParameters(), inet::ospfv2::Ospfv2ConfigReader::loadLoopbackParameters(), inet::ospfv2::Ospfv2ConfigReader::loadVirtualLink(), inet::ospfv2::Ospfv2Area::originateRouterLSA(), inet::ospfv2::LinkStateUpdateHandler::processPacket(), inet::ospfv2::MessageHandler::processPacket(), and rebuildRoutingTable().

◆ getAreaCount()

unsigned long inet::ospfv2::Router::getAreaCount ( ) const

inline

63 { return areas.size(); }

Referenced by inet::ospfv2::Ospfv2Area::originateRouterLSA(), and inet::ospfv2::MessageHandler::processPacket().

◆ getAreaIds()

std::vector< AreaId > inet::ospfv2::Router::getAreaIds ( )

 {
     std::vector<AreaId> areaIds;
     for (auto& entry : areas)
         areaIds.push_back(entry->getAreaID());
     return areaIds;
 }

Referenced by inet::ospfv2::Ospfv2::handleInterfaceDown().

◆ getASBoundaryRouter()

bool inet::ospfv2::Router::getASBoundaryRouter ( ) const

inline

71 { return externalRoutes.size() > 0; }

Referenced by inet::ospfv2::Ospfv2Area::originateRouterLSA().

◆ getASExternalLSA() [1/2]

AsExternalLsa* inet::ospfv2::Router::getASExternalLSA ( unsigned long i )

inline

69 { return asExternalLSAs[i]; }

Referenced by inet::ospfv2::Ospfv2::checkExternalRoute(), and inet::ospfv2::Neighbor::createDatabaseSummary().

◆ getASExternalLSA() [2/2]

const AsExternalLsa* inet::ospfv2::Router::getASExternalLSA ( unsigned long i ) const

inline

70 { return asExternalLSAs[i]; }

◆ getASExternalLSACount()

unsigned long inet::ospfv2::Router::getASExternalLSACount ( ) const

inline

68 { return asExternalLSAs.size(); }

Referenced by inet::ospfv2::Ospfv2::checkExternalRoute(), and inet::ospfv2::Neighbor::createDatabaseSummary().

◆ getContainingAddressRange()

Ipv4AddressRange inet::ospfv2::Router::getContainingAddressRange	(	const Ipv4AddressRange &	addressRange,
		bool *	advertise = `nullptr`
	)		const

Scans through the router's areas' preconfigured address ranges and returns the one containing the input addressRange.

Parameters

addressRange	[in] The address range to look for.
advertise	[out] Whether the advertise flag is set in the returned preconfigured address range.

Returns: The containing preconfigured address range if found, NULL_IPV4ADDRESSRANGE otherwise.

 {
     unsigned long areaCount = areas.size();
     for (unsigned long i = 0; i < areaCount; i++) {
         Ipv4AddressRange containingAddressRange = areas[i]->getContainingAddressRange(addressRange, advertise);
         if (containingAddressRange != NULL_IPV4ADDRESSRANGE) {
             return containingAddressRange;
         }
     }
     if (advertise != nullptr) {
         *advertise = false;
     }
     return NULL_IPV4ADDRESSRANGE;
 }

Referenced by notifyAboutRoutingTableChanges(), and inet::ospfv2::Ospfv2Area::originateSummaryLSA().

◆ getDefaultRoute()

Ipv4Route * inet::ospfv2::Router::getDefaultRoute ( )

get the default route in the routing table.

 {
     for (int32_t i = 0; i < rt->getNumRoutes(); i++) {
         Ipv4Route *entry = rt->getRoute(i);
         if (entry->getDestination().isUnspecified() && entry->getNetmask().isUnspecified())
             return entry;
     }
     return nullptr;
 }

Referenced by inet::ospfv2::Ospfv2ConfigReader::initiateDefaultRouteDistribution().

◆ getMessageHandler()

MessageHandler* inet::ospfv2::Router::getMessageHandler ( )

inline

66 { return messageHandler; }

◆ getNonVirtualInterface()

Ospfv2Interface * inet::ospfv2::Router::getNonVirtualInterface ( unsigned char ifIndex )

Returns the pointer of the physical Interface identified by the input interface index, nullptr if the Router doesn't have such an interface.

Parameters

ifIndex [in] The interface index to look for.

 {
     long areaCount = areas.size();
  
     for (long i = 0; i < areaCount; i++) {
         Ospfv2Interface *intf = areas[i]->getInterface(ifIndex);
         if (intf != nullptr) {
             return intf;
         }
     }
     return nullptr;
 }

Referenced by inet::ospfv2::Ospfv2Area::originateSummaryLSA().

◆ getPreferredEntry()

Ospfv2RoutingTableEntry * inet::ospfv2::Router::getPreferredEntry	(	const Ospfv2Lsa &	lsa,
		bool	skipSelfOriginated,
		std::vector< Ospfv2RoutingTableEntry * > *	fromRoutingTable = `nullptr`
	)

Selects the preferred routing table entry for the input LSA(which is either an AsExternalLsa or a SummaryLsa) according to the algorithm defined in RFC2328 Section 16.4.

points(1) through(3). This method is used when calculating the AS external routes and also when originating an SummaryLsa for an AS Boundary Router.

Parameters

lsa	[in] The LSA describing the destination for which the preferred Routing Entry is sought for.
skipSelfOriginated	[in] Whether to disregard this LSA if it was self-originated.
fromRoutingTable	[in] The Routing Table from which to select the preferred RoutingTableEntry. If it is nullptr then the router's current routing table is used instead.

Returns: The preferred RoutingTableEntry, or nullptr if no such entry exists.

See also: RFC2328 Section 16.4. points(1) through(3); Area::originateSummaryLSA

 {
     // see RFC 2328 16.3. and 16.4.
     if (fromRoutingTable == nullptr)
         fromRoutingTable = &ospfRoutingTable;
  
     const Ospfv2LsaHeader& lsaHeader = lsa.getHeader();
     const Ospfv2AsExternalLsa *asExternalLSA = dynamic_cast<const Ospfv2AsExternalLsa *>(&lsa);
     unsigned long externalCost = (asExternalLSA != nullptr) ? asExternalLSA->getContents().getExternalTOSInfo(0).routeCost : 0;
     unsigned short lsAge = lsaHeader.getLsAge();
     RouterId originatingRouter = lsaHeader.getAdvertisingRouter();
     bool selfOriginated = (originatingRouter == routerID);
     Ipv4Address forwardingAddress; // 0.0.0.0
  
     if (asExternalLSA != nullptr)
         forwardingAddress = asExternalLSA->getContents().getExternalTOSInfo(0).forwardingAddress;
  
     if ((externalCost == LS_INFINITY) || (lsAge == MAX_AGE) || (skipSelfOriginated && selfOriginated)) // (1) and(2)
         return nullptr;
  
     if (!hasRouteToASBoundaryRouter(*fromRoutingTable, originatingRouter)) // (3)
         return nullptr;
  
     if (forwardingAddress.isUnspecified()) { // (3)
         auto asbrEntries = getRoutesToASBoundaryRouter(*fromRoutingTable, originatingRouter);
         if (!rfc1583Compatibility)
             pruneASBoundaryRouterEntries(asbrEntries);
         return selectLeastCostRoutingEntry(asbrEntries);
     }
     else {
         Ospfv2RoutingTableEntry *forwardEntry = lookup(forwardingAddress, fromRoutingTable);
  
         if (forwardEntry == nullptr)
             return nullptr;
  
         if ((forwardEntry->getPathType() != Ospfv2RoutingTableEntry::INTRAAREA) &&
             (forwardEntry->getPathType() != Ospfv2RoutingTableEntry::INTERAREA))
         {
             return nullptr;
         }
  
         // if a direct delivery, update hop address to point to the forward address
         if (isDirectRoute(*forwardEntry)) {
             forwardEntry->clearNextHops();
             NextHop hop = { forwardEntry->getInterface()->getInterfaceId(), forwardingAddress, routerID };
             forwardEntry->addNextHop(hop);
         }
  
         return forwardEntry;
     }
  
     return nullptr;
 }

Referenced by calculateASExternalRoutes(), and inet::ospfv2::Ospfv2Area::originateSummaryLSA().

◆ getRFC1583Compatibility()

bool inet::ospfv2::Router::getRFC1583Compatibility ( ) const

inline

62 { return rfc1583Compatibility; }

◆ getRouterID()

RouterId inet::ospfv2::Router::getRouterID ( ) const

inline

60 { return routerID; }

◆ getRoutesToASBoundaryRouter()

std::vector< Ospfv2RoutingTableEntry * > inet::ospfv2::Router::getRoutesToASBoundaryRouter	(	const std::vector< Ospfv2RoutingTableEntry * > &	fromRoutingTable,
		RouterId	routerID
	)		const

private

Returns an std::vector of routes leading to the AS Boundary Router identified by asbrRouterID from the input fromRoutingTable.

If there are no routes leading to the AS Boundary Router, the returned std::vector is empty.

Parameters

fromRoutingTable	[in] The routing table to look in.
asbrRouterID	[in] The ID of the AS Boundary Router to look for.

 {
     std::vector<Ospfv2RoutingTableEntry *> results;
     for (uint32_t i = 0; i < fromRoutingTable.size(); i++) {
         Ospfv2RoutingTableEntry *routingEntry = fromRoutingTable[i];
         if (routingEntry->getDestination() == (asbrRouterID & routingEntry->getNetmask())) {
             if (!routingEntry->getGateway().isUnspecified())
                 results.push_back(routingEntry);
             else {
                 // ASBR is a directly-connected router
                 for (uint32_t i = 0; i < areas.size(); i++) {
                     Ospfv2Interface *ospfIfEntry = areas[i]->getInterface(routingEntry->getInterface()->getInterfaceId());
                     if (ospfIfEntry) {
                         Neighbor *neighbor = ospfIfEntry->getNeighborById(asbrRouterID);
                         if (neighbor) {
                             results.push_back(routingEntry);
                             break;
                         }
                     }
                 }
             }
         }
     }
     return results;
 }

Referenced by getPreferredEntry().

◆ getRoutingTableEntry() [1/2]

Ospfv2RoutingTableEntry* inet::ospfv2::Router::getRoutingTableEntry ( unsigned long i )

inline

74 { return ospfRoutingTable[i]; }

Referenced by inet::ospfv2::Ospfv2::handleInterfaceDown(), and inet::ospfv2::Ospfv2Area::originateSummaryLSA().

◆ getRoutingTableEntry() [2/2]

const Ospfv2RoutingTableEntry* inet::ospfv2::Router::getRoutingTableEntry ( unsigned long i ) const

inline

75 { return ospfRoutingTable[i]; }

◆ getRoutingTableEntryCount()

unsigned long inet::ospfv2::Router::getRoutingTableEntryCount ( ) const

inline

73 { return ospfRoutingTable.size(); }

Referenced by inet::ospfv2::Ospfv2::handleInterfaceDown(), and inet::ospfv2::Ospfv2Area::originateSummaryLSA().

◆ getUniqueLinkStateID()

LinkStateId inet::ospfv2::Router::getUniqueLinkStateID	(	const Ipv4AddressRange &	destination,
		Metric	destinationCost,
		AsExternalLsa *&	lsaToReoriginate,
		bool	externalMetricIsType2 = `false`
	)		const

private

Generates a unique LinkStateId for a given destination.

This may require the reorigination of an LSA already in the database(with a different LinkStateId).

Parameters

destination	[in] The destination for which a unique LinkStateId is required.
destinationCost	[in] The path cost to the destination.
lsaToReoriginate	[out] The LSA to reoriginate(which was already in the database, and had to be changed).
externalMetricIsType2	[in] True if the destinationCost is given as a Type2 external metric.

Returns: the LinkStateId for the destination.

See also: RFC2328 Appendix E.; Area::getUniqueLinkStateID

 {
     if (lsaToReoriginate != nullptr) {
         delete lsaToReoriginate;
         lsaToReoriginate = nullptr;
     }
  
     LsaKeyType lsaKey;
  
     lsaKey.linkStateID = destination.address;
     lsaKey.advertisingRouter = routerID;
  
     const AsExternalLsa *foundLSA = findASExternalLSA(lsaKey);
  
     if (foundLSA == nullptr) {
         return lsaKey.linkStateID;
     }
     else {
         Ipv4Address existingMask = foundLSA->getContents().getNetworkMask();
  
         if (destination.mask >= existingMask) {
             return lsaKey.linkStateID.makeBroadcastAddress(destination.mask);
         }
         else {
             AsExternalLsa *asExternalLSA = new AsExternalLsa(*foundLSA);
  
             long sequenceNumber = asExternalLSA->getHeader().getLsSequenceNumber();
  
             asExternalLSA->getHeaderForUpdate().setLsAge(0);
             asExternalLSA->getHeaderForUpdate().setLsSequenceNumber((sequenceNumber == MAX_SEQUENCE_NUMBER) ? INITIAL_SEQUENCE_NUMBER : sequenceNumber + 1);
             asExternalLSA->getContentsForUpdate().setNetworkMask(destination.mask);
             asExternalLSA->getContentsForUpdate().getExternalTOSInfoForUpdate(0).E_ExternalMetricType = externalMetricIsType2;
             asExternalLSA->getContentsForUpdate().getExternalTOSInfoForUpdate(0).routeCost = destinationCost;
  
             lsaToReoriginate = asExternalLSA;
  
             return lsaKey.linkStateID.makeBroadcastAddress(existingMask);
         }
     }
 }

◆ hasAddressRange()

bool inet::ospfv2::Router::hasAddressRange ( const Ipv4AddressRange & addressRange ) const

Returns true if one of the Router's Areas the same Ipv4 address range configured as the input Ipv4 address range, false otherwise.

Parameters

addressRange [in] The Ipv4 address range to look for.

 {
     long areaCount = areas.size();
     for (long i = 0; i < areaCount; i++) {
         if (areas[i]->hasAddressRange(addressRange)) {
             return true;
         }
     }
     return false;
 }

Referenced by inet::ospfv2::Ospfv2Area::calculateInterAreaRoutes().

◆ hasAnyNeighborInStates()

bool inet::ospfv2::Router::hasAnyNeighborInStates ( int states ) const

Returns true if any Neighbor on any Interface in any of the Router's Areas is in any of the input states, false otherwise.

Parameters

states [in] A bitfield combination of NeighborStateType values.

 {
     for (uint32_t i = 0; i < areas.size(); i++) {
         if (areas[i]->hasAnyNeighborInStates(states))
             return true;
     }
     return false;
 }

Referenced by ageDatabase(), and inet::ospfv2::LinkStateUpdateHandler::processPacket().

◆ hasRouteToASBoundaryRouter()

bool inet::ospfv2::Router::hasRouteToASBoundaryRouter	(	const std::vector< Ospfv2RoutingTableEntry * > &	inRoutingTable,
		RouterId	routerID
	)		const

private

Returns true if there is a route to the AS Boundary Router identified by asbrRouterID in the input inRoutingTable, false otherwise.

Parameters

inRoutingTable	[in] The routing table to look in.
asbrRouterID	[in] The ID of the AS Boundary Router to look for.

 {
     for (uint32_t i = 0; i < inRoutingTable.size(); i++) {
         Ospfv2RoutingTableEntry *routingEntry = inRoutingTable[i];
         if (routingEntry->getDestination() == (asbrRouterID & routingEntry->getNetmask())) {
             if (!routingEntry->getGateway().isUnspecified())
                 return true;
             else {
                 // ASBR is a directly-connected router
                 bool nextHopFound = false;
                 for (uint32_t i = 0; i < areas.size(); i++) {
                     Ospfv2Interface *ospfIfEntry = areas[i]->getInterface(routingEntry->getInterface()->getInterfaceId());
                     if (ospfIfEntry) {
                         Neighbor *neighbor = ospfIfEntry->getNeighborById(asbrRouterID);
                         if (neighbor) {
                             nextHopFound = true;
                             break;
                         }
                     }
                 }
                 return nextHopFound;
             }
         }
     }
     return false;
 }

Referenced by getPreferredEntry().

◆ installASExternalLSA()

bool inet::ospfv2::Router::installASExternalLSA ( const Ospfv2AsExternalLsa * lsa )

private

Installs a new AS External LSA into the Router's database.

It tries to install keep one of multiple functionally equivalent AS External LSAs in the database. (See the comment in the method implementation.)

Parameters

lsa	[in] The LSA to install. It will be copied into the database.

Returns: True if the routing table needs to be updated, false otherwise.

From RFC2328 Section 12.4.4.1.: "If two routers, both reachable from one another, originate functionally equivalent AS-External-LSAs(i.e., same destination, cost and non-zero forwarding address), then the LSA originated by the router having the highest OSPF Router ID is used. The router having the lower OSPF Router ID can then flush its LSA." The problem is: how do we tell whether two routers are reachable from one another based on a Link State Update packet? 0. We can assume that if this LSA reached this router, then this router is reachable from the other router. But what about the other direction?

The update packet is most likely not sent by the router originating the functionally equivalent AS-External-LSA, so we cannot use the IPv4 packet source address.
The AS-External-LSA contains only the Router ID of the advertising router, so we can only look up "router" type routing entries in the routing table(these contain the Router ID as their Destination ID). However these entries are only inserted into the routing table for intra-area routers...

 {
     // TODO how to solve this problem?
  
     RouterId advertisingRouter = lsa->getHeader().getAdvertisingRouter();
  
     bool reachable = false;
     for (uint32_t i = 0; i < ospfRoutingTable.size(); i++) {
         if ((((ospfRoutingTable[i]->getDestinationType() & Ospfv2RoutingTableEntry::AREA_BORDER_ROUTER_DESTINATION) != 0) ||
              ((ospfRoutingTable[i]->getDestinationType() & Ospfv2RoutingTableEntry::AS_BOUNDARY_ROUTER_DESTINATION) != 0)) &&
             (ospfRoutingTable[i]->getDestination() == advertisingRouter))
         {
             reachable = true;
             break;
         }
     }
  
     bool ownLSAFloodedOut = false;
     LsaKeyType lsaKey;
  
     lsaKey.linkStateID = lsa->getHeader().getLinkStateID();
     lsaKey.advertisingRouter = routerID;
  
     auto lsaIt = asExternalLSAsByID.find(lsaKey);
     if ((lsaIt != asExternalLSAsByID.end()) &&
         reachable &&
         (lsaIt->second->getContents().getExternalTOSInfo(0).E_ExternalMetricType == lsa->getContents().getExternalTOSInfo(0).E_ExternalMetricType) &&
         (lsaIt->second->getContents().getExternalTOSInfo(0).tos == lsa->getContents().getExternalTOSInfo(0).tos) &&
         (lsaIt->second->getContents().getExternalTOSInfo(0).routeCost == lsa->getContents().getExternalTOSInfo(0).routeCost) &&
         (lsa->getContents().getExternalTOSInfo(0).forwardingAddress.getInt() != 0) && // forwarding address != 0.0.0.0
         (lsaIt->second->getContents().getExternalTOSInfo(0).forwardingAddress == lsa->getContents().getExternalTOSInfo(0).forwardingAddress))
     {
         if (routerID > advertisingRouter) {
             return false;
         }
         else {
             lsaIt->second->getHeaderForUpdate().setLsAge(MAX_AGE);
             floodLSA(lsaIt->second, BACKBONE_AREAID);
             lsaIt->second->incrementInstallTime();
             ownLSAFloodedOut = true;
         }
     }
  
     lsaKey.advertisingRouter = advertisingRouter;
  
     lsaIt = asExternalLSAsByID.find(lsaKey);
     if (lsaIt != asExternalLSAsByID.end()) {
         unsigned long areaCount = areas.size();
         for (unsigned long i = 0; i < areaCount; i++) {
             areas[i]->removeFromAllRetransmissionLists(lsaKey);
         }
         return (lsaIt->second->update(lsa)) | ownLSAFloodedOut;
     }
     else {
         AsExternalLsa *lsaCopy = new AsExternalLsa(*lsa);
         asExternalLSAsByID[lsaKey] = lsaCopy;
         ASSERT(lsaCopy->getHeader().getLsaLength() != 0);
         asExternalLSAs.push_back(lsaCopy);
         return true;
     }
 }

Referenced by installLSA(), and updateExternalRoute().

◆ installLSA()

bool inet::ospfv2::Router::installLSA	(	const Ospfv2Lsa *	lsa,
		AreaId	areaID = `BACKBONE_AREAID`
	)

Installs a new LSA into the Router database.

Checks the input LSA's type and installs it into either the selected Area's database, or if it's an AS External LSA then into the Router's common asExternalLSAs list.

Parameters

lsa	[in] The LSA to install. It will be copied into the database.
areaID	[in] Identifies the input Router, Network and Summary LSA's Area.

Returns: True if the routing table needs to be updated, false otherwise.

 {
     switch (lsa->getHeader().getLsType()) {
         case ROUTERLSA_TYPE: {
             auto areaIt = areasByID.find(areaID);
             if (areaIt != areasByID.end()) {
                 const Ospfv2RouterLsa *ospfRouterLSA = check_and_cast<const Ospfv2RouterLsa *>(lsa);
                 return areaIt->second->installRouterLSA(ospfRouterLSA);
             }
         }
         break;
  
         case NETWORKLSA_TYPE: {
             auto areaIt = areasByID.find(areaID);
             if (areaIt != areasByID.end()) {
                 const Ospfv2NetworkLsa *ospfNetworkLSA = check_and_cast<const Ospfv2NetworkLsa *>(lsa);
                 return areaIt->second->installNetworkLSA(ospfNetworkLSA);
             }
         }
         break;
  
         case SUMMARYLSA_NETWORKS_TYPE:
         case SUMMARYLSA_ASBOUNDARYROUTERS_TYPE: {
             auto areaIt = areasByID.find(areaID);
             if (areaIt != areasByID.end()) {
                 const Ospfv2SummaryLsa *ospfSummaryLSA = check_and_cast<const Ospfv2SummaryLsa *>(lsa);
                 return areaIt->second->installSummaryLSA(ospfSummaryLSA);
             }
         }
         break;
  
         case AS_EXTERNAL_LSA_TYPE: {
             const Ospfv2AsExternalLsa *ospfASExternalLSA = check_and_cast<const Ospfv2AsExternalLsa *>(lsa);
             ASSERT(ospfASExternalLSA->getHeader().getLsaLength() != 0);
             return installASExternalLSA(ospfASExternalLSA);
         }
         break;
  
         default:
             ASSERT(false);
             break;
     }
     return false;
 }

Referenced by inet::ospfv2::LinkStateUpdateHandler::processPacket().

◆ isDestinationUnreachable()

bool inet::ospfv2::Router::isDestinationUnreachable ( Ospfv2Lsa * lsa ) const

Returns true if the destination described by the input lsa is in the routing table, false otherwise.

Parameters

lsa	[in] The LSA which describes the destination to look for.

 {
     Ipv4Address destination = Ipv4Address(lsa->getHeader().getLinkStateID());
  
     Ospfv2RouterLsa *routerLSA = dynamic_cast<Ospfv2RouterLsa *>(lsa);
     // TODO verify
     if (routerLSA) {
         RoutingInfo *routingInfo = check_and_cast<RoutingInfo *>(routerLSA);
         if (routerLSA->getHeader().getLinkStateID() == routerID) // this is spfTreeRoot
             return false;
  
         // get the interface address pointing backwards on the shortest path tree
         unsigned int linkCount = routerLSA->getLinksArraySize();
         RouterLsa *toRouterLSA = dynamic_cast<RouterLsa *>(routingInfo->getParent());
         if (toRouterLSA) {
             bool destinationFound = false;
             bool unnumberedPointToPointLink = false;
             Ipv4Address firstNumberedIfAddress;
  
             for (unsigned int i = 0; i < linkCount; i++) {
                 const auto& link = routerLSA->getLinks(i);
  
                 if (link.getType() == POINTTOPOINT_LINK) {
                     if (link.getLinkID() == Ipv4Address(toRouterLSA->getHeader().getLinkStateID())) {
                         if ((link.getLinkData() & 0xFF000000) == 0) {
                             unnumberedPointToPointLink = true;
                             if (!firstNumberedIfAddress.isUnspecified())
                                 break;
                         }
                         else {
                             destination = Ipv4Address(link.getLinkData());
                             destinationFound = true;
                             break;
                         }
                     }
                     else {
                         if (((link.getLinkData() & 0xFF000000) != 0) &&
                             firstNumberedIfAddress.isUnspecified())
                         {
                             firstNumberedIfAddress = Ipv4Address(link.getLinkData());
                         }
                     }
                 }
                 else if (link.getType() == TRANSIT_LINK) {
                     if (firstNumberedIfAddress.isUnspecified())
                         firstNumberedIfAddress = Ipv4Address(link.getLinkData());
                 }
                 else if (link.getType() == VIRTUAL_LINK) {
                     if (link.getLinkID() == toRouterLSA->getHeader().getLinkStateID()) {
                         destination = Ipv4Address(link.getLinkData());
                         destinationFound = true;
                         break;
                     }
                     else {
                         if (firstNumberedIfAddress.isUnspecified())
                             firstNumberedIfAddress = Ipv4Address(link.getLinkData());
                     }
                 }
                 // There's no way to get an interface address for the router from a STUB_LINK
             }
  
             if (unnumberedPointToPointLink) {
                 if (!firstNumberedIfAddress.isUnspecified())
                     destination = firstNumberedIfAddress;
                 else
                     return true;
             }
  
             if (!destinationFound)
                 return true;
         }
         else {
             NetworkLsa *toNetworkLSA = dynamic_cast<NetworkLsa *>(routingInfo->getParent());
             if (toNetworkLSA) {
                 // get the interface address pointing backwards on the shortest path tree
                 bool destinationFound = false;
                 for (unsigned int i = 0; i < linkCount; i++) {
                     const auto& link = routerLSA->getLinks(i);
  
                     if ((link.getType() == TRANSIT_LINK) &&
                         (link.getLinkID() == Ipv4Address(toNetworkLSA->getHeader().getLinkStateID())))
                     {
                         destination = Ipv4Address(link.getLinkData());
                         destinationFound = true;
                         break;
                     }
                 }
                 if (!destinationFound)
                     return true;
             }
             else
                 return true;
         }
     }
  
     Ospfv2NetworkLsa *networkLSA = dynamic_cast<Ospfv2NetworkLsa *>(lsa);
     if (networkLSA)
         destination = networkLSA->getHeader().getLinkStateID() & networkLSA->getNetworkMask();
  
     Ospfv2SummaryLsa *summaryLSA = dynamic_cast<Ospfv2SummaryLsa *>(lsa);
     if ((summaryLSA) && (summaryLSA->getHeader().getLsType() == SUMMARYLSA_NETWORKS_TYPE))
         destination = summaryLSA->getHeader().getLinkStateID() & summaryLSA->getNetworkMask();
  
     Ospfv2AsExternalLsa *asExternalLSA = dynamic_cast<Ospfv2AsExternalLsa *>(lsa);
     if (asExternalLSA)
         destination = asExternalLSA->getHeader().getLinkStateID() & asExternalLSA->getContents().getNetworkMask();
  
     return lookup(destination) == nullptr;
 }

Referenced by inet::ospfv2::Ospfv2Area::ageDatabase(), and ageDatabase().

◆ isDirectRoute()

bool inet::ospfv2::Router::isDirectRoute ( Ospfv2RoutingTableEntry & entry )

private

 {
     if (entry.getGateway().isUnspecified())
         return true;
  
     for (int i = 0; i < ift->getNumInterfaces(); i++) {
         NetworkInterface *intf = ift->getInterface(i);
         if (intf && !intf->isLoopback()) {
             const auto& ipv4data = intf->findProtocolData<Ipv4InterfaceData>();
             if (ipv4data) {
                 if ((entry.getDestination() & ipv4data->getNetmask()) == (ipv4data->getIPAddress() & ipv4data->getNetmask()))
                     return true;
             }
         }
     }
  
     return false;
 }

Referenced by getPreferredEntry(), and rebuildRoutingTable().

◆ isLocalAddress()

bool inet::ospfv2::Router::isLocalAddress ( Ipv4Address address ) const

Returns true if the input Ipv4 address falls into any of the Router's Areas' configured Ipv4 address ranges, false otherwise.

Parameters

address [in] The Ipv4 address to look for.

 {
     long areaCount = areas.size();
     for (long i = 0; i < areaCount; i++) {
         if (areas[i]->isLocalAddress(address)) {
             return true;
         }
     }
     return false;
 }

Referenced by inet::ospfv2::LinkStateUpdateHandler::processPacket().

◆ isOnAnyRetransmissionList()

bool inet::ospfv2::Router::isOnAnyRetransmissionList ( LsaKeyType lsaKey ) const

Returns true if there's at least one LSA on any Neighbor's retransmission list identified by the input lsaKey, false otherwise.

Parameters

lsaKey [in] Identifies the LSAs to look for on the retransmission lists.

 {
     for (uint32_t i = 0; i < areas.size(); i++) {
         if (areas[i]->isOnAnyRetransmissionList(lsaKey))
             return true;
     }
     return false;
 }

Referenced by ageDatabase().

◆ lookup()

Ospfv2RoutingTableEntry * inet::ospfv2::Router::lookup	(	Ipv4Address	destination,
		std::vector< Ospfv2RoutingTableEntry * > *	table = `nullptr`
	)		const

Do a lookup in either the input OSPF routing table, or if it's nullptr then in the Router's own routing table.

See also: RFC2328 Section 11.1.

Parameters

destination	[in] The destination to look up in the routing table.
table	[in] The routing table to do the lookup in.

Returns: The RoutingTableEntry describing the input destination if there's one, false otherwise.

 {
     const std::vector<Ospfv2RoutingTableEntry *>& rTable = (table == nullptr) ? ospfRoutingTable : (*table);
     bool unreachable = false;
     std::vector<Ospfv2RoutingTableEntry *> discard;
  
     for (uint32_t i = 0; i < areas.size(); i++) {
         for (uint32_t j = 0; j < areas[i]->getAddressRangeCount(); j++) {
             Ipv4AddressRange range = areas[i]->getAddressRange(j);
             for (auto entry : rTable) {
                 if (entry->getDestinationType() != Ospfv2RoutingTableEntry::NETWORK_DESTINATION)
                     continue;
                 if (range.containsRange(entry->getDestination(), entry->getNetmask()) &&
                     (entry->getPathType() == Ospfv2RoutingTableEntry::INTRAAREA))
                 {
                     // active area address range
                     Ospfv2RoutingTableEntry *discardEntry = new Ospfv2RoutingTableEntry(ift);
                     discardEntry->setDestination(range.address);
                     discardEntry->setNetmask(range.mask);
                     discardEntry->setDestinationType(Ospfv2RoutingTableEntry::NETWORK_DESTINATION);
                     discardEntry->setPathType(Ospfv2RoutingTableEntry::INTERAREA);
                     discardEntry->setArea(areas[i]->getAreaID());
                     discard.push_back(discardEntry);
                     break;
                 }
             }
         }
     }
  
     Ospfv2RoutingTableEntry *bestMatch = nullptr;
     unsigned long longestMatch = 0;
     unsigned long dest = destination.getInt();
  
     for (auto entry : rTable) {
         if (entry->getDestinationType() != Ospfv2RoutingTableEntry::NETWORK_DESTINATION)
             continue;
         unsigned long entryAddress = entry->getDestination().getInt();
         unsigned long entryMask = entry->getNetmask().getInt();
         if ((entryAddress & entryMask) == (dest & entryMask)) {
             if ((dest & entryMask) > longestMatch) {
                 longestMatch = (dest & entryMask);
                 bestMatch = entry;
             }
         }
     }
  
     if (bestMatch == nullptr)
         unreachable = true;
     else {
         for (auto entry : discard) {
             unsigned long entryAddress = entry->getDestination().getInt();
             unsigned long entryMask = entry->getNetmask().getInt();
             if ((entryAddress & entryMask) == (dest & entryMask)) {
                 if ((dest & entryMask) > longestMatch) {
                     unreachable = true;
                     break;
                 }
             }
         }
     }
  
     for (uint32_t i = 0; i < discard.size(); i++)
         delete discard[i];
  
     if (unreachable)
         return nullptr;
     else
         return bestMatch;
 }

Referenced by calculateASExternalRoutes(), getPreferredEntry(), and isDestinationUnreachable().

◆ notifyAboutRoutingTableChanges()

void inet::ospfv2::Router::notifyAboutRoutingTableChanges ( std::vector< Ospfv2RoutingTableEntry * > & oldRoutingTable )

private

After a routing table rebuild the changes in the routing table are identified and new SummaryLSAs are originated or old ones are flooded out in each area as necessary.

Parameters

oldRoutingTable [in] The previous version of the routing table(which is then compared with the one in routingTable).

See also: RFC2328 Section 12.4. points(5) through(6).

 {
     // return if this router is not an ABR
     if (areas.size() <= 1)
         return;
     auto position = std::find_if(areas.begin(), areas.end(),
             [&] (const Ospfv2Area *m) -> bool { return m->getAreaID() == BACKBONE_AREAID; });
     if (position == areas.end())
         return;
  
     typedef std::map<Ipv4AddressRange, Ospfv2RoutingTableEntry *> RoutingTableEntryMap;
     RoutingTableEntryMap oldTableMap;
     RoutingTableEntryMap newTableMap;
  
     for (uint32_t i = 0; i < oldRoutingTable.size(); i++) {
         Ipv4AddressRange destination(oldRoutingTable[i]->getDestination() & oldRoutingTable[i]->getNetmask(), oldRoutingTable[i]->getNetmask());
         oldTableMap[destination] = oldRoutingTable[i];
     }
  
     for (uint32_t i = 0; i < ospfRoutingTable.size(); i++) {
         Ipv4AddressRange destination(ospfRoutingTable[i]->getDestination() & ospfRoutingTable[i]->getNetmask(), ospfRoutingTable[i]->getNetmask());
         newTableMap[destination] = ospfRoutingTable[i];
     }
  
     for (uint32_t i = 0; i < areas.size(); i++) {
         std::map<LsaKeyType, bool, LsaKeyType_Less> originatedLSAMap;
         std::map<LsaKeyType, bool, LsaKeyType_Less> deletedLSAMap;
         LsaKeyType lsaKey;
  
         // iterate over the new routing table and look for new or modified entries
         for (uint32_t j = 0; j < ospfRoutingTable.size(); j++) {
             Ipv4AddressRange destination(ospfRoutingTable[j]->getDestination() & ospfRoutingTable[j]->getNetmask(), ospfRoutingTable[j]->getNetmask());
             auto destIt = oldTableMap.find(destination);
             if (destIt == oldTableMap.end()) { // new routing entry
                 SummaryLsa *lsaToReoriginate = nullptr;
                 SummaryLsa *newLSA = areas[i]->originateSummaryLSA(ospfRoutingTable[j], originatedLSAMap, lsaToReoriginate);
  
                 if (newLSA != nullptr) {
                     if (lsaToReoriginate != nullptr) {
                         areas[i]->installSummaryLSA(lsaToReoriginate);
                         floodLSA(lsaToReoriginate, areas[i]->getAreaID());
  
                         lsaKey.linkStateID = lsaToReoriginate->getHeader().getLinkStateID();
                         lsaKey.advertisingRouter = routerID;
                         originatedLSAMap[lsaKey] = true;
  
                         delete lsaToReoriginate;
                     }
  
                     areas[i]->installSummaryLSA(newLSA);
                     floodLSA(newLSA, areas[i]->getAreaID());
  
                     lsaKey.linkStateID = newLSA->getHeader().getLinkStateID();
                     lsaKey.advertisingRouter = routerID;
                     originatedLSAMap[lsaKey] = true;
  
                     delete newLSA;
                 }
             }
             else {
                 if (*(ospfRoutingTable[j]) != *(destIt->second)) { // modified routing entry
                     SummaryLsa *lsaToReoriginate = nullptr;
                     SummaryLsa *newLSA = areas[i]->originateSummaryLSA(ospfRoutingTable[j], originatedLSAMap, lsaToReoriginate);
  
                     if (newLSA != nullptr) {
                         if (lsaToReoriginate != nullptr) {
                             areas[i]->installSummaryLSA(lsaToReoriginate);
                             floodLSA(lsaToReoriginate, areas[i]->getAreaID());
  
                             lsaKey.linkStateID = lsaToReoriginate->getHeader().getLinkStateID();
                             lsaKey.advertisingRouter = routerID;
                             originatedLSAMap[lsaKey] = true;
  
                             delete lsaToReoriginate;
                         }
  
                         /*
                          * A router uses initial sequence number the first time it originates any LSA.
                          * Afterwards, the LSA's sequence number is incremented each time the router
                          * originates a new instance of the LSA.
                          */
                         int32_t sequenceNumber = newLSA->getHeader().getLsSequenceNumber();
                         if (sequenceNumber != MAX_SEQUENCE_NUMBER)
                             newLSA->getHeaderForUpdate().setLsSequenceNumber(sequenceNumber + 1);
  
                         areas[i]->installSummaryLSA(newLSA);
                         floodLSA(newLSA, areas[i]->getAreaID());
  
                         lsaKey.linkStateID = newLSA->getHeader().getLinkStateID();
                         lsaKey.advertisingRouter = routerID;
                         originatedLSAMap[lsaKey] = true;
  
                         delete newLSA;
                     }
                     else {
                         Ipv4AddressRange destinationAddressRange(ospfRoutingTable[j]->getDestination(), ospfRoutingTable[j]->getNetmask());
  
                         if ((ospfRoutingTable[j]->getDestinationType() == Ospfv2RoutingTableEntry::NETWORK_DESTINATION) &&
                             ((ospfRoutingTable[j]->getPathType() == Ospfv2RoutingTableEntry::INTRAAREA) ||
                              (ospfRoutingTable[j]->getPathType() == Ospfv2RoutingTableEntry::INTERAREA)))
                         {
                             Ipv4AddressRange containingAddressRange = getContainingAddressRange(destinationAddressRange);
                             if (containingAddressRange != NULL_IPV4ADDRESSRANGE) {
                                 destinationAddressRange = containingAddressRange;
                             }
                         }
  
                         Metric maxRangeCost = 0;
                         Metric oneLessCost = 0;
  
                         for (uint32_t k = 0; k < ospfRoutingTable.size(); k++) {
                             if ((ospfRoutingTable[k]->getDestinationType() == Ospfv2RoutingTableEntry::NETWORK_DESTINATION) &&
                                 (ospfRoutingTable[k]->getPathType() == Ospfv2RoutingTableEntry::INTRAAREA) &&
                                 ((ospfRoutingTable[k]->getDestination().getInt() & ospfRoutingTable[k]->getNetmask().getInt() & destinationAddressRange.mask.getInt()) ==
                                  (destinationAddressRange.address & destinationAddressRange.mask).getInt()) &&
                                 (ospfRoutingTable[k]->getCost() > maxRangeCost))
                             {
                                 oneLessCost = maxRangeCost;
                                 maxRangeCost = ospfRoutingTable[k]->getCost();
                             }
                         }
  
                         if (maxRangeCost == ospfRoutingTable[j]->getCost()) { // this entry gives the range's cost
                             lsaKey.linkStateID = destinationAddressRange.address;
                             lsaKey.advertisingRouter = routerID;
  
                             SummaryLsa *summaryLSA = areas[i]->findSummaryLSA(lsaKey);
  
                             if (summaryLSA != nullptr) {
                                 if (oneLessCost != 0) { // there's an other entry in this range
                                     summaryLSA->setRouteCost(oneLessCost);
                                     floodLSA(summaryLSA, areas[i]->getAreaID());
  
                                     originatedLSAMap[lsaKey] = true;
                                 }
                                 else { // no more entries in this range -> delete it
                                     if (!containsKey(deletedLSAMap, lsaKey)) {
                                         summaryLSA->getHeaderForUpdate().setLsAge(MAX_AGE);
                                         floodLSA(summaryLSA, areas[i]->getAreaID());
  
                                         deletedLSAMap[lsaKey] = true;
                                     }
                                 }
                             }
                         }
                     }
                 }
             }
         }
  
         // iterate over the old routing table and look for deleted entries
         for (uint32_t j = 0; j < oldRoutingTable.size(); j++) {
             Ipv4AddressRange destination(oldRoutingTable[j]->getDestination() & oldRoutingTable[j]->getNetmask(), oldRoutingTable[j]->getNetmask());
             if (!containsKey(newTableMap, destination)) { // deleted routing entry
                 Ipv4AddressRange destinationAddressRange(oldRoutingTable[j]->getDestination(), oldRoutingTable[j]->getNetmask());
  
                 if ((oldRoutingTable[j]->getDestinationType() == Ospfv2RoutingTableEntry::NETWORK_DESTINATION) &&
                     ((oldRoutingTable[j]->getPathType() == Ospfv2RoutingTableEntry::INTRAAREA) ||
                      (oldRoutingTable[j]->getPathType() == Ospfv2RoutingTableEntry::INTERAREA)))
                 {
                     Ipv4AddressRange containingAddressRange = getContainingAddressRange(destinationAddressRange);
                     if (containingAddressRange != NULL_IPV4ADDRESSRANGE) {
                         destinationAddressRange = containingAddressRange;
                     }
                 }
  
                 Metric maxRangeCost = 0;
  
                 unsigned long newRouteCount = ospfRoutingTable.size();
                 for (uint32_t k = 0; k < newRouteCount; k++) {
                     if ((ospfRoutingTable[k]->getDestinationType() == Ospfv2RoutingTableEntry::NETWORK_DESTINATION) &&
                         (ospfRoutingTable[k]->getPathType() == Ospfv2RoutingTableEntry::INTRAAREA) &&
                         ((ospfRoutingTable[k]->getDestination().getInt() & ospfRoutingTable[k]->getNetmask().getInt() & destinationAddressRange.mask.getInt()) ==
                          (destinationAddressRange.address & destinationAddressRange.mask).getInt()) && // FIXME correcting network comparison
                         (ospfRoutingTable[k]->getCost() > maxRangeCost))
                     {
                         maxRangeCost = ospfRoutingTable[k]->getCost();
                     }
                 }
  
                 if (maxRangeCost < oldRoutingTable[j]->getCost()) { // the range's cost will change
                     lsaKey.linkStateID = destinationAddressRange.address;
                     lsaKey.advertisingRouter = routerID;
  
                     SummaryLsa *summaryLSA = areas[i]->findSummaryLSA(lsaKey);
  
                     if (summaryLSA != nullptr) {
                         if (maxRangeCost > 0) { // there's an other entry in this range
                             summaryLSA->setRouteCost(maxRangeCost);
                             floodLSA(summaryLSA, areas[i]->getAreaID());
  
                             originatedLSAMap[lsaKey] = true;
                         }
                         else { // no more entries in this range -> delete it
                             auto deletedIt = deletedLSAMap.find(lsaKey);
                             if (deletedIt == deletedLSAMap.end()) {
                                 summaryLSA->getHeaderForUpdate().setLsAge(MAX_AGE);
                                 floodLSA(summaryLSA, areas[i]->getAreaID());
  
                                 deletedLSAMap[lsaKey] = true;
                             }
                         }
                     }
                 }
             }
         }
     }
 }

Referenced by rebuildRoutingTable().

◆ originateASExternalLSA()

AsExternalLsa * inet::ospfv2::Router::originateASExternalLSA ( AsExternalLsa * lsa )

private

Originates a new AS External LSA based on the input lsa.

Parameters

lsa	[in] The LSA whose contents should be copied into the newly originated LSA.

Returns: The newly originated LSA.

 {
     AsExternalLsa *asExternalLSA = new AsExternalLsa(*lsa);
     Ospfv2LsaHeader& lsaHeader = asExternalLSA->getHeaderForUpdate();
     Ospfv2Options lsaOptions;
  
     lsaHeader.setLsAge(0);
     lsaOptions.E_ExternalRoutingCapability = true;
     lsaHeader.setLsOptions(lsaOptions);
     lsaHeader.setLsSequenceNumber(INITIAL_SEQUENCE_NUMBER);
     asExternalLSA->setSource(LsaTrackingInfo::ORIGINATED);
  
     return asExternalLSA;
 }

Referenced by ageDatabase().

◆ printAsExternalLsa()

void inet::ospfv2::Router::printAsExternalLsa ( )

private

 {
     for (uint32_t i = 0; i < asExternalLSAs.size(); i++) {
         Ospfv2AsExternalLsa *entry = check_and_cast<Ospfv2AsExternalLsa *>(asExternalLSAs[i]);
  
         const Ospfv2LsaHeader& head = entry->getHeader();
         std::string routerId = head.getAdvertisingRouter().str(false);
         EV_DETAIL << "AS External LSA in OSPF router with ID " << routerId << std::endl;
  
         // print header info
         EV_DETAIL << "    LS age: " << head.getLsAge() << std::endl;
         EV_DETAIL << "    LS type: " << head.getLsType() << std::endl;
         EV_DETAIL << "    Link state ID (IP network): " << head.getLinkStateID() << std::endl;
         EV_DETAIL << "    Advertising router: " << head.getAdvertisingRouter() << std::endl;
         EV_DETAIL << "    Seq number: " << head.getLsSequenceNumber() << std::endl;
         EV_DETAIL << "    Length: " << head.getLsaLength() << std::endl;
  
         EV_DETAIL << "    Network Mask: " << entry->getContents().getNetworkMask().str(false) << std::endl;
         EV_DETAIL << "    Metric: " << entry->getContents().getExternalTOSInfo(0).routeCost << std::endl;
         EV_DETAIL << "    E flag: " << ((entry->getContents().getExternalTOSInfo(0).E_ExternalMetricType == true) ? "set" : "unset") << std::endl;
         EV_DETAIL << "    Forwarding Address: " << entry->getContents().getExternalTOSInfo(0).forwardingAddress.str(false) << std::endl;
         EV_DETAIL << "    External Route Tag: " << entry->getContents().getExternalTOSInfo(0).externalRouteTag << std::endl;
         // todo: add ExternalTosInfo externalTOSInfo[];
         EV_DETAIL << std::endl;
     }
 }

Referenced by calculateASExternalRoutes().

◆ pruneASBoundaryRouterEntries()

void inet::ospfv2::Router::pruneASBoundaryRouterEntries ( std::vector< Ospfv2RoutingTableEntry * > & asbrEntries ) const

private

Prunes the input std::vector of RoutingTableEntries according to the RFC2328 Section 16.4.1.

Parameters

asbrEntries [in/out] The list of RoutingTableEntries to prune.

See also: RFC2328 Section 16.4.1.

 {
     bool hasNonBackboneIntraAreaPath = false;
     for (auto routingEntry : asbrEntries) {
         if ((routingEntry->getPathType() == Ospfv2RoutingTableEntry::INTRAAREA) &&
             (routingEntry->getArea() != BACKBONE_AREAID))
         {
             hasNonBackboneIntraAreaPath = true;
             break;
         }
     }
  
     if (hasNonBackboneIntraAreaPath) {
         auto it = asbrEntries.begin();
         while (it != asbrEntries.end()) {
             if (((*it)->getPathType() != Ospfv2RoutingTableEntry::INTRAAREA) ||
                 ((*it)->getArea() == BACKBONE_AREAID))
             {
                 delete *it;
                 it = asbrEntries.erase(it);
             }
             else {
                 it++;
             }
         }
     }
 }

Referenced by getPreferredEntry().

◆ rebuildRoutingTable()

void inet::ospfv2::Router::rebuildRoutingTable ( )

Rebuilds the routing table from scratch(based on the LSA database).

See also: RFC2328 Section 16.

 {
     unsigned long areaCount = areas.size();
     bool hasTransitAreas = false;
     std::vector<Ospfv2RoutingTableEntry *> newTable;
  
     EV_INFO << "--> Rebuilding routing table:\n";
  
     for (uint32_t i = 0; i < areaCount; i++) {
         areas[i]->calculateShortestPathTree(newTable);
         if (areas[i]->getTransitCapability())
             hasTransitAreas = true;
     }
  
     if (areaCount > 1) {
         Ospfv2Area *backbone = getAreaByID(BACKBONE_AREAID);
         // if this is an ABR and at least one adjacency in FULL state is built over the backbone
         if (backbone && backbone->hasAnyNeighborInStates(Neighbor::FULL_STATE))
             backbone->calculateInterAreaRoutes(newTable);
         else {
             for (auto& area : areas)
                 area->calculateInterAreaRoutes(newTable);
         }
     }
     else if (areaCount == 1)
         areas[0]->calculateInterAreaRoutes(newTable);
  
     if (hasTransitAreas) {
         for (uint32_t i = 0; i < areaCount; i++) {
             if (areas[i]->getTransitCapability())
                 areas[i]->recheckSummaryLSAs(newTable);
         }
     }
  
     calculateASExternalRoutes(newTable);
  
     // backup the routing table
     std::vector<Ospfv2RoutingTableEntry *> oldTable;
     oldTable.assign(ospfRoutingTable.begin(), ospfRoutingTable.end());
     ospfRoutingTable.clear();
     ospfRoutingTable.assign(newTable.begin(), newTable.end());
  
     // remove entries from the Ipv4 routing table inserted by the OSPF module
     std::vector<Ipv4Route *> eraseEntries;
     for (int32_t i = 0; i < rt->getNumRoutes(); i++) {
         Ipv4Route *entry = rt->getRoute(i);
         Ospfv2RoutingTableEntry *ospfEntry = dynamic_cast<Ospfv2RoutingTableEntry *>(entry);
         if (ospfEntry != nullptr)
             eraseEntries.push_back(entry);
     }
  
     // add the new routing entries
     std::vector<Ipv4Route *> addEntries;
     for (auto& tableEntry : ospfRoutingTable) {
         if (tableEntry->getDestinationType() == Ospfv2RoutingTableEntry::NETWORK_DESTINATION) {
             // OSPF never adds direct routes into the IP routing table
             if (!isDirectRoute(*tableEntry)) {
                 // ignore advertised loopback addresses with dest=gateway
                 if (tableEntry->getDestination() != tableEntry->getGateway()) {
                     Ipv4Route *entry = new Ospfv2RoutingTableEntry(*tableEntry);
                     addEntries.push_back(entry);
                 }
             }
         }
     }
  
     // find the difference between two tables
     std::vector<Ipv4Route *> diffAddEntries;
     std::vector<Ipv4Route *> diffEraseEntries;
     diffEraseEntries.assign(eraseEntries.begin(), eraseEntries.end());
     for (auto& entry : addEntries) {
         auto position = std::find_if(diffEraseEntries.begin(), diffEraseEntries.end(), [&] (const Ipv4Route *m) -> bool {
             return (m->getDestination() == entry->getDestination()) &&
                    (m->getNetmask() == entry->getNetmask()) &&
                    (m->getInterface()->getInterfaceId() == entry->getInterface()->getInterfaceId()) &&
                    (m->getGateway() == entry->getGateway()) &&
                    (m->getMetric() == entry->getMetric());
         });
         if (position != diffEraseEntries.end())
             diffEraseEntries.erase(position);
         else
             diffAddEntries.push_back(entry);
     }
  
     if (!diffEraseEntries.empty() || !diffAddEntries.empty()) {
         EV_INFO << "OSPF routing table has changed: \n";
         for (auto& entry : diffEraseEntries)
             EV_INFO << "deleted: " << entry << "\n";
         for (auto& entry : diffAddEntries)
             EV_INFO << "added: " << entry << "\n";
     }
     else {
         EV_INFO << "No changes to the OSPF routing table. \n";
     }
  
     for (auto& entry : eraseEntries)
         rt->deleteRoute(entry);
  
     for (auto& entry : addEntries)
         rt->addRoute(entry);
  
     EV_INFO << "<-- Routing table was rebuilt.\n"
             << "Results:\n";
  
     for (auto& entry : ospfRoutingTable)
         EV_INFO << entry << "\n";
  
     notifyAboutRoutingTableChanges(oldTable);
  
     for (auto& entry : oldTable)
         delete entry;
 }

Referenced by inet::ospfv2::Ospfv2Area::ageDatabase(), ageDatabase(), inet::ospfv2::Ospfv2InterfaceState::changeState(), inet::ospfv2::NeighborState::changeState(), inet::ospfv2::HelloHandler::processPacket(), inet::ospfv2::LinkStateUpdateHandler::processPacket(), and updateExternalRoute().

◆ removeExternalRoute()

void inet::ospfv2::Router::removeExternalRoute ( Ipv4Address networkAddress )

Removes an AS External Route from the database.

Parameters

networkAddress [in] The network address of the external route which needs to be removed.

 {
     LsaKeyType lsaKey;
  
     lsaKey.linkStateID = networkAddress;
     lsaKey.advertisingRouter = routerID;
  
     auto lsaIt = asExternalLSAsByID.find(lsaKey);
     if (lsaIt != asExternalLSAsByID.end()) {
         lsaIt->second->getHeaderForUpdate().setLsAge(MAX_AGE);
         lsaIt->second->setPurgeable();
         floodLSA(lsaIt->second, BACKBONE_AREAID);
     }
  
     auto externalIt = externalRoutes.find(networkAddress);
     if (externalIt != externalRoutes.end()) {
         externalRoutes.erase(externalIt);
     }
 }

◆ removeFromAllRetransmissionLists()

void inet::ospfv2::Router::removeFromAllRetransmissionLists ( LsaKeyType lsaKey )

Removes all LSAs from all Neighbor's retransmission lists which are identified by the input lsaKey.

Parameters

lsaKey [in] Identifies the LSAs to remove from the retransmission lists.

 {
     for (uint32_t i = 0; i < areas.size(); i++)
         areas[i]->removeFromAllRetransmissionLists(lsaKey);
 }

Referenced by inet::ospfv2::LinkStateUpdateHandler::processPacket().

◆ selectLeastCostRoutingEntry()

Ospfv2RoutingTableEntry * inet::ospfv2::Router::selectLeastCostRoutingEntry ( std::vector< Ospfv2RoutingTableEntry * > & entries ) const

private

Selects the least cost RoutingTableEntry from the input std::vector of RoutingTableEntries.

Parameters

entries [in] The RoutingTableEntries to choose the least cost one from.

Returns: The least cost entry or nullptr if entries is empty.

 {
     if (entries.empty())
         return nullptr;
  
     Ospfv2RoutingTableEntry *leastCostEntry = entries[0];
     Metric leastCost = leastCostEntry->getCost();
  
     for (uint32_t i = 1; i < entries.size(); i++) {
         Metric currentCost = entries[i]->getCost();
         if ((currentCost < leastCost) ||
             ((currentCost == leastCost) && (entries[i]->getArea() > leastCostEntry->getArea())))
         {
             leastCostEntry = entries[i];
             leastCost = currentCost;
         }
     }
  
     return leastCostEntry;
 }

Referenced by getPreferredEntry().

◆ setRFC1583Compatibility()

void inet::ospfv2::Router::setRFC1583Compatibility ( bool compatibility )

inline

61 { rfc1583Compatibility = compatibility; }

Referenced by inet::ospfv2::Ospfv2ConfigReader::loadConfigFromXML().

◆ setRouterID()

void inet::ospfv2::Router::setRouterID ( RouterId id )

inline

59 { routerID = id; }

◆ updateExternalRoute()

void inet::ospfv2::Router::updateExternalRoute	(	Ipv4Address	networkAddress,
		const Ospfv2AsExternalLsaContents &	externalRouteContents,
		int	ifIndex = `-1`
	)

Stores information on an AS External Route in externalRoutes and intalls(or updates) a new AsExternalLsa into the database.

Parameters

networkAddress	[in] The external route's network address.
externalRouteContents	[in] Route configuration data for the external route.
ifIndex	[in]

 {
     if (ifIndex != -1) {
         bool inRoutingTable = false;
         Ipv4Route *entry = nullptr;
         // add the external route to the routing table if it was not added by another module
         for (int32_t i = 0; i < rt->getNumRoutes(); i++) {
             entry = rt->getRoute(i);
             if ((entry->getDestination() == networkAddress)
                 && (entry->getNetmask() == externalRouteContents.getNetworkMask())) // TODO is it enough?
             {
                 inRoutingTable = true;
                 break;
             }
         }
  
         if (!inRoutingTable) {
             Ipv4Route *entry = new Ipv4Route;
             entry->setDestination(networkAddress);
             entry->setNetmask(externalRouteContents.getNetworkMask());
             entry->setInterface(ift->getInterfaceById(ifIndex));
             entry->setSourceType(IRoute::MANUAL);
             entry->setMetric(externalRouteContents.getExternalTOSInfo(0).routeCost);
             rt->addRoute(entry); // IIpv4RoutingTable deletes entry pointer
         }
         else {
             ASSERT(entry);
             entry->setMetric(externalRouteContents.getExternalTOSInfo(0).routeCost);
         }
     }
  
     AsExternalLsa *asExternalLSA = new AsExternalLsa;
     Ospfv2LsaHeader& lsaHeader = asExternalLSA->getHeaderForUpdate();
     Ospfv2Options lsaOptions;
  
     lsaHeader.setLsAge(0);
     lsaOptions.E_ExternalRoutingCapability = true;
     lsaHeader.setLsOptions(lsaOptions);
     lsaHeader.setLsType(AS_EXTERNAL_LSA_TYPE);
     lsaHeader.setLinkStateID(networkAddress); // TODO get unique LinkStateId
     lsaHeader.setAdvertisingRouter(Ipv4Address(routerID));
     lsaHeader.setLsSequenceNumber(INITIAL_SEQUENCE_NUMBER);
  
     asExternalLSA->setContents(externalRouteContents);
  
     asExternalLSA->setSource(LsaTrackingInfo::ORIGINATED);
  
     externalRoutes[networkAddress] = externalRouteContents;
  
     lsaHeader.setLsaLength(B(calculateLsaSize(*asExternalLSA)).get());
  
     bool rebuild = installASExternalLSA(asExternalLSA);
     floodLSA(asExternalLSA, BACKBONE_AREAID);
     delete asExternalLSA;
  
     if (rebuild)
         rebuildRoutingTable();
 }

Referenced by inet::ospfv2::Ospfv2ConfigReader::initiateDefaultRouteDistribution(), inet::ospfv2::Ospfv2::insertExternalRoute(), and inet::ospfv2::Ospfv2ConfigReader::loadExternalRoute().

Member Data Documentation

◆ ageTimer

cMessage* inet::ospfv2::Router::ageTimer

private

Database age timer - fires every second.

Referenced by ageDatabase(), Router(), and ~Router().

◆ areas

std::vector<Ospfv2Area *> inet::ospfv2::Router::areas

private

◆ areasByID

std::map<AreaId, Ospfv2Area *> inet::ospfv2::Router::areasByID

private

A map of the contained areas with the AreaId as key.

Referenced by addArea(), findLSA(), floodLSA(), getAreaByID(), and installLSA().

◆ asExternalLSAs

std::vector<AsExternalLsa *> inet::ospfv2::Router::asExternalLSAs

private

A list of the ASExternalLSAs advertised by this router.

Referenced by addWatches(), ageDatabase(), calculateASExternalRoutes(), installASExternalLSA(), printAsExternalLsa(), and ~Router().

◆ asExternalLSAsByID

std::map<LsaKeyType, AsExternalLsa *, LsaKeyType_Less> inet::ospfv2::Router::asExternalLSAsByID

private

A map of the ASExternalLSAs advertised by this router.

Referenced by ageDatabase(), findASExternalLSA(), installASExternalLSA(), and removeExternalRoute().

◆ externalRoutes

std::map<Ipv4Address, Ospfv2AsExternalLsaContents> inet::ospfv2::Router::externalRoutes

private

A map of the external route advertised by this router.

Referenced by removeExternalRoute(), and updateExternalRoute().

◆ ift

IInterfaceTable* inet::ospfv2::Router::ift = nullptr

private

Referenced by addExternalRouteInIPTable(), calculateASExternalRoutes(), isDirectRoute(), lookup(), and updateExternalRoute().

◆ messageHandler

MessageHandler* inet::ospfv2::Router::messageHandler

private

The message dispatcher class.

Referenced by ageDatabase(), Router(), and ~Router().

◆ ospfRoutingTable

std::vector<Ospfv2RoutingTableEntry *> inet::ospfv2::Router::ospfRoutingTable

private

The OSPF routing table - contains more information than the one in the IP layer.

Referenced by addWatches(), deleteRoute(), getPreferredEntry(), installASExternalLSA(), lookup(), notifyAboutRoutingTableChanges(), rebuildRoutingTable(), and ~Router().

◆ rfc1583Compatibility

bool inet::ospfv2::Router::rfc1583Compatibility

private

Decides whether to handle the preferred routing table entry to an AS boundary router as defined in RFC1583 or not.

Referenced by calculateASExternalRoutes(), and getPreferredEntry().

◆ routerID

RouterId inet::ospfv2::Router::routerID

private

The router ID assigned by the IP layer.

Referenced by addWatches(), ageDatabase(), getPreferredEntry(), getUniqueLinkStateID(), installASExternalLSA(), isDestinationUnreachable(), notifyAboutRoutingTableChanges(), removeExternalRoute(), and updateExternalRoute().

◆ rt

IIpv4RoutingTable* inet::ospfv2::Router::rt = nullptr

private

Referenced by addExternalRouteInIPTable(), getDefaultRoute(), rebuildRoutingTable(), and updateExternalRoute().

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Router()

◆ ~Router()

Member Function Documentation

◆ addArea()

◆ addExternalRouteInIPTable()

◆ addRoutingTableEntry()

◆ addWatches()

◆ ageDatabase()

◆ calculateASExternalRoutes()

◆ deleteRoute()

◆ findASExternalLSA() [1/2]

◆ findASExternalLSA() [2/2]

◆ findLSA()

◆ floodLSA()

◆ getAreaByAddr()

◆ getAreaByID()

◆ getAreaCount()

◆ getAreaIds()

◆ getASBoundaryRouter()

◆ getASExternalLSA() [1/2]

◆ getASExternalLSA() [2/2]

◆ getASExternalLSACount()

◆ getContainingAddressRange()

◆ getDefaultRoute()

◆ getMessageHandler()

◆ getNonVirtualInterface()

◆ getPreferredEntry()

◆ getRFC1583Compatibility()

◆ getRouterID()

◆ getRoutesToASBoundaryRouter()

◆ getRoutingTableEntry() [1/2]

◆ getRoutingTableEntry() [2/2]

◆ getRoutingTableEntryCount()

◆ getUniqueLinkStateID()

◆ hasAddressRange()

◆ hasAnyNeighborInStates()

◆ hasRouteToASBoundaryRouter()

◆ installASExternalLSA()

◆ installLSA()

◆ isDestinationUnreachable()

◆ isDirectRoute()

◆ isLocalAddress()

◆ isOnAnyRetransmissionList()

◆ lookup()

◆ notifyAboutRoutingTableChanges()

◆ originateASExternalLSA()

◆ printAsExternalLsa()

◆ pruneASBoundaryRouterEntries()

◆ rebuildRoutingTable()

◆ removeExternalRoute()

◆ removeFromAllRetransmissionLists()

◆ selectLeastCostRoutingEntry()

◆ setRFC1583Compatibility()

◆ setRouterID()

◆ updateExternalRoute()

Member Data Documentation

◆ ageTimer

◆ areas

◆ areasByID

◆ asExternalLSAs

◆ asExternalLSAsByID

◆ externalRoutes

◆ ift

◆ messageHandler

◆ ospfRoutingTable

◆ rfc1583Compatibility

◆ routerID

◆ rt