| #include <string> |
| #include <utility> |
| #include "lsdb.hpp" |
| #include "nlsr.hpp" |
| |
| namespace nlsr { |
| |
| using namespace std; |
| |
| void |
| Lsdb::cancelScheduleLsaExpiringEvent(Nlsr& pnlsr, EventId eid) |
| { |
| pnlsr.getScheduler().cancelEvent(eid); |
| } |
| |
| static bool |
| nameLsaCompareByKey(NameLsa& nlsa1, string& key) |
| { |
| return nlsa1.getKey() == key; |
| } |
| |
| |
| bool |
| Lsdb::buildAndInstallOwnNameLsa(Nlsr& pnlsr) |
| { |
| NameLsa nameLsa(pnlsr.getConfParameter().getRouterPrefix() |
| , 1 |
| , pnlsr.getSm().getNameLsaSeq() + 1 |
| , pnlsr.getConfParameter().getRouterDeadInterval() |
| , pnlsr.getNpl()); |
| pnlsr.getSm().setNameLsaSeq(pnlsr.getSm().getNameLsaSeq() + 1); |
| return installNameLsa(pnlsr, nameLsa); |
| } |
| |
| std::pair<NameLsa&, bool> |
| Lsdb::getNameLsa(string key) |
| { |
| std::list<NameLsa>::iterator it = std::find_if(m_nameLsdb.begin(), |
| m_nameLsdb.end(), |
| bind(nameLsaCompareByKey, _1, key)); |
| if (it != m_nameLsdb.end()) |
| { |
| return std::make_pair(boost::ref((*it)), true); |
| } |
| NameLsa nlsa; |
| return std::make_pair(boost::ref(nlsa), false); |
| } |
| |
| bool |
| Lsdb::isNameLsaNew(string key, uint64_t seqNo) |
| { |
| std::pair<NameLsa&, bool> nameLsaCheck = getNameLsa(key); |
| if (nameLsaCheck.second) |
| { |
| if (nameLsaCheck.first.getLsSeqNo() < seqNo) |
| { |
| return true; |
| } |
| else |
| { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| ndn::EventId |
| Lsdb::scheduleNameLsaExpiration(Nlsr& pnlsr, string key, int seqNo, int expTime) |
| { |
| return pnlsr.getScheduler().scheduleEvent(ndn::time::seconds(expTime), |
| ndn::bind(&Lsdb::exprireOrRefreshNameLsa, |
| this, boost::ref(pnlsr), key, seqNo)); |
| } |
| |
| bool |
| Lsdb::installNameLsa(Nlsr& pnlsr, NameLsa& nlsa) |
| { |
| int timeToExpire = m_lsaRefreshTime; |
| std::pair<NameLsa&, bool> chkNameLsa = getNameLsa(nlsa.getKey()); |
| if (!chkNameLsa.second) |
| { |
| addNameLsa(nlsa); |
| nlsa.writeLog(); |
| printNameLsdb(); |
| if (nlsa.getOrigRouter() != pnlsr.getConfParameter().getRouterPrefix()) |
| { |
| pnlsr.getNpt().addNpteByDestName(nlsa.getOrigRouter(), nlsa.getOrigRouter(), |
| pnlsr); |
| std::list<string> nameList = nlsa.getNpl().getNameList(); |
| for (std::list<string>::iterator it = nameList.begin(); it != nameList.end(); |
| it++) |
| { |
| if ((*it) != pnlsr.getConfParameter().getRouterPrefix()) |
| { |
| pnlsr.getNpt().addNpteByDestName((*it), nlsa.getOrigRouter(), pnlsr); |
| } |
| } |
| } |
| if (nlsa.getOrigRouter() != pnlsr.getConfParameter().getRouterPrefix()) |
| { |
| timeToExpire = nlsa.getLifeTime(); |
| } |
| nlsa.setExpiringEventId(scheduleNameLsaExpiration(pnlsr, |
| nlsa.getKey(), |
| nlsa.getLsSeqNo(), |
| timeToExpire)); |
| } |
| else |
| { |
| if (chkNameLsa.first.getLsSeqNo() < nlsa.getLsSeqNo()) |
| { |
| chkNameLsa.first.writeLog(); |
| chkNameLsa.first.setLsSeqNo(nlsa.getLsSeqNo()); |
| chkNameLsa.first.setLifeTime(nlsa.getLifeTime()); |
| chkNameLsa.first.getNpl().sort(); |
| nlsa.getNpl().sort(); |
| std::list<string> nameToAdd; |
| std::set_difference(nlsa.getNpl().getNameList().begin(), |
| nlsa.getNpl().getNameList().end(), |
| chkNameLsa.first.getNpl().getNameList().begin(), |
| chkNameLsa.first.getNpl().getNameList().end(), |
| std::inserter(nameToAdd, nameToAdd.begin())); |
| for (std::list<string>::iterator it = nameToAdd.begin(); it != nameToAdd.end(); |
| ++it) |
| { |
| chkNameLsa.first.addName((*it)); |
| if (nlsa.getOrigRouter() != pnlsr.getConfParameter().getRouterPrefix()) |
| { |
| if ((*it) != pnlsr.getConfParameter().getRouterPrefix()) |
| { |
| pnlsr.getNpt().addNpteByDestName((*it), nlsa.getOrigRouter(), pnlsr); |
| } |
| } |
| } |
| std::list<string> nameToRemove; |
| std::set_difference(chkNameLsa.first.getNpl().getNameList().begin(), |
| chkNameLsa.first.getNpl().getNameList().end(), |
| nlsa.getNpl().getNameList().begin(), |
| nlsa.getNpl().getNameList().end(), |
| std::inserter(nameToRemove, nameToRemove.begin())); |
| for (std::list<string>::iterator it = nameToRemove.begin(); |
| it != nameToRemove.end(); ++it) |
| { |
| chkNameLsa.first.removeName((*it)); |
| if (nlsa.getOrigRouter() != pnlsr.getConfParameter().getRouterPrefix()) |
| { |
| if ((*it) != pnlsr.getConfParameter().getRouterPrefix()) |
| { |
| pnlsr.getNpt().removeNpte((*it), nlsa.getOrigRouter(), pnlsr); |
| } |
| } |
| } |
| if (nlsa.getOrigRouter() != pnlsr.getConfParameter().getRouterPrefix()) |
| { |
| timeToExpire = nlsa.getLifeTime(); |
| } |
| cancelScheduleLsaExpiringEvent(pnlsr, |
| chkNameLsa.first.getExpiringEventId()); |
| chkNameLsa.first.setExpiringEventId(scheduleNameLsaExpiration(pnlsr, |
| nlsa.getKey(), |
| nlsa.getLsSeqNo(), |
| timeToExpire)); |
| chkNameLsa.first.writeLog(); |
| } |
| } |
| return true; |
| } |
| |
| bool |
| Lsdb::addNameLsa(NameLsa& nlsa) |
| { |
| std::list<NameLsa>::iterator it = std::find_if(m_nameLsdb.begin(), |
| m_nameLsdb.end(), |
| bind(nameLsaCompareByKey, _1, |
| nlsa.getKey())); |
| if (it == m_nameLsdb.end()) |
| { |
| m_nameLsdb.push_back(nlsa); |
| return true; |
| } |
| return false; |
| } |
| |
| bool |
| Lsdb::removeNameLsa(Nlsr& pnlsr, string& key) |
| { |
| std::list<NameLsa>::iterator it = std::find_if(m_nameLsdb.begin(), |
| m_nameLsdb.end(), |
| bind(nameLsaCompareByKey, _1, key)); |
| if (it != m_nameLsdb.end()) |
| { |
| (*it).writeLog(); |
| if ((*it).getOrigRouter() != pnlsr.getConfParameter().getRouterPrefix()) |
| { |
| pnlsr.getNpt().removeNpte((*it).getOrigRouter(), (*it).getOrigRouter(), pnlsr); |
| for (std::list<string>::iterator nit = (*it).getNpl().getNameList().begin(); |
| nit != (*it).getNpl().getNameList().end(); ++nit) |
| { |
| if ((*nit) != pnlsr.getConfParameter().getRouterPrefix()) |
| { |
| pnlsr.getNpt().removeNpte((*nit), (*it).getOrigRouter(), pnlsr); |
| } |
| } |
| } |
| m_nameLsdb.erase(it); |
| return true; |
| } |
| return false; |
| } |
| |
| bool |
| Lsdb::doesNameLsaExist(string key) |
| { |
| std::list<NameLsa>::iterator it = std::find_if(m_nameLsdb.begin(), |
| m_nameLsdb.end(), |
| bind(nameLsaCompareByKey, _1, key)); |
| if (it == m_nameLsdb.end()) |
| { |
| return false; |
| } |
| return true; |
| } |
| |
| void |
| Lsdb::printNameLsdb() |
| { |
| cout << "---------------Name LSDB-------------------" << endl; |
| for (std::list<NameLsa>::iterator it = m_nameLsdb.begin(); |
| it != m_nameLsdb.end() ; it++) |
| { |
| cout << (*it) << endl; |
| } |
| } |
| |
| // Cor LSA and LSDB related Functions start here |
| |
| |
| static bool |
| corLsaCompareByKey(CorLsa& clsa, string& key) |
| { |
| return clsa.getKey() == key; |
| } |
| |
| bool |
| Lsdb::buildAndInstallOwnCorLsa(Nlsr& pnlsr) |
| { |
| CorLsa corLsa(pnlsr.getConfParameter().getRouterPrefix() |
| , 3 |
| , pnlsr.getSm().getCorLsaSeq() + 1 |
| , pnlsr.getConfParameter().getRouterDeadInterval() |
| , pnlsr.getConfParameter().getCorR() |
| , pnlsr.getConfParameter().getCorTheta()); |
| pnlsr.getSm().setCorLsaSeq(pnlsr.getSm().getCorLsaSeq() + 1); |
| installCorLsa(pnlsr, corLsa); |
| return true; |
| } |
| |
| std::pair<CorLsa&, bool> |
| Lsdb::getCorLsa(string key) |
| { |
| std::list<CorLsa>::iterator it = std::find_if(m_corLsdb.begin(), |
| m_corLsdb.end(), |
| bind(corLsaCompareByKey, _1, key)); |
| if (it != m_corLsdb.end()) |
| { |
| return std::make_pair(boost::ref((*it)), true); |
| } |
| CorLsa clsa; |
| return std::make_pair(boost::ref(clsa), false); |
| } |
| |
| bool |
| Lsdb::isCorLsaNew(string key, uint64_t seqNo) |
| { |
| std::pair<CorLsa&, bool> corLsaCheck = getCorLsa(key); |
| if (corLsaCheck.second) |
| { |
| if (corLsaCheck.first.getLsSeqNo() < seqNo) |
| { |
| return true; |
| } |
| else |
| { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| ndn::EventId |
| Lsdb::scheduleCorLsaExpiration(Nlsr& pnlsr, string key, int seqNo, int expTime) |
| { |
| return pnlsr.getScheduler().scheduleEvent(ndn::time::seconds(expTime), |
| ndn::bind(&Lsdb::exprireOrRefreshCorLsa, |
| this, boost::ref(pnlsr), |
| key, seqNo)); |
| } |
| |
| bool |
| Lsdb::installCorLsa(Nlsr& pnlsr, CorLsa& clsa) |
| { |
| int timeToExpire = m_lsaRefreshTime; |
| std::pair<CorLsa&, bool> chkCorLsa = getCorLsa(clsa.getKey()); |
| if (!chkCorLsa.second) |
| { |
| addCorLsa(clsa); |
| printCorLsdb(); //debugging purpose |
| if (clsa.getOrigRouter() != pnlsr.getConfParameter().getRouterPrefix()) |
| { |
| pnlsr.getNpt().addNpteByDestName(clsa.getOrigRouter(), clsa.getOrigRouter(), |
| pnlsr); |
| } |
| if (pnlsr.getConfParameter().getIsHyperbolicCalc() >= 1) |
| { |
| pnlsr.getRoutingTable().scheduleRoutingTableCalculation(pnlsr); |
| } |
| if (clsa.getOrigRouter() != pnlsr.getConfParameter().getRouterPrefix()) |
| { |
| timeToExpire = clsa.getLifeTime(); |
| } |
| scheduleCorLsaExpiration(pnlsr, clsa.getKey(), |
| clsa.getLsSeqNo(), timeToExpire); |
| } |
| else |
| { |
| if (chkCorLsa.first.getLsSeqNo() < clsa.getLsSeqNo()) |
| { |
| chkCorLsa.first.setLsSeqNo(clsa.getLsSeqNo()); |
| chkCorLsa.first.setLifeTime(clsa.getLifeTime()); |
| if (!chkCorLsa.first.isEqual(clsa)) |
| { |
| chkCorLsa.first.setCorRadius(clsa.getCorRadius()); |
| chkCorLsa.first.setCorTheta(clsa.getCorTheta()); |
| if (pnlsr.getConfParameter().getIsHyperbolicCalc() >= 1) |
| { |
| pnlsr.getRoutingTable().scheduleRoutingTableCalculation(pnlsr); |
| } |
| } |
| if (clsa.getOrigRouter() != pnlsr.getConfParameter().getRouterPrefix()) |
| { |
| timeToExpire = clsa.getLifeTime(); |
| } |
| cancelScheduleLsaExpiringEvent(pnlsr, |
| chkCorLsa.first.getExpiringEventId()); |
| chkCorLsa.first.setExpiringEventId(scheduleCorLsaExpiration(pnlsr, |
| clsa.getKey(), |
| clsa.getLsSeqNo(), |
| timeToExpire)); |
| } |
| } |
| return true; |
| } |
| |
| bool |
| Lsdb::addCorLsa(CorLsa& clsa) |
| { |
| std::list<CorLsa>::iterator it = std::find_if(m_corLsdb.begin(), |
| m_corLsdb.end(), |
| bind(corLsaCompareByKey, _1, |
| clsa.getKey())); |
| if (it == m_corLsdb.end()) |
| { |
| m_corLsdb.push_back(clsa); |
| return true; |
| } |
| return false; |
| } |
| |
| bool |
| Lsdb::removeCorLsa(Nlsr& pnlsr, string& key) |
| { |
| std::list<CorLsa>::iterator it = std::find_if(m_corLsdb.begin(), |
| m_corLsdb.end(), |
| bind(corLsaCompareByKey, _1, key)); |
| if (it != m_corLsdb.end()) |
| { |
| if ((*it).getOrigRouter() != pnlsr.getConfParameter().getRouterPrefix()) |
| { |
| pnlsr.getNpt().removeNpte((*it).getOrigRouter(), (*it).getOrigRouter(), pnlsr); |
| } |
| m_corLsdb.erase(it); |
| return true; |
| } |
| return false; |
| } |
| |
| bool |
| Lsdb::doesCorLsaExist(string key) |
| { |
| std::list<CorLsa>::iterator it = std::find_if(m_corLsdb.begin(), |
| m_corLsdb.end(), |
| bind(corLsaCompareByKey, _1, key)); |
| if (it == m_corLsdb.end()) |
| { |
| return false; |
| } |
| return true; |
| } |
| |
| void |
| Lsdb::printCorLsdb() //debugging |
| { |
| cout << "---------------Cor LSDB-------------------" << endl; |
| for (std::list<CorLsa>::iterator it = m_corLsdb.begin(); |
| it != m_corLsdb.end() ; it++) |
| { |
| cout << (*it) << endl; |
| } |
| } |
| |
| |
| // Adj LSA and LSDB related function starts here |
| |
| static bool |
| adjLsaCompareByKey(AdjLsa& alsa, string& key) |
| { |
| return alsa.getKey() == key; |
| } |
| |
| |
| void |
| Lsdb::scheduledAdjLsaBuild(Nlsr& pnlsr) |
| { |
| cout << "scheduledAdjLsaBuild Called" << endl; |
| pnlsr.setIsBuildAdjLsaSheduled(0); |
| if (pnlsr.getAdl().isAdjLsaBuildable(pnlsr)) |
| { |
| int adjBuildCount = pnlsr.getAdjBuildCount(); |
| if (adjBuildCount > 0) |
| { |
| if (pnlsr.getAdl().getNumOfActiveNeighbor() > 0) |
| { |
| buildAndInstallOwnAdjLsa(pnlsr); |
| } |
| else |
| { |
| string key = pnlsr.getConfParameter().getRouterPrefix() + "/2"; |
| removeAdjLsa(pnlsr, key); |
| pnlsr.getRoutingTable().scheduleRoutingTableCalculation(pnlsr); |
| } |
| pnlsr.setAdjBuildCount(pnlsr.getAdjBuildCount() - adjBuildCount); |
| } |
| } |
| else |
| { |
| pnlsr.setIsBuildAdjLsaSheduled(1); |
| int schedulingTime = pnlsr.getConfParameter().getInterestRetryNumber() * |
| pnlsr.getConfParameter().getInterestResendTime(); |
| pnlsr.getScheduler().scheduleEvent(ndn::time::seconds(schedulingTime), |
| ndn::bind(&Lsdb::scheduledAdjLsaBuild, |
| pnlsr.getLsdb(), boost::ref(pnlsr))); |
| } |
| } |
| |
| |
| bool |
| Lsdb::addAdjLsa(AdjLsa& alsa) |
| { |
| std::list<AdjLsa>::iterator it = std::find_if(m_adjLsdb.begin(), |
| m_adjLsdb.end(), |
| bind(adjLsaCompareByKey, _1, |
| alsa.getKey())); |
| if (it == m_adjLsdb.end()) |
| { |
| m_adjLsdb.push_back(alsa); |
| return true; |
| } |
| return false; |
| } |
| |
| std::pair<AdjLsa&, bool> |
| Lsdb::getAdjLsa(string key) |
| { |
| std::list<AdjLsa>::iterator it = std::find_if(m_adjLsdb.begin(), |
| m_adjLsdb.end(), |
| bind(adjLsaCompareByKey, _1, key)); |
| if (it != m_adjLsdb.end()) |
| { |
| return std::make_pair(boost::ref((*it)), true); |
| } |
| AdjLsa alsa; |
| return std::make_pair(boost::ref(alsa), false); |
| } |
| |
| |
| bool |
| Lsdb::isAdjLsaNew(string key, uint64_t seqNo) |
| { |
| std::pair<AdjLsa&, bool> adjLsaCheck = getAdjLsa(key); |
| if (adjLsaCheck.second) |
| { |
| if (adjLsaCheck.first.getLsSeqNo() < seqNo) |
| { |
| return true; |
| } |
| else |
| { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| |
| ndn::EventId |
| Lsdb::scheduleAdjLsaExpiration(Nlsr& pnlsr, string key, int seqNo, int expTime) |
| { |
| return pnlsr.getScheduler().scheduleEvent(ndn::time::seconds(expTime), |
| ndn::bind(&Lsdb::exprireOrRefreshAdjLsa, |
| this, boost::ref(pnlsr), |
| key, seqNo)); |
| } |
| |
| bool |
| Lsdb::installAdjLsa(Nlsr& pnlsr, AdjLsa& alsa) |
| { |
| int timeToExpire = m_lsaRefreshTime; |
| std::pair<AdjLsa&, bool> chkAdjLsa = getAdjLsa(alsa.getKey()); |
| if (!chkAdjLsa.second) |
| { |
| addAdjLsa(alsa); |
| alsa.addNptEntries(pnlsr); |
| pnlsr.getRoutingTable().scheduleRoutingTableCalculation(pnlsr); |
| if (alsa.getOrigRouter() != pnlsr.getConfParameter().getRouterPrefix()) |
| { |
| timeToExpire = alsa.getLifeTime(); |
| } |
| scheduleAdjLsaExpiration(pnlsr, alsa.getKey(), |
| alsa.getLsSeqNo(), timeToExpire); |
| } |
| else |
| { |
| if (chkAdjLsa.first.getLsSeqNo() < alsa.getLsSeqNo()) |
| { |
| chkAdjLsa.first.setLsSeqNo(alsa.getLsSeqNo()); |
| chkAdjLsa.first.setLifeTime(alsa.getLifeTime()); |
| if (!chkAdjLsa.first.isEqual(alsa)) |
| { |
| chkAdjLsa.first.getAdl().reset(); |
| chkAdjLsa.first.getAdl().addAdjacentsFromAdl(alsa.getAdl()); |
| pnlsr.getRoutingTable().scheduleRoutingTableCalculation(pnlsr); |
| } |
| if (alsa.getOrigRouter() != pnlsr.getConfParameter().getRouterPrefix()) |
| { |
| timeToExpire = alsa.getLifeTime(); |
| } |
| cancelScheduleLsaExpiringEvent(pnlsr, |
| chkAdjLsa.first.getExpiringEventId()); |
| chkAdjLsa.first.setExpiringEventId(scheduleAdjLsaExpiration(pnlsr, |
| alsa.getKey(), |
| alsa.getLsSeqNo(), |
| timeToExpire)); |
| } |
| } |
| return true; |
| } |
| |
| bool |
| Lsdb::buildAndInstallOwnAdjLsa(Nlsr& pnlsr) |
| { |
| AdjLsa adjLsa(pnlsr.getConfParameter().getRouterPrefix() |
| , 2 |
| , pnlsr.getSm().getAdjLsaSeq() + 1 |
| , pnlsr.getConfParameter().getRouterDeadInterval() |
| , pnlsr.getAdl().getNumOfActiveNeighbor() |
| , pnlsr.getAdl()); |
| pnlsr.getSm().setAdjLsaSeq(pnlsr.getSm().getAdjLsaSeq() + 1); |
| string lsaPrefix = pnlsr.getConfParameter().getChronosyncLsaPrefix() |
| + pnlsr.getConfParameter().getRouterPrefix(); |
| pnlsr.getSlh().publishRoutingUpdate(pnlsr.getSm(), lsaPrefix); |
| return pnlsr.getLsdb().installAdjLsa(pnlsr, adjLsa); |
| } |
| |
| bool |
| Lsdb::removeAdjLsa(Nlsr& pnlsr, string& key) |
| { |
| std::list<AdjLsa>::iterator it = std::find_if(m_adjLsdb.begin(), |
| m_adjLsdb.end(), |
| bind(adjLsaCompareByKey, _1, key)); |
| if (it != m_adjLsdb.end()) |
| { |
| (*it).removeNptEntries(pnlsr); |
| m_adjLsdb.erase(it); |
| return true; |
| } |
| return false; |
| } |
| |
| bool |
| Lsdb::doesAdjLsaExist(string key) |
| { |
| std::list<AdjLsa>::iterator it = std::find_if(m_adjLsdb.begin(), |
| m_adjLsdb.end(), |
| bind(adjLsaCompareByKey, _1, key)); |
| if (it == m_adjLsdb.end()) |
| { |
| return false; |
| } |
| return true; |
| } |
| |
| std::list<AdjLsa>& |
| Lsdb::getAdjLsdb() |
| { |
| return m_adjLsdb; |
| } |
| |
| void |
| Lsdb::setLsaRefreshTime(int lrt) |
| { |
| m_lsaRefreshTime = lrt; |
| } |
| |
| void |
| Lsdb::setThisRouterPrefix(string trp) |
| { |
| m_thisRouterPrefix = trp; |
| } |
| |
| void |
| Lsdb::exprireOrRefreshNameLsa(Nlsr& pnlsr, string lsaKey, uint64_t seqNo) |
| { |
| cout << "Lsdb::exprireOrRefreshNameLsa Called " << endl; |
| cout << "LSA Key : " << lsaKey << " Seq No: " << seqNo << endl; |
| std::pair<NameLsa&, bool> chkNameLsa = getNameLsa(lsaKey); |
| if (chkNameLsa.second) |
| { |
| cout << " LSA Exists with seq no: " << chkNameLsa.first.getLsSeqNo() << endl; |
| if (chkNameLsa.first.getLsSeqNo() == seqNo) |
| { |
| if (chkNameLsa.first.getOrigRouter() == m_thisRouterPrefix) |
| { |
| chkNameLsa.first.writeLog(); |
| cout << "Own Name LSA, so refreshing name LSA" << endl; |
| chkNameLsa.first.setLsSeqNo(chkNameLsa.first.getLsSeqNo() + 1); |
| pnlsr.getSm().setNameLsaSeq(chkNameLsa.first.getLsSeqNo()); |
| chkNameLsa.first.writeLog(); |
| // publish routing update |
| string lsaPrefix = pnlsr.getConfParameter().getChronosyncLsaPrefix() |
| + pnlsr.getConfParameter().getRouterPrefix(); |
| pnlsr.getSlh().publishRoutingUpdate(pnlsr.getSm(), lsaPrefix); |
| } |
| else |
| { |
| cout << "Other's Name LSA, so removing form LSDB" << endl; |
| removeNameLsa(pnlsr, lsaKey); |
| } |
| } |
| } |
| } |
| |
| void |
| Lsdb::exprireOrRefreshAdjLsa(Nlsr& pnlsr, string lsaKey, uint64_t seqNo) |
| { |
| cout << "Lsdb::exprireOrRefreshAdjLsa Called " << endl; |
| cout << "LSA Key : " << lsaKey << " Seq No: " << seqNo << endl; |
| std::pair<AdjLsa&, bool> chkAdjLsa = getAdjLsa(lsaKey); |
| if (chkAdjLsa.second) |
| { |
| cout << " LSA Exists with seq no: " << chkAdjLsa.first.getLsSeqNo() << endl; |
| if (chkAdjLsa.first.getLsSeqNo() == seqNo) |
| { |
| if (chkAdjLsa.first.getOrigRouter() == m_thisRouterPrefix) |
| { |
| cout << "Own Adj LSA, so refreshing Adj LSA" << endl; |
| chkAdjLsa.first.setLsSeqNo(chkAdjLsa.first.getLsSeqNo() + 1); |
| pnlsr.getSm().setAdjLsaSeq(chkAdjLsa.first.getLsSeqNo()); |
| // publish routing update |
| string lsaPrefix = pnlsr.getConfParameter().getChronosyncLsaPrefix() |
| + pnlsr.getConfParameter().getRouterPrefix(); |
| pnlsr.getSlh().publishRoutingUpdate(pnlsr.getSm(), lsaPrefix); |
| } |
| else |
| { |
| cout << "Other's Adj LSA, so removing form LSDB" << endl; |
| removeAdjLsa(pnlsr, lsaKey); |
| } |
| // schedule Routing table calculaiton |
| pnlsr.getRoutingTable().scheduleRoutingTableCalculation(pnlsr); |
| } |
| } |
| } |
| |
| void |
| Lsdb::exprireOrRefreshCorLsa(Nlsr& pnlsr, string lsaKey, uint64_t seqNo) |
| { |
| cout << "Lsdb::exprireOrRefreshCorLsa Called " << endl; |
| cout << "LSA Key : " << lsaKey << " Seq No: " << seqNo << endl; |
| std::pair<CorLsa&, bool> chkCorLsa = getCorLsa(lsaKey); |
| if (chkCorLsa.second) |
| { |
| cout << " LSA Exists with seq no: " << chkCorLsa.first.getLsSeqNo() << endl; |
| if (chkCorLsa.first.getLsSeqNo() == seqNo) |
| { |
| if (chkCorLsa.first.getOrigRouter() == m_thisRouterPrefix) |
| { |
| cout << "Own Cor LSA, so refreshing Cor LSA" << endl; |
| chkCorLsa.first.setLsSeqNo(chkCorLsa.first.getLsSeqNo() + 1); |
| pnlsr.getSm().setCorLsaSeq(chkCorLsa.first.getLsSeqNo()); |
| // publish routing update |
| string lsaPrefix = pnlsr.getConfParameter().getChronosyncLsaPrefix() |
| + pnlsr.getConfParameter().getRouterPrefix(); |
| pnlsr.getSlh().publishRoutingUpdate(pnlsr.getSm(), lsaPrefix); |
| } |
| else |
| { |
| cout << "Other's Cor LSA, so removing form LSDB" << endl; |
| removeCorLsa(pnlsr, lsaKey); |
| } |
| if (pnlsr.getConfParameter().getIsHyperbolicCalc() >= 1) |
| { |
| pnlsr.getRoutingTable().scheduleRoutingTableCalculation(pnlsr); |
| } |
| } |
| } |
| } |
| |
| |
| void |
| Lsdb::printAdjLsdb() |
| { |
| cout << "---------------Adj LSDB-------------------" << endl; |
| for (std::list<AdjLsa>::iterator it = m_adjLsdb.begin(); |
| it != m_adjLsdb.end() ; it++) |
| { |
| cout << (*it) << endl; |
| } |
| } |
| |
| //-----utility function ----- |
| bool |
| Lsdb::doesLsaExist(string key, int lsType) |
| { |
| if (lsType == 1) |
| { |
| return doesNameLsaExist(key); |
| } |
| else if (lsType == 2) |
| { |
| return doesAdjLsaExist(key); |
| } |
| else if (lsType == 3) |
| { |
| return doesCorLsaExist(key); |
| } |
| return false; |
| } |
| |
| }//namespace nlsr |
| |