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

static int
_put8( unsigned char** pData, unsigned int* pLength, uint8_t b )
{
   if ( *pLength < 1 )
   {
      return 0;
   }
   if ( NULL == pData )
   {
      return 0;
   }
   if ( NULL == *pData )
   {
      return 0;
   }

   (*pData)[0] = b;
   *pData += 1;
   *pLength -= 1;
   return 1;
}

static int
_put16( unsigned char** pData, unsigned int* pLength, uint16_t s )
{
   unsigned char* data;
   union
   {
         uint16_t s;
         unsigned char c[2];
   } temp;

   if ( *pLength < 2 )
   {
      return 0;
   }
   if ( NULL == pData )
   {
      return 0;
   }
   if ( NULL == *pData )
   {
      return 0;
   }
   data = *pData;

   temp.s = s;
   data[0] = temp.c[0];
   data[1] = temp.c[1];

   *pData += 2;
   *pLength -= 2;
   return 1;
}

static int
_put32( unsigned char** pData, unsigned int* pLength, uint32_t l )
{
   unsigned char* data;
   union
   {
         uint32_t l;
         unsigned char c[4];
   } temp;

   if ( *pLength < 4 )
   {
      return 0;
   }
   if ( NULL == pData )
   {
      return 0;
   }
   if ( NULL == *pData )
   {
      return 0;
   }
   data = *pData;

   temp.l = l;
   data[0] = temp.c[0];
   data[1] = temp.c[1];
   data[2] = temp.c[2];
   data[3] = temp.c[3];

   *pData += 4;
   *pLength -= 4;
   return 1;
}

static int
_put_addr( unsigned char** pData, unsigned int* pLength, const aodv_addr_t* a )
{
   if ( NULL == pData ) return 0;
   if ( NULL == *pData ) return 0;
   if ( NULL == pLength ) return 0;
   if ( NULL == a ) return 0;
   if ( NULL == a->data ) return 0;
   if ( 0 == a->length ) return 0;
   if ( *pLength < (2+a->length) ) return 0;

   _put16( pData, pLength, htons(a->length) );
   memcpy( *pData, a->data, a->length );
   *pData += a->length;
   *pLength -= a->length;

   return 1;
}

static aodv_chunk_t*
_serialize_rreq( const aodv_rreq_t* rreq )
{
   unsigned char* pData;
   aodv_chunk_t* retval = NULL;
   aodv_chunk_t* tail;
   aodv_node_list_t* ncurr;
   unsigned int length;
   uint16_t flags = 0;

   /* first chunk -- fixed size data */
   length = 1 + sizeof(uint16_t) + sizeof(unsigned char) + sizeof(uint32_t);
   retval = new_aodv_chunk( length );
   if ( NULL == retval )
   {
      return NULL;
   }
   pData = retval->data;
   _put8( &pData, &length, 1 );

   if ( rreq->dest_only_flag) flags |= kAodvRreqD;
   if ( rreq->grat_rrep_flag) flags |= kAodvRreqG;
   _put16( &pData, &length, htons(flags) );
   _put8( &pData, &length, rreq->hop_count );
   _put32( &pData, &length, htonl(rreq->rreq_id) );
   tail = retval;

   /* second chunk -- destination information */
   length =
      sizeof(uint16_t) +
      rreq->destination.length*sizeof(unsigned char) +
      sizeof(uint32_t);
   tail->next = new_aodv_chunk( length );
   if ( NULL == tail->next )
   {
      return NULL;
   }
   tail = tail->next;
   pData = tail->data;
   _put_addr(&pData,&length,&(rreq->destination));
   _put32(&pData,&length,htonl(rreq->dest_seq));

   /* third chunk -- originator information */
   length =
      sizeof(uint16_t) +
      rreq->originator.length*sizeof(unsigned char) +
      sizeof(uint32_t);
   tail->next = new_aodv_chunk( length );
   if ( NULL == tail->next )
   {
      return NULL;
   }
   tail = tail->next;
   pData = tail->data;
   _put_addr(&pData,&length,&(rreq->originator));
   _put32(&pData,&length,htonl(rreq->orig_seq));

   /* additional chunks -- path information */
   ncurr = rreq->path;
   if ( NULL != ncurr )
   {
      do
      {
         length =
            sizeof(uint16_t) +
            ncurr->node.length*sizeof(unsigned char) +
            sizeof(uint32_t);
         tail->next = new_aodv_chunk( length );
         if ( NULL == tail->next )
         {
            return NULL;
         }
         tail = tail->next;
         pData = tail->data;
         _put_addr(&pData,&length,&(ncurr->node));
         _put32(&pData,&length,htonl(ncurr->seq));
         ncurr = ncurr->next;
      } while ( ncurr != rreq->path );
   }

   /* collapse into a single chunk */
   tail = retval;
   retval = collapse_chunk( tail );

   return retval;
}

void
aodv_bcast_rreq( aodv_state_t* state, const aodv_rreq_t* request )
{
   aodv_chunk_t*  msg;
   aodv_msghdr_t  hdrs;
   unsigned int      i;

   if ( NULL == state ) return;
   if ( NULL == state->interfaces.interfaces ) return;

   aodv_set_bcast_addr( &(hdrs.addr) );
   hdrs.ttl  = state->params.net_diameter;

   msg = _serialize_rreq( request );
   if ( NULL == msg ) return;

   aodv_log_rreq_s( state, request, &hdrs );

   for ( i = 0 ; i < state->interfaces.nifaces ; ++i )
   {
      hdrs.interface = state->interfaces.interfaces[i];
      aodv_send_message( state, &hdrs, msg );
   }

   free_aodv_chunk( msg );
}


static aodv_chunk_t*
_serialize_rrep( const aodv_rrep_t* rrep )
{
   unsigned char* pData;
   aodv_chunk_t* retval = NULL;
   aodv_node_list_t* ncurr;
   unsigned int length = k_aodv_rrep_min_len;
   uint16_t flags = 0;
   unsigned int i;

   length += rrep->destination.addr.length + rrep->originator.length;
   ncurr = rrep->path;
   if ( NULL != ncurr )
   {
      do
      {
         length += 6 + ncurr->node.length;
         ncurr = ncurr->next;
      } while ( ncurr != rrep->path );
   }

   retval = new_aodv_chunk( length );
   if ( NULL == retval )
   {
      return NULL;
   }

   pData = retval->data;
   _put8( &pData, &length, 2 );

   if ( rrep->ack_flag) flags |= kAodvRrepA;
   for ( i = 0 ; i < 5 ; ++i )
   {
      if (rrep->destination.prefix & (1<<i))
      {
         flags |= (1 << i);
      }
      if (rrep->apn_count & (1<<i))
      {
         flags |= (1 << (i+5));
      }
   }
   _put16( &pData, &length, htons(flags) );

   _put8( &pData, &length, rrep->hop_count );

   _put_addr( &pData, &length, &(rrep->destination.addr) );
   _put32( &pData, &length, htonl(rrep->dest_seq) );
   _put_addr( &pData, &length, &(rrep->originator) );
   _put32( &pData, &length, htonl(rrep->orig_seq) );

   ncurr = rrep->path;
   if ( NULL != ncurr )
   {
      do
      {
         _put_addr( &pData, &length, &(ncurr->node) );
         _put32( &pData, &length, htonl(ncurr->seq) );
         ncurr = ncurr->next;
      } while ( ncurr != rrep->path );
   }

   return retval;
}

void
aodv_unicast_rrep( aodv_state_t* state, const aodv_rrep_t* response )
{
   aodv_chunk_t*  msg;
   aodv_msghdr_t  hdrs;

   const aodv_node_list_t*  selfnode;
   aodv_table_entry_t*      next_hop;

   if ( NULL == state ) return;
   if ( NULL == response ) return;

   hdrs.addr.data = NULL;
   hdrs.addr.length = 0U;

   selfnode = aodv_find_in_node_list( response->path, &(state->self) );
   if ( ( NULL == selfnode ) ||
        ( selfnode == selfnode->prev ) )
   {
      next_hop = aodv_lookup( &(state->routing_table),
                              &(response->originator) );
      if ( NULL == next_hop ) return;
      set_aodv_addr( &(hdrs.addr), &(next_hop->next_hop) );
      hdrs.interface = next_hop->interface;
   }
   else
   {
      set_aodv_addr( &(hdrs.addr), &(selfnode->prev->node) );
      next_hop = aodv_lookup( &(state->routing_table), &(hdrs.addr) );
      if ( NULL == next_hop ) return;
      hdrs.interface = next_hop->interface;
   }
   hdrs.ttl = state->params.net_diameter;

   msg = _serialize_rrep( response );
   if ( NULL == msg ) return;

   aodv_log_rrep_s( state, response, &hdrs );

   aodv_send_message( state, &hdrs, msg );

   free_aodv_chunk( msg );
}

static aodv_chunk_t*
_serialize_rerr( const aodv_rerr_t* rerr )
{
   unsigned char* pData;
   aodv_chunk_t* retval = NULL;
   aodv_node_list_t* ncurr;
   unsigned int length = k_aodv_rerr_min_len;
   unsigned char ucount = 0;

   ncurr = rerr->unreachable;
   if ( NULL != ncurr )
   {
      do
      {
         ++ucount;
         length += 6 + ncurr->node.length;
         ncurr = ncurr->next;
      } while ( ncurr != rerr->unreachable );
   }

   if ( ucount != rerr->dest_count )
   {
      return NULL;
   }

   retval = new_aodv_chunk( length );
   if ( NULL == retval )
   {
      return NULL;
   }

   pData = retval->data;
   _put8( &pData, &length, 3 );
   _put16( &pData, &length, 0 );
   _put8( &pData, &length, rerr->dest_count );

   ncurr = rerr->unreachable;
   if ( NULL != ncurr )
   {
      do
      {
         _put_addr( &pData, &length, &(ncurr->node) );
         _put32( &pData, &length, htonl(ncurr->seq) );
         ncurr = ncurr->next;
      } while ( ncurr != rerr->unreachable );
   }

   return retval;
}

void
aodv_bcast_rerr( aodv_state_t* state, const aodv_rerr_t* rerr )
{
   aodv_chunk_t*  msg;
   aodv_msghdr_t  hdrs;
   unsigned int      i;

   if ( NULL == state ) return;
   if ( NULL == state->interfaces.interfaces ) return;

   aodv_set_bcast_addr( &(hdrs.addr) );
   hdrs.ttl  = 1;

   msg = _serialize_rerr( rerr );
   if ( NULL == msg ) return;

   aodv_log_rerr_s( state, rerr, &hdrs );

   for ( i = 0 ; i < state->interfaces.nifaces ; ++i )
   {
      hdrs.interface = state->interfaces.interfaces[i];
      aodv_send_message( state, &hdrs, msg );
   }

   free_aodv_chunk( msg );
}

static aodv_chunk_t*
_serialize_rrep_ack()
{
   unsigned char* pData;
   aodv_chunk_t* retval = NULL;
   unsigned int length = k_aodv_rrep_ack_len;

   retval = new_aodv_chunk( length );
   if ( NULL == retval )
   {
      return NULL;
   }

   pData = retval->data;
   _put8( &pData, &length, 4 );
   _put8( &pData, &length, 0 );

   return retval;
}

void
aodv_unicast_rrep_ack( aodv_state_t* state,
                       const aodv_msghdr_t* inhdrs )
{
   aodv_chunk_t*  msg;
   aodv_msghdr_t  hdrs;

   if ( NULL == state ) return;
   if ( NULL == inhdrs ) return;

   hdrs.addr.length = 0;
   hdrs.addr.data = NULL;
   set_aodv_addr( &(hdrs.addr), &(inhdrs->addr) );

   hdrs.interface = inhdrs->interface;
   hdrs.ttl       = 1;

   msg = _serialize_rrep_ack();
   if ( NULL == msg ) return;

   aodv_log_rrep_ack_s( state, &hdrs );

   aodv_send_message( state, &hdrs, msg );

   free_aodv_chunk( msg );
}

---