EpidemicApp.cc

// Copyright 2008 Michael Marsh, University of Maryland.
//
// This file is part of pydtn.
//
// pydtn is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// pydtn is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with pydtn.  If not, see <http://www.gnu.org/licenses/>.
//
// The views and conclusions contained in the software and documentation
// are those of the authors and should not be interpreted as representing
// official policies, either expressed or implied, of the University
// of Maryland.
//
// pydtn extends and embeds the Python interpreter, which is
// Copyright 2001-2006 Python Software Foundation, All Rights Reserved,
// and is released under the PSF License Agreement.
//
// RANLUX random number generation uses the Boost library,
// Copyright 1994-2006 by various authors (details in individual files),
// which is released under the Boost Software License, Version 1.0.

#include "EpidemicApp.h"
#include "EpidemicStore.h"

#include "simlpy/interpreter_hooks.h"
#include "pydtn/parsers.h"
#include <iostream>

using namespace Epidemic;

DTN::ByteString EpidemicApp::kIdentifier((unsigned char*)"epidemic");
unsigned char EpidemicApp::kSummaryVector = 0;
unsigned char EpidemicApp::kDataRequest = 1;

EpidemicApp::EpidemicApp( EpidemicStore* es,
                          DTN::Link* l,
                          const struct timeval& t ) :
   m_store( es ),
   m_link( l )
{
   m_lifetime.tv_sec = t.tv_sec;
   m_lifetime.tv_usec = t.tv_usec;
}

EpidemicApp::~EpidemicApp()
{
   LinkMap::iterator itr = m_linkMap.begin();
   LinkMap::iterator end = m_linkMap.end();
   for ( ; itr != end ; ++itr )
   {
      if ( 0 != itr->second )
      {
         delete itr->second;
      }
   }
}

void
EpidemicApp::newNeighbor( const DTN::ByteString& addr )
{
   if ( 0 == m_store ) return;
   if ( 0 == m_owner ) return;

   // Make sure there's a mock link for this address.
   if ( m_linkMap.end() == m_linkMap.find(addr) )
   {
      m_linkMap[addr] = new Mobility::MockLink(m_link,addr);
   }

   // First, find the last-hop-only bundles for the new neighbor and
   // enqueue them.
   m_store->forwardLastHop( addr, *m_owner );

   // Second, send the summary vector.
   DTN::ByteString* sv = m_store->summaryVector();
   if ( 0 == sv ) return;
   if ( 0 == sv->length() )
   {
      delete sv;
      return;
   }
   DTN::ByteString data;
   data.push_back( kSummaryVector );
   data.append( *sv );
   if ( verbosity() > 1 )
   {
      std::cout << "sending summary vector from "
                << stringify(m_owner->addr())
                << " to "
                << stringify(addr)
                << " ["
                << stringify(*sv)
                << "]"
                << std::endl;
   }
   delete sv;
   struct timeval now = DTN::dtn_time();
   struct timeval exp = DTN::dtn_time();
   exp.tv_sec += m_lifetime.tv_sec;
   exp.tv_usec += m_lifetime.tv_usec;
   while ( exp.tv_usec > 1000000 )
   {
      exp.tv_usec -= 1000000;
      exp.tv_sec += 1;
   }
   DTN::Bundle* b = new DTN::Bundle( m_owner->nextSeq(),
                                     m_owner->addr(),
                                     addr,
                                     data,
                                     now,
                                     exp,
                                     DTN::Bundle::kData,
                                     appID() );
   // We have to set the receiver now.
   b->recv() = addr;
   m_owner->forward(b);
}

void
EpidemicApp::process( const DTN::Bundle& b )
{
   if ( 0 == m_store ) return;

   if ( b.payload().length() < 2 ) return;

   // If we've received a summary vector, look through it for
   // bundles we haven't seen and send a data request.
   if ( kSummaryVector == b.payload()[0] )
   {
      if ( verbosity() > 1 )
      {
         std::cout << "processing a summary vector at "
                   << stringify( m_owner->addr())
                   << " from "
                   << stringify( b.source() )
                   << std::endl;
      }
      EpidemicStore::DigestList* dl =
         EpidemicStore::parseSummaryVector( b.payload().substr(1) );
      if ( 0 == dl ) return;
      DTN::ByteString data;
      data.push_back( kDataRequest );
      EpidemicStore::DigestList::iterator itr = dl->begin();
      EpidemicStore::DigestList::iterator end = dl->end();
      bool haveReq = false;
      for ( ; itr != end ; ++itr )
      {
         if ( ! m_store->seen(*itr) )
         {
            haveReq = true;
            data.append( *itr );
         }
      }
      delete dl;
      if ( ! haveReq ) return;
      if ( verbosity() > 1 )
      {
         std::cout << "sending data request from "
                   << stringify(m_owner->addr())
                   << " to "
                   << stringify(b.source())
                   << " ["
                   << stringify(data)
                   << "]"
                   << std::endl;
      }

      struct timeval now = DTN::dtn_time();
      struct timeval exp = DTN::dtn_time();
      exp.tv_sec += m_lifetime.tv_sec;
      exp.tv_usec += m_lifetime.tv_usec;
      while ( exp.tv_usec > 1000000 )
      {
         exp.tv_usec -= 1000000;
         exp.tv_sec += 1;
      }

      DTN::Bundle* pB = new DTN::Bundle( m_owner->nextSeq(),
                                         m_owner->addr(),
                                         b.source(),
                                         data,
                                         now,
                                         exp,
                                         DTN::Bundle::kData,
                                         appID() );
      // We have to set the receiver now.
      pB->recv() = b.source();
      m_owner->forward(pB);
      return;
   }

   // If we've received a data request, enqueue the specified bundles.
   if ( kDataRequest == b.payload()[0] )
   {
      EpidemicStore::DigestList* dl =
         EpidemicStore::parseSummaryVector( b.payload().substr(1) );
      if ( 0 == dl ) return;

      EpidemicStore::DigestList::iterator itr = dl->begin();
      EpidemicStore::DigestList::iterator end = dl->end();
      for ( ; itr != end ; ++itr )
      {
         DTN::BundlePointer bp = m_store->getPointer(*itr);
         if ( ! bp.isNull() )
         {
            // Copy the bundle.
            DTN::Bundle* pB = bp.repr()->bundle()->clone();
            // Set the next-hop receiver to the requesting node.
            pB->recv() = b.source();
            // Enqueue the bundle.
            m_owner->forward(pB);
         }
      }
      delete dl;

      return;
   }

   // The message type was invalid.  We'll ignore this.
}

DTN::Link*
EpidemicApp::getLink( const DTN::ByteString& addr )
{
   LinkMap::iterator itr = m_linkMap.find(addr);
   if ( m_linkMap.end() == itr ) return 0;
   return itr->second;
}

---