get_route.c

/* 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 "aodv.h"

aodv_table_entry_t*
aodv_get_route( aodv_state_t* state,
                const aodv_addr_t* source,
                const aodv_addr_t* destination,
                int* ecode )
{
   unsigned char have_ecode = 0;
   unsigned char need_rreq = 0;
   aodv_table_entry_t* retval = NULL;
   aodv_rreq_t* crreq;
   struct timeval* tv;
   unsigned long timeout;

   if ( NULL != ecode )
   {
      have_ecode = 1;
      *ecode = AODV_GR_OK;
   }

   if ( NULL == state )
   {
      if ( have_ecode ) *ecode = AODV_GR_NULLSTATE;
      return NULL;
   }

   retval = aodv_lookup( &(state->routing_table), destination );
   if ( NULL != retval )
   {
      if ( aodv_table_entry_is_expired( retval ) )
      {
         if ( retval->valid_route )
         {
            retval->valid_route = 0;
            aodv_incr_seq_base( &(retval->dest_seq) );
         }
         else
         {
            remove_aodv_table_entry( &(state->routing_table), retval );
            retval = NULL;
         }
      }
      else
      {
         if ( retval->valid_route )
         {
            aodv_update_route_expiry( state, retval );
            return retval;
         }
         else
         {
            aodv_update_invalid_route_lifetime( state, retval );
         }
      }
   }

   if ( ( 0 != aodv_cmp_addr( source, &(state->self) ) ) &&
        ( ( NULL == retval ) ||
          ( ! retval->valid_route ) ) )
   {
      aodv_rerr_t rerr;
      rerr.dest_count = 1;
      rerr.unreachable = 0;
      uint32_t seq = 0;
      if ( 0 != retval )
      {
         seq = retval->dest_seq;
      }
      aodv_add_to_node_list( &(rerr.unreachable), destination, seq );
      if ( aodv_insert_time( state->rerr_time_ring ) )
      {
         aodv_bcast_rerr( state, &rerr );
      }
      if ( have_ecode ) *ecode = AODV_GR_NOROUTE;
      return NULL;
   }

   need_rreq = 1;

   crreq = state->rreq_buffer;
   if ( NULL != crreq )
   {
      do
      {
         if ( 0 == aodv_cmp_addr( &(crreq->destination), destination ) )
         {
            need_rreq = 0;
            if ( aodv_pasttime( &(crreq->buffer_time) ) )
            {
               if ( crreq->ntries < state->params.rreq_tries )
               {
                  if ( aodv_insert_time( state->rreq_time_ring ) )
                  {
                     timeout =
                        ( 1 << crreq->ntries ) *
                        state->params.net_traversal_time;
                     (crreq->ntries)++;
                     crreq->rreq_id = aodv_incr_rreq_id(state);
                     tv = &(crreq->buffer_time);
                     aodv_gettime(tv);
                     tv->tv_usec += 1000 * timeout;
                     while ( tv->tv_usec >= 1000000 )
                     {
                        tv->tv_usec -= 1000000;
                        tv->tv_sec += 1;
                     }
                     aodv_bcast_rreq( state, crreq );
                     if ( have_ecode ) *ecode = AODV_GR_PENDING;
                     return NULL;
                  }
               }
               else
               {
                  if ( have_ecode ) *ecode = AODV_GR_NOROUTE;
                  unbuffer_aodv_rreq( state, crreq );
                  return NULL;
               }
            }
            if ( have_ecode ) *ecode = AODV_GR_PENDING;
            return NULL;
         }
         crreq = crreq->next;
      } while ( need_rreq && ( crreq != state->rreq_buffer ) );
   }

   if ( have_ecode ) *ecode = AODV_GR_PENDING;

   if ( need_rreq )
   {
      if ( ! aodv_generate_rreq( state, destination ) )
      {
         if ( have_ecode ) *ecode = AODV_GR_ERROR;
      }
   }

   return NULL;
}

---