Forwarding.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 "Forwarding.h"
#include "Protocol.h"

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

using namespace MobileForwarding;

Forwarding::Forwarding( DTN::Node* owner, DTN::Link* link, Protocol* prot ):
   DTN::ForwardingPolicy(owner),
   m_link(link),
   m_prot(prot)
{
}

Forwarding::~Forwarding()
{
}

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

   // Let the protocol modify the bundle, if it needs to.
   m_prot->tweak(b);

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

   return false;
}

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

   DTN::Bundle* retval = 0;

   // We want to run the loop for *all* bundles, because this also
   // serves as a cleanup of the volatile store for (currently)
   // unroutable bundles.
   DTN::BundlePointer p = m_owner->cachedVolatile();
   DTN::BundlePointer prev;
   while ( ! p.isNull() )
   {
      DTN::Bundle* b = p.repr()->bundle();
      if ( ( !(DTN::Bundle::kBcast & b->type()) ) &&
           ( ( ! m_prot->visible( b->recv() ) ) ||
             ( 0 == m_prot->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;
}

---