rreq_buffer.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"

static void
_buffer_rreq_base( aodv_rreq_t** buffer,
                   aodv_rreq_t* rreq,
                   unsigned int timeout )
{
   aodv_rreq_t* head = NULL;
   aodv_rreq_t* tail = NULL;
   struct timeval* tv = NULL;

   if ( NULL == buffer ) return;
   if ( NULL == rreq ) return;

   if ( NULL == *buffer )
   {
      rreq->next = rreq;
      rreq->prev = rreq;
      *buffer = rreq;
   }
   else
   {
      head = *buffer;
      tail = head->prev;
      rreq->next = head;
      rreq->prev = tail;
      tail->next = rreq;
      head->prev = rreq;
   }

   tv = &(rreq->buffer_time);
   aodv_gettime(tv);
   tv->tv_usec += 1000 * timeout;
   while ( tv->tv_usec >= 1000000 )
   {
      tv->tv_usec -= 1000000;
      tv->tv_sec += 1;
   }
   rreq->ntries = 1;
}

void
buffer_aodv_rreq( aodv_state_t* state, aodv_rreq_t* rreq )
{
   _buffer_rreq_base( &(state->rreq_buffer),
                      rreq,
                      state->params.net_traversal_time );
}

void
buffer_rcvd_aodv_rreq( aodv_state_t* state, aodv_rreq_t* rreq )
{
   _buffer_rreq_base( &(state->rcvd_rreq_buffer),
                      rreq,
                      state->params.path_discovery_time );
}


static aodv_rreq_t*
_unbuffer_rreq_base( aodv_rreq_t** buffer, aodv_rreq_t* rreq )
{
   aodv_rreq_t* head;
   aodv_rreq_t* tail;
   aodv_rreq_t* retval = NULL;
   char is_head = 0;
   char is_tail = 0;

   if ( NULL == buffer ) return NULL;
   if ( NULL == *buffer ) return NULL;
   if ( NULL == rreq ) return NULL;

   head = *buffer;
   tail = head->prev;

   if ( rreq == head ) is_head = 1;
   if ( rreq == tail ) is_tail = 1;

   if ( is_head && is_tail )
   {
      retval = NULL;
      *buffer = NULL;
   }
   else if ( is_head )
   {
      retval = rreq->next;
      *buffer = retval;
      retval->prev = tail;
      tail->next = retval;
   }
   else if ( is_tail )
   {
      retval = tail->prev;
      head->prev = tail->prev;
      tail->prev->next = head;
   }
   else
   {
      retval = rreq->next;
      rreq->prev->next = rreq->next;
      rreq->next->prev = rreq->prev;
   }

   free_aodv_rreq( rreq );

   return retval;
}

aodv_rreq_t*
unbuffer_aodv_rreq( aodv_state_t* state, aodv_rreq_t* rreq )
{
   if ( NULL == state ) return NULL;
   if ( NULL == state->rreq_buffer ) return NULL;
   if ( NULL == rreq ) return NULL;

   return _unbuffer_rreq_base( &(state->rreq_buffer), rreq );
}

aodv_rreq_t*
unbuffer_rcvd_aodv_rreq( aodv_state_t* state, aodv_rreq_t* rreq )
{
   if ( NULL == state ) return NULL;
   if ( NULL == state->rcvd_rreq_buffer ) return NULL;
   if ( NULL == rreq ) return NULL;

   return _unbuffer_rreq_base( &(state->rcvd_rreq_buffer), rreq );
}


/*
 * This routine does double duty: check for the rreq in the buffer
 * and clean out expired entries.  This is lazy garbage collection.
 *
 */
static int
_is_buffered_rreq_base( aodv_rreq_t** buffer, const aodv_rreq_t* rreq )
{
   aodv_rreq_t* head;
   aodv_rreq_t* curr;
   int retval = 0;

   if ( NULL == buffer ) return 0;
   if ( NULL == *buffer ) return 0;
   if ( NULL == rreq ) return 0;

   head = *buffer;
   curr = head;
   do
   {
      if ( aodv_pasttime( &(curr->buffer_time) ) )
      {
         curr = _unbuffer_rreq_base( buffer, curr );
         head = *buffer;
      }

      if ( NULL != curr )
      {
         if ( ( 0 == retval ) &&
              ( 0 == aodv_cmp_addr( &(curr->originator),
                                    &(rreq->originator) ) ) &&
              ( curr->rreq_id == rreq->rreq_id ) )
         {
            retval = 1;
         }
         curr = curr->next;
      }
   } while ( curr != head );

   return retval;
}

int
is_buffered_aodv_rreq( aodv_state_t* state, aodv_rreq_t* rreq )
{
   if ( NULL == state ) return 0;
   if ( NULL == state->rreq_buffer ) return 0;
   if ( NULL == rreq ) return 0;

   return _is_buffered_rreq_base( &(state->rreq_buffer), rreq );
}

int
is_buffered_rcvd_aodv_rreq( aodv_state_t* state, aodv_rreq_t* rreq )
{
   if ( NULL == state ) return 0;
   if ( NULL == state->rcvd_rreq_buffer ) return 0;
   if ( NULL == rreq ) return 0;

   return _is_buffered_rreq_base( &(state->rcvd_rreq_buffer), rreq );
}

aodv_rreq_t*
find_buffered_aodv_rreq( aodv_state_t* state, const aodv_addr_t* dest )
{
   aodv_rreq_t* head;
   aodv_rreq_t* curr;

   if ( NULL == state ) return NULL;
   if ( NULL == state->rreq_buffer ) return NULL;

   head = state->rreq_buffer;
   curr = head;
   do
   {
      if ( 0 == aodv_cmp_addr( &(curr->destination), dest ) ) return curr;
      curr = curr->next;
   } while ( curr != head );
   return NULL;
}

---