Member Avatar for balambika
balambika 0 Newbie Poster

Hi all,

I am using a wireless sensor network simulator called SENSE to setup a simple network and perform some security measures. I am using the AODV routing protocol which is inbuilt in SENSE. The AODV routing protocol finds the shortest route from a given source to a given destination. But it doesn't output the route for me to use it for my work.

I am providing the entire code for the AODV routing protocol as an attachment. I made some changes to print the routing table in the Stop() function. But it is not outputting the correct result. I have assumed that node 54 is the source and node 200 is the destination. Here is my attempt to print the routing table:

template <class PLD>
void AODVI<PLD>::Stop()
{
    routing_table_t::iterator it;
    for ( it=m_routing_table.begin() ; it != m_routing_table.end(); it++ )
    {
       std::cout<<"first entry"<<(*it).first<<std::endl;
       std::cout<<"second entry-dst_seq_num"<<(*it).second.dst_seq_num<<std::endl;
       std::cout<<"second entry-valid_dst_seq"<<(*it).second.valid_dst_seq<< std::endl;
       std::cout << "second entry - hop_count" <<(*it).second.hop_count << std::endl;
       std::cout << "second entry - next_hop" <<(*it).second.next_hop << std::endl;
       std::cout << "second entry - lifetime" <<(*it).second.lifetime << std::endl;
    }
     
    packet_buffer_t::iterator iter=m_packet_buffer.begin();
    for(;iter!=m_packet_buffer.end();iter++)
        (*iter)->free();
}

If I run this, I always get the next_hop to be 200, which the destination node.

Any help is appreciated.

Thanks.

/*

Copyright 2003 Joel Branch, Gilbert (Gang) Chen, Boleslaw K. Szymanski 
and Rensselaer Polytechnic Institute. All worldwide rights reserved.  
A license to use, copy, modify and distribute this software for 
non-commercial research purposes only is hereby granted, provided that 
this copyright notice and accompanying disclaimer is not modified or 
removed from the software.

DISCLAIMER: The software is distributed "AS IS" without any
express or implied warranty, including but not limited to, any
implied warranties of merchantability or fitness for a particular
purpose or any warranty of non-infringement of any current or
pending patent rights. The authors of the software make no
representations about the suitability of this software for any
particular purpose. The entire risk as to the quality and
performance of the software is with the user. Should the software
prove defective, the user assumes the cost of all necessary
servicing, repair or correction. In particular, neither Rensselaer
Polytechnic Institute, nor the authors of the software are liable
for any indirect, special, consequential, or incidental damages
related to the software, to the maximum extent the law
permits.

*/

#include <iostream>
#include <map>
#include <list>

#ifndef AODVI_H
#define AODVI_H

template <class PLD>
struct AODVI_Struct 
{
 public:

    enum { RREQ=0,RREP,RERR,RACK,HELLO,DATA,RTABLE};
    enum { JOIN=0, REPAIR=1, GRATUITOUS=2, DESTINATION=3, UNKNOWN=4};
    enum { RREQ_SIZE=24, RREP_SIZE=20, RERR_SIZE=5, RACK_SIZE=2, DATA_SIZE=12};
    
    // used for control packet flags
    struct flag_struct
    {
	    unsigned int join:1;
	    unsigned int repair:1;
	    unsigned int gratuitous:1;
	    unsigned int destination:1;
	    unsigned int unknown:1;
	    unsigned int acknowledgement:1;
	    unsigned int nodelete:1;
    };
  
    struct rreq_tuple_t
    {
    	int rreq_id;
	    simtime_t rreq_time;
	bool duplicate;
    };
  
    struct route_entry_t
    {
    	int dst_seq_num;
    	bool valid_dst_seq;
	    int hop_count;
	    ether_addr_t next_hop;
	    double lifetime;
    };
  
    struct hdr_struct
    {
	    int type;
    	int TTL;
        flag_struct flags;
	    int hop_count;
	    int rreq_id;
	    ether_addr_t dst_addr;
	    int dst_seq_num;
	    ether_addr_t src_addr;
	    ether_addr_t prev_hop_addr;
	    int src_seq_num;
	    double lifetime;
	    int prefix_size;
	    unsigned int size;

	    bool dump(std::string& str) const ;
    };

    typedef smart_packet_t<hdr_struct, PLD> packet_t;
    typedef PLD payload_t;

    static const int TimeToLive;
    static const simtime_t PathDiscoveryTime;
    static const simtime_t NetTraversalTime;
    static const simtime_t NodeTraversalTime;
    static const simtime_t ActiveRouteTimeout;
    static const simtime_t MyRouteTimeout;

};

template <class PLD> const int AODVI_Struct<PLD>::TimeToLive = 15;
template <class PLD> const simtime_t AODVI_Struct<PLD>::ActiveRouteTimeout = 3;
template <class PLD> const simtime_t AODVI_Struct<PLD>::NodeTraversalTime = 40;
template <class PLD> const simtime_t AODVI_Struct<PLD>::NetTraversalTime = 2 * NodeTraversalTime * 35;
template <class PLD> const simtime_t AODVI_Struct<PLD>::PathDiscoveryTime = 2 * NetTraversalTime;
template <class PLD> const simtime_t AODVI_Struct<PLD>::MyRouteTimeout = 2 * ActiveRouteTimeout; 


template <class PLD>
component AODVI : public TypeII, public AODVI_Struct<PLD>
{
public:
    inport inline void from_transport( payload_t& pld, ether_addr_t& dst, unsigned int size);
    inport inline void from_mac_data (packet_t* pkt, ether_addr_t& dst);
    inport inline void from_mac_ack (bool errflag);

    // This is called when the power manager wakes up the node.
    inport void	from_pm_node_up();

    InfiTimer<pair<AODVI_Struct<PLD>::packet_t*,ether_addr_t> > to_mac_delay;
	
    outport void to_transport ( payload_t& pld );
    outport void to_mac (packet_t* pkt, ether_addr_t& dst, unsigned int size);
	
    inport inline void to_mac_depart(const pair<packet_t*,ether_addr_t>& p, unsigned int i);
    
    AODVI() { connect to_mac_delay.to_component, to_mac_depart;  }
    virtual ~AODVI() {};
    void Start();				        // called when simulation starts
    void Stop();				        // called when simulation stops

    simtime_t ForwardDelay; 
    bool DumpPackets;
    ether_addr_t MyEtherAddr;

    int SentPackets, RecvPackets;
    int TotalHop;
 protected:
    void init_rreq(ether_addr_t);                 // node initiates a route request  
    void receive_rreq(packet_t*);                 // node receives a rreq packet
    void forward_rreq(packet_t*,int); 
    void receive_rrep(packet_t*); 
    void receive_data(packet_t*);
    

    typedef std::multimap<ether_addr_t, rreq_tuple_t, ether_addr_t::compare> rreq_cache_t;
    typedef std::map<ether_addr_t, route_entry_t, ether_addr_t::compare> routing_table_t;
    typedef std::list<packet_t*> packet_buffer_t;

    routing_table_t m_routing_table;
    packet_buffer_t m_packet_buffer;
    rreq_cache_t m_rreq_cache;                         // for tracking received rreq's
    int m_seq_num;                               // node's current sequence number
    int m_req_id;
};



template <class PLD>
void AODVI<PLD>::Start()
{
    m_seq_num = 0;
    m_req_id = 0;
    SentPackets=RecvPackets=0;
    TotalHop=0;
}

template <class PLD>
void AODVI<PLD>::Stop()
{
    //MY CHANGES
    printf ("entering the Stop() of AODVI \n");
    //int src =54, dst =200;
    std::cin.get();
    //ether_addr_t source, dest, next_hop;
    //source = ether_addr_t(src);
    //dest = ether_addr_t(dst);
    //source = my_source;
    //dest = my_destination;
    //routing_table_t::iterator rv_iter;
    std::cout<<"source addr is: "<<(int)my_source << std::endl;
    std::cout<<"destination addr is: "<<(int)my_destination << std::endl;
    std::cout<<"My ethernet address is: " <<MyEtherAddr<<std::endl;
    std::cout <<"the size of m_routing_table is: " << (int)m_routing_table.size()<<std::endl;
    //routing_table_t::iterator iter1 = m_routing_table.find(my_destination);
    //do
    //{
        routing_table_t::iterator it;
        for ( it=m_routing_table.begin() ; it != m_routing_table.end(); it++ )
        {
            std::cout << "first entry" << (*it).first << std::endl;
            std::cout << "second entry - dst_seq_num" <<(*it).second.dst_seq_num << std::endl;
            std::cout << "second entry - valid_dst_seq" <<(*it).second.valid_dst_seq << std::endl;
            std::cout << "second entry - hop_count" <<(*it).second.hop_count << std::endl;
            std::cout << "second entry - next_hop" <<(*it).second.next_hop << std::endl;
            std::cout << "second entry - lifetime" <<(*it).second.lifetime << std::endl;
        }
        //next_hop = (iter1->second).next_hop;                      
        //printf ("the next hop is: %d\n", (int)(iter1->second).next_hop );
        std::cin.get();
        //iter1 = m_routing_table.find((iter1->second).next_hop);
    //}while ( iter1 != m_routing_table.find(my_destination) );
    
    //for ( rv_iter=routing_table_t.begin() ; rv_iter != routing_table_t.end(); rv_iter++ )
    //cout << (*rv_iter).second.next_hop << endl;
    printf ("exiting stop() of AODVI \n" );
    std::cin.get();
    //END OF MY CHANGES */
    packet_buffer_t::iterator iter=m_packet_buffer.begin();
    for(;iter!=m_packet_buffer.end();iter++)
        (*iter)->free();
}

template <class PLD>
void AODVI<PLD>::from_transport( payload_t& pld, ether_addr_t& dst_addr, unsigned int size)
{    
    packet_t* new_p = packet_t::alloc();
    new_p->hdr.type = DATA;
    new_p->hdr.src_addr = MyEtherAddr;
    new_p->hdr.prev_hop_addr = MyEtherAddr; 
    new_p->hdr.dst_addr = dst_addr; 
    new_p->hdr.size = DATA_SIZE + size;
    new_p->hdr.hop_count = 0;
    new_p->pld=pld;

    Printf((DumpPackets,"%d AODVI: %d->%d %s\n",(int)MyEtherAddr,(int)MyEtherAddr,
	    (int)dst_addr,new_p->dump().c_str()));
    
    // check if there's a route to the destination
    routing_table_t::iterator iter = m_routing_table.find(dst_addr);
    
    //MY CHANGES
    printf("inside from_transport() \n");
	printf("the next hop is: %d\n", (int)(iter->second).next_hop );
	std::cin.get();
    //END OF MY CHANGES 
        
    if(iter == m_routing_table.end())
    {
	Printf((DumpPackets,"%d AODVI: no route \n",(int)MyEtherAddr));
	init_rreq(dst_addr);
	// the payload packet gets dropped
	m_packet_buffer.push_back(new_p);
    }
    else
    {
	// route found - send packet 
	    SentPackets++;
	    to_mac(new_p, (iter->second).next_hop, new_p->hdr.size); 
    } 
    
} 

template <class PLD>
void AODVI<PLD>::from_mac_ack (bool)
{
}

template <class PLD>
void AODVI<PLD>::from_mac_data (packet_t* packet, ether_addr_t& dst_addr)
{
    if(dst_addr==MyEtherAddr||dst_addr==ether_addr_t::BROADCAST)
    {
	RecvPackets++;
	Printf((DumpPackets,"%d AODVI: %d %d %s\n",(int)MyEtherAddr,(int)packet->hdr.prev_hop_addr,
		(int)MyEtherAddr,packet->dump().c_str()));

	    switch(packet->hdr.type)
	    {
	    case RREQ:
	        receive_rreq(packet);
	        break;
	    case RREP:
		receive_rrep(packet);
	        break;
	    case DATA:
		receive_data(packet);
	        break; 
	    }
    }
    packet->free();
}

/*
** The inport that is called when the power manager wakes the node up.
** This must be defined even if the protocol doesn't use it.
*/
template <class PLD>
void AODVI<PLD>::from_pm_node_up()
{
  return;
}

template <class PLD>
void AODVI<PLD>::receive_data(packet_t* p)
{
    if(p->hdr.dst_addr == MyEtherAddr)
    {
	TotalHop+= p->hdr.hop_count+1;
	
	/*MY CHANGES
	printf("inside AODVI<PLD>::receive_data() function \n");
	printf("previous hop address is %d\n", (int) p->hdr.prev_hop_addr);
	std::cin.get();
	//END OF MY CHANGES */
	
    p->inc_pld_ref();
	to_transport(p->pld);
	return;
    }

    // check if there's a route to the destination
    routing_t
  • 1 Contributor
  • 0 Replies
  • 50 Views
Be a part of the DaniWeb community

We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, networking, learning, and sharing knowledge.