handle_message.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 <string.h>
#include <netinet/in.h>
#include "aodv.h"

/*
 * Internal routines.
 */

static int
_copy_path( aodv_node_list_t** dst, aodv_node_list_t* src )
{
   aodv_node_list_t* dcurr = NULL;
   aodv_node_list_t* dhead = NULL;
   aodv_node_list_t* dtail = NULL;
   aodv_node_list_t* scurr = src;
   aodv_node_list_t* shead = src;

   if ( NULL == src )
   {
      return 1;
   }

   dhead = (aodv_node_list_t*) malloc( sizeof(aodv_node_list_t) );
   if ( NULL == dhead )
   {
      return 0;
   }
   dhead->node.data = NULL;
   dhead->node.length = 0U;
   set_aodv_addr( &(dhead->node), &(shead->node) );
   dhead->seq  = shead->seq;
   dhead->next = dhead;
   dhead->prev = dhead;
   dtail = dhead;
   scurr = scurr->next;
   for ( ; scurr != shead ; scurr = scurr->next )
   {
      dcurr = (aodv_node_list_t*) malloc( sizeof(aodv_node_list_t) );
      if ( NULL == dcurr )
      {
         free_aodv_node_list( dhead );
         return 0;
      }
      dcurr->prev = dtail;
      dcurr->next = dhead;
      dtail->next = dcurr;
      dhead->prev = dcurr;
      dtail = dcurr;

      dcurr->node.data = NULL;
      dcurr->node.length = 0U;
      set_aodv_addr( &(dcurr->node), &(scurr->node) );
      dcurr->seq  = scurr->seq;
   }

   *dst = dhead;
   return 1;
}

static aodv_rrep_t*
_generate_rrep( aodv_state_t* state,
                const aodv_rreq_t* request,
                const aodv_table_entry_t* entry )
{
   aodv_rrep_t* retval;

   if ( ( 0 != aodv_cmp_addr( &(request->destination), &(state->self) ) ) &&
        ( NULL == entry ) )
   {
      return NULL;
   }

   retval = (aodv_rrep_t*) malloc( sizeof( aodv_rrep_t ) );
   if ( NULL == retval )
   {
      return retval;
   }

   retval->destination.addr.data = NULL;
   retval->destination.addr.length = 0U;
   set_aodv_addr( &(retval->destination.addr) , &(request->destination) );
   retval->originator.data = NULL;
   retval->originator.length = 0U;
   set_aodv_addr( &(retval->originator) , &(request->originator) );
   retval->orig_seq = request->orig_seq;
   retval->ack_flag = state->use_acks;
   retval->apn_count = request->hop_count - 1;
   retval->path = NULL;
   if ( ! _copy_path( &(retval->path), request->path ) )
   {
      free_aodv_rrep( retval );
      return NULL;
   }
   if ( 0 == aodv_cmp_addr( &(request->destination), &(state->self) ) )
   {
      retval->hop_count = 0;
      retval->destination.prefix = state->subnet_size;
      if ( aodv_cmp_seq( request->dest_seq, state->sequence_number ) > 0 )
      {
         state->sequence_number = request->dest_seq;
         aodv_incr_seq( state );
      }
      retval->dest_seq = state->sequence_number;
   }
   else
   {
      retval->hop_count = entry->hop_count;
      retval->destination.prefix = entry->destination.prefix;
      retval->dest_seq = entry->dest_seq;
   }

   aodv_log_rrep_c( state, retval );

   return retval;
}

static aodv_rreq_t*
_unserialize_rreq( const aodv_chunk_t* message )
{
   aodv_rreq_t* request;
   unsigned char* pData;
   unsigned int length;
   unsigned char i;
   uint8_t  b;
   uint16_t s;
   uint32_t l;

   if ( NULL == message )
   {
      return NULL;
   }

   length = message->length;

   request = (aodv_rreq_t*) malloc( sizeof( aodv_rreq_t ) );
   if ( NULL == request )
   {
      return NULL;
   }

   pData = message->data;

   request->next = NULL;
   request->prev = NULL;
   request->path = NULL;
   request->buffer_time.tv_sec = -1;
   request->buffer_time.tv_usec = 0;

   if ( ! aodv_get8( &pData, &length, &b ) )
   {
      free_aodv_rreq(request);
      return NULL;
   }

   if ( ! aodv_get16( &pData, &length, &s ) )
   {
      free_aodv_rreq(request);
      return NULL;
   }
   request->dest_only_flag = ( ntohs(s) & kAodvRreqD ) ? 1 : 0;
   request->grat_rrep_flag = ( ntohs(s) & kAodvRreqG ) ? 1 : 0;

   if ( ! aodv_get8( &pData, &length, &b ) )
   {
      free_aodv_rreq(request);
      return NULL;
   }
   request->hop_count = b;

   if ( ! aodv_get32( &pData, &length, &l ) )
   {
      free_aodv_rreq(request);
      return NULL;
   }
   request->rreq_id = ntohl(l);

   if ( ! aodv_get_addr( &pData, &length, &(request->destination) ) )
   {
      free_aodv_rreq(request);
      return NULL;
   }

   if ( ! aodv_get32( &pData, &length, &l ) )
   {
      free_aodv_rreq(request);
      return NULL;
   }
   request->dest_seq = ntohl(l);

   if ( ! aodv_get_addr( &pData, &length, &(request->originator) ) )
   {
      free_aodv_rreq(request);
      return NULL;
   }

   if ( ! aodv_get32( &pData, &length, &l ) )
   {
      free_aodv_rreq(request);
      return NULL;
   }
   request->orig_seq = ntohl(l);

   for ( i = 0 ; i < request->hop_count - 1 ; ++i )
   {
      aodv_addr_t addr;
      uint32_t seq;

      if ( ! aodv_get_addr( &pData, &length, &addr ) )
      {
         free_aodv_rreq(request);
         return NULL;
      }

      if ( ! aodv_get32( &pData, &length, &l ) )
      {
         free_aodv_rreq(request);
         return NULL;
      }
      seq = ntohl(l);

      if ( ! aodv_add_to_node_list( &(request->path), &addr, seq ) )
      {
         free_aodv_rreq(request);
         return NULL;
      }
   }

   return request;
}


static int
_handle_rreq( aodv_state_t* state,
              const aodv_msghdr_t* hdrs,
              const aodv_chunk_t* message )
{
   aodv_rreq_t* rreq = _unserialize_rreq( message );
   aodv_rrep_t* rrep;

   aodv_table_entry_t*  entry;
   aodv_table_entry_t*  oentry;

   aodv_node_list_t   originator;
   aodv_node_list_t*  ncurr;;

   if ( NULL == rreq ) return 0;

   rreq->ttl = hdrs->ttl;
   aodv_log_rreq_r( state, rreq, hdrs );

   if ( 0 == aodv_cmp_addr( &(rreq->originator), &(state->self) ) )
   {
      free_aodv_rreq( rreq );
      return 1;
   }

   ++(rreq->hop_count);

   originator.next = NULL;
   originator.prev = NULL;
   originator.node.data = NULL;
   originator.node.length = 0U;
   set_aodv_addr( &(originator.node), &(rreq->originator) );
   originator.seq  = rreq->orig_seq;
   oentry =
      update_aodv_table_entry( state, hdrs, &originator, rreq->hop_count );
   if ( NULL == oentry )
   {
      free_aodv_rreq( rreq );
      return 0;
   }
   ncurr = rreq->path;
   if ( NULL != ncurr )
   {
      unsigned char hops = rreq->hop_count;
      do
      {
         --hops;
         if ( NULL == update_aodv_table_entry( state, hdrs, ncurr, hops ) )
         {
            free_aodv_rreq( rreq );
            return 0;
         }
         ncurr = ncurr->next;
      } while ( ( ncurr != rreq->path ) && ( hops > 0 ) );
   }

   if ( is_buffered_rcvd_aodv_rreq( state, rreq ) )
   {
      free_aodv_rreq( rreq );
      return 1;
   }
   buffer_rcvd_aodv_rreq( state, rreq );

   if ( 0 == aodv_cmp_addr( &(rreq->destination), &(state->self) ) )
   {
      rrep = _generate_rrep( state, rreq, NULL );
      if ( NULL == rrep ) return 0;
      aodv_unicast_rrep( state, rrep );
      free_aodv_rrep( rrep );
      return 1;
   }

   if ( ! aodv_add_to_node_list( &(rreq->path),
                                 &(state->self),
                                 state->sequence_number ) )
   {
      return 0;
   }

   entry = aodv_lookup( &(state->routing_table), &(rreq->destination) );

   if ( NULL != entry )
   {
      if ( aodv_cmp_seq( entry->dest_seq, rreq->dest_seq ) > 0 )
      {
         rreq->dest_seq = entry->dest_seq;
      }

      if ( entry->valid_route && (! rreq->dest_only_flag) )
      {
         rrep = _generate_rrep( state, rreq, entry );
         if ( NULL == rrep ) return 0;
         aodv_unicast_rrep( state, rrep );
         free_aodv_rrep( rrep );
         if ( rreq->grat_rrep_flag )
         {
            aodv_rrep_t  grrep;
            grrep.path = NULL;
            grrep.ack_flag = state->use_acks;
            grrep.apn_count = 0;
            grrep.hop_count = rreq->hop_count;
            grrep.destination.addr.data = NULL;
            grrep.destination.addr.length = 0U;
            set_aodv_addr( &(grrep.destination.addr), &(rreq->originator) );
            grrep.destination.prefix = 0;
            grrep.dest_seq = rreq->orig_seq;
            grrep.originator.data = NULL;
            grrep.originator.length = 0U;
            set_aodv_addr( &(grrep.originator), &(rreq->destination) );
            grrep.orig_seq = rreq->dest_seq;
            aodv_unicast_rrep( state, &grrep );
         }
         return 1;
      }
   }

   if ( rreq->ttl <= 1 )
   {
      return 1;
   }
   --(rreq->ttl);

   aodv_bcast_rreq( state, rreq );

   return 0;
}

static aodv_rrep_t*
_unserialize_rrep( const aodv_chunk_t* message )
{
   aodv_rrep_t* response;
   unsigned char* pData;
   unsigned int length;
   unsigned char i;
   uint8_t  b;
   uint16_t s;
   uint32_t l;
   uint16_t temp16;

   if ( NULL == message )
   {
      return NULL;
   }

   length = message->length;
   if ( length < k_aodv_rrep_min_len )
   {
      return NULL;
   }

   response = (aodv_rrep_t*) malloc( sizeof( aodv_rrep_t ) );
   if ( NULL == response )
   {
      return NULL;
   }

   pData = message->data;

   response->path = NULL;

   if ( ! aodv_get8( &pData, &length, &b ) )
   {
      free_aodv_rrep(response);
      return NULL;
   }

   if ( ! aodv_get16( &pData, &length, &s ) )
   {
      free_aodv_rrep(response);
      return NULL;
   }
   temp16 = ntohs(s);
   response->ack_flag = ( temp16 & kAodvRrepA ) ? 1 : 0;
   response->destination.prefix = 0;
   for ( i = 0 ; i < 5 ; ++i, temp16 >>= 1 )
   {
      if ( temp16 & 1 )
      {
         response->destination.prefix &= ( 1 << i );
      }
   }
   response->apn_count = 0;
   for ( i = 0 ; i < 5 ; ++i, temp16 >>= 1 )
   {
      if ( temp16 & 1 )
      {
         response->apn_count &= ( 1 << i );
      }
   }

   if ( ! aodv_get8( &pData, &length, &b ) )
   {
      free_aodv_rrep(response);
      return NULL;
   }
   response->hop_count = b;

   if ( ! aodv_get_addr( &pData, &length, &(response->destination.addr) ) )
   {
      free_aodv_rrep(response);
      return NULL;
   }

   if ( ! aodv_get32( &pData, &length, &l ) )
   {
      free_aodv_rrep(response);
      return NULL;
   }
   response->dest_seq = ntohl(l);

   if ( ! aodv_get_addr( &pData, &length, &(response->originator) ) )
   {
      free_aodv_rrep(response);
      return NULL;
   }

   if ( ! aodv_get32( &pData, &length, &l ) )
   {
      free_aodv_rrep(response);
      return NULL;
   }
   response->orig_seq = ntohl(l);

   for ( i = 0 ; i < response->apn_count ; ++i )
   {
      aodv_addr_t addr;
      uint32_t   seq;

      if ( ! aodv_get_addr( &pData, &length, &addr ) )
      {
         free_aodv_rrep(response);
         return NULL;
      }

      if ( ! aodv_get32( &pData, &length, &l ) )
      {
         free_aodv_rrep(response);
         return NULL;
      }
      seq = ntohl(l);

      if ( ! aodv_add_to_node_list( &(response->path), &addr, seq ) )
      {
         free_aodv_rrep(response);
         return NULL;
      }
   }

   return response;
}

static int
_handle_rrep( aodv_state_t* state,
              const aodv_msghdr_t* hdrs,
              const aodv_chunk_t* message )
{
   aodv_rrep_t* rrep = _unserialize_rrep( message );
   aodv_table_entry_t* entry;
   aodv_node_list_t  nl;
   aodv_node_list_t* ncurr;
   unsigned char update = 0;
   char cmp;

   if ( NULL == rrep ) return 0;

   aodv_log_rrep_r( state, rrep, hdrs );

   ++(rrep->hop_count);

   nl.node.data = NULL;
   nl.node.length = 0U;
   set_aodv_addr( &(nl.node), &(rrep->destination.addr) );
   nl.seq  = rrep->dest_seq;
   entry = update_aodv_table_entry( state, hdrs, &nl, rrep->hop_count );
   if ( NULL == entry )
   {
      free_aodv_rrep( rrep );
      return 0;
   }
   entry->destination.prefix = rrep->destination.prefix;
   aodv_route_notify( state, &(entry->destination.addr) );

   ncurr = rrep->path;
   if ( NULL != ncurr )
   {
      unsigned char hops = rrep->hop_count;
      do
      {
         --hops;
         if ( NULL == update_aodv_table_entry( state, hdrs, ncurr, hops ) )
         {
            free_aodv_rrep( rrep );
            return 0;
         }
         aodv_route_notify( state, &(ncurr->node) );
         ncurr = ncurr->next;
      } while ( ( ncurr != rrep->path ) && ( hops > 0 ) );
   }

   if ( rrep->ack_flag )
   {
      aodv_unicast_rrep_ack( state, hdrs );
   }

   if ( 0 == aodv_cmp_addr( &(rrep->destination.addr), &(state->self) ) )
   {
      free_aodv_rrep( rrep );
      return 1;
   }

   if ( 0 == aodv_cmp_addr( &(rrep->originator), &(state->self) ) )
   {
      aodv_rreq_t* rreq =
         find_buffered_aodv_rreq( state, &(rrep->destination.addr) );
      if ( NULL != rreq )
      {
         unbuffer_aodv_rreq( state, rreq );
      }
   }
   else
   {
      aodv_unicast_rrep( state, rrep );
   }

   free_aodv_rrep( rrep );

   return 1;
}

static aodv_rerr_t*
_unserialize_rerr( const aodv_chunk_t* message )
{
   aodv_rerr_t* retval;
   unsigned char* pData;
   unsigned int length;
   unsigned char i;
   uint8_t  b;
   uint16_t s;
   uint32_t l;

   if ( NULL == message )
   {
      return NULL;
   }

   length = message->length;
   if ( length < k_aodv_rerr_min_len )
   {
      return NULL;
   }

   retval = (aodv_rerr_t*) malloc( sizeof( aodv_rerr_t ) );
   if ( NULL == retval )
   {
      return NULL;
   }

   pData = message->data;

   retval->unreachable = NULL;

   if ( ! aodv_get8( &pData, &length, &b ) )
   {
      free_aodv_rerr(retval);
      return NULL;
   }

   if ( ! aodv_get16( &pData, &length, &s ) )
   {
      free_aodv_rerr(retval);
      return NULL;
   }

   if ( ! aodv_get8( &pData, &length, &b ) )
   {
      free_aodv_rerr(retval);
      return NULL;
   }
   retval->dest_count = b;

   for ( i = 0 ; i < retval->dest_count ; ++i )
   {
      aodv_addr_t addr;
      uint32_t   seq;

      if ( ! aodv_get_addr( &pData, &length, &addr ) )
      {
         free_aodv_rerr(retval);
         return NULL;
      }

      if ( ! aodv_get32( &pData, &length, &l ) )
      {
         free_aodv_rerr(retval);
         return NULL;
      }
      seq = ntohl(l);

      if ( ! aodv_add_to_node_list( &(retval->unreachable), &addr, seq ) )
      {
         free_aodv_rerr(retval);
         return NULL;
      }
   }

   return retval;
}

static int
_handle_rerr( aodv_state_t* state,
              const aodv_msghdr_t* hdrs,
              const aodv_chunk_t* message )
{
   aodv_rerr_t* rerr = _unserialize_rerr( message );
   aodv_table_entry_t* eroute;
   aodv_table_entry_t* uroute;
   aodv_node_list_t* uhead;
   aodv_node_list_t* ucurr;
   aodv_rerr_t newerr;
   unsigned int gen_rerr = 0;
   char cmp;

   if ( NULL == rerr ) return 0;

   aodv_log_rerr_r( state, rerr, hdrs );

   /*
    * First create a route to the sender, if there isn't one.
    */
   eroute = aodv_lookup( &(state->routing_table), &(hdrs->addr) );
   if ( NULL == eroute )
   {
      eroute = add_aodv_table_entry( &(state->routing_table),
                                     &(hdrs->addr),
                                     0 );
      if ( NULL != eroute )
      {
         aodv_update_route_expiry( state, eroute );
         eroute->dest_seq = 0;
         set_aodv_addr( &(eroute->next_hop), &(hdrs->addr) );
         eroute->hop_count = 1;
         eroute->interface = hdrs->interface;
         eroute->valid_route = 1;
      }
   }

   /*
    * Now look for routes to invalidate, adding them to a new RERR message
    * if appropriate.
    */
   newerr.dest_count = 0;
   newerr.unreachable = NULL;
   uhead = rerr->unreachable;
   ucurr = uhead;
   if ( uhead )
   {
      do
      {
         uroute = aodv_lookup( &(state->routing_table), &(ucurr->node) );
         if ( NULL != uroute )
         {
            cmp = aodv_cmp_seq( ucurr->seq, uroute->dest_seq );
            if ( ( 0 == aodv_cmp_addr(&(uroute->next_hop), &(hdrs->addr)) ) &&
                 uroute->valid_route &&
                 ( ( 0 == ucurr->seq ) || ( cmp > 0 ) ) )
            {
               gen_rerr = 1;
               newerr.dest_count++;
               aodv_add_to_node_list( &(newerr.unreachable),
                                         &(uroute->destination.addr),
                                         uroute->dest_seq );
               uroute->valid_route = 0;
               if ( cmp > 0 )
               {
                  uroute->dest_seq = ucurr->seq;
               }
            }
         }
         ucurr = ucurr->next;
      } while ( ucurr != uhead );
   }

   /*
    * Send the new RERR message, if needed.
    */
   if ( gen_rerr )
   {
      if (  aodv_insert_time( state->rerr_time_ring ) )
      {
         aodv_bcast_rerr( state, &(newerr) );
      }
   }

   return 1;
}

static int
_handle_rrep_ack( aodv_state_t* state,
                  const aodv_msghdr_t* hdrs,
                  const aodv_chunk_t* message )
{
   aodv_log_rrep_ack_r( state, hdrs );
   return 0;
}


/*
 * Entry point.
 */

int
aodv_handle_message( aodv_state_t* state,
                     const aodv_msghdr_t* hdrs,
                     const aodv_chunk_t* message )
{
   int retval = 0;

   aodv_chunk_t* msg;

   if ( NULL == state )
   {
      return retval;
   }

   msg = collapse_chunk( message );
   if ( NULL == msg )
   {
      return retval;
   }

   if ( msg->length < 1 )
   {
      free_aodv_chunk(msg);
      return retval;
   }

   switch( msg->data[0] )
   {
      case 1 :
         retval = _handle_rreq(state,hdrs,msg);
         break;
      case 2 :
         retval = _handle_rrep(state,hdrs,msg);
         break;
      case 3 :
         retval = _handle_rerr(state,hdrs,msg);
         break;
      case 4 :
         retval = _handle_rrep_ack(state,hdrs,msg);
         break;
      default :
         retval = 0;
   }

   free_aodv_chunk(msg);
   return retval;
}

---