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

/*
 * This routine allocates a new state structure and performs most of
 * the necessary initialization.  Once the parameters have been set
 * correctly (including a call to recompute_aodv_params if any have
 * been changed), configure_aodv_state should be called to complete
 * the initialization.
 */
aodv_state_t*
new_aodv_state( const aodv_addr_t* self, uint16_t prefix )
{
   aodv_state_t* state = NULL;
   state = (aodv_state_t*) malloc( sizeof(aodv_state_t) );
   if ( NULL == state )
   {
      return NULL;
   }
   init_aodv_state( state, self, prefix );

   return state;
}

/*
 * This routine performs the necessary initialization of an allocate
 * state structure.  Once the parameters have been set correctly
 * (including a call to recompute_aodv_params if any have been
 * changed), configure_aodv_state should be called to complete the
 * initialization.
 */
void
init_aodv_state( aodv_state_t* state,
                 const aodv_addr_t* self,
                 uint16_t prefix )
{
   if ( NULL == state )
   {
      return;
   }
   state->self.data = NULL;
   state->self.length = 0U;
   set_aodv_addr( &(state->self), self );
   state->subnet_size = prefix;
   state->sequence_number = 1;
   state->rreq_id = 0;
   state->rreq_buffer = NULL;
   state->rcvd_rreq_buffer = NULL;
   state->rreq_time_ring = NULL;
   state->rerr_time_ring = NULL;
   state->use_acks = 0;
   state->interfaces.interfaces = NULL;
   state->interfaces.nifaces = 0;
   state->interfaces.lifaces = 0;
   state->routing_table.head = NULL;
   set_aodv_param_defaults( state );
}

/*
 * Most of the initialization should have been done before this is
 * called.  All this routine does is to set up the circular buffers
 * that control the rate with which RREQ and RERR messages are
 * generated.
 */
void
configure_aodv_state( aodv_state_t* state )
{
   if ( NULL != state->rreq_time_ring )
   {
      free_aodv_time_ring( state->rreq_time_ring );
   }
   state->rreq_time_ring =
      (aodv_time_ring_t*) malloc( sizeof(aodv_time_ring_t) );
   if ( NULL == state->rreq_time_ring ) return;
   aodv_initialize_time_ring( state->rreq_time_ring,
                              state->params.rreq_ratelimit );

   if ( NULL != state->rerr_time_ring )
   {
      free_aodv_time_ring( state->rerr_time_ring );
   }
   state->rerr_time_ring =
      (aodv_time_ring_t*) malloc( sizeof(aodv_time_ring_t) );
   if ( NULL == state->rerr_time_ring ) return;
   aodv_initialize_time_ring( state->rerr_time_ring,
                              state->params.rerr_ratelimit );
}

static void
_free_rreq_buffer( aodv_rreq_t* buffer )
{
   aodv_rreq_t* curr;
   aodv_rreq_t* next;

   if ( NULL == buffer ) return;

   curr = buffer;
   do
   {
      next = curr->next;
      free_aodv_rreq( curr );
      curr = next;
   } while ( curr != buffer );
}

void
free_aodv_state( aodv_state_t* state )
{
   if ( NULL == state ) return;
   clear_aodv_state( state );
   free(state);
}

void
clear_aodv_state( aodv_state_t* state )
{
   if ( NULL == state ) return;
   _free_rreq_buffer( state->rreq_buffer );
   _free_rreq_buffer( state->rcvd_rreq_buffer );

   free_aodv_time_ring( state->rreq_time_ring );
   free_aodv_time_ring( state->rerr_time_ring );

   if ( NULL != state->interfaces.interfaces )
   {
      free( state->interfaces.interfaces );
   }

   clear_aodv_routing_table( &(state->routing_table) );
}

---