AnsaOSPFRouter.cc

Go to the documentation of this file.

#include "AnsaOSPFRouter.h"
#include "RoutingTableAccess.h"

AnsaOSPF::Router::Router(AnsaOSPF::RouterID id, cSimpleModule* containingModule) :
    routerID(id),
    rfc1583Compatibility(false)
{
    messageHandler = new AnsaOSPF::MessageHandler(this, containingModule);
    ageTimer = new OSPFTimer;
    ageTimer->setTimerKind(DatabaseAgeTimer);
    ageTimer->setContextPointer(this);
    ageTimer->setName("AnsaOSPF::Router::DatabaseAgeTimer");
    messageHandler->StartTimer(ageTimer, 1.0);
    
}


AnsaOSPF::Router::~Router(void)
{
    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;
}


void AnsaOSPF::Router::AddWatches(void)
{
    WATCH(routerID);
    WATCH_PTRVECTOR(areas);
    WATCH_PTRVECTOR(asExternalLSAs);
}


void AnsaOSPF::Router::AddArea(AnsaOSPF::Area* area)
{

    area->SetRouter(this);
    areasByID[area->GetAreaID()] = area;
    areas.push_back(area);
}


AnsaOSPF::Area* AnsaOSPF::Router::GetArea(AnsaOSPF::AreaID areaID)
{
    std::map<AnsaOSPF::AreaID, AnsaOSPF::Area*>::iterator areaIt = areasByID.find(areaID);
    if (areaIt != areasByID.end()) {
        return (areaIt->second);
    }
    else {
        return NULL;
    }
}


AnsaOSPF::Area* AnsaOSPF::Router::GetArea(AnsaOSPF::IPv4Address address)
{
    long areaCount = areas.size();
    for (long i = 0; i < areaCount; i++) {
        if (areas[i]->ContainsAddress(address)) {
            return areas[i];
        }
    }
    return NULL;
}


AnsaOSPF::Interface* AnsaOSPF::Router::GetNonVirtualInterface(unsigned char ifIndex)
{
    long areaCount = areas.size();
    for (long i = 0; i < areaCount; i++) {
        AnsaOSPF::Interface* intf = areas[i]->GetInterface(ifIndex);
        if (intf != NULL) {
            return intf;
        }
    }
    return NULL;
}


bool AnsaOSPF::Router::InstallLSA(OSPFLSA* lsa, AnsaOSPF::AreaID areaID /*= BackboneAreaID*/)
{
    switch (lsa->getHeader().getLsType()) {
        case RouterLSAType:
            {
                std::map<AnsaOSPF::AreaID, AnsaOSPF::Area*>::iterator areaIt = areasByID.find(areaID);
                if (areaIt != areasByID.end()) {
                    OSPFRouterLSA* ospfRouterLSA = check_and_cast<OSPFRouterLSA*> (lsa);
                    return areaIt->second->InstallRouterLSA(ospfRouterLSA);
                }
            }
            break;
        case NetworkLSAType:
            {
                std::map<AnsaOSPF::AreaID, AnsaOSPF::Area*>::iterator areaIt = areasByID.find(areaID);
                if (areaIt != areasByID.end()) {
                    OSPFNetworkLSA* ospfNetworkLSA = check_and_cast<OSPFNetworkLSA*> (lsa);
                    return areaIt->second->InstallNetworkLSA(ospfNetworkLSA);
                }
            }
            break;
        case SummaryLSA_NetworksType:
        case SummaryLSA_ASBoundaryRoutersType:
            {
                std::map<AnsaOSPF::AreaID, AnsaOSPF::Area*>::iterator areaIt = areasByID.find(areaID);
                if (areaIt != areasByID.end()) {
                    OSPFSummaryLSA* ospfSummaryLSA = check_and_cast<OSPFSummaryLSA*> (lsa);
                    return areaIt->second->InstallSummaryLSA(ospfSummaryLSA);
                }
            }
            break;
        case ASExternalLSAType:
            {
                OSPFASExternalLSA* ospfASExternalLSA = check_and_cast<OSPFASExternalLSA*> (lsa);
                return InstallASExternalLSA(ospfASExternalLSA);
            }
            break;
        default:
            ASSERT(false);
            break;
    }
    return false;
}


bool AnsaOSPF::Router::InstallASExternalLSA(OSPFASExternalLSA* lsa)
{
     // TODO: how to solve this problem?

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

    for (unsigned int i = 0; i < routeCount; i++) {
        if ((((routingTable[i]->GetDestinationType() & AnsaOSPF::RoutingTableEntry::AreaBorderRouterDestination) != 0) ||
             ((routingTable[i]->GetDestinationType() & AnsaOSPF::RoutingTableEntry::ASBoundaryRouterDestination) != 0)) &&
            (routingTable[i]->GetDestinationID().getInt() == advertisingRouter))
        {
            reachable = true;
            break;
        }
    }

    bool             ownLSAFloodedOut = false;
    AnsaOSPF::LSAKeyType lsaKey;

    lsaKey.linkStateID = lsa->getHeader().getLinkStateID();
    lsaKey.advertisingRouter = routerID;

    std::map<AnsaOSPF::LSAKeyType, AnsaOSPF::ASExternalLSA*, AnsaOSPF::LSAKeyType_Less>::iterator 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, AnsaOSPF::BackboneAreaID);
            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 {
        AnsaOSPF::ASExternalLSA* lsaCopy = new AnsaOSPF::ASExternalLSA(*lsa);
        asExternalLSAsByID[lsaKey] = lsaCopy;
        asExternalLSAs.push_back(lsaCopy);
        return true;
    }
}


OSPFLSA* AnsaOSPF::Router::FindLSA(LSAType lsaType, AnsaOSPF::LSAKeyType lsaKey, AnsaOSPF::AreaID areaID)
{
    switch (lsaType) {
        case RouterLSAType:
            {
                std::map<AnsaOSPF::AreaID, AnsaOSPF::Area*>::iterator areaIt = areasByID.find(areaID);
                if (areaIt != areasByID.end()) {
                    return areaIt->second->FindRouterLSA(lsaKey.linkStateID);
                }
            }
            break;
        case NetworkLSAType:
            {
                std::map<AnsaOSPF::AreaID, AnsaOSPF::Area*>::iterator areaIt = areasByID.find(areaID);
                if (areaIt != areasByID.end()) {
                    return areaIt->second->FindNetworkLSA(lsaKey.linkStateID);
                }
            }
            break;
        case SummaryLSA_NetworksType:
        case SummaryLSA_ASBoundaryRoutersType:
            {
                std::map<AnsaOSPF::AreaID, AnsaOSPF::Area*>::iterator areaIt = areasByID.find(areaID);
                if (areaIt != areasByID.end()) {
                    return areaIt->second->FindSummaryLSA(lsaKey);
                }
            }
            break;
        case ASExternalLSAType:
            {
                return FindASExternalLSA(lsaKey);
            }
            break;
        default:
            ASSERT(false);
            break;
    }
    return NULL;
}


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


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


void AnsaOSPF::Router::AgeDatabase(void)
{
    long lsaCount            = asExternalLSAs.size();
    bool rebuildRoutingTable = false;

    for (long i = 0; i < lsaCount; i++) {
        unsigned short       lsAge          = asExternalLSAs[i]->getHeader().getLsAge();
        bool                 selfOriginated = (asExternalLSAs[i]->getHeader().getAdvertisingRouter().getInt() == routerID);
        bool                 unreachable    = IsDestinationUnreachable(asExternalLSAs[i]);
        AnsaOSPF::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 << "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, AnsaOSPF::BackboneAreaID);
                lsa->IncrementInstallTime();
            } else {
                long sequenceNumber = lsa->getHeader().getLsSequenceNumber();
                if (sequenceNumber == MAX_SEQUENCE_NUMBER) {
                    lsa->getHeader().setLsAge(MAX_AGE);
                    FloodLSA(lsa, AnsaOSPF::BackboneAreaID);
                    lsa->IncrementInstallTime();
                } else {
                    AnsaOSPF::ASExternalLSA* newLSA = OriginateASExternalLSA(lsa);

                    newLSA->getHeader().setLsSequenceNumber(sequenceNumber + 1);
                    newLSA->getHeader().setLsChecksum(0);    // TODO: calculate correct LS checksum
                    rebuildRoutingTable |= lsa->Update(newLSA);
                    delete newLSA;

                    FloodLSA(lsa, AnsaOSPF::BackboneAreaID);
                }
            }
        }
        if (!selfOriginated && (lsAge == MAX_AGE - 1)) {
            lsa->getHeader().setLsAge(MAX_AGE);
            FloodLSA(lsa, AnsaOSPF::BackboneAreaID);
            lsa->IncrementInstallTime();
        }
        if (lsAge == MAX_AGE) {
            AnsaOSPF::LSAKeyType lsaKey;

            lsaKey.linkStateID       = lsa->getHeader().getLinkStateID();
            lsaKey.advertisingRouter = lsa->getHeader().getAdvertisingRouter().getInt();

            if (!IsOnAnyRetransmissionList(lsaKey) &&
                !HasAnyNeighborInStates(AnsaOSPF::Neighbor::ExchangeState | AnsaOSPF::Neighbor::LoadingState))
            {
                if (!selfOriginated || unreachable) {
                    asExternalLSAsByID.erase(lsaKey);
                    delete lsa;
                    asExternalLSAs[i] = NULL;
                    rebuildRoutingTable = true;
                } else {
                    if (lsa->GetPurgeable()) {
                        asExternalLSAsByID.erase(lsaKey);
                        delete lsa;
                        asExternalLSAs[i] = NULL;
                        rebuildRoutingTable = true;
                    } else {
                        AnsaOSPF::ASExternalLSA* newLSA              = OriginateASExternalLSA(lsa);
                        long                 sequenceNumber      = lsa->getHeader().getLsSequenceNumber();

                        newLSA->getHeader().setLsSequenceNumber((sequenceNumber == MAX_SEQUENCE_NUMBER) ? INITIAL_SEQUENCE_NUMBER : sequenceNumber + 1);
                        newLSA->getHeader().setLsChecksum(0);    // TODO: calculate correct LS checksum
                        rebuildRoutingTable |= lsa->Update(newLSA);
                        delete newLSA;

                        FloodLSA(lsa, AnsaOSPF::BackboneAreaID);
                    }
                }
            }
        }
    }

    std::vector<ASExternalLSA*>::iterator it = asExternalLSAs.begin();
    while (it != asExternalLSAs.end()) {
        if ((*it) == NULL) {
            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 (rebuildRoutingTable) {
        RebuildRoutingTable();
    }
}


bool AnsaOSPF::Router::HasAnyNeighborInStates(int states) const
{
    long areaCount = areas.size();
    for (long i = 0; i < areaCount; i++) {
        if (areas[i]->HasAnyNeighborInStates(states)) {
            return true;
        }
    }
    return false;
}


void AnsaOSPF::Router::RemoveFromAllRetransmissionLists(AnsaOSPF::LSAKeyType lsaKey)
{
    long areaCount = areas.size();
    for (long i = 0; i < areaCount; i++) {
        areas[i]->RemoveFromAllRetransmissionLists(lsaKey);
    }
}


bool AnsaOSPF::Router::IsOnAnyRetransmissionList(AnsaOSPF::LSAKeyType lsaKey) const
{
    long areaCount = areas.size();
    for (long i = 0; i < areaCount; i++) {
        if (areas[i]->IsOnAnyRetransmissionList(lsaKey)) {
            return true;
        }
    }
    return false;
}


bool AnsaOSPF::Router::FloodLSA(OSPFLSA* lsa, AnsaOSPF::AreaID areaID /*= BackboneAreaID*/, AnsaOSPF::Interface* intf /*= NULL*/, AnsaOSPF::Neighbor* neighbor /*= NULL*/)
{
    bool floodedBackOut = false;

    if (lsa != NULL) {
        if (lsa->getHeader().getLsType() == ASExternalLSAType) {
            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 {
            std::map<AnsaOSPF::AreaID, AnsaOSPF::Area*>::iterator areaIt = areasByID.find(areaID);
            if (areaIt != areasByID.end()) {
                floodedBackOut = areaIt->second->FloodLSA(lsa, intf, neighbor);
            }
        }
    }

    return floodedBackOut;
}


bool AnsaOSPF::Router::IsLocalAddress(AnsaOSPF::IPv4Address address) const
{
    long areaCount = areas.size();
    for (long i = 0; i < areaCount; i++) {
        if (areas[i]->IsLocalAddress(address)) {
            return true;
        }
    }
    return false;
}


bool AnsaOSPF::Router::HasAddressRange(AnsaOSPF::IPv4AddressRange addressRange) const
{
    long areaCount = areas.size();
    for (long i = 0; i < areaCount; i++) {
        if (areas[i]->HasAddressRange(addressRange)) {
            return true;
        }
    }
    return false;
}


AnsaOSPF::ASExternalLSA* AnsaOSPF::Router::OriginateASExternalLSA(AnsaOSPF::ASExternalLSA* lsa)
{
    AnsaOSPF::ASExternalLSA* asExternalLSA = new AnsaOSPF::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(AnsaOSPF::LSATrackingInfo::Originated);

    return asExternalLSA;
}


bool AnsaOSPF::Router::IsDestinationUnreachable(OSPFLSA* lsa) const
{
    IPAddress destination = 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 != NULL) {
        AnsaOSPF::RoutingInfo* routingInfo = check_and_cast<AnsaOSPF::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();
        AnsaOSPF::RouterLSA* toRouterLSA = dynamic_cast<AnsaOSPF::RouterLSA*> (routingInfo->GetParent());
        if (toRouterLSA != NULL) {
            bool      destinationFound           = false;
            bool      unnumberedPointToPointLink = false;
            IPAddress firstNumberedIfAddress;

            for (unsigned int i = 0; i < linkCount; i++) {
                Link& link = routerLSA->getLinks(i);

                if (link.getType() == PointToPointLink) {
                    if (link.getLinkID() == toRouterLSA->getHeader().getLinkStateID()) {
                        if ((link.getLinkData() & 0xFF000000) == 0) {
                            unnumberedPointToPointLink = true;
                            if (!firstNumberedIfAddress.isUnspecified()) {
                                break;
                            }
                        } else {
                            destination = link.getLinkData();
                            destinationFound = true;
                            break;
                        }
                    } else {
                        if (((link.getLinkData() & 0xFF000000) != 0) &&
                             firstNumberedIfAddress.isUnspecified())
                        {
                            firstNumberedIfAddress = link.getLinkData();
                        }
                    }
                } else if (link.getType() == TransitLink) {
                    if (firstNumberedIfAddress.isUnspecified()) {
                        firstNumberedIfAddress = link.getLinkData();
                    }
                } else if (link.getType() == VirtualLink) {
                    if (link.getLinkID() == toRouterLSA->getHeader().getLinkStateID()) {
                        destination = link.getLinkData();
                        destinationFound = true;
                        break;
                    } else {
                        if (firstNumberedIfAddress.isUnspecified()) {
                            firstNumberedIfAddress = link.getLinkData();
                        }
                    }
                }
                // There's no way to get an interface address for the router from a StubLink
            }
            if (unnumberedPointToPointLink) {
                if (!firstNumberedIfAddress.isUnspecified()) {
                    destination = firstNumberedIfAddress;
                } else {
                    return true;
                }
            }
            if (!destinationFound) {
                return true;
            }
        } else {
            AnsaOSPF::NetworkLSA* toNetworkLSA = dynamic_cast<AnsaOSPF::NetworkLSA*> (routingInfo->GetParent());
            if (toNetworkLSA != NULL) {
                // 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() == TransitLink) &&
                        (link.getLinkID() == toNetworkLSA->getHeader().getLinkStateID()))
                    {
                        destination = link.getLinkData();
                        destinationFound = true;
                        break;
                    }
                }
                if (!destinationFound) {
                    return true;
                }
            } else {
                return true;
            }
        }
    }
    if (networkLSA != NULL) {
        destination = networkLSA->getHeader().getLinkStateID() & networkLSA->getNetworkMask().getInt();
    }
    if ((summaryLSA != NULL) && (summaryLSA->getHeader().getLsType() == SummaryLSA_NetworksType)) {
        destination = summaryLSA->getHeader().getLinkStateID() & summaryLSA->getNetworkMask().getInt();
    }
    if (asExternalLSA != NULL) {
        destination = asExternalLSA->getHeader().getLinkStateID() & asExternalLSA->getContents().getNetworkMask().getInt();
    }

    if (Lookup(destination) == NULL) {
        return true;
    } else {
        return false;
    }
}


AnsaOSPF::RoutingTableEntry* AnsaOSPF::Router::Lookup(IPAddress destination, std::vector<AnsaOSPF::RoutingTableEntry*>* table /*= NULL*/) const
{
    const std::vector<AnsaOSPF::RoutingTableEntry*>& rTable           = (table == NULL) ? routingTable : (*table);
    unsigned long                                dest             = destination.getInt();
    unsigned long                                routingTableSize = rTable.size();
    bool                                         unreachable      = false;
    std::vector<AnsaOSPF::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++) {
            AnsaOSPF::IPv4AddressRange range = areas[i]->GetAddressRange(j);

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

                if (entry->GetDestinationType() != AnsaOSPF::RoutingTableEntry::NetworkDestination) {
                    continue;
                }
                if (((entry->GetDestinationID().getInt() & entry->GetAddressMask().getInt() & ULongFromIPv4Address(range.mask)) == ULongFromIPv4Address(range.address & range.mask)) &&
                    (entry->GetPathType() == AnsaOSPF::RoutingTableEntry::IntraArea))
                {
                    // active area address range
                    AnsaOSPF::RoutingTableEntry* discardEntry = new AnsaOSPF::RoutingTableEntry;
                    discardEntry->SetDestinationID(ULongFromIPv4Address(range.address));
                    discardEntry->SetAddressMask(ULongFromIPv4Address(range.mask));
                    discardEntry->SetDestinationType(AnsaOSPF::RoutingTableEntry::NetworkDestination);
                    discardEntry->SetPathType(AnsaOSPF::RoutingTableEntry::InterArea);
                    discardEntry->SetArea(areas[i]->GetAreaID());
                    discard.push_back(discardEntry);
                    break;
                }
            }
        }
    }

    AnsaOSPF::RoutingTableEntry* bestMatch = NULL;
    unsigned long            longestMatch = 0;

    for (i = 0; i < routingTableSize; i++) {
        if (rTable[i]->GetDestinationType() == AnsaOSPF::RoutingTableEntry::NetworkDestination) {
            AnsaOSPF::RoutingTableEntry* entry        = rTable[i];
            unsigned long            entryAddress = entry->GetDestinationID().getInt();
            unsigned long            entryMask    = entry->GetAddressMask().getInt();

            if ((entryAddress & entryMask) == (dest & entryMask)) {
                if ((dest & entryMask) > longestMatch) {
                    longestMatch = (dest & entryMask);
                    bestMatch    = entry;
                }
            }
        }
    }

    unsigned int discardCount = discard.size();
    if (bestMatch == NULL) {
        unreachable = true;
    } else {
        for (i = 0; i < discardCount; i++) {
            AnsaOSPF::RoutingTableEntry* entry        = discard[i];
            unsigned long            entryAddress = entry->GetDestinationID().getInt();
            unsigned long            entryMask    = entry->GetAddressMask().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 NULL;
    } else {
        return bestMatch;
    }
}


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

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

    for (i = 0; i < areaCount; i++) {
        areas[i]->CalculateShortestPathTree(newTable);
        if (areas[i]->GetTransitCapability()) {
            hasTransitAreas = true;
        }
    }
    if (areaCount > 1) {
        AnsaOSPF::Area* backbone = GetArea(AnsaOSPF::BackboneAreaID);
        if (backbone != NULL) {
            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<AnsaOSPF::RoutingTableEntry*> oldTable;

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

    RoutingTableAccess         routingTableAccess;
    std::vector<const IPRoute*> eraseEntries;
    IRoutingTable*              simRoutingTable    = routingTableAccess.get();
    unsigned long              routingEntryNumber = simRoutingTable->getNumRoutes();
    // remove entries from the IP routing table inserted by the OSPF module
    for (i = 0; i < routingEntryNumber; i++) {
        const IPRoute *entry = simRoutingTable->getRoute(i);
        const AnsaOSPF::RoutingTableEntry* ospfEntry = dynamic_cast<const AnsaOSPF::RoutingTableEntry*>(entry);
        if (ospfEntry != NULL) {
            eraseEntries.push_back(entry);
        }
    }

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

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

    NotifyAboutRoutingTableChanges(oldTable);

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

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

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


bool AnsaOSPF::Router::HasRouteToASBoundaryRouter(const std::vector<AnsaOSPF::RoutingTableEntry*>& inRoutingTable, AnsaOSPF::RouterID asbrRouterID) const
{
    long routeCount = inRoutingTable.size();
    for (long i = 0; i < routeCount; i++) {
        AnsaOSPF::RoutingTableEntry* routingEntry = inRoutingTable[i];
        if (((routingEntry->GetDestinationType() & AnsaOSPF::RoutingTableEntry::ASBoundaryRouterDestination) != 0) &&
            (routingEntry->GetDestinationID().getInt() == asbrRouterID))
        {
            return true;
        }
    }
    return false;
}


std::vector<AnsaOSPF::RoutingTableEntry*> AnsaOSPF::Router::GetRoutesToASBoundaryRouter(const std::vector<AnsaOSPF::RoutingTableEntry*>& fromRoutingTable, AnsaOSPF::RouterID asbrRouterID) const
{
    std::vector<AnsaOSPF::RoutingTableEntry*> results;
    long                                  routeCount = fromRoutingTable.size();

    for (long i = 0; i < routeCount; i++) {
        AnsaOSPF::RoutingTableEntry* routingEntry = fromRoutingTable[i];
        if (((routingEntry->GetDestinationType() & AnsaOSPF::RoutingTableEntry::ASBoundaryRouterDestination) != 0) &&
            (routingEntry->GetDestinationID().getInt() == asbrRouterID))
        {
            results.push_back(routingEntry);
        }
    }
    return results;
}


void AnsaOSPF::Router::PruneASBoundaryRouterEntries(std::vector<AnsaOSPF::RoutingTableEntry*>& asbrEntries) const
{
    bool hasNonBackboneIntraAreaPath = false;
    for (std::vector<AnsaOSPF::RoutingTableEntry*>::iterator it = asbrEntries.begin(); it != asbrEntries.end(); it++) {
        AnsaOSPF::RoutingTableEntry* routingEntry = *it;
        if ((routingEntry->GetPathType() == AnsaOSPF::RoutingTableEntry::IntraArea) &&
            (routingEntry->GetArea() != AnsaOSPF::BackboneAreaID))
        {
            hasNonBackboneIntraAreaPath = true;
            break;
        }
    }

    if (hasNonBackboneIntraAreaPath) {
        std::vector<AnsaOSPF::RoutingTableEntry*>::iterator it = asbrEntries.begin();
        while (it != asbrEntries.end()) {
            if (((*it)->GetPathType() != AnsaOSPF::RoutingTableEntry::IntraArea) ||
                ((*it)->GetArea() == AnsaOSPF::BackboneAreaID))
            {
                it = asbrEntries.erase(it);
            } else {
                it++;
            }
        }
    }
}


AnsaOSPF::RoutingTableEntry* AnsaOSPF::Router::SelectLeastCostRoutingEntry(std::vector<AnsaOSPF::RoutingTableEntry*>& entries) const
{
    if (entries.empty()) {
        return NULL;
    }

    AnsaOSPF::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;
}


AnsaOSPF::RoutingTableEntry* AnsaOSPF::Router::GetPreferredEntry(const OSPFLSA& lsa, bool skipSelfOriginated, std::vector<AnsaOSPF::RoutingTableEntry*>* fromRoutingTable /*= NULL*/)
{
    if (fromRoutingTable == NULL) {
        fromRoutingTable = &routingTable;
    }

    const OSPFLSAHeader&     lsaHeader         = lsa.getHeader();
    const OSPFASExternalLSA* asExternalLSA     = dynamic_cast<const OSPFASExternalLSA*> (&lsa);
    unsigned long            externalCost      = (asExternalLSA != NULL) ? asExternalLSA->getContents().getRouteCost() : 0;
    unsigned short           lsAge             = lsaHeader.getLsAge();
    AnsaOSPF::RouterID           originatingRouter = lsaHeader.getAdvertisingRouter().getInt();
    bool                     selfOriginated    = (originatingRouter == routerID);
    IPAddress                forwardingAddress; // 0.0.0.0

    if (asExternalLSA != NULL) {
        forwardingAddress = asExternalLSA->getContents().getForwardingAddress();
    }

    if ((externalCost == LS_INFINITY) || (lsAge == MAX_AGE) || (skipSelfOriginated && selfOriginated)) { // (1) and(2)
        return NULL;
    }

    if (!HasRouteToASBoundaryRouter(*fromRoutingTable, originatingRouter)) { // (3)
        return NULL;
    }

    if (forwardingAddress.isUnspecified()) {   // (3)
        std::vector<AnsaOSPF::RoutingTableEntry*> asbrEntries = GetRoutesToASBoundaryRouter(*fromRoutingTable, originatingRouter);
        if (!rfc1583Compatibility) {
            PruneASBoundaryRouterEntries(asbrEntries);
        }
        return SelectLeastCostRoutingEntry(asbrEntries);
    } else {
        AnsaOSPF::RoutingTableEntry* forwardEntry = Lookup(forwardingAddress, fromRoutingTable);

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

        if ((forwardEntry->GetPathType() != AnsaOSPF::RoutingTableEntry::IntraArea) &&
            (forwardEntry->GetPathType() != AnsaOSPF::RoutingTableEntry::InterArea))
        {
            return NULL;
        }

        return forwardEntry;
    }

    return NULL;
}


void AnsaOSPF::Router::CalculateASExternalRoutes(std::vector<AnsaOSPF::RoutingTableEntry*>& newRoutingTable)
{
    unsigned long lsaCount = asExternalLSAs.size();
    unsigned long i;

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

        AnsaOSPF::RoutingTableEntry* preferredEntry = GetPreferredEntry(*currentLSA, true, &newRoutingTable);
        if (preferredEntry == NULL) {
            continue;
        }

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

        Metric                   preferredCost    = preferredEntry->GetCost();
        AnsaOSPF::RoutingTableEntry* destinationEntry = Lookup(destination, &newRoutingTable);   // (5)
        if (destinationEntry == NULL) {
            bool                     type2ExternalMetric = currentLSA->getContents().getE_ExternalMetricType();
            unsigned int             nextHopCount        = preferredEntry->GetNextHopCount();
            AnsaOSPF::RoutingTableEntry* newEntry            = new AnsaOSPF::RoutingTableEntry;

            newEntry->SetDestinationID(destination);
            newEntry->SetAddressMask(currentLSA->getContents().getNetworkMask().getInt());
            newEntry->SetArea(preferredEntry->GetArea());
            newEntry->SetPathType(type2ExternalMetric ? AnsaOSPF::RoutingTableEntry::Type2External : AnsaOSPF::RoutingTableEntry::Type1External);
            if (type2ExternalMetric) {
                newEntry->SetCost(preferredCost);
                newEntry->SetType2Cost(externalCost);
            } else {
                newEntry->SetCost(preferredCost + externalCost);
            }
            newEntry->SetDestinationType(AnsaOSPF::RoutingTableEntry::NetworkDestination);
            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 {
            AnsaOSPF::RoutingTableEntry::RoutingPathType destinationPathType = destinationEntry->GetPathType();
            bool                                     type2ExternalMetric = currentLSA->getContents().getE_ExternalMetricType();
            unsigned int                             nextHopCount        = preferredEntry->GetNextHopCount();

            if ((destinationPathType == AnsaOSPF::RoutingTableEntry::IntraArea) ||
                (destinationPathType == AnsaOSPF::RoutingTableEntry::InterArea))   // (6) (a)
            {
                continue;
            }

            if (((destinationPathType == AnsaOSPF::RoutingTableEntry::Type1External) &&
                 (type2ExternalMetric)) ||
                ((destinationPathType == AnsaOSPF::RoutingTableEntry::Type2External) &&
                 (type2ExternalMetric) &&
                 (destinationEntry->GetType2Cost() < externalCost))) // (6) (b)
            {
                continue;
            }

            AnsaOSPF::RoutingTableEntry* destinationPreferredEntry = GetPreferredEntry(*(destinationEntry->GetLinkStateOrigin()), false, &newRoutingTable);
            if ((!rfc1583Compatibility) &&
                (destinationPreferredEntry->GetPathType() == AnsaOSPF::RoutingTableEntry::IntraArea) &&
                (destinationPreferredEntry->GetArea() != AnsaOSPF::BackboneAreaID) &&
                ((preferredEntry->GetPathType() != AnsaOSPF::RoutingTableEntry::IntraArea) ||
                 (preferredEntry->GetArea() == AnsaOSPF::BackboneAreaID)))
            {
                continue;
            }

            if ((((destinationPathType == AnsaOSPF::RoutingTableEntry::Type1External) &&
                  (!type2ExternalMetric) &&
                  (destinationEntry->GetCost() < preferredCost + externalCost))) ||
                ((destinationPathType == AnsaOSPF::RoutingTableEntry::Type2External) &&
                 (type2ExternalMetric) &&
                 (destinationEntry->GetType2Cost() == externalCost) &&
                 (destinationPreferredEntry->GetCost() < preferredCost)))
            {
                continue;
            }

            if (((destinationPathType == AnsaOSPF::RoutingTableEntry::Type1External) &&
                 (!type2ExternalMetric) &&
                 (destinationEntry->GetCost() == (preferredCost + externalCost))) ||
                ((destinationPathType == AnsaOSPF::RoutingTableEntry::Type2External) &&
                 (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 ? AnsaOSPF::RoutingTableEntry::Type2External : AnsaOSPF::RoutingTableEntry::Type1External);
            if (type2ExternalMetric) {
                destinationEntry->SetCost(preferredCost);
                destinationEntry->SetType2Cost(externalCost);
            } else {
                destinationEntry->SetCost(preferredCost + externalCost);
            }
            destinationEntry->SetDestinationType(AnsaOSPF::RoutingTableEntry::NetworkDestination);
            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);
            }
        }
    }
}


AnsaOSPF::IPv4AddressRange AnsaOSPF::Router::GetContainingAddressRange(AnsaOSPF::IPv4AddressRange addressRange, bool* advertise /*= NULL*/) const
{
    unsigned long areaCount = areas.size();
    for (unsigned long i = 0; i < areaCount; i++) {
        AnsaOSPF::IPv4AddressRange containingAddressRange = areas[i]->GetContainingAddressRange(addressRange, advertise);
        if (containingAddressRange != AnsaOSPF::NullIPv4AddressRange) {
            return containingAddressRange;
        }
    }
    if (advertise != NULL) {
        *advertise = false;
    }
    return AnsaOSPF::NullIPv4AddressRange;
}


AnsaOSPF::LinkStateID AnsaOSPF::Router::GetUniqueLinkStateID(AnsaOSPF::IPv4AddressRange destination,
                                                      AnsaOSPF::Metric destinationCost,
                                                      AnsaOSPF::ASExternalLSA*& lsaToReoriginate,
                                                      bool externalMetricIsType2 /*= false*/) const
{
    if (lsaToReoriginate != NULL) {
        delete lsaToReoriginate;
        lsaToReoriginate = NULL;
    }

    AnsaOSPF::LSAKeyType lsaKey;

    lsaKey.linkStateID = ULongFromIPv4Address(destination.address);
    lsaKey.advertisingRouter = routerID;

    const AnsaOSPF::ASExternalLSA* foundLSA = FindASExternalLSA(lsaKey);

    if (foundLSA == NULL) {
        return lsaKey.linkStateID;
    } else {
        AnsaOSPF::IPv4Address existingMask = IPv4AddressFromULong(foundLSA->getContents().getNetworkMask().getInt());

        if (destination.mask >= existingMask) {
            return (lsaKey.linkStateID | (~(ULongFromIPv4Address(destination.mask))));
        } else {
            AnsaOSPF::ASExternalLSA* asExternalLSA = new AnsaOSPF::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(ULongFromIPv4Address(destination.mask));
            asExternalLSA->getContents().setE_ExternalMetricType(externalMetricIsType2);
            asExternalLSA->getContents().setRouteCost(destinationCost);
            asExternalLSA->getHeader().setLsChecksum(0);    // TODO: calculate correct LS checksum

            lsaToReoriginate = asExternalLSA;

            return (lsaKey.linkStateID | (~(ULongFromIPv4Address(existingMask))));
        }
    }
}


// TODO: review this algorithm + add virtual link changes(RFC2328 Section 16.7.).
void AnsaOSPF::Router::NotifyAboutRoutingTableChanges(std::vector<AnsaOSPF::RoutingTableEntry*>& oldRoutingTable)
{
    if (areas.size() <= 1) {
        return;
    }

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

    for (i = 0; i < routeCount; i++) {
        unsigned long destination = oldRoutingTable[i]->GetDestinationID().getInt() & oldRoutingTable[i]->GetAddressMask().getInt();
        oldTableMap[destination] = oldRoutingTable[i];
    }

    routeCount = routingTable.size();
    for (i = 0; i < routeCount; i++) {
        unsigned long   destination = routingTable[i]->GetDestinationID().getInt() & routingTable[i]->GetAddressMask().getInt();
        newTableMap[destination] = routingTable[i];
    }

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

        routeCount = routingTable.size();
        for (j = 0; j < routeCount; j++) {
            unsigned long                                         destination = routingTable[j]->GetDestinationID().getInt() & routingTable[j]->GetAddressMask().getInt();
            std::map<unsigned long, RoutingTableEntry*>::iterator destIt      = oldTableMap.find(destination);
            if (destIt == oldTableMap.end()) { // new routing entry
                AnsaOSPF::SummaryLSA* lsaToReoriginate = NULL;
                AnsaOSPF::SummaryLSA* newLSA           = areas[i]->OriginateSummaryLSA(routingTable[j], originatedLSAMap, lsaToReoriginate);

                if (newLSA != NULL) {
                    if (lsaToReoriginate != NULL) {
                        areas[i]->InstallSummaryLSA(lsaToReoriginate);
//                        FloodLSA(lsaToReoriginate, AnsaOSPF::BackboneAreaID);
                        FloodLSA(lsaToReoriginate, areas[i]->GetAreaID());

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

                        delete lsaToReoriginate;
                    }

                    areas[i]->InstallSummaryLSA(newLSA);
//                    FloodLSA(newLSA, AnsaOSPF::BackboneAreaID);
                    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
                    AnsaOSPF::SummaryLSA* lsaToReoriginate = NULL;
                    AnsaOSPF::SummaryLSA* newLSA           = areas[i]->OriginateSummaryLSA(routingTable[j], originatedLSAMap, lsaToReoriginate);

                    if (newLSA != NULL) {
                        if (lsaToReoriginate != NULL) {
                            areas[i]->InstallSummaryLSA(lsaToReoriginate);
//                            FloodLSA(lsaToReoriginate, AnsaOSPF::BackboneAreaID);
                            FloodLSA(lsaToReoriginate, areas[i]->GetAreaID());

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

                            delete lsaToReoriginate;
                        }

                        areas[i]->InstallSummaryLSA(newLSA);
//                        FloodLSA(newLSA, AnsaOSPF::BackboneAreaID);
                        FloodLSA(newLSA, areas[i]->GetAreaID());

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

                        delete newLSA;
                    } else {
                        AnsaOSPF::IPv4AddressRange destinationAddressRange;

                        destinationAddressRange.address = IPv4AddressFromULong(routingTable[j]->GetDestinationID().getInt());
                        destinationAddressRange.mask = IPv4AddressFromULong(routingTable[j]->GetAddressMask().getInt());

                        if ((routingTable[j]->GetDestinationType() == AnsaOSPF::RoutingTableEntry::NetworkDestination) &&
                            ((routingTable[j]->GetPathType() == AnsaOSPF::RoutingTableEntry::IntraArea) ||
                             (routingTable[j]->GetPathType() == AnsaOSPF::RoutingTableEntry::InterArea)))
                        {
                            AnsaOSPF::IPv4AddressRange containingAddressRange = GetContainingAddressRange(destinationAddressRange);
                            if (containingAddressRange != AnsaOSPF::NullIPv4AddressRange) {
                                destinationAddressRange = containingAddressRange;
                            }
                        }

                        Metric maxRangeCost = 0;
                        Metric oneLessCost  = 0;

                        for (k = 0; k < routeCount; k++) {
                            if ((routingTable[k]->GetDestinationType() == AnsaOSPF::RoutingTableEntry::NetworkDestination) &&
                                (routingTable[k]->GetPathType() == AnsaOSPF::RoutingTableEntry::IntraArea) &&
                                ((routingTable[k]->GetDestinationID().getInt() & routingTable[k]->GetAddressMask().getInt() & ULongFromIPv4Address(destinationAddressRange.mask)) ==
                                 ULongFromIPv4Address(destinationAddressRange.address & destinationAddressRange.mask)) &&
                                (routingTable[k]->GetCost() > maxRangeCost))
                            {
                                oneLessCost  = maxRangeCost;
                                maxRangeCost = routingTable[k]->GetCost();
                            }
                        }

                        if (maxRangeCost == routingTable[j]->GetCost()) {  // this entry gives the range's cost
                            lsaKey.linkStateID       = ULongFromIPv4Address(destinationAddressRange.address);
                            lsaKey.advertisingRouter = routerID;

                            AnsaOSPF::SummaryLSA* summaryLSA = areas[i]->FindSummaryLSA(lsaKey);

                            if (summaryLSA != NULL) {
                                if (oneLessCost != 0) { // there's an other entry in this range
                                    summaryLSA->setRouteCost(oneLessCost);
//                                    FloodLSA(summaryLSA, AnsaOSPF::BackboneAreaID);
                                    FloodLSA(summaryLSA, areas[i]->GetAreaID());

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

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

        routeCount = oldRoutingTable.size();
        for (j = 0; j < routeCount; j++) {
            unsigned long                                         destination = oldRoutingTable[j]->GetDestinationID().getInt() & oldRoutingTable[j]->GetAddressMask().getInt();
            std::map<unsigned long, RoutingTableEntry*>::iterator destIt      = newTableMap.find(destination);
            if (destIt == newTableMap.end()) { // deleted routing entry

                AnsaOSPF::IPv4AddressRange destinationAddressRange;

                destinationAddressRange.address = IPv4AddressFromULong(oldRoutingTable[j]->GetDestinationID().getInt());
                destinationAddressRange.mask = IPv4AddressFromULong(oldRoutingTable[j]->GetAddressMask().getInt());

                if ((oldRoutingTable[j]->GetDestinationType() == AnsaOSPF::RoutingTableEntry::NetworkDestination) &&
                    ((oldRoutingTable[j]->GetPathType() == AnsaOSPF::RoutingTableEntry::IntraArea) ||
                     (oldRoutingTable[j]->GetPathType() == AnsaOSPF::RoutingTableEntry::InterArea)))
                {
                    AnsaOSPF::IPv4AddressRange containingAddressRange = GetContainingAddressRange(destinationAddressRange);
                    if (containingAddressRange != AnsaOSPF::NullIPv4AddressRange) {
                        destinationAddressRange = containingAddressRange;
                    }
                }

                Metric maxRangeCost = 0;

                unsigned long newRouteCount = routingTable.size();
                for (k = 0; k < newRouteCount; k++) {
                    if ((routingTable[k]->GetDestinationType() == AnsaOSPF::RoutingTableEntry::NetworkDestination) &&
                        (routingTable[k]->GetPathType() == AnsaOSPF::RoutingTableEntry::IntraArea) &&
                        ((routingTable[k]->GetDestinationID().getInt() & routingTable[k]->GetAddressMask().getInt() & ULongFromIPv4Address(destinationAddressRange.mask)) ==
                         ULongFromIPv4Address(destinationAddressRange.address & destinationAddressRange.mask)) &&
                        (routingTable[k]->GetCost() > maxRangeCost))
                    {
                        maxRangeCost = routingTable[k]->GetCost();
                    }
                }

                if (maxRangeCost < oldRoutingTable[j]->GetCost()) {  // the range's cost will change
                    lsaKey.linkStateID       = ULongFromIPv4Address(destinationAddressRange.address);
                    lsaKey.advertisingRouter = routerID;

                    AnsaOSPF::SummaryLSA* summaryLSA = areas[i]->FindSummaryLSA(lsaKey);

                    if (summaryLSA != NULL) {
                        if (maxRangeCost > 0) { // there's an other entry in this range
                            summaryLSA->setRouteCost(maxRangeCost);
//                            FloodLSA(summaryLSA, AnsaOSPF::BackboneAreaID);
                            FloodLSA(summaryLSA, areas[i]->GetAreaID());

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

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


void AnsaOSPF::Router::UpdateExternalRoute(AnsaOSPF::IPv4Address networkAddress, const OSPFASExternalLSAContents& externalRouteContents, int ifIndex)
{
    AnsaOSPF::ASExternalLSA* asExternalLSA = new AnsaOSPF::ASExternalLSA;
    OSPFLSAHeader&       lsaHeader     = asExternalLSA->getHeader();
    OSPFOptions          lsaOptions;
    //AnsaOSPF::LSAKeyType     lsaKey;

    IRoutingTable*      simRoutingTable    = RoutingTableAccess().get();
    unsigned long      routingEntryNumber = simRoutingTable->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 IPRoute *entry = simRoutingTable->getRoute(i);
        if ((entry->getHost().getInt() & entry->getNetmask().getInt()) ==
            (ULongFromIPv4Address(networkAddress) & externalRouteContents.getNetworkMask().getInt()))
        {
            inRoutingTable = true;
        }
    }
    if (!inRoutingTable) {
        IPRoute* entry = new IPRoute;
        entry->setHost(ULongFromIPv4Address(networkAddress));
        entry->setNetmask(externalRouteContents.getNetworkMask());
        entry->setInterface(InterfaceTableAccess().get()->getInterfaceById(ifIndex));
        entry->setType(IPRoute::REMOTE);
        entry->setSource(IPRoute::MANUAL);
        entry->setMetric(externalRouteContents.getRouteCost());
        simRoutingTable->addRoute(entry);   // IRoutingTable deletes entry pointer
    }

    lsaHeader.setLsAge(0);
    memset(&lsaOptions, 0, sizeof(OSPFOptions));
    lsaOptions.E_ExternalRoutingCapability = true;
    lsaHeader.setLsOptions(lsaOptions);
    lsaHeader.setLsType(ASExternalLSAType);
    lsaHeader.setLinkStateID(ULongFromIPv4Address(networkAddress));   // TODO: get unique LinkStateID
    lsaHeader.setAdvertisingRouter(routerID);
    lsaHeader.setLsSequenceNumber(INITIAL_SEQUENCE_NUMBER);

    asExternalLSA->setContents(externalRouteContents);

    lsaHeader.setLsChecksum(0);    // TODO: calculate correct LS checksum

    asExternalLSA->SetSource(AnsaOSPF::LSATrackingInfo::Originated);

    externalRoutes[networkAddress] = externalRouteContents;

    bool rebuild = InstallASExternalLSA(asExternalLSA);
    FloodLSA(asExternalLSA, AnsaOSPF::BackboneAreaID);
    delete asExternalLSA;

    if (rebuild) {
        RebuildRoutingTable();
    }
}


void AnsaOSPF::Router::RemoveExternalRoute(AnsaOSPF::IPv4Address networkAddress)
{
    AnsaOSPF::LSAKeyType     lsaKey;

    lsaKey.linkStateID = ULongFromIPv4Address(networkAddress);
    lsaKey.advertisingRouter = routerID;

    std::map<AnsaOSPF::LSAKeyType, AnsaOSPF::ASExternalLSA*, AnsaOSPF::LSAKeyType_Less>::iterator lsaIt = asExternalLSAsByID.find(lsaKey);
    if (lsaIt != asExternalLSAsByID.end()) {
        lsaIt->second->getHeader().setLsAge(MAX_AGE);
        lsaIt->second->SetPurgeable();
        FloodLSA(lsaIt->second, AnsaOSPF::BackboneAreaID);
    }

    std::map<AnsaOSPF::IPv4Address, OSPFASExternalLSAContents, AnsaOSPF::IPv4Address_Less>::iterator externalIt = externalRoutes.find(networkAddress);
    if (externalIt != externalRoutes.end()) {
        externalRoutes.erase(externalIt);
    }
}