aodv.h

/* 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.
 */

#ifndef __AODV_H__
#define __AODV_H__

#ifdef __cplusplus
extern "C" {
#endif

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

/* We're using POSIX types, rather than ISO C99 types. */
#include <sys/types.h>

extern const uint16_t k_aodv_udp_port; 
extern const uint16_t kAodvRreqD; 
extern const uint16_t kAodvRreqG; 
extern const uint16_t kAodvRrepA; 
extern const unsigned int k_aodv_rreq_min_len; 
extern const unsigned int k_aodv_rrep_min_len; 
extern const unsigned int k_aodv_rerr_min_len; 
extern const unsigned int k_aodv_rrep_ack_len; 
enum
{
   AODV_GR_OK, 
   AODV_GR_NULLSTATE, 
   AODV_GR_PENDING, 
   AODV_GR_NOROUTE, 
   AODV_GR_ERROR 
};

typedef struct aodv_addr
{
      uint16_t       length; 
      unsigned char*  data; 
} aodv_addr_t; 
typedef struct aodv_chunk
{
      unsigned int        length; 
      unsigned char*      data; 
      struct aodv_chunk*  next; 
} aodv_chunk_t; 
typedef struct aodv_msghdr
{
      aodv_addr_t    addr; 
      unsigned char  ttl; 
      int            interface; 
} aodv_msghdr_t; 
typedef struct aodv_prefix
{
      aodv_addr_t  addr; 
      uint16_t     prefix; 
} aodv_prefix_t; 
typedef struct aodv_node_list
{
      struct aodv_node_list*  next; 
      struct aodv_node_list*  prev; 
      aodv_addr_t  node; 
      uint32_t    seq; 
} aodv_node_list_t; 
typedef struct aodv_rreq
{
      struct aodv_rreq*  next; 
      struct aodv_rreq*  prev; 
      struct timeval     buffer_time; 
      unsigned int       ntries; 
      unsigned int       ttl; 
      unsigned char      dest_only_flag; 
      unsigned char      grat_rrep_flag; 
      unsigned char      hop_count; 
      uint32_t           rreq_id; 
      aodv_addr_t        destination; 
      uint32_t           dest_seq; 
      aodv_addr_t        originator; 
      uint32_t           orig_seq; 
      aodv_node_list_t*  path; 
} aodv_rreq_t; 
typedef struct aodv_rrep
{
      unsigned char      ack_flag; 
      unsigned char      apn_count; 
      unsigned char      hop_count; 
      aodv_prefix_t      destination; 
      uint32_t           dest_seq; 
      aodv_addr_t        originator; 
      uint32_t           orig_seq; 
      aodv_node_list_t*  path; 
} aodv_rrep_t; 
typedef struct aodv_rerr
{
      unsigned char      dest_count; 
      aodv_node_list_t*  unreachable; 
} aodv_rerr_t; 
typedef struct aodv_table_entry
{
      struct aodv_table_entry*  next; 
      struct aodv_table_entry*  prev; 
      aodv_prefix_t             destination; 
      uint32_t                  dest_seq; 
      aodv_addr_t               next_hop; 
      struct timeval            lifetime; 
      unsigned char             hop_count; 
      int                       interface; 
      unsigned char             valid_route; 
} aodv_table_entry_t; 
typedef struct aodv_routing_table
{
      aodv_table_entry_t*  head; 
} aodv_routing_table_t; 
typedef struct aodv_parameters
{
      unsigned int  node_traversal_time; 
      unsigned int  net_diameter; 
      unsigned int  net_traversal_time; 
      unsigned int  path_discovery_time; 
      unsigned int  active_route_timeout; 
      unsigned int  delete_period; 
      unsigned int  rreq_tries; 
      unsigned int  rreq_ratelimit; 
      unsigned int  rerr_ratelimit; 
      unsigned int  hello_interval; 
      unsigned int  allowed_hello_loss; 
      unsigned int  next_hop_wait; 
      unsigned int  blacklist_timeout; 
} aodv_parameters_t; 
typedef struct aodv_time_ring
{
      struct timeval*  ring; 
      unsigned int     size; 
      unsigned int     offset; 
} aodv_time_ring_t; 
typedef struct aodv_interfaces
{
      int*          interfaces; 
      unsigned int  nifaces; 
      unsigned int  lifaces; 
} aodv_interfaces_t; 
typedef struct aodv_state
{
      aodv_parameters_t     params; 
      aodv_addr_t           self; 
      unsigned char         subnet_size; 
      uint32_t              sequence_number; 
      uint32_t              rreq_id; 
      aodv_rreq_t*          rreq_buffer; 
      aodv_rreq_t*          rcvd_rreq_buffer; 
      aodv_time_ring_t*     rreq_time_ring; 
      aodv_time_ring_t*     rerr_time_ring; 
      unsigned char         use_acks; 
      aodv_interfaces_t     interfaces; 
      aodv_routing_table_t  routing_table; 
} aodv_state_t; 
int
aodv_gettime(struct timeval* tv);

void
aodv_route_notify( const aodv_state_t* state, const aodv_addr_t* dest );

void
aodv_set_bcast_addr( aodv_addr_t* a );

void
aodv_send_message( aodv_state_t* state,
                   const aodv_msghdr_t* headers,
                   const aodv_chunk_t* message );

void
aodv_log_rreq_s( const aodv_state_t* state,
                 const aodv_rreq_t* rreq,
                 const aodv_msghdr_t* hdrs );

void
aodv_log_rrep_c( const aodv_state_t* state,
                 const aodv_rrep_t* rrep );

void
aodv_log_rrep_s( const aodv_state_t* state,
                 const aodv_rrep_t* rrep,
                 const aodv_msghdr_t* hdrs );

void
aodv_log_rerr_s( const aodv_state_t* state,
                 const aodv_rerr_t* rerr,
                 const aodv_msghdr_t* hdrs );

void
aodv_log_rrep_ack_s( const aodv_state_t* state,
                     const aodv_msghdr_t* hdrs );

void
aodv_log_rreq_r( const aodv_state_t* state,
                 const aodv_rreq_t* rreq,
                 const aodv_msghdr_t* hdrs );

void
aodv_log_rrep_r( const aodv_state_t* state,
                 const aodv_rrep_t* rrep,
                 const aodv_msghdr_t* hdrs );

void
aodv_log_rerr_r( const aodv_state_t* state,
                 const aodv_rerr_t* rerr,
                 const aodv_msghdr_t* hdrs );

void
aodv_log_rrep_ack_r( const aodv_state_t* state,
                     const aodv_msghdr_t* hdrs );

aodv_table_entry_t*
aodv_get_route( aodv_state_t* state,
                const aodv_addr_t* source,
                const aodv_addr_t* destination,
                int* ecode );

void
clear_aodv_routing_table( aodv_routing_table_t* table );

aodv_table_entry_t*
add_aodv_table_entry( aodv_routing_table_t* table,
                      const aodv_addr_t* destination,
                      uint16_t prefix_size );

void
remove_aodv_table_entry( aodv_routing_table_t* table,
                         aodv_table_entry_t* entry );

aodv_table_entry_t*
update_aodv_table_entry( aodv_state_t* state,
                         const aodv_msghdr_t* hdrs,
                         const aodv_node_list_t* node,
                         unsigned char hop_count );

aodv_table_entry_t*
new_aodv_table_entry();

void
free_aodv_table_entry( aodv_table_entry_t* entry );

aodv_table_entry_t*
aodv_lookup( const aodv_routing_table_t* table,
             const aodv_addr_t* destination );

void
aodv_invalidate_route( aodv_state_t* state, const aodv_addr_t* destination );

void
aodv_invalidate_routing_entry( aodv_state_t* state,
                               aodv_table_entry_t* entry );

unsigned char
aodv_table_entry_is_expired( const aodv_table_entry_t* entry );

void
aodv_update_route_expiry( const aodv_state_t* state,
                          aodv_table_entry_t* entry );

void
aodv_update_invalid_route_lifetime( const aodv_state_t* state,
                                    aodv_table_entry_t* entry );

void
aodv_broken_link( aodv_state_t* state, const aodv_addr_t* bad_hop );

int
aodv_generate_rreq( aodv_state_t* state, const aodv_addr_t* destination );

int
aodv_handle_message( aodv_state_t* state,
                     const aodv_msghdr_t* headers,
                     const aodv_chunk_t* message );

void
aodv_bcast_rreq( aodv_state_t* state, const aodv_rreq_t* request );

void
aodv_unicast_rrep( aodv_state_t* state, const aodv_rrep_t* response );

void
aodv_bcast_rerr( aodv_state_t* state, const aodv_rerr_t* rerr );

void
aodv_unicast_rrep_ack( aodv_state_t* state,
                       const aodv_msghdr_t* inhdrs );

unsigned char
aodv_pasttime( const struct timeval* tv );

aodv_state_t*
new_aodv_state( const aodv_addr_t* self, uint16_t prefix );

void
init_aodv_state( aodv_state_t* state,
                 const aodv_addr_t* self,
                 uint16_t prefix );

void
configure_aodv_state( aodv_state_t* state );

void
free_aodv_state( aodv_state_t* state );

void
clear_aodv_state( aodv_state_t* state );

void
set_aodv_param_defaults( aodv_state_t* state );

void
recompute_aodv_params( aodv_state_t* state );

uint32_t
aodv_incr_seq_base( uint32_t* seq );

uint32_t
aodv_incr_seq( aodv_state_t* state );

uint32_t
aodv_incr_rreq_id( aodv_state_t* state );

char
aodv_cmp_seq( uint32_t a, uint32_t b );

char
aodv_cmp_addr( const aodv_addr_t* a, const aodv_addr_t* b );

void
buffer_aodv_rreq( aodv_state_t* state, aodv_rreq_t* rreq );

void
buffer_rcvd_aodv_rreq( aodv_state_t* state, aodv_rreq_t* rreq );

aodv_rreq_t*
unbuffer_aodv_rreq( aodv_state_t* state, aodv_rreq_t* rreq );

aodv_rreq_t*
unbuffer_rcvd_aodv_rreq( aodv_state_t* state, aodv_rreq_t* rreq );

int
is_buffered_aodv_rreq( aodv_state_t* state, aodv_rreq_t* rreq );

int
is_buffered_rcvd_aodv_rreq( aodv_state_t* state, aodv_rreq_t* rreq );

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

void
aodv_initialize_time_ring( aodv_time_ring_t* ring, unsigned int size );

int
aodv_insert_time( aodv_time_ring_t* ring );

int
aodv_add_interface( aodv_state_t* state, int iface );

int
aodv_add_to_node_list( aodv_node_list_t** path,
                       const aodv_addr_t* addr,
                       uint32_t seq );

const aodv_node_list_t*
aodv_find_in_node_list( const aodv_node_list_t* nodes,
                        const aodv_addr_t* addr );

int
aodv_get8( unsigned char** pData, unsigned int* pLength, uint8_t* b );

int
aodv_get16( unsigned char** pData, unsigned int* pLength, uint16_t* s );

int
aodv_get32( unsigned char** pData, unsigned int* pLength, uint32_t* l );

int
aodv_get_addr( unsigned char** pData, unsigned int* pLength, aodv_addr_t* a );

void
set_aodv_addr( aodv_addr_t* dest, const aodv_addr_t* src );

aodv_chunk_t*
new_aodv_chunk( unsigned int length );

void
free_aodv_chunk( aodv_chunk_t* chunk );

aodv_chunk_t*
collapse_chunk( const aodv_chunk_t* bigchunk );

void
free_aodv_node_list( aodv_node_list_t* head );

void
free_aodv_time_ring( aodv_time_ring_t* ring );

void
free_aodv_rreq( aodv_rreq_t* r );

void
free_aodv_rrep( aodv_rrep_t* r );

void
free_aodv_rerr( aodv_rerr_t* r );

#ifdef __cplusplus
}
#endif

#endif /* __AODV_H__ */

---