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
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;
}
Exemple #3
0
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;
}
Exemple #4
0
 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;
 }
Exemple #5
0
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();
}
Exemple #6
0
 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());
     }
 }
  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));
    }
    
 }

 }
Exemple #9
0
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
  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
 onReadData(const ndn::Interest& interest, ndn::Data& data)
 {
   int rc = memcmp(data.getContent().value(), content, sizeof(content));
   BOOST_CHECK_EQUAL(rc, 0);
 }