void Nlsrc::onControlResponse(const std::string& info, const ndn::Data& data) { if (data.getMetaInfo().getType() == ndn::tlv::ContentType_Nack) { std::cerr << "ERROR: Run-time advertise/withdraw disabled" << std::endl; return; } ndn::nfd::ControlResponse response; try { response.wireDecode(data.getContent().blockFromValue()); } catch (const std::exception& e) { std::cerr << "ERROR: Control response decoding error" << std::endl; return; } uint32_t code = response.getCode(); if (code != RESPONSE_CODE_SUCCESS) { std::cerr << "Name prefix update error (code: " << code << ")" << std::endl; return; } std::cout << "Applied Name prefix update successfully: " << info << std::endl; }
void EdgeStrategy::toNack( ndn::Data& data, const ndn::Interest& interest ) { // ensure that denied data doesn't leave the network data.setContent( ndn::Block() ); data.wireEncode(); // do whatever a normal router would do RouterStrategy::toNack( data, interest ); }
void EdgeStrategy::toPreserve( ndn::Data& data, const ndn::Interest& interest ) { if( data.getContentType() == ndn::tlv::ContentType_Nack ) { data.setContent( ndn::Block() ); data.wireEncode(); } }
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(); }
// This is the first function that incoming Hello data will // see. This checks if the data appears to be signed, and passes it // on to validate the content of the data. void HelloProtocol::onContent(const ndn::Interest& interest, const ndn::Data& data) { _LOG_DEBUG("Received data for INFO(name): " << data.getName()); if (data.getSignature().hasKeyLocator()) { if (data.getSignature().getKeyLocator().getType() == ndn::KeyLocator::KeyLocator_Name) { _LOG_DEBUG("Data signed with: " << data.getSignature().getKeyLocator().getName()); } } m_nlsr.getValidator().validate(data, ndn::bind(&HelloProtocol::onContentValidated, this, _1), ndn::bind(&HelloProtocol::onContentValidationFailed, this, _1, _2)); }
void SimpleDataRetrieval::onData(const ndn::Interest& interest, ndn::Data& data) { if (m_isRunning == false) return; ConsumerDataCallback onDataEnteredContext = EMPTY_CALLBACK; m_context->getContextOption(DATA_ENTER_CNTX, onDataEnteredContext); if (onDataEnteredContext != EMPTY_CALLBACK) { onDataEnteredContext(*dynamic_cast<Consumer*>(m_context), data); } ConsumerInterestCallback onInterestSatisfied = EMPTY_CALLBACK; m_context->getContextOption(INTEREST_SATISFIED, onInterestSatisfied); if (onInterestSatisfied != EMPTY_CALLBACK) { onInterestSatisfied(*dynamic_cast<Consumer*>(m_context), const_cast<Interest&>(interest)); } ConsumerDataVerificationCallback onDataToVerify = EMPTY_CALLBACK; m_context->getContextOption(DATA_TO_VERIFY, onDataToVerify); if (onDataToVerify != EMPTY_CALLBACK) { if (onDataToVerify(*dynamic_cast<Consumer*>(m_context), data) == true) // runs verification routine { const Block content = data.getContent(); ConsumerContentCallback onPayload = EMPTY_CALLBACK; m_context->getContextOption(CONTENT_RETRIEVED, onPayload); if (onPayload != EMPTY_CALLBACK) { onPayload(*dynamic_cast<Consumer*>(m_context), content.value(), content.value_size()); } } } else { const Block content = data.getContent(); ConsumerContentCallback onPayload = EMPTY_CALLBACK; m_context->getContextOption(CONTENT_RETRIEVED, onPayload); if (onPayload != EMPTY_CALLBACK) { onPayload(*dynamic_cast<Consumer*>(m_context), content.value(), content.value_size()); } } m_isRunning = false; }
void onData(const ndn::Interest& interest, ndn::Data& data) { m_isDataReceived = true; if (m_isPayloadOnlySet) { const ndn::Block& block = data.getContent(); std::cout.write(reinterpret_cast<const char*>(block.value()), block.value_size()); } else { const ndn::Block& block = data.wireEncode(); std::cout.write(reinterpret_cast<const char*>(block.wire()), block.size()); } }
bool EdgeStrategy::filterOutgoingData ( const nfd::Face& face, const ndn::Interest& interest, ndn::Data& data, ns3::Time& delay ) { auto in_face = getFaceTable().get( data.getIncomingFaceId() ); bool coming_from_network = !in_face->isEdge(); bool going_to_network = !face.isEdge(); // if the data is coming from and leaving to // the same network then we don't need to do // anything special if( coming_from_network == going_to_network ) { return RouterStrategy::filterOutgoingData ( face, interest, data, delay ); } // if the data is coming into the network then // we just change its current network if( going_to_network ) { BOOST_ASSERT( data.getCurrentNetwork() == ndn::RouteTracker::EXIT_NETWORK ); tracers::edge->data_entered( data ); data.setCurrentNetwork( ndn::RouteTracker::INTERNET_NETWORK ); return RouterStrategy::filterOutgoingData ( face, interest, data, delay ); } // if the data is leaving the network then we change // its current network if( coming_from_network ) { BOOST_ASSERT( data.getCurrentNetwork() == ndn::RouteTracker::INTERNET_NETWORK ); tracers::edge->data_left( data ); data.setCurrentNetwork( ndn::RouteTracker::ENTRY_NETWORK ); return RouterStrategy::filterOutgoingData ( face, interest, data, delay ); } // this should never happen BOOST_ASSERT( false ); return true; }
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 ); }
virtual ndn::shared_ptr<const ndn::Data> preCertificateValidation(const ndn::Data& data) { ndn::shared_ptr<ndn::Data> internalData = ndn::make_shared<ndn::Data>(); internalData->wireDecode(data.getContent().blockFromValue()); return internalData; }
void PutDataToFile(ndn::Data data){ const ndn::Block& block = data.getContent(); size_t fileSize = block.value_size(); std::cout << fileSize << std::endl; std::ofstream fout; fout.open("/home/hult/dataPacketFile"); fout.write((char*)(reinterpret_cast<const uint8_t*>(block.value())), block.value_size()); fout.close(); }
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 validate(const ndn::Data& data) { BOOST_CHECK_EQUAL(data.getFreshnessPeriod(), m_expectedFreshnessPeriod); ndn::Block payload = data.getContent(); m_buffer.appendByteArray(payload.value(), payload.value_size()); // uint64_t segmentNo = data.getName()[-1].toSegment(); if (data.getFinalBlockId() != data.getName()[-1]) { return; } // wrap data in a single Content TLV for easy parsing m_buffer.prependVarNumber(m_buffer.size()); m_buffer.prependVarNumber(ndn::tlv::Content); BOOST_TEST_CHECKPOINT("creating parser"); ndn::Block parser(m_buffer.buf(), m_buffer.size()); BOOST_TEST_CHECKPOINT("parsing aggregated response"); parser.parse(); BOOST_REQUIRE_EQUAL(parser.elements_size(), m_publisher.getLimit()); uint64_t expectedNo = m_publisher.getLimit() - 1; for (ndn::Block::element_const_iterator i = parser.elements_begin(); i != parser.elements_end(); ++i) { uint64_t number = readNonNegativeInteger(*i); BOOST_REQUIRE_EQUAL(number, expectedNo); --expectedNo; } }
virtual void onData(const ndn::Interest& interest, const ndn::Data& data) { int dollarfound=0; int hashfound=0; int i=0; cout << data.getName().size() << endl; int comp_size=data.getName().size(); string last_comp=data.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 Data " << data << std::endl; const ndn::Block& payload = data.getContent(); std:: cout << "payload: "; std::cout.write(reinterpret_cast<const char*>(payload.value()), payload.value_size()); std:: cout << std::endl; if(dollarfound==1) { printf("Inside Dollar Found\n"); const char *sending=reinterpret_cast<const char*>(payload.value()); string received=string(sending); int max_seg_consumer=stoi(received); printf("Maximum Number of Segments is =%d\n",max_seg_consumer); //Write code to express interest for the 0th segment string seg_req_0=UriDecode(data.getName().toUri()); seg_req_0.pop_back(); seg_req_0.append(to_string(max_seg_consumer)); seg_req_0.append("/#0"); printf("String for 0th segment is :"); cout<<seg_req_0<<endl; char str_send[2][1000]; memset(&str_send,0,sizeof(str_send)); strcpy(str_send[0], seg_req_0.c_str()); cout<<"String being sent in $ is:"<<str_send[0]<<endl; const ndn::Name name1(str_send[0]); ndn::Interest request(name1); m_face.expressInterest(request, bind(&Consumer::onData, this, _1, _2), bind(&Consumer::onTimeout, this, _1)); // m_face.processEvents(); } if(hashfound==1){ printf("Inside Hash Fund\n"); //Write code to print to the file and ask the next segment string filename; for(i=0;i<comp_size-2;i++) { string mid=data.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; FILE *fp1=fopen(node_n.c_str(),"a"); fseek(fp1, 0L, SEEK_END); int start_ind=0; start_ind=stoi(check.substr(1)); const char *sending=reinterpret_cast<const char*>(payload.value()); int start1=start_ind*MAX_SEG; fseek(fp1,start1,SEEK_SET); int just_checking=0; if (!(just_checking=fwrite(sending,1,(int)payload.value_size(),fp1))) { fprintf(stderr, "Failure"); //perror(???) I sometimes see code that says perror here and I don't know //exactly what this does. } printf("Just checking.......%d\n",just_checking); //fwrite(sending,1,(int)payload.value_size(),fp1); // fwrite(sending,1,payload.value_size(),fp1); fclose(fp1); /* int start_ind=stoi(check.substr(1)); std::ofstream ofs; ofs.open (node_n, std::ofstream::out | std::ofstream::app); ofs.write(reinterpret_cast<const char*>(payload.value()), payload.value_size()); ofs.close();*/ start_ind++; // printf("Maximum segment count inside the hash function before the condition is:%d and value of start is: %d\n",max_seg_consumer,start_ind); int max_seg_consumer=stoi(UriDecode(data.getName().get(comp_size-2).toUri())); if(start_ind<max_seg_consumer) { printf("Inside the if consition for max segments\n"); string seg_req=UriDecode(data.getName().toUri()); size_t found = seg_req.find_last_of("#"); seg_req=seg_req.substr(0,found+1); seg_req.append(to_string(start_ind)); char str_send[5][1000]; memset(&str_send,0,sizeof(str_send)); strcpy(str_send[0], seg_req.c_str()); cout<<"String that is being sent in ####"<<str_send<<endl; const ndn::Name name1(str_send[0]); ndn::Interest request(name1); m_face.expressInterest(request, bind(&Consumer::onData, this, _1, _2), bind(&Consumer::onTimeout, this, _1)); } else { char buf[16]; snprintf(buf, 16, "%lu", time(NULL)); strcat(timer,"\n"); char tab2[100]; memset(&tab2,0,sizeof(tab2)); strcpy(tab2, node_n.c_str()); strcat(timer,tab2); strcat(timer," End: "); strcat(timer,buf); strcat(timer,"\n"); FILE *fp3; fp3=fopen("logs_shivani.txt","a"); fwrite(timer,1,sizeof(timer),fp3); fclose(fp3); memset(&timer,0,sizeof(timer)); } } }
void putDataToBuffer(ndn::Data dataPacket, char *buffer){ const ndn::Block& block = dataPacket.getContent(); memcpy(buffer, (char*)(reinterpret_cast<const uint8_t*>(block.value())), block.value_size()); }
void onReadData(const ndn::Interest& interest, ndn::Data& data) { int rc = memcmp(data.getContent().value(), content, sizeof(content)); BOOST_CHECK_EQUAL(rc, 0); }
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(); } }