inet::ospf::Router Class Reference

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

#include <OSPFRouter.h>

Public Member Functions
	Router (RouterID id, 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
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
RoutingTableEntry *	getRoutingTableEntry (unsigned long i)
const RoutingTableEntry *	getRoutingTableEntry (unsigned long i) const
void	addRoutingTableEntry (RoutingTableEntry *entry)
void	addWatches ()
	Adds OMNeT++ watches for the routerID, the list of Areas and the list of AS External LSAs. More...
void	addArea (Area *area)
	Adds a new Area to the Area list. More...
Area *	getAreaByID (AreaID areaID)
	Returns the pointer to the Area identified by the input areaID, if it's on the Area list, nullptr otherwise. More...
Area *	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...
Interface *	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 (OSPFLSA *lsa, AreaID areaID=BACKBONE_AREAID)
	Installs a new LSA into the Router database. More...
OSPFLSA *	findLSA (LSAType 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 (OSPFLSA *lsa, AreaID areaID=BACKBONE_AREAID, Interface *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 (OSPFLSA *lsa) const
	Returns true if the destination described by the input lsa is in the routing table, false otherwise. More...
RoutingTableEntry *	lookup (IPv4Address destination, std::vector< RoutingTableEntry * > *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...
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...
void	updateExternalRoute (IPv4Address networkAddress, const OSPFASExternalLSAContents &externalRouteContents, int ifIndex)
	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 OSPFASExternalLSAContents &externalRouteContents, int ifIndex)
	Add an AS External Route in IPRoutingTable. More...
void	removeExternalRoute (IPv4Address networkAddress)
	Removes an AS External Route from the database. More...
RoutingTableEntry *	getPreferredEntry (const OSPFLSA &lsa, bool skipSelfOriginated, std::vector< RoutingTableEntry * > *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 (OSPFASExternalLSA *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< RoutingTableEntry * > &newRoutingTable)
	Calculate the AS External Routes from the ASExternalLSAs in the database. More...
void	notifyAboutRoutingTableChanges (std::vector< RoutingTableEntry * > &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< RoutingTableEntry * > &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< RoutingTableEntry * >	getRoutesToASBoundaryRouter (const std::vector< RoutingTableEntry * > &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< RoutingTableEntry * > &asbrEntries) const
	Prunes the input std::vector of RoutingTableEntries according to the RFC2328 Section 16.4.1. More...
RoutingTableEntry *	selectLeastCostRoutingEntry (std::vector< RoutingTableEntry * > &entries) const
	Selects the least cost RoutingTableEntry from the input std::vector of RoutingTableEntries. More...

Private Attributes
IInterfaceTable *	ift
IIPv4RoutingTable *	rt
RouterID	routerID
	The router ID assigned by the IP layer. More...
std::map< AreaID, Area * >	areasByID
	A map of the contained areas with the AreaID as key. More...
std::vector< Area * >	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, OSPFASExternalLSAContents >	externalRoutes
	A map of the external route advertised by this router. More...
cMessage *	ageTimer
	Database age timer - fires every second. More...
std::vector< RoutingTableEntry * >	routingTable
	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

inet::ospf::Router::Router	(	RouterID	id,
		cSimpleModule *	containingModule,
		IInterfaceTable *	ift,
		IIPv4RoutingTable *	rt
	)

Constructor.

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

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

inet::ospf::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 = routingTable.size();
    for (long k = 0; k < routeCount; k++) {
        delete routingTable[k];
    }
    messageHandler->clearTimer(ageTimer);
    delete ageTimer;
    delete messageHandler;
}

Member Function Documentation

void inet::ospf::Router::addArea

(

Area *

area

)

Adds a new Area to the Area list.

Parameters

area	[in] The Area to add.

Referenced by inet::ospf::OSPFConfigReader::loadAreaFromXML().

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

void inet::ospf::Router::addExternalRouteInIPTable	(	IPv4Address	networkAddress,
		const OSPFASExternalLSAContents &	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]

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

{
    int routingEntryNumber = rt->getNumRoutes();
    bool inRoutingTable = false;

    // add the external route to the IPv4 routing table if it was not added by another module
    for (int i = 1; i < routingEntryNumber; 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(OSPF_BGP_DEFAULT_COST);
        rt->addRoute(entry);
    }
}

void inet::ospf::Router::addRoutingTableEntry ( RoutingTableEntry *  entry )

inline

{ routingTable.push_back(entry); }

void inet::ospf::Router::addWatches

(

)

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

Referenced by inet::ospf::OSPFRouting::createOspfRouter().

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

void inet::ospf::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.

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

{
    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->getHeader().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->getHeader().setLsAge(MAX_AGE);
                floodLSA(lsa, BACKBONE_AREAID);
                lsa->incrementInstallTime();
            }
            else {
                long sequenceNumber = lsa->getHeader().getLsSequenceNumber();
                if (sequenceNumber == MAX_SEQUENCE_NUMBER) {
                    lsa->getHeader().setLsAge(MAX_AGE);
                    floodLSA(lsa, BACKBONE_AREAID);
                    lsa->incrementInstallTime();
                }
                else {
                    ASExternalLSA *newLSA = originateASExternalLSA(lsa);

                    newLSA->getHeader().setLsSequenceNumber(sequenceNumber + 1);
                    shouldRebuildRoutingTable |= lsa->update(newLSA);
                    delete newLSA;

                    floodLSA(lsa, BACKBONE_AREAID);
                }
            }
        }
        if (!selfOriginated && (lsAge == MAX_AGE - 1)) {
            lsa->getHeader().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->getHeader().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++;
        }
    }

    long areaCount = areas.size();
    for (long j = 0; j < areaCount; j++) {
        areas[j]->ageDatabase();
    }
    messageHandler->startTimer(ageTimer, 1.0);

    if (shouldRebuildRoutingTable) {
        rebuildRoutingTable();
    }
}

void inet::ospf::Router::calculateASExternalRoutes ( std::vector< RoutingTableEntry * > &  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.

Referenced by rebuildRoutingTable().

{
    // see RFC 2328 16.4.
    unsigned long lsaCount = asExternalLSAs.size();
    unsigned long i;

    for (i = 0; i < lsaCount; i++) {
        ASExternalLSA *currentLSA = asExternalLSAs[i];
        OSPFLSAHeader& currentHeader = currentLSA->getHeader();
        unsigned short externalCost = currentLSA->getContents().getRouteCost();
        RouterID originatingRouter = currentHeader.getAdvertisingRouter();

        RoutingTableEntry *preferredEntry = getPreferredEntry(*currentLSA, true, &newRoutingTable);
        if (preferredEntry == nullptr) {
            continue;
        }

        IPv4Address destination = currentHeader.getLinkStateID() & currentLSA->getContents().getNetworkMask();

        Metric preferredCost = preferredEntry->getCost();
        RoutingTableEntry *destinationEntry = lookup(destination, &newRoutingTable);    // (5)
        if (destinationEntry == nullptr) {
            bool type2ExternalMetric = currentLSA->getContents().getE_ExternalMetricType();
            unsigned int nextHopCount = preferredEntry->getNextHopCount();
            RoutingTableEntry *newEntry = new RoutingTableEntry(ift);

            newEntry->setDestination(destination);
            newEntry->setNetmask(currentLSA->getContents().getNetworkMask());
            newEntry->setArea(preferredEntry->getArea());
            newEntry->setPathType(type2ExternalMetric ? RoutingTableEntry::TYPE2_EXTERNAL : RoutingTableEntry::TYPE1_EXTERNAL);
            if (type2ExternalMetric) {
                newEntry->setCost(preferredCost);
                newEntry->setType2Cost(externalCost);
            }
            else {
                newEntry->setCost(preferredCost + externalCost);
            }
            newEntry->setDestinationType(RoutingTableEntry::NETWORK_DESTINATION);
            newEntry->setOptionalCapabilities(currentHeader.getLsOptions());
            newEntry->setLinkStateOrigin(currentLSA);

            for (unsigned int j = 0; j < nextHopCount; j++) {
                NextHop nextHop = preferredEntry->getNextHop(j);

                nextHop.advertisingRouter = originatingRouter;
                newEntry->addNextHop(nextHop);
            }

            newRoutingTable.push_back(newEntry);
        }
        else {
            RoutingTableEntry::RoutingPathType destinationPathType = destinationEntry->getPathType();
            bool type2ExternalMetric = currentLSA->getContents().getE_ExternalMetricType();
            unsigned int nextHopCount = preferredEntry->getNextHopCount();

            if ((destinationPathType == RoutingTableEntry::INTRAAREA) ||
                (destinationPathType == RoutingTableEntry::INTERAREA))    // (6) (a)
            {
                continue;
            }

            if (((destinationPathType == RoutingTableEntry::TYPE1_EXTERNAL) &&
                 (type2ExternalMetric)) ||
                ((destinationPathType == RoutingTableEntry::TYPE2_EXTERNAL) &&
                 (type2ExternalMetric) &&
                 (destinationEntry->getType2Cost() < externalCost)))    // (6) (b)
            {
                continue;
            }

            RoutingTableEntry *destinationPreferredEntry = getPreferredEntry(*(destinationEntry->getLinkStateOrigin()), false, &newRoutingTable);
            if ((!rfc1583Compatibility) &&
                (destinationPreferredEntry->getPathType() == RoutingTableEntry::INTRAAREA) &&
                (destinationPreferredEntry->getArea() != BACKBONE_AREAID) &&
                ((preferredEntry->getPathType() != RoutingTableEntry::INTRAAREA) ||
                 (preferredEntry->getArea() == BACKBONE_AREAID)))
            {
                continue;
            }

            if ((((destinationPathType == RoutingTableEntry::TYPE1_EXTERNAL) &&
                  (!type2ExternalMetric) &&
                  (destinationEntry->getCost() < preferredCost + externalCost))) ||
                ((destinationPathType == RoutingTableEntry::TYPE2_EXTERNAL) &&
                 (type2ExternalMetric) &&
                 (destinationEntry->getType2Cost() == externalCost) &&
                 (destinationPreferredEntry->getCost() < preferredCost)))
            {
                continue;
            }

            if (((destinationPathType == RoutingTableEntry::TYPE1_EXTERNAL) &&
                 (!type2ExternalMetric) &&
                 (destinationEntry->getCost() == (preferredCost + externalCost))) ||
                ((destinationPathType == RoutingTableEntry::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);

                    nextHop.advertisingRouter = originatingRouter;
                    destinationEntry->addNextHop(nextHop);
                }
                continue;
            }

            // LSA is better
            destinationEntry->setArea(preferredEntry->getArea());
            destinationEntry->setPathType(type2ExternalMetric ? RoutingTableEntry::TYPE2_EXTERNAL : RoutingTableEntry::TYPE1_EXTERNAL);
            if (type2ExternalMetric) {
                destinationEntry->setCost(preferredCost);
                destinationEntry->setType2Cost(externalCost);
            }
            else {
                destinationEntry->setCost(preferredCost + externalCost);
            }
            destinationEntry->setDestinationType(RoutingTableEntry::NETWORK_DESTINATION);
            destinationEntry->setOptionalCapabilities(currentHeader.getLsOptions());
            destinationEntry->clearNextHops();

            for (unsigned int j = 0; j < nextHopCount; j++) {
                NextHop nextHop = preferredEntry->getNextHop(j);

                nextHop.advertisingRouter = originatingRouter;
                destinationEntry->addNextHop(nextHop);
            }
        }
    }
}

ASExternalLSA * inet::ospf::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.

Referenced by findLSA(), and getUniqueLinkStateID().

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

const ASExternalLSA * inet::ospf::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.

{
    std::map<LSAKeyType, ASExternalLSA *, LSAKeyType_Less>::const_iterator lsaIt = asExternalLSAsByID.find(lsaKey);
    if (lsaIt != asExternalLSAsByID.end()) {
        return lsaIt->second;
    }
    else {
        return nullptr;
    }
}

OSPFLSA * inet::ospf::Router::findLSA	(	LSAType	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.

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

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

bool inet::ospf::Router::floodLSA	(	OSPFLSA *	lsa,
		AreaID	areaID = BACKBONE_AREAID,
		Interface *	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.

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

{
    bool floodedBackOut = false;

    if (lsa != nullptr) {
        if (lsa->getHeader().getLsType() == AS_EXTERNAL_LSA_TYPE) {
            long areaCount = areas.size();
            for (long i = 0; i < areaCount; i++) {
                if (areas[i]->getExternalRoutingCapability()) {
                    if (areas[i]->floodLSA(lsa, intf, neighbor)) {
                        floodedBackOut = true;
                    }
                }
            }
        }
        else {
            auto areaIt = areasByID.find(areaID);
            if (areaIt != areasByID.end()) {
                floodedBackOut = areaIt->second->floodLSA(lsa, intf, neighbor);
            }
        }
    }

    return floodedBackOut;
}

Area * inet::ospf::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;
}

Area * inet::ospf::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.

Referenced by inet::ospf::Area::calculateShortestPathTree(), inet::ospf::OSPFConfigReader::loadHostRoute(), inet::ospf::OSPFConfigReader::loadInterfaceParameters(), inet::ospf::OSPFConfigReader::loadVirtualLink(), inet::ospf::Area::originateRouterLSA(), inet::ospf::LinkStateUpdateHandler::processPacket(), inet::ospf::MessageHandler::processPacket(), and rebuildRoutingTable().

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

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

inline

Referenced by inet::ospf::Area::originateRouterLSA(), and inet::ospf::MessageHandler::processPacket().

{ return areas.size(); }

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

inline

Referenced by inet::ospf::Area::originateRouterLSA().

{ return externalRoutes.size() > 0; }

ASExternalLSA* inet::ospf::Router::getASExternalLSA ( unsigned long  i )

inline

Referenced by inet::ospf::OSPFRouting::checkExternalRoute(), and inet::ospf::Neighbor::createDatabaseSummary().

{ return asExternalLSAs[i]; }

const ASExternalLSA* inet::ospf::Router::getASExternalLSA ( unsigned long  i ) const

inline

{ return asExternalLSAs[i]; }

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

inline

Referenced by inet::ospf::OSPFRouting::checkExternalRoute(), and inet::ospf::Neighbor::createDatabaseSummary().

{ return asExternalLSAs.size(); }

IPv4AddressRange inet::ospf::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.

Referenced by notifyAboutRoutingTableChanges(), and inet::ospf::Area::originateSummaryLSA().

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

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

inline

Referenced by inet::ospf::LinkStateUpdateHandler::acknowledgeLSA(), inet::ospf::Neighbor::clearRequestRetransmissionTimer(), inet::ospf::Neighbor::clearUpdateRetransmissionTimer(), inet::ospf::Interface::floodLSA(), inet::ospf::OSPFRouting::handleMessage(), inet::ospf::NeighborStateLoading::processEvent(), inet::ospf::InterfaceStatePointToPoint::processEvent(), inet::ospf::NeighborStateExchange::processEvent(), inet::ospf::NeighborStateDown::processEvent(), inet::ospf::NeighborStateExchangeStart::processEvent(), inet::ospf::NeighborStateFull::processEvent(), inet::ospf::NeighborStateInit::processEvent(), inet::ospf::InterfaceStateNotDesignatedRouter::processEvent(), inet::ospf::InterfaceStateWaiting::processEvent(), inet::ospf::NeighborStateTwoWay::processEvent(), inet::ospf::InterfaceStateBackup::processEvent(), inet::ospf::InterfaceStateDesignatedRouter::processEvent(), inet::ospf::NeighborStateAttempt::processEvent(), inet::ospf::InterfaceStateDown::processEvent(), inet::ospf::LinkStateRequestHandler::processPacket(), inet::ospf::HelloHandler::processPacket(), inet::ospf::LinkStateAcknowledgementHandler::processPacket(), inet::ospf::DatabaseDescriptionHandler::processPacket(), inet::ospf::LinkStateUpdateHandler::processPacket(), inet::ospf::Interface::reset(), inet::ospf::Neighbor::reset(), inet::ospf::Neighbor::retransmitDatabaseDescriptionPacket(), inet::ospf::Neighbor::retransmitUpdatePacket(), inet::ospf::Neighbor::sendDatabaseDescriptionPacket(), inet::ospf::Interface::sendDelayedAcknowledgements(), inet::ospf::Interface::sendHelloPacket(), inet::ospf::Neighbor::sendLinkStateRequestPacket(), inet::ospf::Interface::sendLSAcknowledgement(), inet::ospf::Neighbor::startRequestRetransmissionTimer(), inet::ospf::Neighbor::startUpdateRetransmissionTimer(), inet::ospf::Interface::~Interface(), and inet::ospf::Neighbor::~Neighbor().

{ return messageHandler; }

Interface * inet::ospf::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.

Referenced by inet::ospf::Area::originateSummaryLSA().

{
    long areaCount = areas.size();

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

RoutingTableEntry * inet::ospf::Router::getPreferredEntry	(	const OSPFLSA &	lsa,
		bool	skipSelfOriginated,
		std::vector< RoutingTableEntry * > *	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

Referenced by calculateASExternalRoutes(), and inet::ospf::Area::originateSummaryLSA().

{
    // see RFC 2328 16.3. and 16.4.
    if (fromRoutingTable == nullptr) {
        fromRoutingTable = &routingTable;
    }

    const OSPFLSAHeader& lsaHeader = lsa.getHeader();
    const OSPFASExternalLSA *asExternalLSA = dynamic_cast<const OSPFASExternalLSA *>(&lsa);
    unsigned long externalCost = (asExternalLSA != nullptr) ? asExternalLSA->getContents().getRouteCost() : 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().getForwardingAddress();
    }

    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)
        std::vector<RoutingTableEntry *> asbrEntries = getRoutesToASBoundaryRouter(*fromRoutingTable, originatingRouter);
        if (!rfc1583Compatibility) {
            pruneASBoundaryRouterEntries(asbrEntries);
        }
        return selectLeastCostRoutingEntry(asbrEntries);
    }
    else {
        RoutingTableEntry *forwardEntry = lookup(forwardingAddress, fromRoutingTable);

        if (forwardEntry == nullptr) {
            return nullptr;
        }

        if ((forwardEntry->getPathType() != RoutingTableEntry::INTRAAREA) &&
            (forwardEntry->getPathType() != RoutingTableEntry::INTERAREA))
        {
            return nullptr;
        }

        return forwardEntry;
    }

    return nullptr;
}

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

inline

{ return rfc1583Compatibility; }

RouterID inet::ospf::Router::getRouterID ( ) const

inline

Referenced by inet::ospf::LinkStateUpdateHandler::acknowledgeLSA(), inet::ospf::Area::ageDatabase(), inet::ospf::InterfaceState::calculateDesignatedRouter(), inet::ospf::Area::calculateInterAreaRoutes(), inet::ospf::Area::calculateNextHops(), inet::ospf::Area::calculateShortestPathTree(), inet::ospf::InterfaceState::changeState(), inet::ospf::NeighborState::changeState(), inet::ospf::Interface::createUpdatePacket(), inet::ospf::Area::getUniqueLinkStateID(), inet::ospf::MessageHandler::messageReceived(), inet::ospf::Neighbor::needAdjacency(), inet::ospf::Area::originateNetworkLSA(), inet::ospf::Area::originateRouterLSA(), inet::ospf::Area::originateSummaryLSA(), inet::ospf::HelloHandler::processPacket(), inet::ospf::DatabaseDescriptionHandler::processPacket(), inet::ospf::LinkStateUpdateHandler::processPacket(), inet::ospf::Area::recheckSummaryLSAs(), inet::ospf::Neighbor::retransmitUpdatePacket(), inet::ospf::Neighbor::sendDatabaseDescriptionPacket(), inet::ospf::Interface::sendDelayedAcknowledgements(), inet::ospf::Interface::sendHelloPacket(), inet::ospf::Neighbor::sendLinkStateRequestPacket(), and inet::ospf::Interface::sendLSAcknowledgement().

{ return routerID; }

std::vector< RoutingTableEntry * > inet::ospf::Router::getRoutesToASBoundaryRouter ( const std::vector< RoutingTableEntry * > &  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.

Referenced by getPreferredEntry().

{
    std::vector<RoutingTableEntry *> results;
    long routeCount = fromRoutingTable.size();

    for (long i = 0; i < routeCount; i++) {
        RoutingTableEntry *routingEntry = fromRoutingTable[i];
        if (((routingEntry->getDestinationType() & RoutingTableEntry::AS_BOUNDARY_ROUTER_DESTINATION) != 0) &&
            (routingEntry->getDestination() == asbrRouterID))
        {
            results.push_back(routingEntry);
        }
    }
    return results;
}

RoutingTableEntry* inet::ospf::Router::getRoutingTableEntry ( unsigned long  i )

inline

Referenced by inet::ospf::Area::originateSummaryLSA().

{ return routingTable[i]; }

const RoutingTableEntry* inet::ospf::Router::getRoutingTableEntry ( unsigned long  i ) const

inline

{ return routingTable[i]; }

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

inline

Referenced by inet::ospf::Area::originateSummaryLSA().

{ return routingTable.size(); }

LinkStateID inet::ospf::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->getHeader().setLsAge(0);
            asExternalLSA->getHeader().setLsSequenceNumber((sequenceNumber == MAX_SEQUENCE_NUMBER) ? INITIAL_SEQUENCE_NUMBER : sequenceNumber + 1);
            asExternalLSA->getContents().setNetworkMask(destination.mask);
            asExternalLSA->getContents().setE_ExternalMetricType(externalMetricIsType2);
            asExternalLSA->getContents().setRouteCost(destinationCost);

            lsaToReoriginate = asExternalLSA;

            return lsaKey.linkStateID.makeBroadcastAddress(existingMask);
        }
    }
}

bool inet::ospf::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.

Referenced by inet::ospf::Area::calculateInterAreaRoutes().

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

bool inet::ospf::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.

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

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

bool inet::ospf::Router::hasRouteToASBoundaryRouter ( const std::vector< RoutingTableEntry * > &  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.

Referenced by getPreferredEntry().

{
    long routeCount = inRoutingTable.size();
    for (long i = 0; i < routeCount; i++) {
        RoutingTableEntry *routingEntry = inRoutingTable[i];
        if (((routingEntry->getDestinationType() & RoutingTableEntry::AS_BOUNDARY_ROUTER_DESTINATION) != 0) &&
            (routingEntry->getDestination() == asbrRouterID))
        {
            return true;
        }
    }
    return false;
}

bool inet::ospf::Router::installASExternalLSA ( OSPFASExternalLSA *  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?

1. 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.
2. 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...

Referenced by installLSA(), and updateExternalRoute().

{
    // TODO: how to solve this problem?

    RouterID advertisingRouter = lsa->getHeader().getAdvertisingRouter();
    bool reachable = false;
    unsigned int routeCount = routingTable.size();

    for (unsigned int i = 0; i < routeCount; i++) {
        if ((((routingTable[i]->getDestinationType() & RoutingTableEntry::AREA_BORDER_ROUTER_DESTINATION) != 0) ||
             ((routingTable[i]->getDestinationType() & RoutingTableEntry::AS_BOUNDARY_ROUTER_DESTINATION) != 0)) &&
            (routingTable[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().getE_ExternalMetricType() == lsa->getContents().getE_ExternalMetricType()) &&
        (lsaIt->second->getContents().getRouteCost() == lsa->getContents().getRouteCost()) &&
        (lsa->getContents().getForwardingAddress().getInt() != 0) &&    // forwarding address != 0.0.0.0
        (lsaIt->second->getContents().getForwardingAddress() == lsa->getContents().getForwardingAddress()))
    {
        if (routerID > advertisingRouter) {
            return false;
        }
        else {
            lsaIt->second->getHeader().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;
        asExternalLSAs.push_back(lsaCopy);
        return true;
    }
}

bool inet::ospf::Router::installLSA	(	OSPFLSA *	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.

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

{
    switch (lsa->getHeader().getLsType()) {
        case ROUTERLSA_TYPE: {
            auto areaIt = areasByID.find(areaID);
            if (areaIt != areasByID.end()) {
                OSPFRouterLSA *ospfRouterLSA = check_and_cast<OSPFRouterLSA *>(lsa);
                return areaIt->second->installRouterLSA(ospfRouterLSA);
            }
        }
        break;

        case NETWORKLSA_TYPE: {
            auto areaIt = areasByID.find(areaID);
            if (areaIt != areasByID.end()) {
                OSPFNetworkLSA *ospfNetworkLSA = check_and_cast<OSPFNetworkLSA *>(lsa);
                return areaIt->second->installNetworkLSA(ospfNetworkLSA);
            }
        }
        break;

        case SUMMARYLSA_NETWORKS_TYPE:
        case SUMMARYLSA_ASBOUNDARYROUTERS_TYPE: {
            auto areaIt = areasByID.find(areaID);
            if (areaIt != areasByID.end()) {
                OSPFSummaryLSA *ospfSummaryLSA = check_and_cast<OSPFSummaryLSA *>(lsa);
                return areaIt->second->installSummaryLSA(ospfSummaryLSA);
            }
        }
        break;

        case AS_EXTERNAL_LSA_TYPE: {
            OSPFASExternalLSA *ospfASExternalLSA = check_and_cast<OSPFASExternalLSA *>(lsa);
            return installASExternalLSA(ospfASExternalLSA);
        }
        break;

        default:
            ASSERT(false);
            break;
    }
    return false;
}

bool inet::ospf::Router::isDestinationUnreachable

(

OSPFLSA *

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.

Referenced by inet::ospf::Area::ageDatabase(), and ageDatabase().

{
    IPv4Address destination = IPv4Address(lsa->getHeader().getLinkStateID());

    OSPFRouterLSA *routerLSA = dynamic_cast<OSPFRouterLSA *>(lsa);
    OSPFNetworkLSA *networkLSA = dynamic_cast<OSPFNetworkLSA *>(lsa);
    OSPFSummaryLSA *summaryLSA = dynamic_cast<OSPFSummaryLSA *>(lsa);
    OSPFASExternalLSA *asExternalLSA = dynamic_cast<OSPFASExternalLSA *>(lsa);
    // TODO: verify
    if (routerLSA != nullptr) {
        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 != nullptr) {
            bool destinationFound = false;
            bool unnumberedPointToPointLink = false;
            IPv4Address firstNumberedIfAddress;

            for (unsigned int i = 0; i < linkCount; i++) {
                Link& 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 != nullptr) {
                // get the interface address pointing backwards on the shortest path tree
                bool destinationFound = false;
                for (unsigned int i = 0; i < linkCount; i++) {
                    Link& 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;
            }
        }
    }
    if (networkLSA != nullptr) {
        destination = networkLSA->getHeader().getLinkStateID() & networkLSA->getNetworkMask();
    }
    if ((summaryLSA != nullptr) && (summaryLSA->getHeader().getLsType() == SUMMARYLSA_NETWORKS_TYPE)) {
        destination = summaryLSA->getHeader().getLinkStateID() & summaryLSA->getNetworkMask();
    }
    if (asExternalLSA != nullptr) {
        destination = asExternalLSA->getHeader().getLinkStateID() & asExternalLSA->getContents().getNetworkMask();
    }

    if (lookup(destination) == nullptr) {
        return true;
    }
    else {
        return false;
    }
}

bool inet::ospf::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.

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

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

bool inet::ospf::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.

Referenced by ageDatabase().

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

RoutingTableEntry * inet::ospf::Router::lookup	(	IPv4Address	destination,
		std::vector< RoutingTableEntry * > *	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.

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

{
    const std::vector<RoutingTableEntry *>& rTable = (table == nullptr) ? routingTable : (*table);
    unsigned long dest = destination.getInt();
    unsigned long routingTableSize = rTable.size();
    bool unreachable = false;
    std::vector<RoutingTableEntry *> discard;
    unsigned long i;

    unsigned long areaCount = areas.size();
    for (i = 0; i < areaCount; i++) {
        unsigned int addressRangeCount = areas[i]->getAddressRangeCount();
        for (unsigned int j = 0; j < addressRangeCount; j++) {
            IPv4AddressRange range = areas[i]->getAddressRange(j);

            for (unsigned int k = 0; k < routingTableSize; k++) {
                RoutingTableEntry *entry = rTable[k];

                if (entry->getDestinationType() != RoutingTableEntry::NETWORK_DESTINATION) {
                    continue;
                }
//                if (((entry->getDestination().getInt() & entry->getNetmask().getInt() & range.mask.getInt()) == (range.address & range.mask).getInt()) &&
//                    (entry->getPathType() == RoutingTableEntry::INTRAAREA))
                if (range.containsRange(entry->getDestination(), entry->getNetmask()) &&
                    (entry->getPathType() == RoutingTableEntry::INTRAAREA))
                {
                    // active area address range
                    RoutingTableEntry *discardEntry = new RoutingTableEntry(ift);
                    discardEntry->setDestination(range.address);
                    discardEntry->setNetmask(range.mask);
                    discardEntry->setDestinationType(RoutingTableEntry::NETWORK_DESTINATION);
                    discardEntry->setPathType(RoutingTableEntry::INTERAREA);
                    discardEntry->setArea(areas[i]->getAreaID());
                    discard.push_back(discardEntry);
                    break;
                }
            }
        }
    }

    RoutingTableEntry *bestMatch = nullptr;
    unsigned long longestMatch = 0;

    for (i = 0; i < routingTableSize; i++) {
        if (rTable[i]->getDestinationType() == RoutingTableEntry::NETWORK_DESTINATION) {
            RoutingTableEntry *entry = rTable[i];
            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;
                }
            }
        }
    }

    unsigned int discardCount = discard.size();
    if (bestMatch == nullptr) {
        unreachable = true;
    }
    else {
        for (i = 0; i < discardCount; i++) {
            RoutingTableEntry *entry = discard[i];
            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 (i = 0; i < discardCount; i++) {
        delete discard[i];
    }

    if (unreachable) {
        return nullptr;
    }
    else {
        return bestMatch;
    }
}

void inet::ospf::Router::notifyAboutRoutingTableChanges ( std::vector< RoutingTableEntry * > &  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).

Referenced by rebuildRoutingTable().

{
    if (areas.size() <= 1) {
        return;
    }

    typedef std::map<IPv4AddressRange, RoutingTableEntry *> RoutingTableEntryMap;
    unsigned long routeCount = oldRoutingTable.size();
    RoutingTableEntryMap oldTableMap;
    RoutingTableEntryMap newTableMap;
    unsigned long i, j, k;

    for (i = 0; i < routeCount; i++) {
        IPv4AddressRange destination(oldRoutingTable[i]->getDestination() & oldRoutingTable[i]->getNetmask(), oldRoutingTable[i]->getNetmask());
        oldTableMap[destination] = oldRoutingTable[i];
    }

    routeCount = routingTable.size();
    for (i = 0; i < routeCount; i++) {
        IPv4AddressRange destination(routingTable[i]->getDestination() & routingTable[i]->getNetmask(), routingTable[i]->getNetmask());
        newTableMap[destination] = routingTable[i];
    }

    unsigned long areaCount = areas.size();
    for (i = 0; i < areaCount; i++) {
        std::map<LSAKeyType, bool, LSAKeyType_Less> originatedLSAMap;
        std::map<LSAKeyType, bool, LSAKeyType_Less> deletedLSAMap;
        LSAKeyType lsaKey;

        routeCount = routingTable.size();
        for (j = 0; j < routeCount; j++) {
            IPv4AddressRange destination(routingTable[j]->getDestination() & routingTable[j]->getNetmask(), routingTable[j]->getNetmask());
            auto destIt = oldTableMap.find(destination);
            if (destIt == oldTableMap.end()) {    // new routing entry
                SummaryLSA *lsaToReoriginate = nullptr;
                SummaryLSA *newLSA = areas[i]->originateSummaryLSA(routingTable[j], originatedLSAMap, lsaToReoriginate);

                if (newLSA != nullptr) {
                    if (lsaToReoriginate != nullptr) {
                        areas[i]->installSummaryLSA(lsaToReoriginate);
//                        floodLSA(lsaToReoriginate, BACKBONE_AREAID);
                        floodLSA(lsaToReoriginate, areas[i]->getAreaID());

                        lsaKey.linkStateID = lsaToReoriginate->getHeader().getLinkStateID();
                        lsaKey.advertisingRouter = routerID;
                        originatedLSAMap[lsaKey] = true;

                        delete lsaToReoriginate;
                    }

                    areas[i]->installSummaryLSA(newLSA);
//                    floodLSA(newLSA, BACKBONE_AREAID);
                    floodLSA(newLSA, areas[i]->getAreaID());

                    lsaKey.linkStateID = newLSA->getHeader().getLinkStateID();
                    lsaKey.advertisingRouter = routerID;
                    originatedLSAMap[lsaKey] = true;

                    delete newLSA;
                }
            }
            else {
                if (*(routingTable[j]) != *(destIt->second)) {    // modified routing entry
                    SummaryLSA *lsaToReoriginate = nullptr;
                    SummaryLSA *newLSA = areas[i]->originateSummaryLSA(routingTable[j], originatedLSAMap, lsaToReoriginate);

                    if (newLSA != nullptr) {
                        if (lsaToReoriginate != nullptr) {
                            areas[i]->installSummaryLSA(lsaToReoriginate);
//                            floodLSA(lsaToReoriginate, BACKBONE_AREAID);
                            floodLSA(lsaToReoriginate, areas[i]->getAreaID());

                            lsaKey.linkStateID = lsaToReoriginate->getHeader().getLinkStateID();
                            lsaKey.advertisingRouter = routerID;
                            originatedLSAMap[lsaKey] = true;

                            delete lsaToReoriginate;
                        }

                        areas[i]->installSummaryLSA(newLSA);
//                        floodLSA(newLSA, BACKBONE_AREAID);
                        floodLSA(newLSA, areas[i]->getAreaID());

                        lsaKey.linkStateID = newLSA->getHeader().getLinkStateID();
                        lsaKey.advertisingRouter = routerID;
                        originatedLSAMap[lsaKey] = true;

                        delete newLSA;
                    }
                    else {
                        IPv4AddressRange destinationAddressRange(routingTable[j]->getDestination(), routingTable[j]->getNetmask());

                        if ((routingTable[j]->getDestinationType() == RoutingTableEntry::NETWORK_DESTINATION) &&
                            ((routingTable[j]->getPathType() == RoutingTableEntry::INTRAAREA) ||
                             (routingTable[j]->getPathType() == RoutingTableEntry::INTERAREA)))
                        {
                            IPv4AddressRange containingAddressRange = getContainingAddressRange(destinationAddressRange);
                            if (containingAddressRange != NULL_IPV4ADDRESSRANGE) {
                                destinationAddressRange = containingAddressRange;
                            }
                        }

                        Metric maxRangeCost = 0;
                        Metric oneLessCost = 0;

                        for (k = 0; k < routeCount; k++) {
                            if ((routingTable[k]->getDestinationType() == RoutingTableEntry::NETWORK_DESTINATION) &&
                                (routingTable[k]->getPathType() == RoutingTableEntry::INTRAAREA) &&
                                ((routingTable[k]->getDestination().getInt() & routingTable[k]->getNetmask().getInt() & destinationAddressRange.mask.getInt()) ==
                                 (destinationAddressRange.address & destinationAddressRange.mask).getInt()) &&
                                (routingTable[k]->getCost() > maxRangeCost))
                            {
                                oneLessCost = maxRangeCost;
                                maxRangeCost = routingTable[k]->getCost();
                            }
                        }

                        if (maxRangeCost == routingTable[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, BACKBONE_AREAID);
                                    floodLSA(summaryLSA, areas[i]->getAreaID());

                                    originatedLSAMap[lsaKey] = true;
                                }
                                else {    // no more entries in this range -> delete it
                                    std::map<LSAKeyType, bool, LSAKeyType_Less>::const_iterator deletedIt = deletedLSAMap.find(lsaKey);
                                    if (deletedIt == deletedLSAMap.end()) {
                                        summaryLSA->getHeader().setLsAge(MAX_AGE);
//                                        floodLSA(summaryLSA, BACKBONE_AREAID);
                                        floodLSA(summaryLSA, areas[i]->getAreaID());

                                        deletedLSAMap[lsaKey] = true;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        routeCount = oldRoutingTable.size();
        for (j = 0; j < routeCount; j++) {
            IPv4AddressRange destination(oldRoutingTable[j]->getDestination() & oldRoutingTable[j]->getNetmask(), oldRoutingTable[j]->getNetmask());
            auto destIt = newTableMap.find(destination);
            if (destIt == newTableMap.end()) {    // deleted routing entry
                IPv4AddressRange destinationAddressRange(oldRoutingTable[j]->getDestination(), oldRoutingTable[j]->getNetmask());

                if ((oldRoutingTable[j]->getDestinationType() == RoutingTableEntry::NETWORK_DESTINATION) &&
                    ((oldRoutingTable[j]->getPathType() == RoutingTableEntry::INTRAAREA) ||
                     (oldRoutingTable[j]->getPathType() == RoutingTableEntry::INTERAREA)))
                {
                    IPv4AddressRange containingAddressRange = getContainingAddressRange(destinationAddressRange);
                    if (containingAddressRange != NULL_IPV4ADDRESSRANGE) {
                        destinationAddressRange = containingAddressRange;
                    }
                }

                Metric maxRangeCost = 0;

                unsigned long newRouteCount = routingTable.size();
                for (k = 0; k < newRouteCount; k++) {
                    if ((routingTable[k]->getDestinationType() == RoutingTableEntry::NETWORK_DESTINATION) &&
                        (routingTable[k]->getPathType() == RoutingTableEntry::INTRAAREA) &&
                        ((routingTable[k]->getDestination().getInt() & routingTable[k]->getNetmask().getInt() & destinationAddressRange.mask.getInt()) ==
                         (destinationAddressRange.address & destinationAddressRange.mask).getInt()) &&    //FIXME correcting network comparison
                        (routingTable[k]->getCost() > maxRangeCost))
                    {
                        maxRangeCost = routingTable[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, BACKBONE_AREAID);

                            originatedLSAMap[lsaKey] = true;
                        }
                        else {    // no more entries in this range -> delete it
                            std::map<LSAKeyType, bool, LSAKeyType_Less>::const_iterator deletedIt = deletedLSAMap.find(lsaKey);
                            if (deletedIt == deletedLSAMap.end()) {
                                summaryLSA->getHeader().setLsAge(MAX_AGE);
                                floodLSA(summaryLSA, BACKBONE_AREAID);

                                deletedLSAMap[lsaKey] = true;
                            }
                        }
                    }
                }
            }
        }
    }
}

ASExternalLSA * inet::ospf::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.

Referenced by ageDatabase().

{
    ASExternalLSA *asExternalLSA = new ASExternalLSA(*lsa);
    OSPFLSAHeader& lsaHeader = asExternalLSA->getHeader();
    OSPFOptions lsaOptions;

    lsaHeader.setLsAge(0);
    memset(&lsaOptions, 0, sizeof(OSPFOptions));
    lsaOptions.E_ExternalRoutingCapability = true;
    lsaHeader.setLsOptions(lsaOptions);
    lsaHeader.setLsSequenceNumber(INITIAL_SEQUENCE_NUMBER);
    asExternalLSA->setSource(LSATrackingInfo::ORIGINATED);

    return asExternalLSA;
}

void inet::ospf::Router::pruneASBoundaryRouterEntries ( std::vector< RoutingTableEntry * > &  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.

Referenced by getPreferredEntry().

{
    bool hasNonBackboneIntraAreaPath = false;
    for (auto routingEntry : asbrEntries) {
        if ((routingEntry->getPathType() == RoutingTableEntry::INTRAAREA) &&
            (routingEntry->getArea() != BACKBONE_AREAID))
        {
            hasNonBackboneIntraAreaPath = true;
            break;
        }
    }

    if (hasNonBackboneIntraAreaPath) {
        auto it = asbrEntries.begin();
        while (it != asbrEntries.end()) {
            if (((*it)->getPathType() != RoutingTableEntry::INTRAAREA) ||
                ((*it)->getArea() == BACKBONE_AREAID))
            {
                it = asbrEntries.erase(it);
            }
            else {
                it++;
            }
        }
    }
}

void inet::ospf::Router::rebuildRoutingTable

(

)

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

See also

RFC2328 Section 16.

Referenced by inet::ospf::Area::ageDatabase(), ageDatabase(), inet::ospf::InterfaceState::changeState(), inet::ospf::NeighborState::changeState(), inet::ospf::HelloHandler::processPacket(), inet::ospf::LinkStateUpdateHandler::processPacket(), and updateExternalRoute().

{
    unsigned long areaCount = areas.size();
    bool hasTransitAreas = false;
    std::vector<RoutingTableEntry *> newTable;
    unsigned long i;

    EV_INFO << "Rebuilding routing table:\n";

    for (i = 0; i < areaCount; i++) {
        areas[i]->calculateShortestPathTree(newTable);
        if (areas[i]->getTransitCapability()) {
            hasTransitAreas = true;
        }
    }
    if (areaCount > 1) {
        Area *backbone = getAreaByID(BACKBONE_AREAID);
        if (backbone != nullptr) {
            backbone->calculateInterAreaRoutes(newTable);
        }
    }
    else {
        if (areaCount == 1) {
            areas[0]->calculateInterAreaRoutes(newTable);
        }
    }
    if (hasTransitAreas) {
        for (i = 0; i < areaCount; i++) {
            if (areas[i]->getTransitCapability()) {
                areas[i]->recheckSummaryLSAs(newTable);
            }
        }
    }
    calculateASExternalRoutes(newTable);

    // backup the routing table
    unsigned long routeCount = routingTable.size();
    std::vector<RoutingTableEntry *> oldTable;

    oldTable.assign(routingTable.begin(), routingTable.end());
    routingTable.clear();
    routingTable.assign(newTable.begin(), newTable.end());

    std::vector<IPv4Route *> eraseEntries;
    unsigned long routingEntryNumber = rt->getNumRoutes();
    // remove entries from the IPv4 routing table inserted by the OSPF module
    for (i = 0; i < routingEntryNumber; i++) {
        IPv4Route *entry = rt->getRoute(i);
        RoutingTableEntry *ospfEntry = dynamic_cast<RoutingTableEntry *>(entry);
        if (ospfEntry != nullptr) {
            eraseEntries.push_back(entry);
        }
    }

    unsigned int eraseCount = eraseEntries.size();
    for (i = 0; i < eraseCount; i++) {
        rt->deleteRoute(eraseEntries[i]);
    }

    // add the new routing entries
    routeCount = routingTable.size();
    for (i = 0; i < routeCount; i++) {
        if (routingTable[i]->getDestinationType() == RoutingTableEntry::NETWORK_DESTINATION) {
            rt->addRoute(new RoutingTableEntry(*(routingTable[i])));
        }
    }

    notifyAboutRoutingTableChanges(oldTable);

    routeCount = oldTable.size();
    for (i = 0; i < routeCount; i++) {
        delete (oldTable[i]);
    }

    EV_INFO << "Routing table was rebuilt.\n"
            << "Results:\n";

    routeCount = routingTable.size();
    for (i = 0; i < routeCount; i++) {
        EV_INFO << *routingTable[i]
                << "\n";
    }
}

void inet::ospf::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->getHeader().setLsAge(MAX_AGE);
        lsaIt->second->setPurgeable();
        floodLSA(lsaIt->second, BACKBONE_AREAID);
    }

    auto externalIt = externalRoutes.find(networkAddress);
    if (externalIt != externalRoutes.end()) {
        externalRoutes.erase(externalIt);
    }
}

void inet::ospf::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.

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

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

RoutingTableEntry * inet::ospf::Router::selectLeastCostRoutingEntry ( std::vector< RoutingTableEntry * > &  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.

Referenced by getPreferredEntry().

{
    if (entries.empty()) {
        return nullptr;
    }

    RoutingTableEntry *leastCostEntry = entries[0];
    Metric leastCost = leastCostEntry->getCost();
    long routeCount = entries.size();

    for (long i = 1; i < routeCount; i++) {
        Metric currentCost = entries[i]->getCost();
        if ((currentCost < leastCost) ||
            ((currentCost == leastCost) && (entries[i]->getArea() > leastCostEntry->getArea())))
        {
            leastCostEntry = entries[i];
            leastCost = currentCost;
        }
    }

    return leastCostEntry;
}

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

inline

Referenced by inet::ospf::OSPFConfigReader::loadConfigFromXML().

{ rfc1583Compatibility = compatibility; }

void inet::ospf::Router::setRouterID ( RouterID  id )

inline

{ routerID = id; }

void inet::ospf::Router::updateExternalRoute	(	IPv4Address	networkAddress,
		const OSPFASExternalLSAContents &	externalRouteContents,
		int	ifIndex
	)

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]

Referenced by inet::ospf::OSPFRouting::insertExternalRoute(), and inet::ospf::OSPFConfigReader::loadExternalRoute().

{
    ASExternalLSA *asExternalLSA = new ASExternalLSA;
    OSPFLSAHeader& lsaHeader = asExternalLSA->getHeader();
    OSPFOptions lsaOptions;
    //LSAKeyType lsaKey;

    unsigned long routingEntryNumber = rt->getNumRoutes();
    bool inRoutingTable = false;
    // add the external route to the routing table if it was not added by another module
    for (unsigned long i = 0; i < routingEntryNumber; i++) {
        const IPv4Route *entry = rt->getRoute(i);
        if ((entry->getDestination() == networkAddress)
            && (entry->getNetmask() == externalRouteContents.getNetworkMask()))    //TODO is it enough?
        {
            inRoutingTable = true;
        }
    }

    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.getRouteCost());
        rt->addRoute(entry);    // IIPv4RoutingTable deletes entry pointer
    }

    lsaHeader.setLsAge(0);
    memset(&lsaOptions, 0, sizeof(OSPFOptions));
    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;

    bool rebuild = installASExternalLSA(asExternalLSA);
    floodLSA(asExternalLSA, BACKBONE_AREAID);
    delete asExternalLSA;

    if (rebuild) {
        rebuildRoutingTable();
    }
}

Member Data Documentation

cMessage* inet::ospf::Router::ageTimer

private

Database age timer - fires every second.

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

std::vector<Area *> inet::ospf::Router::areas

private

A list of the contained areas.

Referenced by addArea(), addWatches(), ageDatabase(), floodLSA(), getAreaByAddr(), getContainingAddressRange(), getNonVirtualInterface(), hasAddressRange(), hasAnyNeighborInStates(), installASExternalLSA(), isLocalAddress(), isOnAnyRetransmissionList(), lookup(), notifyAboutRoutingTableChanges(), rebuildRoutingTable(), removeFromAllRetransmissionLists(), and ~Router().

std::map<AreaID, Area *> inet::ospf::Router::areasByID

private

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

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

std::vector<ASExternalLSA *> inet::ospf::Router::asExternalLSAs

private

A list of the ASExternalLSAs advertised by this router.

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

std::map<LSAKeyType, ASExternalLSA *, LSAKeyType_Less> inet::ospf::Router::asExternalLSAsByID

private

A map of the ASExternalLSAs advertised by this router.

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

std::map<IPv4Address, OSPFASExternalLSAContents> inet::ospf::Router::externalRoutes

private

A map of the external route advertised by this router.

Referenced by removeExternalRoute(), and updateExternalRoute().

IInterfaceTable* inet::ospf::Router::ift

private

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

MessageHandler* inet::ospf::Router::messageHandler

private

The message dispatcher class.

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

bool inet::ospf::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 inet::ospf::Router::routerID

private

The router ID assigned by the IP layer.

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

std::vector<RoutingTableEntry *> inet::ospf::Router::routingTable

private

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

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

IIPv4RoutingTable* inet::ospf::Router::rt

private

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

---

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

• OSPFRouter.h
• OSPFRouter.cc