AODVForwardingPolicy.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 "config.h"

#include "dtnaodv.h"
#include "AODVForwardingPolicy.h"
#include "AODVLink.h"
#include "AODVApp.h"
#include "dtn/Exception.h"
#include "dtn/Bundle.h"
#include "dtn/Node.h"
#include "dtn/RoutingTable.h" // for DTN::NoRoute exception

#include <iostream>

AODVForwardingPolicy::AODVForwardingPolicy( DTN::Node* owner,
                                            uint16_t prefix ) :
   DTN::ForwardingPolicy( owner ),
   m_link(0)
{
   if ( 0 == owner ) throw DTN::Exception( __FILE__ , __LINE__ );

   aodv_addr_t self;
   fill_addr( self, owner->addr() );

   init_aodv_state( &m_state, &self, prefix );
   configure_aodv_state( &m_state );
   aodv_add_interface( &m_state, 0 );
}

AODVForwardingPolicy::~AODVForwardingPolicy()
{
   clear_aodv_state( &m_state );
}

void
AODVForwardingPolicy::cache( DTN::BundlePointer& p )
{
}

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

   // handle broadcasts first
   if ( DTN::Bundle::kBcast & b->type() )
   {
      if ( m_link->available() )
      {
         m_owner->send( b, *m_link );
         return true;
      }
      return false;
   }

   // lookup aodv route (might trigger RREQ)
   int e;
   aodv_addr_t src;
   fill_addr( src, b->source() );
   aodv_addr_t dest;
   fill_addr( dest, b->destination() );
   aodv_table_entry_t* r = aodv_get_route( &m_state,
                                           &src,
                                           &dest,
                                           &e );
   if ( 0 == r )
   {
      if ( AODV_GR_NOROUTE == e )
      {
         throw DTN::NoRoute( __FILE__ , __LINE__ );
      }
      return false;
   }
   // check link availability
   if ( m_link->available() )
   {
      // try to send (using a dummy link)
      AODVLink dl( r, m_link );
      m_owner->send( b, dl );
      return true;
   }

   return false;
}

DTN::Bundle*
AODVForwardingPolicy::forwardOn( const DTN::Link& l )
{
   if ( 0 == m_owner )
   {
      throw DTN::Exception( __FILE__ , __LINE__ );
   }

   DTN::BundlePointer p = m_owner->cachedVolatile();
   while ( ! p.isNull() )
   {
      DTN::Bundle* b = p.repr()->bundle();
      int e;
      aodv_addr_t src;
      fill_addr( src, b->source() );
      aodv_addr_t dest;
      fill_addr( dest, b->destination() );
      aodv_table_entry_t* r = aodv_get_route( &m_state,
                                              &src,
                                              &dest,
                                              &e );
      if ( 0 != r )
      {
         m_owner->remove(b,false);
         return b;
      }
      p = p.next();
   }
   return 0;
}

void
AODVForwardingPolicy::handleMessage( const DTN::Bundle& b )
{
   if ( 0 == m_owner ) return;

   aodv_msghdr_t headers;
   fill_addr( headers.addr, b.source() );
   headers.ttl = 2; // we're not really using this
   headers.interface = 0; // we're not really using this

   aodv_chunk_t message;
   const DTN::ByteString& data = b.payload();
   message.length = data.length();
   message.data = (unsigned char*)malloc(message.length*sizeof(unsigned char));
   message.next = 0;
   data.copy( message.data, message.length, 0 );

   aodv_handle_message(&m_state,&headers,&message);

   free(headers.addr.data);
   free(message.data);
}

unsigned int
AODVForwardingPolicy::traversalTime() const
{
   return m_state.params.net_traversal_time;
}

void
AODVForwardingPolicy::addLink( DTN::Link* l )
{
   if ( 0 != l )
   {
      m_link = l;
   }
}

void
AODVForwardingPolicy::notify()
{
   if ( 0 == m_owner ) return;
   if ( 0 == m_link ) return;
   if ( m_link->available() )
   {
      m_owner->forwardOn( *m_link );
   }
}

---