EpidemicForwarding.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 "EpidemicForwarding.h"
#include "EpidemicApp.h"

#include "dtn/Bundle.h"
#include "dtn/Node.h"

using namespace Epidemic;

EpidemicForwarding::EpidemicForwarding( DTN::Node* owner,
                                        DTN::Link* link,
                                        EpidemicApp* app ):
   DTN::ForwardingPolicy(owner),
   m_link(link),
   m_app(app)
{
}

EpidemicForwarding::~EpidemicForwarding()
{
}

bool
EpidemicForwarding::forward( DTN::Bundle* b )
{
   if ( 0 == b ) return false;
   if ( 0 == m_owner ) return false;
   if ( 0 == m_link ) return false;
   if ( 0 == m_app ) return false;

   if ( m_link->available() )
   {
      try
      {
         if ( DTN::Bundle::kBcast & b->type() )
         {
            m_owner->send( b , *m_link );
            return true;
         }
         DTN::Link* l = m_app->getLink( b->recv() );
         if ( 0 != l )
         {
            m_owner->send( b , *l );
            return true;
         }
      }
      catch ( ... )
      {
      }
   }

   return false;
}

DTN::Bundle*
EpidemicForwarding::forwardOn( const DTN::Link& l )
{
   if ( 0 == m_owner ) return 0;

   DTN::Bundle* retval = 0;

   DTN::BundlePointer p =  m_owner->cachedVolatile();
   DTN::BundlePointer prev;
   while ( ! p.isNull() )
   {
      DTN::Bundle* b = p.repr()->bundle();
      if ( ( !(DTN::Bundle::kBcast & b->type()) ) &&
           ( 0 == m_app->getLink( b->recv() ) ) )
      {
         m_owner->remove(b,true,DTN::NoRouteDrop::inst);
         p = prev;
      }
      else if ( 0 == retval )
      {
         retval = b;
      }
      prev = p;
      if ( p.isNull() )
      {
         p = m_owner->cachedVolatile();
      }
      else
      {
         p = p.next();
      }
   }

   if ( 0 != retval )
   {
      m_owner->remove(retval,false);
   }
   return retval;
}

---