ptr_lib::shared_ptr<DataBlock> FrameBuffer::acquireData(const ndn::Interest& interest, ndn::Name& nalType ) { lock_guard<recursive_mutex> scopedLock(syncMutex_); ptr_lib::shared_ptr<DataBlock> data; std::map<ndn::Name, ptr_lib::shared_ptr<DataBlock> >::reverse_iterator re_iter; //iter = activeSlots_.find(interest.getName()); ndn::Name name; for( re_iter = activeSlots_.rbegin(); re_iter != activeSlots_.rend(); ++re_iter ) { name = re_iter->first; if( interest.getName().equals(name.getPrefix(interest.getName().size()))) { nalType = name.getSubName(-2); break; } } if (re_iter!=activeSlots_.rend()) //if found { data = re_iter->second; //cout << "********** size:" << segBlock->size() << " &data=" << (void*)(segBlock->dataPtr()) << endl; } return data; }
void EdgeStrategy::onDataDenied ( const ndn::Data& data, const ndn::Interest& interest, ns3::Time& delay, const std::string& why ) { // if the denied data isn't leaving the network // then we just do the normal router stuff auto in_face = getFaceTable().get( data.getIncomingFaceId() ); auto out_face = getFaceTable().get( interest.getIncomingFaceId() ); bool coming_from_network = !in_face->isEdge(); bool going_to_network = !out_face->isEdge(); if( coming_from_network == going_to_network ) { RouterStrategy::onDataDenied( data, interest, delay, why ); return; } if( going_to_network ) { BOOST_ASSERT( data.getCurrentNetwork() == ndn::RouteTracker::INTERNET_NETWORK ); RouterStrategy::onDataDenied( data, interest, delay, why ); return; } // if the data is denied then we add the // tag used to retrieve it to the negative // cache; however we only want to do this // when the data is leaving the internet // and going into the client network // and the data's access level > 0 BOOST_ASSERT( data.getCurrentNetwork() == ndn::RouteTracker::ENTRY_NETWORK ); if( data.getAccessLevel() > 0 ) { BOOST_ASSERT( interest.hasAuthTag() ); tracers::edge->bloom_insert ( interest.getAuthTag(), s_edge_bloom_delay ); delay += s_edge_bloom_delay; m_negative_cache.insert( interest.getAuthTag() ); } // do whatever a normal router would do RouterStrategy::onDataDenied( data, interest, delay, why ); }
void HelloProtocol::processInterestTimedOut(const ndn::Interest& interest) { /* interest name: /<neighbor>/NLSR/INFO/<router> */ const ndn::Name interestName(interest.getName()); _LOG_DEBUG("Interest timed out for Name: " << interestName); if (interestName.get(-2).toUri() != INFO_COMPONENT) { return; } ndn::Name neighbor = interestName.getPrefix(-3); _LOG_DEBUG("Neighbor: " << neighbor); m_nlsr.getAdjacencyList().incrementTimedOutInterestCount(neighbor); Adjacent::Status status = m_nlsr.getAdjacencyList().getStatusOfNeighbor(neighbor); uint32_t infoIntTimedOutCount = m_nlsr.getAdjacencyList().getTimedOutInterestCount(neighbor); _LOG_DEBUG("Status: " << status); _LOG_DEBUG("Info Interest Timed out: " << infoIntTimedOutCount); if ((infoIntTimedOutCount < m_nlsr.getConfParameter().getInterestRetryNumber())) { /* interest name: /<neighbor>/NLSR/INFO/<router> */ ndn::Name interestName(neighbor); interestName.append(NLSR_COMPONENT); interestName.append(INFO_COMPONENT); interestName.append(m_nlsr.getConfParameter().getRouterPrefix().wireEncode()); expressInterest(interestName, m_nlsr.getConfParameter().getInterestResendTime()); } else if ((status == Adjacent::STATUS_ACTIVE) && (infoIntTimedOutCount == m_nlsr.getConfParameter().getInterestRetryNumber())) { m_nlsr.getAdjacencyList().setStatusOfNeighbor(neighbor, Adjacent::STATUS_INACTIVE); m_nlsr.getLsdb().scheduleAdjLsaBuild(); } }
void respondToAnyInterest(const ndn::Interest& interest) { auto data = std::make_shared<ndn::Data>(interest.getName()); m_keyChain.sign(*data); m_faceProducer.put(*data); }
void EdgeStrategy::onDataSatisfied ( const ndn::Data& data, const ndn::Interest& interest, ns3::Time& delay ) { // if the satisfied data isn't leaving the network // then we just do the normal router stuff auto in_face = getFaceTable().get( data.getIncomingFaceId() ); auto out_face = getFaceTable().get( interest.getIncomingFaceId() ); bool coming_from_network = !in_face->isEdge(); bool going_to_network = !out_face->isEdge(); if( coming_from_network == going_to_network ) { RouterStrategy::onDataSatisfied( data, interest, delay ); return; } if( going_to_network ) { BOOST_ASSERT( data.getCurrentNetwork() == ndn::RouteTracker::INTERNET_NETWORK ); RouterStrategy::onDataSatisfied( data, interest, delay ); return; } // if the data is satisfied then we add it to // the positive cache if it isn't marked with // the no recache flag and if its access level > 0 BOOST_ASSERT( data.getCurrentNetwork() == ndn::RouteTracker::ENTRY_NETWORK ); if( !data.getNoReCacheFlag() && data.getAccessLevel() > 0 ) { BOOST_ASSERT( interest.hasAuthTag() ); tracers::edge->bloom_insert ( interest.getAuthTag(), s_edge_bloom_delay ); delay += s_edge_bloom_delay; m_positive_cache.insert( interest.getAuthTag() ); } RouterStrategy::onDataSatisfied( data, interest, delay ); }
void HelloProtocol::processInterest(const ndn::Name& name, const ndn::Interest& interest) { /* interest name: /<neighbor>/NLSR/INFO/<router> */ const ndn::Name interestName = interest.getName(); _LOG_DEBUG("Interest Received for Name: " << interestName); if (interestName.get(-2).toUri() != INFO_COMPONENT) { return; } ndn::Name neighbor; neighbor.wireDecode(interestName.get(-1).blockFromValue()); _LOG_DEBUG("Neighbor: " << neighbor); if (m_nlsr.getAdjacencyList().isNeighbor(neighbor)) { ndn::shared_ptr<ndn::Data> data = ndn::make_shared<ndn::Data>(); data->setName(ndn::Name(interest.getName()).appendVersion()); data->setFreshnessPeriod(ndn::time::seconds(10)); // 10 sec data->setContent(reinterpret_cast<const uint8_t*>(INFO_COMPONENT.c_str()), INFO_COMPONENT.size()); m_nlsr.getKeyChain().sign(*data, m_nlsr.getDefaultCertName()); _LOG_DEBUG("Sending out data for name: " << interest.getName()); m_nlsr.getNlsrFace().put(*data); Adjacent *adjacent = m_nlsr.getAdjacencyList().findAdjacent(neighbor); // If this neighbor was previously inactive, send our own hello interest, too if (adjacent->getStatus() == Adjacent::STATUS_INACTIVE) { // We can only do that if the neighbor currently has a face. if(adjacent->getFaceId() != 0){ /* interest name: /<neighbor>/NLSR/INFO/<router> */ ndn::Name interestName(neighbor); interestName.append(NLSR_COMPONENT); interestName.append(INFO_COMPONENT); interestName.append(m_nlsr.getConfParameter().getRouterPrefix().wireEncode()); expressInterest(interestName, m_nlsr.getConfParameter().getInterestResendTime()); } // If the originator of the Interest currently lacks a Face, we // need to give it one. else { registerPrefixes(adjacent->getName(), adjacent->getConnectingFaceUri(), adjacent->getLinkCost(), ndn::time::milliseconds::max()); } } } }
void PrefixUpdateProcessor::sendNack(const ndn::Interest& request) { ndn::MetaInfo metaInfo; metaInfo.setType(ndn::tlv::ContentType_Nack); shared_ptr<ndn::Data> responseData = std::make_shared<ndn::Data>(request.getName()); responseData->setMetaInfo(metaInfo); m_keyChain.sign(*responseData); m_face.put(*responseData); }
void onData( ndn::Face &face, const ndn::Interest& interest, ndn::Data& data, int globalReference, int localReference, int patternId, boost::posix_time::ptime sentTime ) { double roundTripTime; int receivedContentLength; std::string receivedContent; std::string logLine; logLine = ""; logLine += "Data Received - PatternType="+toString(patternId+1); logLine += ", GlobalID="+toString(globalReference); logLine += ", LocalID="+toString(localReference); logLine += ", Name="+interest.getName().toUri(); boost::posix_time::time_duration roundTripDuration; totalInterestReceived_++; trafficPattern_[patternId].totalInterestReceived++; if (trafficPattern_[patternId].expectedContent != "") { receivedContent = (char*)(data.getContent().value()); receivedContentLength = data.getContent().value_size(); receivedContent = receivedContent.substr(0, receivedContentLength); if (receivedContent != trafficPattern_[patternId].expectedContent) { contentInconsistencies_++; trafficPattern_[patternId].contentInconsistencies++; logLine += ", IsConsistent=No"; } else logLine += ", IsConsistent=Yes"; } else logLine += ", IsConsistent=NotChecked"; m_logger.log(logLine, true, false); roundTripDuration = boost::posix_time::microsec_clock::local_time() - sentTime; roundTripTime = roundTripDuration.total_microseconds()/1000.0; if (minimumInterestRoundTripTime_ > roundTripTime) minimumInterestRoundTripTime_ = roundTripTime; if (maximumInterestRoundTripTime_ < roundTripTime) maximumInterestRoundTripTime_ = roundTripTime; if (trafficPattern_[patternId].minimumInterestRoundTripTime > roundTripTime) trafficPattern_[patternId].minimumInterestRoundTripTime = roundTripTime; if (trafficPattern_[patternId].maximumInterestRoundTripTime < roundTripTime) trafficPattern_[patternId].maximumInterestRoundTripTime = roundTripTime; totalInterestRoundTripTime_ += roundTripTime; trafficPattern_[patternId].totalInterestRoundTripTime += roundTripTime; if (totalInterestSent_ == interestCount_) signalHandler(); }
void HelloProtocol::processInterest(const ndn::Name& name, const ndn::Interest& interest) { /* interest name: /<neighbor>/NLSR/INFO/<router> */ const ndn::Name interestName = interest.getName(); _LOG_DEBUG("Interest Received for Name: " << interestName); if (interestName.get(-2).toUri() != INFO_COMPONENT) { return; } ndn::Name neighbor; neighbor.wireDecode(interestName.get(-1).blockFromValue()); _LOG_DEBUG("Neighbor: " << neighbor); if (m_nlsr.getAdjacencyList().isNeighbor(neighbor)) { ndn::shared_ptr<ndn::Data> data = ndn::make_shared<ndn::Data>(); data->setName(ndn::Name(interest.getName()).appendVersion()); data->setFreshnessPeriod(ndn::time::seconds(10)); // 10 sec data->setContent(reinterpret_cast<const uint8_t*>(INFO_COMPONENT.c_str()), INFO_COMPONENT.size()); m_nlsr.getKeyChain().sign(*data, m_nlsr.getDefaultCertName()); _LOG_DEBUG("Sending out data for name: " << interest.getName()); m_nlsr.getNlsrFace().put(*data); Adjacent *adjacent = m_nlsr.getAdjacencyList().findAdjacent(neighbor); if (adjacent->getStatus() == 0) { if(adjacent->getFaceId() != 0){ /* interest name: /<neighbor>/NLSR/INFO/<router> */ ndn::Name interestName(neighbor); interestName.append(NLSR_COMPONENT); interestName.append(INFO_COMPONENT); interestName.append(m_nlsr.getConfParameter().getRouterPrefix().wireEncode()); expressInterest(interestName, m_nlsr.getConfParameter().getInterestResendTime()); } else { registerPrefixes(adjacent->getName(), adjacent->getConnectingFaceUri(), adjacent->getLinkCost(), ndn::time::milliseconds::max()); } } } }
void onInterest(const ndn::Name& name, const ndn::Interest& interest) { ndn::Name interestName(interest.getName()); if(DEBUG) std::cout << "received interest: " << interest.getName() << std::endl; //run scripts if requested by server ndn::Name cmpName(getFilter()+SCRIPT_SUFFIX); int num_components = cmpName.size(); if(cmpName.isPrefixOf(interestName)) { int numberOfComponents = interestName.size(); for(int i = num_components; i < numberOfComponents; ++i) { m_scriptsList.push_front(interestName[i].toUri()); } runScripts(interestName); } else { int numberOfComponents = interestName.size(); if(!m_remoteLinks.empty()) { std::cerr << "remote links list is not empty - check for a missing reports!!" << std::endl; m_remoteLinks.clear(); } for(int i = name.size(); i < numberOfComponents; ++i) { m_remoteLinks.insert(interestName[i].toUri()); } // ask for local status fetchFaceStatusInformation(interestName); } }
void onTimeout( ndn::Face &face, const ndn::Interest& interest, int globalReference, int localReference, int patternId) { std::string logLine; logLine = ""; logLine += "Interest Timed Out - PatternType="+toString(patternId+1); logLine += ", GlobalID="+toString(globalReference); logLine += ", LocalID="+toString(localReference); logLine += ", Name="+interest.getName().toUri(); m_logger.log(logLine, true, false); if (totalInterestSent_ == interestCount_) signalHandler(); }
void HelloProtocol::processInterestTimedOut(const ndn::Interest& interest) { /* interest name: /<neighbor>/NLSR/INFO/<router> */ const ndn::Name interestName(interest.getName()); _LOG_DEBUG("Interest timed out for Name: " << interestName); if (interestName.get(-2).toUri() != INFO_COMPONENT) { return; } ndn::Name neighbor = interestName.getPrefix(-3); _LOG_DEBUG("Neighbor: " << neighbor); m_nlsr.getAdjacencyList().incrementTimedOutInterestCount(neighbor); int status = m_nlsr.getAdjacencyList().getStatusOfNeighbor(neighbor); uint32_t infoIntTimedOutCount = m_nlsr.getAdjacencyList().getTimedOutInterestCount(neighbor); _LOG_DEBUG("Status: " << status); _LOG_DEBUG("Info Interest Timed out: " << infoIntTimedOutCount); if ((infoIntTimedOutCount < m_nlsr.getConfParameter().getInterestRetryNumber())) { /* interest name: /<neighbor>/NLSR/INFO/<router> */ ndn::Name interestName(neighbor); interestName.append(NLSR_COMPONENT); interestName.append(INFO_COMPONENT); interestName.append(m_nlsr.getConfParameter().getRouterPrefix().wireEncode()); expressInterest(interestName, m_nlsr.getConfParameter().getInterestResendTime()); } else if ((status == 1) && (infoIntTimedOutCount == m_nlsr.getConfParameter().getInterestRetryNumber())) { m_nlsr.getAdjacencyList().setStatusOfNeighbor(neighbor, 0); m_nlsr.incrementAdjBuildCount(); if (m_nlsr.getIsBuildAdjLsaSheduled() == false) { _LOG_DEBUG("Scheduling scheduledAdjLsaBuild"); m_nlsr.setIsBuildAdjLsaSheduled(true); // event here m_nlsr.getScheduler().scheduleEvent(ndn::time::seconds(5), ndn::bind(&Lsdb::scheduledAdjLsaBuild, &m_nlsr.getLsdb())); } } }
bool EdgeStrategy::filterOutgoingInterest ( const nfd::Face& face, ndn::Interest& interest, ns3::Time& delay ) { auto in_face = getFaceTable().get( interest.getIncomingFaceId() ); bool coming_from_network = !in_face->isEdge(); bool going_to_network = !face.isEdge(); // if the interest coming from and going to // the same network then we don't need to do // anything special if( coming_from_network == going_to_network ) { return RouterStrategy::filterOutgoingInterest ( face, interest, delay ); } // if the interest is leaving the network then just change // current network if( coming_from_network ) { BOOST_ASSERT( interest.getCurrentNetwork() == ndn::RouteTracker::INTERNET_NETWORK ); tracers::edge->interest_left( interest ); interest.setCurrentNetwork( ndn::RouteTracker::EXIT_NETWORK ); return RouterStrategy::filterOutgoingInterest ( face, interest, delay ); } // if the interest is entering the network then // we need to do some extra stuff BOOST_ASSERT( interest.getCurrentNetwork() == ndn::RouteTracker::ENTRY_NETWORK ); tracers::edge->interest_entered( interest ); interest.setCurrentNetwork( ndn::RouteTracker::INTERNET_NETWORK ); // if the interest doesn't have an auth tag, or its auth level // is 0 then we don't do any authentication if( !interest.hasAuthTag() || interest.getAuthTag().getAccessLevel() == 0 ) { return RouterStrategy::filterOutgoingInterest( face, interest, delay ); } const ndn::AuthTag& auth = interest.getAuthTag(); // if the auth tag provided by the interest is expired // then we can drop the interest if( auth.isExpired() ) { tracers::edge->blocked_interest ( interest, tracers::BlockedExpired ); onInterestDropped( interest, face, "Expired auth" ); return false; } // if the interest and auth tag have different prefixes // then we drop the interest if( !auth.getPrefix().isPrefixOf( interest.getName() ) ) { tracers::edge->blocked_interest ( interest, tracers::BlockedBadPrefix ); onInterestDropped( interest, face, "Mismatched prefix" ); return false; } // if the interest route hash doesn't match its auth tag // then we can drop it if( interest.getEntryRoute() != auth.getRouteHash() ) { tracers::edge->blocked_interest ( interest, tracers::BlockedBadRoute ); onInterestDropped( interest, face, "Bad route" ); return false; } // if the interest auth is in the positive auth cache then // we set its auth validity probability tracers::edge->bloom_lookup( auth, s_edge_bloom_delay ); delay += s_edge_bloom_delay; if( m_positive_cache.contains( auth ) ) { double fpp = m_positive_cache.getEffectiveFPP(); double prob = (double)1.0 - fpp; uint32_t iprob = prob*0xFFFFFFFF; interest.setAuthValidityProb( iprob ); } else { // if it's in the negative cache then we validate // its signature manually tracers::edge->bloom_lookup( auth, s_edge_bloom_delay ); delay += s_edge_bloom_delay; if( m_negative_cache.contains( auth ) ) { // we simulate verification delay by incrementing // the processing delay tracers::edge->sigverif( auth, s_edge_signature_delay ); delay += EdgeStrategy::s_edge_signature_delay; if( auth.getSignature().getValue().value_size() > 0 && auth.getSignature().getValue().value()[0] != 0 ) { // if signature is valid then set auth validity // and put auth into positive cache interest.setAuthValidityProb( 0xFFFFFFFF ); tracers::edge->auth_cached ( auth, tracers::CachedPositiveMoved ); m_positive_cache.insert( auth ); } else { // otherwise we drop the interest onInterestDropped( interest, face, "negative cache, manual validation failed" ); return false; } } else { // if the auth isn't in either cache then // we set validity probability to 0 interest.setAuthValidityProb( 0 ); } } return RouterStrategy::filterOutgoingInterest( face, interest, delay ); }
void onData(const ndn::Interest& interest, ndn::Data& data, std::string linkPrefix) { std::cout << "Data received for: " << interest.getName() << std::endl; CollectorData reply; reply.wireDecode(data.getContent().blockFromValue()); if(reply.m_statusList.empty()) { std::cerr << "received data is empty!!" << std::endl; } // get the list of the remote links requested for this prefix std::unordered_map<std::string,std::list<ndn::NdnMapServer::linkPair>>::const_iterator got = m_linksList.find(linkPrefix); if(got == m_linksList.end()) { std::cerr << "failed to recognize the prefix: " << linkPrefix << std::endl; } else { std::list<ndn::NdnMapServer::linkPair> prefixList = got->second; for (unsigned i=0; i< reply.m_statusList.size(); i++) { int LinkId = 0; std::cout << "Reply: " << reply.m_statusList.at(i); // get the link id of the current IP for (auto pair = prefixList.cbegin(); pair != prefixList.cend(); ++pair) { if((*pair).linkIp == reply.m_statusList[i].getLinkIp()) { if (DEBUG) std::cout << " Link ID for " << linkPrefix << " and " << reply.m_statusList[i].getLinkIp() << " is " << (*pair).linkId << std::endl; LinkId = (*pair).linkId; } } std::string cmdStr("http://"); cmdStr += m_mapServerAddr; cmdStr += "/bw/"; cmdStr += std::to_string(LinkId); cmdStr += "/" + reply.m_statusList[i].getTimestamp() + "/"; cmdStr += std::to_string(reply.m_statusList[i].getTx() * 8) + "/"; cmdStr += std::to_string(reply.m_statusList[i].getRx() * 8); if (DEBUG) std::cout << "cmd to pass to curl: " << cmdStr << std::endl; int status; // check for zombies waitpid(-1, &status, WNOHANG); int pid; if ((pid = fork()) < 0) printf("for failed for curl %s\n", cmdStr.c_str()); else { if (pid == 0) execl("/usr/bin/curl","curl", "-s", "-L", cmdStr.c_str(), NULL); } // check for zombies again waitpid(-1, &status, WNOHANG); } reply.m_statusList.clear(); } }
void onTimeout(const ndn::Interest& interest) { std::cout << "onTimeout: " << interest.getName() << std::endl; }
virtual void onInterest(const ndn::InterestFilter& filter, const ndn::Interest& interest) { int dollarfound=0; int hashfound=0; printf("This doesn't work"); std::cout << "Checking if this works " << interest.getName().size() << std::endl; int comp_size=interest.getName().size(); string last_comp=interest.getName().get(comp_size-1).toUri(); string check=UriDecode(last_comp); cout<<check<<endl; cout<<"Last component is "<<last_comp<<endl; std::size_t found = check.find("#"); if (found!=std::string::npos) { hashfound=1; } found = check.find("$"); if (found!=std::string::npos) { dollarfound=1; } printf("DollarFound:%d and HashFound:%d\n",dollarfound,hashfound); std::cout << "Received Interest " << interest << std::endl; //Creating the file name std::shared_ptr<ndn::Data> response(std::make_shared<ndn::Data>(interest.getName())); if(dollarfound==1) { int i=0; string filename; for(i=0;i<comp_size-1;i++) { string mid=interest.getName().get(i).toUri(); string checking=UriDecode(mid); filename = filename + '_' +mid; } char node_name[node_size]; gethostname(node_name,node_size); string node_n=string(node_name); node_n.append("-"); node_n=node_n + filename; cout<<node_n<<endl; // char data[1000]; FILE *fp1=fopen(node_n.c_str(),"r+"); fseek(fp1, 0L, SEEK_END); int number_of_segments=0; int size= ftell(fp1); if(size%MAX_SEG!=0) { number_of_segments=(size/MAX_SEG)+1; } else { number_of_segments=(size/MAX_SEG); } string data1=to_string(number_of_segments); // string data2='$'+data1; printf("Number of Segments is =%d\n",number_of_segments); response->setContent(reinterpret_cast<const uint8_t*>(data1.c_str()), data1.size()); fclose(fp1); } if(hashfound==1){ int i=0; string filename; for(i=0;i<comp_size-2;i++) { string mid=interest.getName().get(i).toUri(); string checking=UriDecode(mid); filename = filename + '_' +mid; } char node_name[node_size]; gethostname(node_name,node_size); string node_n=string(node_name); node_n.append("-"); node_n=node_n + filename; cout<<node_n<<endl; char data[1000]; // char data[32]; FILE *fp1=fopen(node_n.c_str(),"r+"); fseek(fp1, 0L, SEEK_END); // int number_of_segments=0; //int size= ftell(fp1); int start=0; start=stoi(check.substr(1))*MAX_SEG; fseek(fp1,start,SEEK_SET); memset(&data,0,sizeof(data)); size_t check=fread(data,MAX_SEG,1,fp1); if(check==0) printf("Error\n"); // printf("Data: %s\n",data); string msg=string(data); response->setContent(reinterpret_cast<const uint8_t*>(data), MAX_SEG); // printf("Size of the outgoing message is:%d",msg.size()); cout<<msg.c_str()<<endl; } m_keyChain.sign(*response); m_face.put(*response); }
void my_routing::on_timeout( uint32_t error_code, const ndn::Interest& interest) { std::cout << "Request timed out (ErrorCode: " << error_code << "): " << interest.getName().toUri() << std::endl; m_has_error = true; }