DFPolicy.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 "DFPolicy.h"
#include "DFApp.h"
#include "dtn/Bundle.h"
#include "dtn/Node.h"

using namespace DifferentialForwarding;

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

DFPolicy::~DFPolicy()
{
}

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

   // broadcasts and acknowledgments get sent as long as the link is
   // available
   if ( ( DTN::Bundle::kBcast & b->type() ) ||
        ( DTN::Bundle::kACK & b->type() ) )
   {
      if ( m_link->available() )
      {
         m_owner->send( b, *m_link );
         return true;
      }
      return false;
   }

   // everything else requires a downhill connection
   DTN::Link* dl = m_app->linked( b->destination() );
   if ( 0 == dl ) return false;
   if ( m_link->available() )
   {
      m_owner->send( b, *dl );
      return true;
   }

   return false;
}

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

   DTN::BundlePointer firstFallback;
   DTN::BundlePointer p = m_owner->cachedVolatile();

   // Look for a sendable bundle.  Also, keep track of the first
   // broadcast or ACK we see, since that will be sent as a fallback
   // if nothing else could be.
   while ( ! p.isNull() )
   {
      DTN::Bundle* b = p.repr()->bundle();
      if ( 0 != m_app->linked( b->destination() ) )
      {
         m_owner->remove(b,false);
         return b;
      }
      if ( firstFallback.isNull() )
      {
         if ( ( DTN::Bundle::kBcast & b->type() ) ||
              ( DTN::Bundle::kACK & b->type() ) )
         {
            firstFallback = p;
         }
      }
      p = p.next();
   }

   // At this point, we weren't able to send anything, so check the
   // fallback.
   if ( ! firstFallback.isNull() )
   {
      DTN::Bundle* b = firstFallback.repr()->bundle();
      m_owner->remove(b,false);
      return b;
   }

   // We have nothing that we're able to send.
   return 0;
}

---