aodvi.h

nRF24E1 sample sensor node code

    SentPackets++;
        to_mac(new_p, ether_addr_t::BROADCAST, new_p->hdr.size);
} 

template <class PLD>
void AODVI<PLD>::receive_rreq(packet_t* p)
{
    ether_addr_t src = p->hdr.src_addr;
    int id = p->hdr.rreq_id; 
    int max_seq_num = p->hdr.dst_seq_num;

    // check if RREQ with same source IP and RREQ ID was received 
    // within at least last PathDiscoveryTime
    rreq_cache_t::iterator iter; 
    for(iter = m_rreq_cache.begin(); iter != m_rreq_cache.end(); iter++)
    {
	    if((iter->first == src) && ((iter->second).rreq_id == id) /*&& 
	        ((SimTime() - (iter->second).rreq_time) <= PathDiscoveryTime)*/ )
	    {
	        Printf((DumpPackets,"aodv%d duplicate RREQ received\n",(int)MyEtherAddr)); 
	        return;
	    }
    }
 
    // store the RREQ info in rreq cache
    rreq_tuple_t tuple;
    tuple.rreq_id = id;
    tuple.rreq_time = SimTime();
    m_rreq_cache.insert(make_pair(src,tuple));
 
    // search for reverse route to source node
    routing_table_t::iterator rv_iter = m_routing_table.find(src);
    if(rv_iter == m_routing_table.end())
    {
	    // create new entry
	    route_entry_t t;
	    t.dst_seq_num = p->hdr.dst_seq_num; 
	    t.valid_dst_seq = true;
	    t.hop_count = p->hdr.hop_count; 
	    t.next_hop = p->hdr.prev_hop_addr;
	    t.lifetime = SimTime() + 2*NetTraversalTime - 2*p->hdr.hop_count*NodeTraversalTime;

    	rv_iter=m_routing_table.insert(make_pair(src, t)).first;
    }
    else
    {
	    // update entry
	    if(p->hdr.dst_seq_num > rv_iter->second.dst_seq_num)
	        rv_iter->second.dst_seq_num = p->hdr.dst_seq_num;
 
	    rv_iter->second.hop_count = p->hdr.hop_count;
	    rv_iter->second.next_hop = p->hdr.prev_hop_addr;
	    rv_iter->second.valid_dst_seq = true;
 
	    simtime_t  lt = SimTime() + 2*NetTraversalTime - 2*p->hdr.hop_count*NodeTraversalTime;
	    if( lt > rv_iter->second.lifetime)
	        rv_iter->second.lifetime = lt;  
    }

    // ALL prior operation was for processing the reverse routing table entry.
    // Now we decide whether or not to forward on the RREQ.
 
    ether_addr_t dst = p->hdr.dst_addr; 

    if(MyEtherAddr == dst)
    {
        Printf((DumpPackets, "aodv%d received rreq at destination from %d with hop %d\n", (int)MyEtherAddr, (int)p->hdr.prev_hop_addr,p->hdr.hop_count));
	    // current node is the destination 
	    packet_t* new_p = packet_t::alloc();

	    if(m_seq_num <  p->hdr.dst_seq_num)
	        m_seq_num = p->hdr.dst_seq_num;

	    new_p->hdr.src_addr = MyEtherAddr;
	    new_p->hdr.prev_hop_addr = MyEtherAddr; 
	    new_p->hdr.type = RREP;
	    new_p->hdr.dst_seq_num = m_seq_num;
	    new_p->hdr.hop_count = 0;
	    new_p->hdr.lifetime = SimTime() + MyRouteTimeout;
	    new_p->hdr.dst_addr = p->hdr.src_addr;
	    new_p->hdr.size = RREP_SIZE; 
	    new_p->hdr.flags.repair = 0;
	    new_p->hdr.flags.acknowledgement = 0;
	
	    // unicast the RREP back to the source via next hop node
	    SentPackets++;
	    to_mac(new_p, rv_iter->second.next_hop, new_p->hdr.size);
    }
    else
    {

	    bool reply = false;
	    routing_table_t::iterator fw_iter = m_routing_table.find(dst);
 
	    // confirm condition under which an RREP may be sent 
	    if(fw_iter != m_routing_table.end())
	    {
	        if( fw_iter->second.valid_dst_seq == true && 
		    fw_iter->second.dst_seq_num >= p->hdr.dst_seq_num )
	        {
		        max_seq_num = fw_iter->second.dst_seq_num;
		        if(p->hdr.flags.destination == false)
		            reply = true;
	        }
	    }

	    if(reply==true)
	    {
	        // current node is an intermediate node 
	        packet_t* new_p = packet_t::alloc();

	        // copy current node's known dest. seq num into RREP dest. seq num
	        new_p->hdr.dst_seq_num = fw_iter->second.dst_seq_num;
	        new_p->hdr.hop_count = fw_iter->second.hop_count; 
	        new_p->hdr.lifetime = fw_iter->second.lifetime;
	        new_p->hdr.src_addr = fw_iter->first;
	        new_p->hdr.prev_hop_addr = MyEtherAddr; 
	        new_p->hdr.type = RREP;
	        new_p->hdr.dst_addr = p->hdr.src_addr;
	        new_p->hdr.size = RREP_SIZE; 
	        new_p->hdr.flags.repair = 0;
	        new_p->hdr.flags.acknowledgement = 0;

	        // send packet
	        Printf((DumpPackets,"aodv%d sending %s\n",(int)MyEtherAddr,new_p->dump().c_str()));
	        SentPackets++;
	        to_mac_delay.Set(make_pair(new_p, rv_iter->second.next_hop), SimTime()+Random(ForwardDelay));
	    }
	    else
	    {
	        // must forward the rreq
	        forward_rreq(p,max_seq_num);
	    }
    }
}

template <class PLD>
void AODVI<PLD>::forward_rreq(packet_t* p, int max_seq_num)
{
    if(p->hdr.TTL > 1) 
    {
	    packet_t* new_p = packet_t::alloc();
	    new_p->hdr.type = RREQ; 
	    new_p->hdr.TTL = p->hdr.TTL - 1; 
	    new_p->hdr.src_addr = p->hdr.src_addr;
	    new_p->hdr.dst_addr = p->hdr.dst_addr;
	    new_p->hdr.prev_hop_addr = MyEtherAddr;
	    new_p->hdr.hop_count = p->hdr.hop_count + 1;
	    new_p->hdr.rreq_id = p->hdr.rreq_id;
	    new_p->hdr.size = RREQ_SIZE; 
	    new_p->hdr.flags=p->hdr.flags;
	    new_p->hdr.dst_seq_num = max_seq_num;
	 
	    SentPackets++;
	    to_mac_delay.Set(make_pair(new_p, (ether_addr_t)ether_addr_t::BROADCAST),SimTime()+Random(ForwardDelay));
    }
}

template <class PLD>
void AODVI<PLD>::receive_rrep(packet_t* p)
{
    // check if forward route for destination exists and update -
    // if not, create route
    routing_table_t::iterator fw_iter = m_routing_table.find(p->hdr.src_addr);
    if(fw_iter == m_routing_table.end())
    {
	    // create new entry
	    route_entry_t t;
	    t.dst_seq_num = p->hdr.dst_seq_num;
	    t.valid_dst_seq = true;
	    t.hop_count = p->hdr.hop_count + 1;
	    t.next_hop = p->hdr.prev_hop_addr;
	    t.lifetime = SimTime() + p->hdr.lifetime;
	
	    fw_iter=m_routing_table.insert(make_pair(p->hdr.src_addr, t)).first;

	    packet_buffer_t::iterator iter,curr;
	    iter=m_packet_buffer.begin();
	    while(iter!=m_packet_buffer.end())
	    {
	        curr = iter;
	        iter ++;
	        if((*curr)->hdr.dst_addr==p->hdr.src_addr)
	        {
		        Printf((DumpPackets,"aodv%d sending buffered packet to %d %s\n",(int)MyEtherAddr,
			        (int)fw_iter->second.next_hop,(*curr)->dump().c_str()));
		        SentPackets++;
	            to_mac(*curr, fw_iter->second.next_hop, (*curr)->hdr.size);
	            m_packet_buffer.erase(curr);
 	        }
	    }
    }
    else
    {
	    bool update = false;
	
	    if( fw_iter->second.valid_dst_seq == false)
	        update = true;
	    else if ( p->hdr.dst_seq_num > fw_iter->second.dst_seq_num)
	        update = true;
	    else if( p->hdr.dst_seq_num == fw_iter->second.dst_seq_num && 
		     p->hdr.hop_count < fw_iter->second.hop_count )
	        update = true;
	
	    if(update == true)
	    {
	        // update entry
	        (fw_iter->second).dst_seq_num = p->hdr.dst_seq_num;
	        (fw_iter->second).valid_dst_seq = true;
	        (fw_iter->second).hop_count = p->hdr.hop_count + 1;
	        (fw_iter->second).next_hop = p->hdr.prev_hop_addr;
	        (fw_iter->second).lifetime = p->hdr.lifetime;
	    }
    }

    // ALL prior operation was for processing the forward routing table entry.
    // Now we decide whether or not to forward on the RREP.

    if(MyEtherAddr != p->hdr.dst_addr)
    {
	    // unicast the RREP back to the source via next hop node
	    // look up next hop in reverse routing table
	    routing_table_t::iterator rv_iter = m_routing_table.find(p->hdr.dst_addr);
	    if(rv_iter == m_routing_table.end())
	    {
	        printf("[%f] net%d reverse routing error: no route back to the source!\n", SimTime(), (int)MyEtherAddr);
	        return;
	    }
	    else
	    {   
	        packet_t* new_p = packet_t::alloc();
	    
	        new_p->hdr.src_addr = p->hdr.src_addr;
	        new_p->hdr.prev_hop_addr = MyEtherAddr;
	        new_p->hdr.dst_addr = p->hdr.dst_addr; 
	        new_p->hdr.type = RREP;
	        new_p->hdr.dst_seq_num = p->hdr.dst_seq_num;
	        new_p->hdr.hop_count = p->hdr.hop_count + 1;
	        new_p->hdr.lifetime = p->hdr.lifetime;
	        new_p->hdr.size = RREP_SIZE;
	        new_p->hdr.flags.repair=0;
	        new_p->hdr.flags.acknowledgement=0;
	        Printf((DumpPackets,"aodv%d sending %s\n",(int)MyEtherAddr,new_p->dump().c_str()));
	        SentPackets++;
	        to_mac(new_p, rv_iter->second.next_hop, new_p->hdr.size);
	    }

	    // update lifetime entry for reverse route table
	    if((rv_iter->second).lifetime < (SimTime() + ActiveRouteTimeout))
	        (rv_iter->second).lifetime = SimTime() + ActiveRouteTimeout; 
    }
    else
    {

    }
}

template <class PLD>
void AODVI<PLD>::to_mac_depart(const pair<packet_t*,ether_addr_t>&p, unsigned int i)
{
	to_mac(p.first,p.second,p.first->hdr.size);
}


template <class PLD>
bool AODVI_Struct<PLD>::hdr_struct::dump(std::string& str) const 
{ 
    char buffer[100];
    std::string t;
    switch(type)
    {
    case RREQ:
        t="REQUEST";
	break;    
    case RREP:
        t="REPLY";
	break;
    case DATA:
        t="DATA";
	break;
    case HELLO:
        t="HELLO";
	break;
    }
    sprintf(buffer,"%s %d %d %d %d->%d->%d (%d %d) ",
	    t.c_str(),TTL,hop_count, rreq_id, (int)prev_hop_addr,
	    (int)src_addr,(int)dst_addr,src_seq_num,dst_seq_num);
    str=buffer;
    return type==DATA;
}


#endif /* AODVI_H */